Le programme d'installation std::vector dans le constructeur de la classe

Je suis de la conception d'une classe qui a un std::vector<int> comme une variable d'instance. Je suis à l'aide d'un std::vector parce que j'ai besoin de définir sa taille au moment de l'exécution. Voici les parties pertinentes de mon code:

my_class.h:

#include <vector>
using std::vector;
class MyClass {
    int size;
    vector<int> vec;
}

my_class.cc:

#include "my_class.h"
using std::vector
MyClass::MyClass(int m_size) : size(m_size) {
     vec = new vector<int>(size,0);
}

Lorsque je tente de compiler je reçois ces messages d'erreur:

g++ -c -Wall my_class.cc -o my_class.o

my_class.cc: In constructor ‘MyClass::MyClass(int):

  my_class.cc:4 error: no match for ‘operator=’ in ‘((MyClass*)this)->My_Class::vec = ((*(const allocator_type*)(& std::allocator<int>())), (operator new(24u), (<statement>, ((std::vector<int>*)<anonymous>))))’

make: *** [my_class.o] Error 1

Cependant, lorsque je change la ligne incriminée:

vector<int> temp(size,0);
vec = temp;

Maintenant compile sans problème et je reçois le comportement désiré et peut accéder à mon vecteur de

vec[i]  //i having been defined as an int yada yada yada

Cette solution de contournement est d'accord, mais j'aimerais comprendre pourquoi il fonctionne et la première méthode échoue. Merci à l'avance.

new vector retourne un pointeur n'est pas une valeur, pour vous d'être en mesure d'affecter à votre variable membre vec
Ma conjecture est que vous venez de Java ou en C# et si donc, mes conseils sérieux est d'obtenir une bonne introduction à C++ livre premier.
Et merci de toujours poster le code réel via le copier+coller. Le code que vous avez posté est incomplète
Côté: avez-vous vraiment besoin de la size membre? Rappelons que les vecteurs de porter autour de leur taille, qui peut toujours être interrogé comme suit: vec.size().

OriginalL'auteur fenkerbb | 2012-07-10

c++constructor new-operator stdvector

22

Viens de faire:
```
MyClass::MyClass(int m_size) : size(m_size), vec(m_size, 0)
```
Vous semblent déjà connaître initialiseur de listes, pourquoi ne pas initialiser le vecteur directement?
```
vec = new vector<int>(size,0);
```
est illégale, car new retourne un pointeur et dans votre cas, vec est un objet.

Votre seconde option:
```
vector<int> temp(size,0);
vec = temp;
```
bien qu'il compile, ne surcharge de travail pour peu de gain. Au moment où vous atteignez la cession, les deux vecteurs ont déjà été construits et rejetés par la suite.

IIRC cela va entraîner des avertissements avec GCC en raison de l'ordre de l'initialisation - vous devez commander les initialisations dans la liste des initialiseurs de la même manière que les variables membres de la classe.
Merci pour le commentaire, basée sur elle, j'ai essayé de faire vec = *(new vector<int>(szie,0)); et qui a également travaillé, mais je vais utiliser la liste des initialiseurs merci!
ce que vous avez fait est mal - il crée une fuite de mémoire. new alloue de la mémoire sur le tas, crée un objet et renvoie un pointeur vers elle. Ce que vous avez fait a été affecter le contenu de cet objet à votre membre de l'objet et de l'oublier à propos de l'origine -, mais il reste encore alloué à jamais. Lorsque vous appelez new vous devez enregistrer l'adresse, il retourne (un pointeur) et éventuellement appel delete sur le pointeur!
non, ne fais pas *(new...). Fuite de mémoire.

OriginalL'auteur
10

