C++ C++；长度恒定的数组成员（的初始化）

我有一个包含数组的类。我希望将此数组设置为常量的长度：

// Entities.h
    class Entities
    {
        private:
            const int maxLimit;
            int objects[maxLimit];
            int currentUsage;

        public:
            Entities();

            bool addObject(int identifier);
            void showStructure();
    };

我遇到的主要问题是构造函数。我想：

// Entities.cpp
    Entities::Entities() : maxLimit(50)
    {
        currentUsage = 0;
        cout << "Entities constructed with max of 50" << endl;
    }

//Entities.cpp
实体：：实体（）：最大限制（50）
{
currentUsage=0；
cout要动态分配内存，您可能需要使用'new'关键字，如

对象的定义如下：

int * objects;

在构造函数中，您可以执行以下操作：

objects = new int [maxLimit];

编辑：

忘了提一下，完成后需要释放数组，可能是在类的析构函数中

delete[] objects;

const int
s必须在声明时初始化。如果在声明时不知道它必须是什么值，则必须采用不同的策略

您需要在构造函数中创建数组，同时将指针保持在外部。这是您想要做的吗

在你们班：

private:
    int maxLimit;
    int* objects;

和外部：

Entities::Entities() : maxLimit(50)
{
    currentUsage = 0;
    cout << "Entities constructed with max of 50" << endl;
    objects = new int[maxLimit];
}

Entities::~Entities()
{
    delete [] objects;
}

Entities:：Entities（）：maxLimit（50）
{
currentUsage=0；
cout数组必须有一个恒定的长度。我的意思是该类的所有对象的长度都相同。这是因为编译器必须知道每个对象的大小，并且该特定类的所有对象的长度都必须相同。因此，以下方法可以做到这一点：

class Entities
{
    private:
            static const int maxLimit = 50;
            int objects[maxLimit];
            int currentUsage;

    public:
            Entities();

            bool addObject(int identifier);
            void showStructure();
};

在cpp文件中：

const int Entities::maxLimit;

我更喜欢使用枚举，因为我不必在cpp文件中定义静态：

class Entities
{
    private:
            enum { maxLimit = 50 };
            int objects[maxLimit];
            int currentUsage;

    public:
            Entities();

            bool addObject(int identifier);
            void showStructure();
};

如果您想要数组的每对象大小，则可以使用动态数组。
vector
就是这样一种：

class Entities
{
    private:
            const int maxLimit;
            std::vector<int> objects;
            int currentUsage;

    public:
            Entities();

            bool addObject(int identifier);
            void showStructure();
};

// Entities.cpp
Entities::Entities(int limit) 
    : maxLimit(limit), objects(limit), currentUsage(0)
{
    cout << "Entities constructed with max of 50" << endl;
}

类实体
{
私人：
const int maxLimit；
向量对象；
int当前使用情况；
公众：
实体（）；
bool addObject（int标识符）；
void showStructure（）；
};
//实体.cpp
实体：：实体（整数限制）
：maxLimit（限制）、对象（限制）、currentUsage（0）
{
cout如果需要在编译时设置数组大小，可以使用模板参数：

template<size_t maxLimit>
class Entities
{
    int objects[maxLimit];
    public:
        Entities() {}
        ...
};

Entities<1000> inst;

模板
类实体
{
int对象[maxLimit]；
公众：
实体（）{}
...
};
实体研究所；
如果所有对象具有相同的长度，则长度可以是静态的。这使其成为允许作为数组绑定的常量整数表达式：

class Entities
{
    private:
        static const int maxLimit = 50;
        int objects[maxLimit];
        int currentUsage;
    //...
};

请记住，sizeof（Entities）是一个有效的表达式。每个Entities对象都有相同的大小。
使用std:：vector，您将获得预期的行为。无需担心指针、副本等

#include <vector>

class Entities
{
private:
  const int limit;
  std::vector<int> objects;

public:
  Entities(int a_limit)
    : limit(a_limit), objects(a_limit)
  { }

  void addObject(int identifier)
  {
    if (objects.size() == limit)
      throw whatever;
    objects.push_back(identifier);
  }
};

#包括
类实体
{
私人：
常数整数极限；
向量对象；
公众：
实体（整数限制）
：限制（a_限制），对象（a_限制）
{ }
void addObject（int标识符）
{
if（objects.size（）==限制）
扔任何东西；
对象。推回（标识符）；
}
};
+1对于枚举技巧，它通常是围绕静态整数+1的最佳“破解”这在不使用动态内存的情况下解决了他的问题，这意味着它比迄今为止提出的任何其他建议（就回答他的问题的精神而言）都要好。顺便说一句，如果使用向量，私有maxLimit成员将是多余的。Brian，如果在运行时指定了向量的大小，这是否意味着它分配的内存实际上将来自堆？或者向量是否足够聪明，可以在堆栈上扩展自身？Joseph，向量解决方案从堆中获取内存。th前两个不带堆分配。c++1x将使用std:：dynarray正是为了这个目的：在runtim时确定长度，但仍然有一个恒定的长度（即不改变长度），并且在可能的情况下从堆栈分配。最好包含一个复制构造函数和运算符=（），否则意外复制将导致析构函数被调用两次。（例如，删除同一指针上的[]两次。）（或者您可以使该类不可压缩。）…甚至更好地使用std:：vector对象；objects.resize（maxLimit）；并跳过赋值运算符和析构函数。您可以在构造函数的初始化列表中初始化const int。在您的示例中，maxLimit可以是const。您忽略了复制构造函数&运算符=（）。意外复制此对象将导致析构函数运行两次。（删除[]并两次删除同一指针。）你不能在声明的时候初始化它们，顺便说一句（你可以初始化静态常量）。当心！你很快就会成为一个常量上瘾者！但这意味着让类主体对所有客户端都可见。哈。类主体对所有客户端都是可见的，你的观点是什么？