Modificare il significato del codice mediante sostituzione di dichiarazione anticipata con includono

Question

Google C++ Style Guide stati che

In casi estremi, la sostituzione di un #include con una dichiarazione anticipata può silenziosamente cambiare il significato del codice.

Potete per favore aiutarmi a trovare alcuni esempi?

Answer 1

Ecco due casi. Uno di loro è UB, l'altro penso che è definito cambiamento di comportamento (supponendo che non ODR o simili violazioni: vale a dire, nessuna chiamata a foo vede mai la definizione di A, ma sono incerto)

namespace N { 
    struct B {}; 
    struct A;//:B{}; 
} 

void foo(N::B*){ 
    std::cout << "B\n"; 
} 
template<class T, class=std::enable_if_t<!std::is_convertible<T*,N::B*>{}>> 
void foo(T*){ 
    std::cout << "T\n"; 
} 

int main() { 
    foo((N::A*)0); 
} 

sostituzione struct A; con struct A:B{}; cambierà quale dei sovraccarichi foo viene chiamato.

Inoltre, delete A; chiamerà ~A() se è visibile quando viene chiamato delete A;. Altrimenti, se c'è un distruttore non banale, abbiamo UB. In questo caso, il significato del codice cambia in quanto va da UB a DB, che suppongo sia un cambiamento di significato.

Answer 2

Uno degli esempi più insidiosi di cui sono a conoscenza è il cast in stile C associato all'ereditarietà.

Diciamo che avete:

class Parent1 {}; 
class Parent2 {}; 

class Child : public Parent1, public Parent2 {}; 

Poi in qualche altro file Lanci da parent2 a figlio:

Parent2* parent2_ptr = new Child; 
Child* obj = (Child*)parent2_ptr; 

Con la definizione completa il cast C-stile è un static_cast, correttamente sistemando l'indirizzo. Con una dichiarazione anticipata (di Child) il cast in stile C diventa un reinterpret_cast interrompendo in modo silenzioso il codice.