Où (dans quel segment de mémoire) sont des objets (d'une classe) stockés en C++?

Question

Prenons la classe suivante, par exemple

class Shape{ 
    public: 
     Circle (int x): number(x){} 
     virtual area() {return x**2;} 

    private: 
     int number; 
} 

En principal, nous créons les objets

int main(){ 
    Shape *foo = new Shape(8); 
    Shape *bar = new Shape(65); 
    Shape &obj1 = *foo, &obj2 = *bar; 
} 

Je crois que les objets 1 et 2 sont stockés dans le tas. Pourquoi donc? Comme une question secondaire. Est-ce que le mot-clé virtual, ou/et la façon dont les objets sont définis (par exemple, obj1 = * foo), ont un impact sur leur positionnement dans la mémoire?

Answer 1

Il existe (grosso modo) deux types d'objets W.R.T. leur gestion de la mémoire:

1. objets Un peut être entièrement construit lors de la compilation
2. Un objet ne peut être entièrement construit en utilisant des informations qui ne sont pas disponibles qu'après le programme est exécuté

Par exemple , tout objet de type constexpr peut être entièrement évalué et construit pendant la compilation et peut donc être placé dans un segment de données de mémoire en tant qu'optimisation (du point de vue puriste, il est valide, mais loin d'être optimal, de construire de tels objets pendant l'exécution Mais cela va gaspiller les cycles CPU et faire l'initialisation/démarrage plus long).

Voici quelques exemples de ces objets:

const char * const helloWorld = "Hello, world!"; 
struct TSilly{ 
    TSilly(int _i = 0) : i(_i) {} 
    int i; 
}; 
const TSilly silly1; 
const TSilly silly2(42); 
TSilly silly3; // doesn't have to be constexpr to qualify for static allocation. 
       // This one you can declare as /*extern TSilly silly3;*/ in 
       // header file and access from other compilation units 
static TSilly silly4; // can be local to compilation unit, too 

int main() 
{ 
    return 0; 
} 

Tous les autres objets devraient attendre jusqu'à ce que l'exécution à construire.

Des exemples de tels objets:

const char * exeName1; // statically allocated by compiler 

int main(int argc, char **argv) 
{ 
    exeName1 = argv[0]; // now points to a string 

    // buffer is allocated in free storage (heap) bu variable itself is on stack 
    char * exeName2 = new char[strlen(argv[0] + 1]; 
    strcpy(exeName2, argv[0]); // now contains a COPY of a string 

    char exeName3[1024]; // likely allocated on stack, be careful with that as stack space is limited 
    strncpy(exeName3, argv[0], 1024); // will COPY at most 1023 characters from a string 

    delete [] exeName2; // don't forget to clean up 
    // exename3 will be auto-cleaned when we exit the function 

    return 0; 
} 

Comme vous pouvez le voir un objet en C++ sera mis dans un segment de données ou dans une mémoire libre (tas) en fonction de sa durée de vie.

Seuls les objets alloués dynamiquement sont garantis d'être mis en mémoire libre. Je ne pense pas que la spécification fasse une promesse d'utilisation de segments de données pour objets alloués statiquement - il appartient au compilateur d'effectuer et d'utiliser cette optimisation.

Pour plus d'informations, voir "Classes de stockage C++".

Il existe de nombreux sujets avancés sur la gestion de la mémoire que vous voudrez peut-être examiner. Le plus pertinent à cette discussion est probablement le constructeur in-place qui vous permet d'avoir un objet d'exécution construit dans une mémoire allouée dans le segment de données de l'exécutable.