C++ get array key in constructor of array of a custom class/struct?

Question

If I have a simple class like this:

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

And later, I create an array of these classes:

MyClass testing[10];

How, in the constructor, would I access the array key so I can set the myArrayKeyValue appropriately for each element of the array? So that I get this:

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

Is it possible to accomplish this in the constructor? Or do I have to just loop through the array and assign the values manually?

Answer 1

Is it possible to accomplish this in the constructor?

No.

Or do I have to just loop through the array and assign the values manually?

Yes. Although you might be able to redesign so that you don't need the knowledge of the index inside and outside of these instances.

Possible alternatives would include:

• an associative container like map<int, MyClass>
• a set<MyClass> with the key value being the ordering criteria

Answer 2

You cannot do this directly from the constructor; it has no access to the object's location in the array. You will have to write a loop to do the initialization.

Alternatively -- and I'm feeling slightly disgusted at even mentioning this -- use a global or static counter that you increment from the constructor. Construction order is guaranteed to proceed from the start of the array to the end, so this will technically work. But it's horrible.

(Incidentally, the constructor in your example is private, so the array declaration wouldn't even compile.)

Answer 3

Simple zero-based static member that is incremented in the constructor should do. You'd need to reset it before creating an array though. Whether this is a good idea is a completely different topic :)

Answer 4

You could also use a static counter as follows :

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;

But you have the responsability to reset manually, or there will be memory trespassing. This would be corrected by encapsulating at higher level (reset in destructor).

Edit: I had the same idea as Nikolai N Fetissov, and to anticipate : static members as such are not to be used in multithreaded programs.

Answer 5

Something like this would be possible:

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; 
}

Answer 6

It might be valuable to consider what end result you want and to try to achieve it by other means.

One way to proceed might be this:

std::vector<MyClass> v;
for (size_t i=0; i<nCount; i++)
    v.push_back(MyClass(static_cast<int>(i)));