Perché non è compilatore errore di tempo gettati quando chiamiamo a una funzione C

Question

Secondo l'esempio, che la standard fornisce al N4296::13.3.3 [over.match.best]

namespace A 
{ 
    extern "C" void f(int = 5); 
} 

namespace B 
{ 
    extern "C" void f(int = 5); 
} 

using A::f; 
using B::f; 

void use() 
{ 
    f(3); // OK, default argument was not used for viability 
    f(); // Error: found default argument twice 
} 

come standard dice a N4296::7.5/6 [dcl.link]:

due dichiarazioni per una funzione con collegamento di linguaggio C con lo stesso nome di funzione (ignorando i nomi di spazi dei nomi che lo qualificano) che vengono visualizzati in ambiti di spazio dei nomi diversi, fare riferimento alla stessa funzione.

ho cercato di scoprire una cosa del genere da solo esempio:

#include <iostream> 

namespace A 
{ 
    extern "C" void foo(int a = 5){ std::cout << a << "1" << std::endl; } 
} 

namespace B 
{ 
    extern "C" void foo(int a = 5); 
} 

using A::foo; 
using B::foo; 

int main() 
{ 
    foo(); //Error 
    foo(2); 
} 

DEMO

Allora perché il mio esempio funziona? Quali sono le differenze tra il mio esempio e l'esempio dello standard a meno che non abbia definito esplicitamente la funzione nello spazio dei nomi A? Perché questo è così importante?

Answer 1

Come già osservato nei commenti, non vi è alcuna differenza rilevante tra l'esempio dello standard e l'esempio. I compilatori che implementano correttamente il problema standard sono una diagnostica per entrambi.

Il fatto che questo è chiaramente un bug del compilatore in almeno clang e Intel può essere visto quando si modifica l'esempio al insensato

namespace A 
{ 
    extern "C" void f(int = 5); 
} 

namespace B 
{ 
    extern "C" void f(int = 3); // different default argument 
} 

using A::f; 
using B::f; 

void use() 
{ 
    f(); // No error ! 
} 

Nonostante ottenendo due diversi argomenti di default, nessun errore o anche viene generato un avviso. Viene utilizzato uno degli argomenti predefiniti, il primo con Intel, il secondo con clang.

GCC rifiuta questo esempio insensato, quindi non c'è un modo semplice e veloce per verificare che sia chiaramente un bug in GCC, ma ciò non cambia il fatto che lo sia: come notato, accetta silenziosamente l'esempio dallo standard in cui lo standard indica dove deve essere rilevato un errore.