Was bedeutet der Satz, der sich auf Funktionen bezieht, die durch eine using-Deklaration eingeführt werden?

Question

Ich studiere die C++ 03 Standard- und jetzt [7.3.3]/11 lese, aber ich habe Probleme mit der folgenden Passage zu verstehen:

Wenn eine Funktionsdeklaration in Namespacebereich oder blockiert Umfang die gleichen Namen hat und der gleiche Parameter Typen als eine Funktion von einer using-Deklaration eingeführt, und die Deklarationen deklarieren nicht die gleiche Funktion, das Programm ist schlecht gebildet.

Ich habe nirgendwo Beispiele dieser Situation gefunden und ich verstehe die Bedeutung dieser Passage nicht.

Answer 1

Was es bedeutet, ist, dass:

namespace namespace_1 
{ 
    void foo(int number); 
} 
using namespace_1::foo; 
void foo(int roll_no); 

Das bedeutet, das Programm ist schlecht ausgebildet. Ich glaube, es bedeutet zu sagen, dass die Funktion zu lesen wäre verwirrend. An einem Punkt würde die Funktionsdefinition den übergebenen int als Ganzzahl (allgemein) verwenden, aber im anderen Fall würden wir ihn als roll_no verwenden.

Dies würde auch Mehrdeutigkeit in überladenen Funktionsübereinstimmung verursachen.

Die Quelle, die Sie zitiert sind knapp unterhalb der Linien ein Beispiel gibt Ihnen zitierten:

namespace B { 
    void f(int); 
    void f(double); 
} 
namespace C { 
    void f(int); 
    void f(double); 
    void f(char); 
} 
void h() { 
    using B::f;  // B::f(int) and B::f(double) 
    using C::f;  // C::f(int), C::f(double), and C::f(char) 
    f('h');   // calls C::f(char) 
    f(1);    // error: ambiguous: B::f(int) or C::f(int)? 
    void f(int);  // error: f(int) conflicts with C::f(int) and B::f(int) 
} 

Answer 2

Das folgende Programm enthält den Fehler

#include <iostream> 

namespace _1{ 
    int f(){ 
     std::cout << "_1::f\n"; 
    } 
} 

namespace _2{ 
/* 
*If a function declaration in namespace scope or block scope has the 
*same name and the same parameter types as a function introduced by 
* a using-declaration 
*/ 
    using _1::f; 
// This is not the same function as introduced by the using directive 
    int f(){ 
     std::cout << "_2::f\n"; 
    } 
} 

int main(){ 
    _2::f(); 
} 

Die Diagnose ist

main.cpp: In function ‘int _2::f()’: 
main.cpp:13:11: error: ‘int _2::f()’ conflicts with a previous declaration 
    int f(){ 

Im Gegensatz dazu ist das folgende Programm korrekt. Der Namespace _1 wird über eine using-Direktive eingeführt.

#include <iostream> 

namespace _1{ 
    int f(){ 
     std::cout << "_1::f\n"; 
    } 
} 

namespace _2{ 
    using namespace _1; 

    int f(){ 
     std::cout << "_2::f\n"; 
    } 
} 

int main(){ 
    _2::f(); 
} 

Mit dem erwarteten Ausgang

_2::f 

Wie für die gleiche Situation in Block Umfang Sie

#include <iostream> 

namespace _1{ 
    int f(){ 
     std::cout << "_1::f\n"; 
    } 
} 

namespace _2{ 

    int g(){ 
// As before but in block scope. 
     using _1::f; 

     int f(); 
     f(); 
    } 
    int f(){ 
     std::cout << "_2::f\n";   
    } 

} 

int main(){ 
    _2::f(); 
} 

Die Diagnose ist identisch

main.cpp: In function ‘int _2::g()’: 
main.cpp:15:15: error: ‘int _2::f()’ conflicts with a previous declaration 
     int f(); 
      ^

Das Parallelkonstrukt das erfolgreiche Probe wäre über

#include <iostream> 

namespace _1{ 
    int f(){ 
     std::cout << "_1::f\n"; 
    } 
} 

namespace _2{ 

    int g(){ 
     using namespace _1; 

     int f(); 
     f(); 
    } 
    int f(){ 
     std::cout << "_2::f\n";   
    } 

} 

int main(){ 
    _2::g(); 
} 

Mit dem Ausgang

_2::f