C++ 序列向量

我有一个数据结构Seq，它继承了类向量，但有一些额外的功能。 使用此数据结构Seq，我有一个预定义的数据结构：

typedef Seq< vector<int> > MxInt2d;

只是我想我必须初始化这个向量，我没有它的构造函数。我应该写一个构造函数来初始化它吗

---

因此，如果一方面我有以下数据结构的声明：

    MxInt2d myEdges_;

然后初始化。 另一方面，变量循环的声明：

 vector<MxInt2d> loops;

向量循环；

如果我想在循环[0]中复制MyEdge_的前5个元素，我将使用以下语法：

for (int i=0;i<5;i++)
  loops[0].push_back(myEdges_[i]);

---

for（int i=0；i除非必须，否则不要使用指针。再次使用
vector
：

vector<MxInt2d> loops;

只有在填充了
循环之后
才能开始填充其元素。
除非必须，否则不要使用指针。再次使用
向量
：

vector<MxInt2d> loops;

只有在填充了
循环之后
才能开始填充其元素。
在进入问题之前——观察：

您是否继承了向量？派生向量不是一个好主意。所有标准STL容器，没有虚拟析构函数，没有类虚析构函数的公共继承是在进入问题之前的主要C++ NO./P>< P>。
你是否继承了向量？派生向量不是一个好主意。所有标准的STL容器，都没有虚拟析构函数，并且从没有虚拟析构函数的类公开继承是一个主要的C++ NO.NO./P>< P>从STL容器继承不是一个好主意，因为它们没有虚拟析构函数，这可能导致下一个。如果您试图通过基指针删除派生指针（希望我没有弄错）。
从STL容器继承不是一个好主意，因为它们没有虚拟析构函数，如果您试图通过基指针删除派生指针，这可能会导致欠定义行为（希望我做对了）如果您可以创建MxInt2d的数组/向量，而不是将其作为指针。
不，不一定。std:：vector会将所有元素初始化为0，因此，如果这是您需要的，您就不必编写自定义构造函数。
不，不一定。std:：vector会将所有元素初始化为0，因此，如果这是您需要的，您就不必重新编写一个自定义的构造函数。
 数组在C++中是邪恶的。对于几乎任何可以使用数组的任何东西，都可以使用向量。一个常见的问题；初始化的问题可以得到解决。参阅本讨论。< /P>
因此，可以毫无问题地使用“向量循环”

在C++中，数组是邪恶的。你可以用矢量来表示几乎任何可以使用数组的向量。一个常见的问题；初始化的问题可以得到解决。参阅这个讨论。< /P>
因此，可以毫无问题地使用“向量循环”

嗯，
你这里有几个问题

第一，你不应该从vector派生。如果你需要用vector编写自定义代码，你应该用你的自定义代码编写一个类，它有一个vector，而不是一个vector。例如：

class Seq
{
public:
   // assorted constructors

// construct vec_ with zero elements
   Seq() {}; 

// construct vec_ with one element
   Seq(int singleItemToAdd) 
: vec_(1, singleItemToAdd) {};

// construct vec_ with 'multipleItemsToAdd' elements
   Seq(const int* multipleItemsToAdd, size_t numItemsToAdd) 
: vec_(multipleItemsToAdd,multipleItemsToAdd+numItemsToAdd) {}; 


   // assorted custom operations (instead of deriving from vector)
   void customSeqOperation() const
   {
      /// your custom stuff here
      :   :
   }
private:
   vector<int> vec_;
};

class-Seq
{
公众：
//各种构造
//用零元素构造向量
Seq（）{}；
//用一个元素构造向量
序号（int singleItemToAdd）
：vec_1，singleItemToAdd{}；
//使用“multipleItemsToAdd”元素构造向量
Seq（常数int*倍数stoadd，大小numItemsToAdd）
：vec_（multipleItemsToAdd，multipleItemsToAdd+numItemsToAdd）{}；
//分类自定义操作（而不是从向量派生）
void customSeqOperation（）常量
{
///你的定制物品在这里
:   :
}
私人：
向量向量；
};

下一个问题是，您说这段代码可以编译，但在运行时崩溃：

vector<MxInt2d> loops;
for (int i=0;i<5;i++)
  loops[0].push_back(myEdges_[i]);

向量循环；
对于（inti=0；i，这里有几个问题

第一，你不应该从vector派生。如果你需要用vector编写自定义代码，你应该用你的自定义代码编写一个类，它有一个vector，而不是一个vector。例如：

class Seq
{
public:
   // assorted constructors

// construct vec_ with zero elements
   Seq() {}; 

// construct vec_ with one element
   Seq(int singleItemToAdd) 
: vec_(1, singleItemToAdd) {};

// construct vec_ with 'multipleItemsToAdd' elements
   Seq(const int* multipleItemsToAdd, size_t numItemsToAdd) 
: vec_(multipleItemsToAdd,multipleItemsToAdd+numItemsToAdd) {}; 


   // assorted custom operations (instead of deriving from vector)
   void customSeqOperation() const
   {
      /// your custom stuff here
      :   :
   }
private:
   vector<int> vec_;
};

class-Seq
{
公众：
//各种构造
//用零元素构造向量
Seq（）{}；
//用一个元素构造向量
序号（int singleItemToAdd）
：vec_1，singleItemToAdd{}；
//使用“multipleItemsToAdd”元素构造向量
Seq（常数int*倍数stoadd，大小numItemsToAdd）
：vec_（multipleItemsToAdd，multipleItemsToAdd+numItemsToAdd）{}；
//分类自定义操作（而不是从向量派生）
void customSeqOperation（）常量
{
///你的定制物品在这里
:   :
}
私人：
向量向量；
};

下一个问题是，您说这段代码可以编译，但在运行时崩溃：

vector<MxInt2d> loops;
for (int i=0;i<5;i++)
  loops[0].push_back(myEdges_[i]);

向量循环；
对于（int i=0；i..正确的解决方案是拥有一个私有向量成员并手动将所有调用委托给它。这是一个经常引用的观点，但在我看来是错误的。它只在您希望通过基指针删除派生对象时才起作用。在大多数情况下，当从STL容器派生时，您希望您的派生类成为下一个类的基层次结构（如有）。给该类一个虚拟dtor…正确的解决方案是拥有一个私有向量成员并手动将所有调用委托给它。这是一个经常引用的观点，但在我看来是错误的。它只在您希望通过基指针删除派生对象时才起作用。在大多数情况下，从STL容器派生时，您希望您的派生类是base获取进一步的类层次结构（如果有）。为该类提供虚拟dtor。
vector<MxInt2d> loops;
MxInt2d firstElement = getTheElement();
loops.push_back(firstElement);   
for (int i=0;i<5;i++)
  loops[0].push_back(myEdges_[i]);