1

如果我有这样一个简单的类：

class MyClass
{
    MyClass(){}
    ~MyClass(){}
public:   
    int myArrayKeyValue;
};

后来，我创建了这些类的数组：

MyClass testing[10];

如何在构造函数中访问数组键，以便myArrayKeyValue为数组的每个元素设置适当的值？所以我得到这个：

testing[0].myArrayKeyValue = 0;
testing[1].myArrayKeyValue = 1;
testing[2].myArrayKeyValue = 2;
testing[3].myArrayKeyValue = 3;
etc...

是否可以在构造函数中完成此操作？还是我必须遍历数组并手动分配值？

4

6 回答 6

3

是否可以在构造函数中完成此操作？

不。

还是我必须遍历数组并手动分配值？

是的。尽管您可能能够重新设计，以便您不需要这些实例内部和外部的索引知识。

可能的替代方案包括：

  • 一个关联容器，例如map<int, MyClass>
  • aset<MyClass>键值为排序标准
于 2010-07-11T17:09:19.030 回答
0

这样的事情是可能的：

class MyClass { 
public: 
  MyClass(int index) { myArrayKeyValue = index; } 
  ~MyClass();
private:
int myArrayKeyValue;
}; 

int main() 
{ 
  MyClass testing[5] = { MyClass(1), MyClass (2), 
                   MyClass (3), MyClass (4), MyClass (5) };

  return 0; 
}
于 2010-07-11T17:27:31.097 回答
0

考虑您想要的最终结果并尝试通过其他方式实现它可能很有价值。

一种方法可能是这样的：

std::vector<MyClass> v;
for (size_t i=0; i<nCount; i++)
    v.push_back(MyClass(static_cast<int>(i)));
于 2010-07-11T17:38:33.713 回答
0

您不能直接从构造函数中执行此操作；它无法访问对象在数组中的位置。您将不得不编写一个循环来进行初始化。

或者——即使提到这一点，我也感到有点反感——使用从构造函数中递增的全局或静态计数器。保证构建顺序从数组的开始到结束，所以这在技术上是可行的。但这太可怕了。

（顺便说一句，您示例中的构造函数是私有的，因此数组声明甚至无法编译。）

于 2010-07-11T17:10:49.613 回答
0

在构造函数中递增的简单的从零开始的static成员应该这样做。不过，您需要在创建数组之前重置它。这是否是一个好主意是一个完全不同的话题:)

于 2010-07-11T17:12:02.707 回答
-1

您还可以使用静态计数器，如下所示：

class MyClass {
    static size_t static_counter;

    size_t m_value;
public:
    MyClass() {
        m_value = static_counter++;
    }

    inline static void reset() {
        static_counter = 0;
    }

    inline size_t get_value() const {
        return m_value;
    }
};

size_t MyClass::static_counter = 0;

但是你有责任手动重置，否则会有内存侵入。这将通过在更高级别封装（在析构函数中重置）来纠正。

编辑：我和 Nikolai N Fetissov 有同样的想法，并且预期：静态成员本身不能用于多线程程序。

于 2010-07-11T17:19:53.320 回答