Eu quero ser capaz de inicializar um vetor de tamanho 'TAMANHO' antes principal. Normalmente eu faria
static vector<int> myVector(4,100);
int main() {
// Here I have a vector of size 4 with all the entries equal to 100
}
Mas o problema é que eu gostaria de inicializar o primeiro item do vetor a ser de um determinado valor, e outro para outro valor.
Existe uma maneira fácil de fazer isso?
Tente isto:
static int init[] = { 1, 2, 3 };
static vector<int> vi(init, init + sizeof init / sizeof init[ 0 ]);
Além disso, ver std::generate(se você quiser inicializar dentro de uma função).
Um pouco hackish, mas você poderia fazer isso:
struct MyInitializer {
MyInitializer() {
myVector[0]=100;
//...
}
} myInitializer; // This object gets constructed before main()
Você pode usar lista separada por vírgulas de impulso .
Ou apenas criar uma função e chamar isso:
std::vector<int> init()
{
...
}
static std::vector<int> myvec = init()
Um pouco ineficiente talvez, mas que pode não importa para você agora, e com C ++ 0x e movê-lo será muito rápido.
Se você quiser evitar a cópia (para C ++ 03 e anteriores), use um smart-ponteiro:
std::vector<int>* init() {
return new std::vector<int>(42);
}
static boost::scoped_ptr<std::vector<int>> myvec(init());
Envolvê-la por uma classe:
class SpecialVector
{
public:
SpecialVector()
{
myVector[0] = 1;
myVector[1] = 4;
// etc.
}
const vector<int> & GetVector() const
{
return myVector;
}
private:
vector<int> myVector;
};
static SpecialVector SpVec;
int main() {
}
Aqui está uma solução alternativa:
#include <vector>
static std::vector<int> myVector(4,100);
bool init()
{
myVector[0] = 42;
return true;
}
bool initresult = init();
int main()
{
;
}
C ++ 0x permitirá listas inicializador para contentores normais, assim como agregados:
std::vector<int> bottles_of_beer_on_the_wall = {100, 99, 98, 97};
Obviamente não é padrão ainda, mas está supostamente apoiado por GCC 4.4. Não consigo encontrar documentação para ele em MSVC, mas Herb Sutter foi dizendo que sua c ++ 0x apoio está à frente da comissão de ...
Ao invés de usar um global, eu sugiro que é melhor usar um estático local. Como a inicialização do seu vector acontece antes principal é introduziu quaisquer exceções lançadas lá não vai ser pego por principal. Digamos, por exemplo, você tem um tipo que quando ele é construído pode lançar uma exceção:
class A {
public:
A() {
// ... code that might throw an exception
}
};
Para o seguinte inicialização, o try / catch no corpo principal não vai pegar a exceção lançada pelo construtor, e que o seu programa vai simplesmente morrer imediatame