L'utilisation de vecteur est légal dans votre classe, le problème est de savoir comment vous l'initialiser:
```
#include <vector>

class MyClass {
public:
    MyClass(int m_size);

    //... more things...
private:
    int size;
    vector<int> vec;
}
```
De l'affectation d'un pointeur vers un nouvel objet vectoriel, comme si ce vecteur de l'objet n'a pas été initialisé.
```
vec = new vector<int>(size,0);
```
Si vous voulez vraiment que cela fonctionne, alors vous devez déclarer votre vec objet:
```
vector<int> * vec;
```
Et n'oubliez pas d'ajouter un destructeur:
```
MyClass::~MyClass {
    delete vec;
}
```
Pourquoi il travail quand vous avez abandonné le new particule? Parce que vous êtes la création d'un nouvel objet vector, et écraser celui de votre classe (ce qui ne garantit pas l'original pour être correctement éliminés, cependant).

Vous avez réellement n'avez pas besoin de le faire. Votre vector objet est déjà initialisé (son constructeur par défaut appelé) lorsque vous avez atteint le constructeur de Maclasse. Si vous voulez juste être sûr que la mémoire est réservé pour size éléments:
```
MyClass::MyClass(int m_size): size(m_size) {
    vec.reserve( size );
}
```
Si vous voulez que votre vecteur d'avoir size éléments, puis:
```
MyClass::MyClass(int m_size): size(m_size), vec(m_size, 0)
    {}
```
Enfin, comme l'un des commentateurs de points, la taille n'est pas réellement nécessaire une fois que le vecteur a été construit. De sorte que vous pouvez vous débarrasser de la size membre:
```
class MyClass {
public:
    MyClass(int m_size): vec(m_size, 0)
        {}

    unsigned int getSize() const
        { return vec.size(); }

    //... more things...
private:
    vector<int> vec;
}
```
Espère que cette aide.

Le vector sait que sa taille, si tous les size est en train de faire est de garder la trace du nombre d'éléments dans vector, proposez-vous vous débarrasser de size.
Très vrai, je vais modifier ma réponse à impliquer votre commentaire.

OriginalL'auteur

#include <vector>
#include <iostream>
#include <string>
#include <typeinfo>
using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::to_string;
class Parse
{
private:
string         m_str;
vector<string> m_vec;
public:
//Constructor with all defaults (1 of 4 constructors)
Parse(){ 
cout << "\ncreating class with all default values\n";
m_str = "";
m_vec.push_back("");    
}
//Constructor with all cases used
Parse  (string         &tmp_str,
vector<string> tmp_vec):
m_str          (tmp_str),
m_vec          (tmp_vec)
{
cout << "Your vector contains " + to_string(m_str.size()) + " arguments\n";
}
//Constructor with other contents given but not vector
Parse  (string         &tmp_str): 
m_str          (tmp_str)
{
m_vec.push_back("");
}
//Constructor with only Vector given but not other contents
Parse  (vector<string>   tmp_vec):
m_vec           (tmp_vec)
{
m_str = "";
}
string get_str_var(){return m_str;}
void classed_print_vector_strings()
{
for (string i : m_vec){ cout << i << " \n";}
}
};
//rm ./class_vector; g++ class_vector.cpp -o class_vector -std=c++17; ./class_vector arg1 arg2 arg3
int main(int argc, char *argv[])
{
//turn **argv to a vector
vector<string> args(argv, argv + argc);
//iterate from argv through argv+argc
//initialize with default arguments.
Parse tracker1;
//initalize with all used arguments
Parse tracker2(args[0], args);
//initalize with only the vector
Parse tracker3(args);
//initalzie without the vector, but with another arg
Parse tracker4(args[0]);
cout << "\nTracker 1 ---------------------\n";
tracker1.classed_print_vector_strings();
cout << "\nTracker 2 ---------------------\n";
tracker2.classed_print_vector_strings();
cout << "\nTracker 3 ---------------------\n";
tracker3.classed_print_vector_strings();
cout << "\nTracker 4 ---------------------\n";
tracker4.classed_print_vector_strings();
return 0;
}
//rm ./class_vector; g++ class_vector.cpp -o class_vector -std=c++17; ./class_vector arg1 arg2 arg3
//This will show you how to create a class that will give 
//you the option to initilize the class with or without 
//the vector with other arguments present and/or not present. 
// My Background. . .  
// github.com/Radicalware  
// Radicalware.net  
// https://www.youtube.com/channel/UCivwmYxoOdDT3GmDnD0CfQA/playlists

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.