¿Cuáles son los elementos más sorprendentes del estándar C++?

Question

He decidido familiarizarme más con mi lenguaje de programación favorito, pero solo leyendo el estándar es aburrido.

¿Cuáles son los elementos más sorprendentes, contrarios a la intuición o simplemente extraños de C++? ¿Qué te ha sorprendido lo suficiente como para haber corrido hacia tu compilador más cercano para comprobar si es realmente cierto?

Voy a aceptar la primera respuesta que no voy a creer, incluso después de Lo he probado. :)

Answer 1

El orden de varios declaradores es en realidad desordenada:

volatile long int const long extern unsigned x; 

es lo mismo que

extern const volatile unsigned long long int x; 

Answer 2

Teniendo en cuenta lo implacable C++ suele ser, me pareció un poco sorprendente que la norma permite en realidad a delete punteros nulos.

Answer 3

Otra respuesta que podría agregar sería el calificador throw(). Por ejemplo:

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

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

Intuitivamente, esto parece como un contrato con el compilador, lo que indica que esta función no se le permite lanzar cualquier excepción a excepción de los enumerados. Pero en realidad, esto no hace nada en tiempo de compilación. Más bien es un mecanismo en tiempo de ejecución y no evitará que la función arroje una excepción. Peor aún, si se lanza una excepción no listada, termina su aplicación con una llamada al std::terminate().

Answer 4

No es muy conocido que un iniciador de matriz puede saltar en el índice como en la definición de enumeración.

// 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}; 

mayoría de these son ciertas para C++ también.

Answer 5

me pareció algo sorprendente que

class aclass 
{ 
public: 
int a; 
}; 

some_function(aclass()); 

tendrá a inicializado a 0 en some_function, mientras

aclass ac; 
some_function(ac); 

lo dejará unitinitalized. Si define explícitamente el constructor por defecto de aclass:

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

continuación aclass ac; también inicializar a-0.

Answer 6

Objetos de tipo de cambio durante la construcción.

En particular, cuando se llama a una función virtual desde un constructor, se llamará a no llamando a la anulación más derivada. Por el contrario, está llamando a la implementación de la clase que está actualmente construyendo.Si esa implementación es 0 (función virtual pura), su programa se bloqueará en el tiempo de ejecución.

Un ejemplo semi-real-mundo:

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

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

Al construir un objeto ConcreteGuy, el programa terminará con un mensaje de "llamar la función virtual pura" de error.

Es por eso que llamar a las funciones virtuales de los constructores se considera malo.

Answer 7

En C++ declaraciones evaluar a algo ...

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