Est-ce que l'appel du constructeur d'une classe vide utilise réellement de la mémoire?

Question

Supposons que j'ai une classe comme

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

Et puis je l'invoquons en utilisant

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

Est-ce que cette cause une mémoire à allouer sur la pile pour la création d'un objet « vide »? Évidemment, les arguments doivent être poussés sur la pile, mais je ne veux pas encourir de frais supplémentaires. Fondamentalement, j'utilise le constructeur en tant que membre statique.

La raison pour laquelle je veux faire cela est à cause de modèles. Le code actuel ressemble

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

qui me permet d'écrire quelque chose comme

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

pour que je sois à se spécialiser un paramètre de modèle, sans avoir à spécifier le type de T. En outre, j'espère que le compilateur optimisera les autres branches à l'intérieur du constructeur. Si quelqu'un sait si c'est vrai ou comment vérifier, ce serait grandement apprécié. J'ai supposé aussi que jeter des modèles dans la situation ne change pas le problème de la "classe vide" d'en haut, n'est-ce pas?

Answer 1

Stroustrup Citation:

Pourquoi la taille d'une classe vide non nul? Pour vous assurer que les adresses de deux objets différents seront différentes. Pour la même raison, "nouveau" renvoie toujours des pointeurs vers des objets distincts. Tenir compte:

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

Il y a une règle intéressante qui dit qu'une classe de base vide n'a pas besoin d'être représenté par un octet séparé:

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

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

Cette optimisation est sûr et peut être le plus utile. Il permet à un programmeur d'utiliser des classes vides pour représenter des concepts très simples sans surcharge. Certains compilateurs actuels fournissent cette "optimisation de classe de base vide".

Answer 2

Cela pourrait, peut-être, pas, selon les circonstances. Si vous dites:

Empty e; 
Empty * ep = & e; 

alors évidemment les choses doivent être allouées.

Answer 3

Essayez-le et voir. De nombreux compilateurs élimineront ces objets temporaires lorsqu'on leur demandera d'optimiser leur sortie.

Si le démontage est trop complexe, puis créer deux fonctions avec un nombre différent de ces objets et de voir s'il y a une différence dans les emplacements de pile d'objets qui les entourent, quelque chose comme:

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

puis essayer en cours d'exécution que par rapport à une fonction empty8 avec huit vides créés. Avec g ++ sur x86, si vous prenez l'adresse de l'un des vides, vous obtenez un emplacement entre x et a sur la pile, incluant donc x dans la sortie. Vous ne pouvez pas supposer que le stockage des objets se terminera dans le même ordre que celui déclaré dans le code source.