supongamos que tenemos la siguiente clase:

class MyInteger {
private:
  int n_;
public:
  MyInteger(int n) : n_(n) {};
  //MORE STUFF
};

Y supongamos esta clase no tiene un valor predeterminado trivial constructor MyInteger(). Yo siempre debe suministrar una int para inicializar por alguna razón. Y, a continuación, supongamos que en alguna parte de mi código necesito un vector<MyInteger>. ¿Cómo puedo inicializar cada MyInteger de los componentes de esta vector<>?

Tengo dos situaciones (probablemente la solución es la misma, pero voy a estado de todos modos), una normal de la variable dentro de una función:

int main(){
    vector<MyInteger> foo(10);  //how do I initialize each 
                                //MyInteger field of this vector? 
    doStuff(foo);
}

y como datos en una clase:

class MyFunClass {
private:
   vector<MyInteger> myVector;

public:
   MyFunClass(int size, int myIntegerValue) : myVector(size) {}; 
   //what do I put here if I need the 
   //initialization to call MyInteger(myIntegerValue) for all 
   //components of myVector?
};

Es posible hacerlo sólo en la lista de inicialización o debo escribir la inicialización con la mano en el MyFunClass(int, int) constructor?

Esto parece tan básico, y sin embargo de alguna manera me perdí inmy libro y no lo puede encontrar en la web.

  • Si el entero ser el mismo para todas las instancias dentro del vector?
  • Es lo suficientemente bueno. Sólo quiero aprender cómo inicializar el vector. El código real donde esta duda parecía no es exactamente esto. Yo sólo quería un simple código con el mismo problema.
  • En mi código real tengo un vector de gráficos y una clase que es una colección de gráficos, y estoy usando un vector<Graph> como un contenedor. El problema es que el número de gráficos en la colección debe ser el mismo que el tamaño de los Gráficos, así que tienen que pasar para que el Gráfico constructor de la misma int paso al constructor de vector.

5 Comentarios

  1. 30

    Hay muchas maneras de llegar allí. Aquí están algunos de ellos (en ningún orden en particular, de la presencia).

    Uso vector(size_type n, const T& t) constructor. Inicializa el vector con n copias de t. Por ejemplo:

    #include <vector>
    
    struct MyInt
    {
        int value;
        MyInt (int value) : value (value) {}
    };
    
    struct MyStuff
    {
        std::vector<MyInt> values;
    
        MyStuff () : values (10, MyInt (20))
        {
        }
    };

    Inserción de elementos en el vector de uno en uno. Esto puede ser útil cuando los valores deben ser diferentes. Por ejemplo:

    #include <vector>
    
    struct MyInt
    {
        int value;
        MyInt (int value) : value (value) {}
    };
    
    struct MyStuff
    {
        std::vector<MyInt> values;
    
        MyStuff () : values ()
        {
            values.reserve (10); //Reserve memory not to allocate it 10 times...
            for (int i = 0; i < 10; ++i)
            {
                values.push_back (MyInt (i));
            }
        }
    };

    Otra opción es la lista de inicialización del constructor, si C++0x es una opción:

    #include <vector>
    
    struct MyInt
    {
        int value;
        MyInt (int value) : value (value) {}
    };
    
    struct MyStuff
    {
        std::vector<MyInt> values;
    
        MyStuff () : values ({ MyInt (1), MyInt (2), MyInt (3) /* ... */})
        {
        }
    };

    Por supuesto, hay una opción para proporcionar constructor predeterminado y/o usar algo distinto std::vector.

    Espero que ayude.

    • +1 para el C++0x inicialización. Se me pegaba a él!
    • Hum! ¿G++ es compatible con C++0x todavía?
    • Sí. Consulte gcc.gnu.org/projects/cxx0x.html
    • Ahora que es de 2017, probablemente me inicio con el C++11 inicialización ejemplo.
    • Alternativamente, en los miembros de la lista de inicialización de MyStuff por defecto del cto r, puede utilizar el uniforme de inicialización así: MyStuff () : values{ {1}, {2}, {3} } {}
  2. 11

    Si los elementos del vector, no por defecto-edificable, entonces hay ciertas cosas que no puedes hacer con el vector. Usted no puede escribir esto (ejemplo 1):

    vector<MyInteger> foo(10);

    Sin embargo, puede escribir esto (ejemplo 2):

    vector<MyInteger> foo(10, MyInteger(37));

    (Esto sólo requiere un constructor de copia.) El segundo argumento es un archivo de inicialización de los elementos del vector.

    En su caso, también podríamos escribir:

    vector<MyInteger> foo(10, 37);

    …desde MyInteger tiene un no-constructor explícito de tomar «int» como argumento. Por lo que el compilador de fundición de 37 a MyInteger(37) y dar el mismo resultado que en el ejemplo 2.

    Usted puede ser que desee para el estudio de la documentación en std::vector.

  3. 6
    vector<MyInteger> foo(10, MyInteger(MY_INT_VALUE));
    
    MyFunClass(int size, int myIntegerValue) : myVector(size, MyInteger(myIntegerValue)) {}; 
  4. 6

    Además de todas las respuestas que respondieron a la pregunta, muy bien, en caso de que su clase MyInteger no es copia-edificable, puede utilizar este truco : en lugar de crear vector< MyInteger>, podría crear vector< shared_ptr< MyInteger > >

  5. 1

    De inicialización listas pueden ser utilizadas sin referencia a los objetos subyacentes.

    #include <string>
    #include <vector>
    using namespace std;
    
    
    class Test
    {
       public:
       struct NumStr
       {
          int num;
          string str;
       };
    
       Test(vector<int> v1,vector<NumStr> v2) : _v1(v1),_v2(v2) {}
       vector<int> _v1;
       vector<NumStr> _v2;
    };
    
    int main()
    {
       Test t={ {1,2,3}, {{1,"one"}, {2,"two"}, {3,"three"}} };
       cout << t._v1[1] << " " << t._v2[1].num << " " << t._v2[1].str << endl;
       return 0;
    }

    de salida: 2 de 2 dos

Dejar respuesta

Please enter your comment!
Please enter your name here