C++ 阵列内存分配不需要'；行不通

我有接下来的课程：

class A {
};

class B : public A {
  int num;
};

我主要有：

int main() {
    A* vec; // A is a class with pure virtual functions
    vec = new B[2]; // want to create a vector of B
}

vec[0]定义正确，但vec[1]为空。为什么它没有给我一个合适的记忆

我不想改变主线。让它工作起来

（我知道我可以将main改为：B*vec=new B[2]，但我不想要）

---

感谢您的帮助

> P>不能对数组进行多态处理，C++语言不支持。表达式

vec[x]

使用指针算法来确定元素的位置。如果您是通过基类指针访问它，那么如果对象的大小以任何方式发生变化，它将不起作用

例如，基类的大小为4字节，子类的大小为8字节

base *a = new child[4];

当您访问

a[1]

时，编译器使用基类的大小计算偏移量。在本例中，偏移量为4字节，最终指向第一个元素的中间

我建议使用带有适当智能指针的

std:：vector

或

std:：array

指针

// For arrays that needs to be resized (requires delete for each new)
std::vector<A*> vec(5, NULL);
for(int i = 0; i < vec.size(); i++)
{
    vec[i] = new B();
}

// for arrays that are fixed in size (requires delete for each new)
std::array<A*, 5> vec;
for(int i = 0; i < vec.size(); i++)
{
    vec[i] = new B();
}

// for arrays that are fixed in size with smart pointers
// no delete needed 
std::array<std::unique_ptr<A>, 5> vec;
for(int i = 0; i < vec.size(); i++)
{
    vec[i].reset(new B());
}

//对于需要调整大小的数组（每个新数组都需要删除）
std：：向量向量向量（5，空）；
对于（int i=0；i > p>不能对数组进行多态处理，C++语言不支持。表达式
vec[x]
使用指针算法来确定元素的位置。如果您是通过基类指针访问它，那么如果对象的大小以任何方式发生变化，它将不起作用

例如，基类的大小为4字节，子类的大小为8字节

base *a = new child[4];

当您访问
a[1]
时，编译器使用基类的大小计算偏移量。在本例中，偏移量为4字节，最终指向第一个元素的中间

我建议使用带有适当智能指针的
std:：vector
或
std:：array
指针

// For arrays that needs to be resized (requires delete for each new)
std::vector<A*> vec(5, NULL);
for(int i = 0; i < vec.size(); i++)
{
    vec[i] = new B();
}

// for arrays that are fixed in size (requires delete for each new)
std::array<A*, 5> vec;
for(int i = 0; i < vec.size(); i++)
{
    vec[i] = new B();
}

// for arrays that are fixed in size with smart pointers
// no delete needed 
std::array<std::unique_ptr<A>, 5> vec;
for(int i = 0; i < vec.size(); i++)
{
    vec[i].reset(new B());
}

//对于需要调整大小的数组（每个新数组都需要删除）
std：：向量向量向量（5，空）；
对于（int i=0；i
此代码片段说明了您遇到的问题

#include <iostream>
using namespace std;
class A {
};

class B : public A {
  int num;
};

int main() {
    A* vec; // A is a class with pure virtual functions
    vec = new B[2]; // want to create a vector of B

    cout << sizeof(vec) << endl;
    cout << sizeof(*vec) << endl;
    cout << sizeof(vec[2]) << endl;
    cout << sizeof(new B()) << endl;
}

#包括
使用名称空间std；
甲级{
};
B类：公共A{
int-num；
};
int main（）{
A*vec；//A是一个具有纯虚函数的类
vec=new B[2]；//要创建B的向量吗
cout此代码片段说明了您遇到的问题

#include <iostream>
using namespace std;
class A {
};

class B : public A {
  int num;
};

int main() {
    A* vec; // A is a class with pure virtual functions
    vec = new B[2]; // want to create a vector of B

    cout << sizeof(vec) << endl;
    cout << sizeof(*vec) << endl;
    cout << sizeof(vec[2]) << endl;
    cout << sizeof(new B()) << endl;
}

#包括
使用名称空间std；
甲级{
};
B类：公共A{
int-num；
};
int main（）{
A*vec；//A是一个具有纯虚函数的类
vec=new B[2]；//要创建B的向量吗
cout如果您希望它是多态的，只需创建一个指针数组

新建一个*[array\u size]
如果您希望它是多态的，只需创建一个指针数组

newa*[array\u size]
复制复制你不能只做B*vec\u cp=new B[2]；memcpy（vec，vec\u cp，sizeof（vec\u cp））？通过直接在内存上操作，您可以绕过这一限制。仅仅因为对象正确地存在于内存中并不意味着指针算法可以工作。在这种情况下，vec指针仍然会被破坏，vec[2]将仍然指向内存中的一个字节，而不是指向第二个B对象所需的8个字节。@geogesl
B
可以隐式转换为
A
，因此您的memcpy执行与普通旧赋值相同的操作。您仍然会遇到同样的问题。@CaptainObvlious，谢谢！代码：A vec*[5]=新的B*[5]；它将为我分配一个1*5的矩阵，对吗？@Alonhmiel是的，括号内的数字指定要分配的元素数。在这种情况下，它是一个由5个指针组成的数组，用于键入
a
类型的对象。你不能只做B*vec_cp=new B[2]；memcpy（vec，vec_cp，sizeof（vec_cp））？通过直接在内存上操作，您可以绕过这一限制。仅仅因为对象正确地存在于内存中并不意味着指针算法可以工作。在这种情况下，vec指针仍然会被破坏，vec[2]将仍然指向内存中的一个字节，而不是指向第二个B对象所需的8个字节。@geogesl
B
可以隐式转换为
A
，因此您的memcpy执行与普通旧赋值相同的操作。您仍然会遇到同样的问题。@CaptainObvlious，谢谢！代码：A vec*[5]=new B*[5]；它将为我分配一个1*5的矩阵，对吗？@AlonShmiel是的，括号内的数字指定要分配的元素数。在这种情况下，它是一个由5个指针组成的数组，用于键入
a
类型的对象。