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

字符串
实际上，在这种形式下，你不能调用带参数的构造函数。这是语言规范所不允许的。
但是，如果你使用std::vector，我推荐你使用，那么你可以创建一个vector调用非默认构造函数：

#include <vector> //header file where std::vector is defined

std::vector<MyClass>  arr(num, MyClass(10,20));

型
它创建了一个num元素的向量，每个元素都是通过调用类的复制构造函数来创建的，并将MyClass(10,20)作为参数传递给它。
vector也很好，因为现在你不需要自己管理内存。既不需要手动分配，也不需要手动释放。另外，你可以随时通过调用arr.size()来知道元素的数量。你总是知道vector包含多少元素。你也可以随时添加元素，只需调用.push_back()成员函数：

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

型
现在你可以访问元素，就像访问数组一样，即通过使用index：

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

型
此外，您可以使用迭代器来促进惯用编程，使您能够使用来自<algorithm>头部的各种算法函数：

#include <algorithm> //header file where std::for_each is defined

std::for_each(arr.begin(), arr.end(), f);

型
其中f是一个函数，它接受一个MyClass&（或MyClass const &）类型的参数，这取决于你想在f中做什么。
在C++11中，你可以使用lambda：

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

型

在C++0x中，这个语法可以工作，它可以在new表达式中调用非默认构造函数：

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

字符串
但我怀疑当元素的数量只在运行时可用时它是否有效。
矢量方法会更好，正如Nawaz的回答所示。

指针到指针的指针等价于：

• 指针数组
• vector<T*>指针向量。

我过去使用的一种方法是使用双指针。这种方法消除了向量数据结构的开销，并且需要更好的内存效率。

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

字符串
几乎可以与任何你能想象到的控制结构一起工作。
缺点是内存分配不连续，可能会影响大量num s的速度。

你也可以这样做：

MyClass *myVar[num];

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

字符串

实际上，你可以使用一个placement new来处理这个问题：

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

字符串

@Nawaz answer在使用vector方面非常好，但对我不起作用，因为它创建了相同对象的vector（所有对象都引用同一个对象）

class Graph
{
 public:
  Graph(long V); // none default Constructor
}
std::vector<Graph>  myGraph;
for (int i = 0; i < T; i++) // read all graphs
    {
        Graph newGraph(N);
        myGraph.push_back(newGraph);
    }

字符串