c++ - remix - smart contracts ethereum

¿Cómo inicializo un vector stl de objetos que tienen constructores no triviales?

Question

supongamos que tengo la siguiente clase:

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

Y supongamos que esta clase no tiene un constructor trivial predeterminado MyInteger() . Siempre debo proporcionar un int para inicializarlo por alguna razón. Y luego supongamos que en algún lugar de mi código necesito un vector<MyInteger> . ¿Cómo inicializo cada componente MyInteger en este vector<> ?

Tengo dos situaciones (probablemente la solución sea la misma, pero las mencionaré de todos modos), una variable normal 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 solo en la lista de inicialización o debo escribir la inicialización a mano en el constructor MyFunClass (int, int)?

Esto parece muy básico, y sin embargo, de alguna manera lo perdí en mi libro y no puedo encontrarlo en la web.

Answer 1

Además de todas las respuestas que respondieron muy bien a la pregunta, en el caso de que su clase MyInteger no sea copiable, podría usar este truco: en lugar de crear el vector< MyInteger> , podría crear el vector< shared_ptr< MyInteger > >

Answer 2

Hay muchas maneras de llegar allí. Estos son algunos de ellos (sin ningún orden particular de presencia).

Utilice el vector(size_type n, const T& t) . 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))
{
}
};

Empuje los elementos al vector uno por uno. Esto podría ser útil cuando los valores deberían 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 el constructor predeterminado y / o usar algo que no sea std::vector .

Espero eso ayude.

Answer 3

Si los elementos del vector no son predecibles, entonces hay ciertas cosas que no se pueden hacer con el vector. No puedes escribir esto (ejemplo 1):

vector<MyInteger> foo(10);

Sin embargo, puede escribir esto (ejemplo 2):

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

(Esto solo requiere un constructor de copia). El segundo argumento es un inicializador para los elementos del vector.

En tu caso, también puedes escribir:

vector<MyInteger> foo(10, 37);

... ya que MyInteger tiene un constructor no explícito que toma "int" como argumento. Entonces el compilador convertirá 37 en MyInteger (37) y dará el mismo resultado que en el ejemplo 2.

Es posible que desee estudiar la documentación en std :: vector .

Answer 4

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