C++ vecteur push_back

Quelle est la bonne façon de pousser un nouvel objet élément sur un std::vector? Je veux que les données allouées dans le vecteur. Sera-ce de copier l'objet newradio dans le vecteur et ensuite se débarrasser de newradio quand elle est hors de portée (par exemple de la pile)?

vector<Radio> m_radios;
Radio newradio(radioNum);
m_radios.push_back(newradio);

Et puis, quand je libre de l'objet contenant m_radios, ce sera gratuit toute la mémoire allouée par le vecteur?

InformationsquelleAutor user623879 | 2011-09-11

c++vector

36

std::vector gère sa propre mémoire. Cela signifie que, lorsque le destructeur d'un vecteur est appelé la mémoire occupée par le vecteur est libéré. std::vector invoque également un objet destructeur quand il est enlevé (par erase, pop_back, clear ou le vecteur du destructeur).

Quand vous faites cela:
```
Radio newradio(radioNum);
m_radios.push_back(newradio);
```
Vous ajoutez une copie de newradio (créé à l'aide de Radios'constructeur de copie) pour le vecteur. newradio sera détruite quand elle est hors de portée, et la copie sera détruit quand il est supprimé à partir du vecteur (comme pour n'importe quel objet).

C'est un point important: std::vector seulement les magasins de copies d'un objet, ce qui signifie que l'objet doit avoir un sens constructeur de copie (et un opérateur d'affectation, mais c'est un autre problème). Si vous avez un vecteur de pointeurs, alors que le pointeur lui-même va être copié, et non pas ce qu'il désigne. Notez que ce comportement est le même pour chaque conteneur standard (comme std::list ou std::set).

En règle générale, si vous n'êtes pas à l'aide de pointeurs, alors vous n'avez pas à vous soucier de libération de la mémoire vous-même.

En C++11, la plupart des conteneurs (y compris les vector) ont un emplace_back méthode qui construit un objet en place à la fin du conteneur. Il faut un tas de paramètres et appelle le constructeur qui correspond le mieux à ces paramètres (ou échoue si aucun constructeur existent), l'utilisation de ce constructeur pour créer l'objet, sans aucune copie, à la fin du conteneur. Ainsi, le code ci-dessus peut être réécrite comme:
```
m_radios.emplace_back(radioNum); //construct a Radio in place, 
                                 //passing radioNum as the constructor argument
```
Aussi en C++11, les conteneurs sont généralement déplacer au courant, donc ils n'ont plus besoin d'objets pour être copiables: si elles sont mobiliers, puis le conteneur va déplacer son contenu (p. ex. lors de réaffectations, par exemple). Copiables types sont encore nécessaires si vous souhaitez copier le vecteur.
- Bien que correcte à l'époque, cette réponse pourrait utiliser une mise à jour de mentionner emplace_back
- Très bon point, M. Canard.
InformationsquelleAutor Etienne de Martel
4

push_back() permettra de stocker une copie de son argument dans le vecteur. Aussi longtemps que Radio met en œuvre correcte de la valeur de la sémantique, il n'y aura pas de problèmes avec elle.

InformationsquelleAutor K-ballo
1

Oui poussant newRadio va pousser une copie de la Radio de l'objet dans le vecteur. Vous n'avez pas besoin de libérer le vecteur car il est en local uniquement de sorte qu'il sera détruit une fois que vous êtes hors de sa portée. Si par exemple vous avez écrit
```
vector<Radio> *m_radios = new vector<Radio>();
```
Ensuite, vous avez pour libérer de la mémoire en appelant le vecteur destructeur manuellement.

InformationsquelleAutor Jesus Ramos

Essayez ceci:

#include<iostream.h>
#include<vector.h>

class base
{
int i;
public:

    base(int z=0){i=z;cout<<"okk constructor "<<i<<" called\n";}
    base(const base& b1){i=b1.i;cout<<"copy constructor "<<i<<" called\n";}
    void display(){cout<<" val is "<<i<<" \n";}
    ~base(){cout<<"destructor of "<<i<<" base called\n";}
};


    int main()
    {
        cout<<"before anything\n";
        vector<base> basev;
        base baseobj1(1);
        base baseobj2(2);
        base baseobj3(3);
        base baseobj4(4);
        base baseobj5(5);
        base baseobj6(6);
        base baseobj7(7);
        base baseobj8(8);
        base baseobj9(9);
        base baseobj10(10);


        basev.push_back(baseobj1);
        cout<<"second push back\n";
        basev.push_back(baseobj2);
        cout<<"third push back\n";
        basev.push_back(baseobj3);
        cout<<"fourth push back\n";
        basev.push_back(baseobj4);
        cout<<"fifth push back\n";
        basev.push_back(baseobj5);
        cout<<"sixth push back\n";
        basev.push_back(baseobj6);
        cout<<"seventh push back\n";
        basev.push_back(baseobj7);
        cout<<"eighth push back\n";
        basev.push_back(baseobj8);
        cout<<"ninth push back\n";
        basev.push_back(baseobj9);
        cout<<"10th push back\n";
        basev.push_back(baseobj10);
        cout<<"after all push back\n";


        cout<<"before clear\n";
        basev.clear();
        cout<<"after clear\n";


}

de sortie:

before anything
okk constructor 1 called
okk constructor 2 called
okk constructor 3 called
okk constructor 4 called
okk constructor 5 called
okk constructor 6 called
okk constructor 7 called
okk constructor 8 called
okk constructor 9 called
okk constructor 10 called
copy constructor 1 called
second push back
copy constructor 1 called
copy constructor 2 called
destructor of 1 base called
third push back
copy constructor 1 called
copy constructor 2 called
copy constructor 3 called
destructor of 1 base called
destructor of 2 base called
fourth push back
copy constructor 4 called
fifth push back
copy constructor 1 called
copy constructor 2 called
copy constructor 3 called
copy constructor 4 called
copy constructor 5 called
destructor of 1 base called
destructor of 2 base called
destructor of 3 base called
destructor of 4 base called
sixth push back
copy constructor 6 called
seventh push back
copy constructor 7 called
eighth push back
copy constructor 8 called
ninth push back
copy constructor 1 called
copy constructor 2 called
copy constructor 3 called
copy constructor 4 called
copy constructor 5 called
copy constructor 6 called
copy constructor 7 called
copy constructor 8 called
copy constructor 9 called
destructor of 1 base called
destructor of 2 base called
destructor of 3 base called
destructor of 4 base called
destructor of 5 base called
destructor of 6 base called
destructor of 7 base called
destructor of 8 base called
10th push back
copy constructor 10 called
after all push back
before clear
destructor of 1 base called
destructor of 2 base called
destructor of 3 base called
destructor of 4 base called
destructor of 5 base called
destructor of 6 base called
destructor of 7 base called
destructor of 8 base called
destructor of 9 base called
destructor of 10 base called
after clear
destructor of 10 base called
destructor of 9 base called
destructor of 8 base called
destructor of 7 base called
destructor of 6 base called
destructor of 5 base called
destructor of 4 base called
destructor of 3 base called
destructor of 2 base called
destructor of 1 base called

Merci de modifier votre réponse et de formater le code afin de le rendre lisible.
Je ne comprends pas ce qui se passe dans ce code :S quelqu'un pourrait-il m'expliquer? Merci

InformationsquelleAutor Monotosh Mondal

0

Yup, radioNum sera copié en m_radios. Tant que vous n'êtes pas la désallocation de pointeurs quand newradio.~Radio(); se produit (hors de portée), c'est OK. Si m_radios, ou une sous-classe utilise des pointeurs, vous aurez besoin de passer à l' pointeurs intelligents (shared_ptr).

Quand m_radios est hors de portée, le destructeur est appelé automatiquement, et tous les trucs std::vector détient est libéré.

InformationsquelleAutor Mateen Ulhaq
0

En plus d'autres réponses que de vérifier que l'objet est copié dans le récipient lors de l'utilisation de push_back via des appels au constructeur de copie, vous pouvez également garder à l'esprit les nouvelles emplace_back fonctionnalité ajoutée avec c++0x.

Appel emplace_back permet de contourner la création de tous les objets temporaires et ont l'objet construit dans l'intérieur du récipient directement. emplace_back est un varardic modèle de fonction qui accepte les paramètres que vous devez passer au constructeur de votre objet, donc dans ce cas:
```
std::vector<Radio> m_radios;
m_radios.emplace_back(radioNum);
```
ne créera aucun intermédiaire temporaires. Cela peut être utile si vos objets sont chers à copier.

Espère que cette aide.

InformationsquelleAutor Darren Engwirda
0

Par défaut, std::vector gère la mémoire elle-même en utilisant le constructeur de copie de la classe sous-jacente. Ainsi, il agit un peu comme si l'élément du vecteur est une variable locale (lorsque le vecteur est hors de portée, l'élément est détruite).

Lorsque vous ne souhaitez pas ce comportement, vous pouvez utiliser un vector de pointeur ou boost::ptr_vector à la place.

InformationsquelleAutor nuKs

Vous devez vous connecter pour publier un commentaire.