como declarar dinamicamente uma matriz de objects com um construtor em c + +

Eu queria saber se era possível criar uma matriz de objects quando o object precisa de coisas passadas para o construtor. Eu quero algo assim:

MyClass *myVar; myVar = new MyClass[num]; // I would like to specify the array size after declaration int i = 0; for(i = 0;i < num;i++) myVar[i] = new MyClass(0,0); // I would also like to populate the array with new objects 

Eu sei que isso funciona:

 MyClass *myVar; myVar = new MyClass[num]; 

mas isso só funciona quando o construtor não passa nada. O que estou tentando fazer é possível? Se sim, como faço isso?

EDIT: Eu descobri como fazê-lo com o uso de matrizes. Aqui está como eu fiz:

 MyClass **myVar; myVar = new MyClass *[num]; for(i = 0;i < num;i++) myVar[0] = new MyClass(0,0); 

Eu usaria vetores e tal, mas meu professor nos disse para usar matrizes básicas sempre que possível. A solução acima eu realmente consegui de algum código que meu professor escreveu. Obrigado a todos pela vossa ajuda!

 MyClass *myVar; myVar = new MyClass[num]; 

Na verdade, neste formulário, você não pode chamar o construtor que recebe o (s) parâmetro (s). Não é permitido pela especificação da linguagem.

No entanto, se você usar std::vector , que eu recomendo que você use, então você pode criar um construtor de chamada não padrão como:

 #include  //header file where std::vector is defined std::vector arr(num, MyClass(10,20)); 

Cria um vetor de num elementos, cada elemento é criado chamando construtor de cópia da class, passando MyClass(10,20) como argumento para ele.

O vetor também é bom porque agora você não precisa gerenciar a memory sozinho. Nem alocação manual, nem desalocação manual. Além disso, você pode saber o número de elementos chamando arr.size() qualquer momento. Você sempre sabe quantos elementos o vetor contém. Você também pode adicionar elementos a qualquer momento, apenas chamando a function de membro .push_back() como:

 arr.push_back(MyClass(20,30)); 

E agora você pode acessar elementos, assim como você acessa array, ou seja, usando index:

 f(arr[i]); // 0 <= i < arr.size(); 

Além disso, você pode usar iteradores que facilitam a programação idiomática, permitindo que você use várias funções header como:

 #include  //header file where std::for_each is defined std::for_each(arr.begin(), arr.end(), f); 

onde f é a function que recebe um argumento do tipo MyClass& (ou MyClass const & ) dependendo do que você deseja fazer em f .

Em C ++ 11, você pode usar lambda como:

 std::for_each(arr.begin(), arr.end(), [](const MyClass & m) { //working with m }); 

Em C ++ 0 x, esta gramática funciona, que pode chamar o construtor não-padrão em nova expressão:

 MyClass *myVar; myVar = new MyClass[2]{{10, 20},{20, 30}}; 

Mas duvido que funcione quando o número de elementos disponíveis apenas em tempo de execução.

A abordagem vetorial seria melhor, como mostrado na resposta de Nawaz.

Uma maneira que eu fiz isso no passado é usando um ponteiro duplo.

 MyClass ** myvar; myvar = new Myclass*[num] for(int i = 0; i < 4; i++){ *(myvar+i) = new Myclass(i);} 

Funciona com praticamente qualquer estrutura de controle que você possa imaginar, o único revés é que os objects não serão necessariamente consecutivos no heap.

Na verdade, você pode usar um posicionamento novo para lidar com isso:

 MyClass * myVar; myVar = reinterpret_cast(new char[num * sizeof(MyClass)]); int i = 0; for (i = 0; i < num; i++) { new(&myVar[i]) MyClass(0,0); } 

Você pode fazer algo assim também:

 MyClass *myVar[num]; for(int i = 0; i < num; i += 1) { myVar[i] = new MyClass(0, 0); }