C++ 类的可变长度数组

我有一些代码实际上是这样的：

class dummie_type
{
    public:
    int a;

    void do_stuff()
    {
        // blah
    }
};

class dummie_type dummie[10];

void main()
{
    subroutine();
}

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[5].do_stuff();
}

注意，类的数组是全局的，我需要它保持全局性（说来话长）。 我需要修改这段代码，使类数组的长度可变。我知道这需要创建一个全局指针，然后将其设置为指向一个内存块，该内存块在main中被malloc'ed或new'ed，我知道我必须将“.”字符更改为“->”，但除此之外，我一直无法生成编译器可以接受的内容。我特别不确定如何声明指向类数组的全局指针

---

编辑：对不起，我应该在前面说，数组大小将在main（）的开始附近计算一次，并且从那时起将保持不变。

您能更改它，使其成为向量吗

std::vector<dummie_type> dummie;

int main() {

    //populate();
    //showing alternative loop based approach
    populateWithLoop(calc_size());
    subroutine();
 }

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[1].do_stuff();
}

void populate() {

   dummie_type a;
   dummie_type b;
   dummie_type c;

   dummie.push_back(a);
   dummie.push_back(b);
   dummie.push_back(c);

   //will print out 3
   std::cout << dummie.size() << std::endl;

   dummie_type d;
   dummie.push_back(d);

   //will print out 4
   std::cout << dummie.size() << std::endl;


}

populateWithLoop(int n) {

   for(int i=0; i<n; i++) {
       dummie_type temp;
       dummie.push_back(temp);
   }
}

std:：向量假人；
int main（）{
//填充（）；
//显示基于循环的替代方法
填充循环（计算大小（））；
子程序（）；
}
void子例程（）
{
傻瓜[3].a=27；//等等。。。
傻瓜[1]。做东西（）；
}
void填充（）{
a型假人；
b型假人；
c型假人；
假人。推回（a）；
假人。推回（b）；
假人。推回（c）；
//将打印出3个
你能把它改成向量吗

std::vector<dummie_type> dummie;

int main() {

    //populate();
    //showing alternative loop based approach
    populateWithLoop(calc_size());
    subroutine();
 }

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[1].do_stuff();
}

void populate() {

   dummie_type a;
   dummie_type b;
   dummie_type c;

   dummie.push_back(a);
   dummie.push_back(b);
   dummie.push_back(c);

   //will print out 3
   std::cout << dummie.size() << std::endl;

   dummie_type d;
   dummie.push_back(d);

   //will print out 4
   std::cout << dummie.size() << std::endl;


}

populateWithLoop(int n) {

   for(int i=0; i<n; i++) {
       dummie_type temp;
       dummie.push_back(temp);
   }
}

std:：向量假人；
int main（）{
//填充（）；
//显示基于循环的替代方法
填充循环（计算大小（））；
子程序（）；
}
void子例程（）
{
傻瓜[3].a=27；//等等。。。
傻瓜[1]。做东西（）；
}
void填充（）{
a型假人；
b型假人；
c型假人；
假人。推回（a）；
假人。推回（b）；
假人。推回（c）；
//将打印出3个
标准：：cout
我知道这需要创建一个全局指针，然后将其设置为指向一个内存块，该内存块在main中被malloc'ed或new'ed，我知道我必须将“.”字符更改为“->”但除此之外，我一直无法生成编译器可以接受的东西。我特别不确定如何声明指向类数组的全局指针

基本上就是这样。你将dummie声明为
dummie\u-type*dummie；
，然后在main中执行
dummie=new dummie\u-type[size]；
。不，你不需要将
更改为
->

我知道这需要创建一个全局指针，然后将其设置为指向一个内存块，该内存块在main中被malloc'ed或new'ed，我知道我必须将“.”字符更改为“->”但除此之外，我一直无法生成编译器可以接受的东西。我特别不确定如何声明指向类数组的全局指针

基本上就是这样。你将dummie声明为
dummie\u type*dummie；
，然后在main中执行
dummie=new dummie\u type[size]；
。不，你不需要将
更改为
->
使用指向类对象的指针数组

使用
std:：vector
s，它可以是

typedef dummie_type * dummie_ptr;
typedef vector<dummie_ptr> dummie_array;

使用指向类对象的指针数组

使用
std:：vector
s，它可以是

typedef dummie_type * dummie_ptr;
typedef vector<dummie_ptr> dummie_array;

如果按照Glen的建议，将此作为一个向量实施，当您需要在开始时进行一次性分配时，您将保留（），例如：

一个次要的效率是测试编译器分配的初始容量是否足以满足您的需要。在这种情况下，您不需要重新分配。向量的初始容量在第一次推回期间保留：

// ...
dummie_type a_dummie = new dummie_type();
dummie.push_back(a_dummie);
if (slots_i_need > dummie.capacity())
   dummie.reserve(slots_i_need);
else
   {} // nothing to do.

如果按照Glen的建议，将此作为一个向量实施，当您需要在开始时进行一次性分配时，您将保留（），例如：

一个次要的效率是测试编译器分配的初始容量是否足以满足您的需要。在这种情况下，您不需要重新分配。向量的初始容量在第一次推回期间保留：

// ...
dummie_type a_dummie = new dummie_type();
dummie.push_back(a_dummie);
if (slots_i_need > dummie.capacity())
   dummie.reserve(slots_i_need);
else
   {} // nothing to do.

<>我不认为你需要改变你的访问器。在C++中，数组与指针几乎没有区别。考虑如何将数组传递给函数：


与

您必须处理“数组”的初始分配。
此表单将允许您保留当前使用情况


void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[5].do_stuff();
}

<>我不认为你需要改变你的访问器。在C++中，数组与指针几乎没有区别。考虑如何将数组传递给函数：


与

您必须处理“数组”的初始分配。
此表单将允许您保留当前使用情况


void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[5].do_stuff();
}

这是一个对象数组，不是一个类数组。相关的是，如果他使用一个对象数组，每当他调整数组大小时，每个元素都会调用构造函数和析构函数，这是没有意义的。所以他实际上需要一个指向对象的指针数组，而不是指向对象数组的指针。我发现这是错误的。这是错误的不打算重新分配每一个
push_back
。此外，通过使用
指针向量
，您可能会破坏
向量
通常会获得的任何缓存性能。您的“指针向量”实际上只是一个
列表
。这是一个对象数组，而不是一个类数组。相关的是，如果他使用一个对象数组，每当他调整数组大小时，都会为每个元素调用构造函数和析构函数，这是没有意义的。因此他实际上需要一个指向对象的指针数组，而不是指向对象数组的指针对象。我发现这是不正确的。它不会重新分配每一个
推回
。此外，您可能会通过使用
指针向量
，破坏通常从
向量
中获得的任何缓存性能。您的“指针向量”实际上只是一个
列表
。编译器几乎肯定会以fa的形式为您搜索代码

void subroutine()
{
    dummie[3].a = 27; // etc...
    dummie[5].do_stuff();
}