Quali sono gli elementi più sorprendenti dello standard C++?

Question

Ho deciso di familiarizzare con il mio linguaggio di programmazione preferito, ma lo solo la lettura dello standard è noioso.

Quali sono gli elementi più sorprendenti, controintuitivi o semplicemente bizzarri del C++? Cosa ti ha scioccato abbastanza da correre al tuo compilatore più vicino per verificare se è vero?

Accetterò la prima risposta che non crederò nemmeno dopo L'ho provato. :)

Answer 1

L'ordine dei vari dichiaratori è in realtà non ordinato:

volatile long int const long extern unsigned x; 

è uguale

extern const volatile unsigned long long int x; 

Answer 2

Considerando quanto inesorabile C++ è solitamente, ho trovato alquanto sorprendente che lo standard permette effettivamente a delete puntatori nulli.

Answer 3

Un'altra risposta che potrei aggiungere sarebbe il qualificatore throw(). Per esempio:

void dosomething() throw() 
{ 
    // .... 
} 

void doSomethingElse() throw(std::exception) 
{ 
    // .... 
} 

Intuitivamente, questo mi sembra un contratto con il compilatore, indicando che questa funzione non è permesso di gettare le eventuali eccezioni ad eccezione di quelli elencati. Ma in realtà, questo non fa nulla al momento della compilazione. Piuttosto si tratta di un meccanismo in fase di esecuzione e non impedirà alla funzione di generare effettivamente un'eccezione. Ancora peggio, se viene lanciata un'eccezione non elencata, termina l'applicazione con una chiamata a std::terminate().

Answer 4

Non è molto noto che un iniziatore di array può saltare in indice come nella definizione di enumerazione.

// initializing an array of int 
int a[ 7] = { [5]=1, [2]=3, 2}; 
// resulting in 
int a[ 7] = { 0, 0, 3, 2, 0, 1, 0}; 

// initializing an array of struct 
struct { int x,y; } ar[ 4] = { [1].x=23, [3].y=34, [1].y=-1, [1].x=12}; 
// resulting in 
struct { int x,y; } ar[ 4] = { { 0, 0}, { 12, -1}, { 0, 0}, { 0, 34}}; 

// interesting usage 
char forbidden[ 256] = { ['a']=1, ['e']=1, ['i']=1, ['o']=1, ['u']=1}; 

La maggior parte di these vale anche per C++.

Answer 5

ho trovato un po 'sorprendente che

class aclass 
{ 
public: 
int a; 
}; 

some_function(aclass()); 

dovrà a inizializzati per 0 in some_function, mentre

aclass ac; 
some_function(ac); 

lascerà unitinitalized. Se si definisce esplicitamente il costruttore di default di aclass:

class aclass 
{ 
public: 
aclass(): a() {} 
int a; 
}; 

poi aclass ac; sarà anche inizializzare a-0.

Answer 6

Gli oggetti cambiano tipo durante la costruzione.

In particolare, quando si chiama una funzione virtuale da un costruttore, si non si chiama chiamando l'override più derivato. Piuttosto, stai chiamando l'implementazione dalla classe che stai creando attualmente.Se tale implementazione risulta essere 0 (pura funzione virtuale), il programma si arresta in modo anomalo in fase di runtime.

Un esempio semi-mondo reale:

class AbstractBase { 
    public: 
    AbstractBase() { 
     log << "Creating " << className() << endl; 
    } 
    protected: 
    virtual string className() const = 0; 
} 

class ConcreteGuy { 
    protected: 
    virtual string className() const { return "ConcreteGuy"; } 
} 

Al momento la costruzione di un oggetto ConcreteGuy, il programma terminerà con un messaggio di "chiamata puro virtuale funzione" errore.

Ecco perché chiamare le funzioni virtuali dai costruttori è considerato malvagio.

Answer 7

In C++ dichiarazioni valutare a qualcosa ...

int main() 
{ 
    "This is a valid C++ program!" 
    "I will list the first five primes:"; 
    2; 
    3; 
    5; 
    7; 
    11; 
}