¿Llamar al constructor de una clase vacía realmente usa alguna memoria?

Question

Supongamos que tengo una clase como

class Empty{ 
    Empty(int a){ cout << a; } 
} 

Y luego invocarlo usando

int main(){ 
    Empty(2); 
    return 0; 
} 

Will esta causa cualquier memoria que se asignará en la pila para la creación de un objeto "vacío"? Obviamente, los argumentos deben ser empujados a la pila, pero no quiero incurrir en gastos adicionales. Básicamente, estoy usando el constructor como un miembro estático.

La razón por la que quiero hacer esto es por las plantillas. El código real se parece

template <int which> 
class FuncName{ 
    template <class T> 
    FuncName(const T &value){ 
     if(which == 1){ 
      // specific behavior 
     }else if(which == 2){ 
      // other specific behavior 
     } 
    } 
}; 

que me permite escribir algo como

int main(){ 
    int a = 1; 
    FuncName<1>(a); 
} 

por lo que llego a especializar un parámetro de plantilla, al no tener que especificar el tipo de T. Además, espero que el compilador optimice las otras ramas dentro del constructor. Si alguien sabe si esto es cierto o cómo verificarlo, sería muy apreciado. También asumí que lanzar plantillas a la situación no cambia el problema de la "clase vacía" de arriba, ¿es así?

Answer 1

Citando BS:

¿Por qué es el tamaño de una clase vacía no es cero? Para garantizar que las direcciones de dos objetos diferentes serán diferentes. Por la misma razón, "nuevo" siempre devuelve punteros a objetos distintos. Consideremos:

class Empty { }; 

void f() 
{ 
    Empty a, b; 
    if (&a == &b) cout << "impossible: report error to compiler supplier"; 

    Empty* p1 = new Empty; 
    Empty* p2 = new Empty; 
    if (p1 == p2) cout << "impossible: report error to compiler supplier"; 
} 

hay una regla interesante que dice que una clase base vacía no tiene por qué ser representado por un byte separado:

struct X : Empty { 
    int a; 
    // ... 
}; 

void f(X* p) 
{ 
    void* p1 = p; 
    void* p2 = &p->a; 
    if (p1 == p2) cout << "nice: good optimizer"; 
} 

Esta optimización es seguro y puede ser más útil. Permite a un programador utilizar clases vacías para representar conceptos muy simples sin gastos generales. Algunos compiladores actuales proporcionan esta "optimización de clase base vacía".

Answer 2

Podría, podría ser, no, dependiendo de las circunstancias. Si dices:

Empty e; 
Empty * ep = & e; 

entonces, obviamente, las cosas tienen que ser asignadas.

Answer 3

Pruébalo y mira. Muchos compiladores eliminarán dichos objetos temporales cuando se les pida que optimicen su salida.

Si el desmontaje es demasiado complejo, a continuación, crear dos funciones con diferente número de tales objetos y ver si hay alguna diferencia en los lugares de la pila de objetos que les rodea, algo así como:

void empty1 (int x) 
{ 
    using namespace std; 

    int a; 
    Empty e1 (x); 
    int b; 

    cout << endl; 
    cout << "empty1" << endl; 
    cout << hex << int (&x) << " " << dec << (&x - &a) << endl; 
    cout << hex << int (&a) << " " << dec << (&a - &b) << endl; 
} 

y luego tratar ejecutando eso en comparación con una función empty8 con ocho vacíos creados. Con g ++ en x86, si toma la dirección de cualquiera de los vacíos obtiene una ubicación entre x y a en la pila, por lo tanto, incluye x en la salida. No puede suponer que el almacenamiento de los objetos terminará en el mismo orden en que se declararon en el código fuente.