Array with undefined size as Class-member

Question

I'm searching for a way to define an array as a class-member with an undefined size (which will be defined on initialization).

class MyArrayOfInts {
    private:
        int[] array;    // should declare the array with an (yet) undefined length

    public:
        MyArrayOfInts(int);
        int Get(int);
        void Set(int, int);
};
MyArrayOfInts::MyArrayOfInts(int length) {
    this->array = int[length];  // defines the array here
}
int MyArrayOfInts::Get(int index) {
    return this->array[index];
}
void MyArrayOfInts:Set(int index, int value) {
    this->array[index] = value;
}

How can I achieve this behaviour ?

Answer 1

Why not just use std::vector<int>?

Answer 2

Declare it as:

int* array;

Then you can initialize it this way:

MyArrayOfInts::MyArrayOfInts(int length) {
    this->array = new int[length];
}

Don't forget to free the memory in the destrutor:

MyArrayOfInts::~MyArrayOfInts() {
    delete [] this->array;
}

Answer 3

Is the class declaration complete ? If the constructor of the class takes the size of the array as an argument and you don't want to resize the array, then templatizing the class can give you runtime behaviour.

Now, we don't have to pass the size of the array as argument to the constructor.

template<size_t size>
class MyClass
{
public:

    MyClass()  { std::iota(arr_m, arr_m + size, 1);  }
    int operator[](int index) const
    {
        return arr_m[index];
    }
    int& operator[](int index)
    {
        return arr_m[index];
    }

    void Set(size_t index, int value)
    {
        arr_m[index] = value;
    }

private:
    int arr_m[size];
};

int main()
{
    {
        MyClass<5> obj;
        std::cout << obj[4] << std::endl;
    }
    {
        MyClass<4> obj;
        std::cout << obj[3] << std::endl; 
        obj.Set(3, 30);
        std::cout << obj[3] << std::endl; 

    }
}

Answer 4

In response to critics in the comments

I think many people fail to notice a crucial given in the question: since the question asks specifically how to declare an int[N] array inside a struct, it follows that each N will yield a distinct static type to the compiler.

As much as my approach is being 'critiqued' for this property, I did not invent it: it is a requirement from the original question. I can join the chorus saying: "just don't" or "impossible" but as a curious engineer I feel I'm often more helped by defining the boundaries of ust what is in fact still possible.

I'll take a moment to come up with a sketch of an answer to mainly UncleBen interesting challenge. Of course I could hand-waive 'just use template metaprogramming' but it sure would be more convincing and fun to come up with a sample1

1 ^{only to follow that sample with a big warning: don't do this in actual life} :)

---

The TR1 (or c++0x) type std::array does exactly that; you'll need to make the containing class generic to cater for the array size:

template <size_t N> struct MyArrayOfInts : MyArrayOfIntsBase /* for polymorphism */
{
    std::array<int, N> _data;

    explicit MyArrayOfInts(const int data[N])
    {
        std::copy(data, data+N, _data);
    }
};

You can make the thing easier to work with by doing a smart template overloaded factory:

template <size_t N>
    MyArrayOfInts<N> MakeMyArray(const int (&data)[N])
    { return MyArrayOfInts<N>(data); }

Answer 5

I'm working on this too for solving a dynamic array problem - I found the answer provided was sufficient to resolve.

This is tricky because arrays in functions from my reading do not continue after function ends, arrays have a lot of strange nuance, however if trying to make a dynamic array without being allowed to use a vector, I believe this is the best approach..

Other approaches such as calling new and delete upon the same pointed to array can/will lead to double free pending the compiler as it causes some undefined behavior.

class arrayObject
{
public:
arrayObject();
~arrayObject();
int   createArray(int firstArray[]);
void  getSize();
void  getValue();
void  deleting();
// private: 
int *array;
int size;
int counter;
int number;
};

arrayObject::arrayObject()
{
this->array = new int[size];
}

arrayObject::~arrayObject()
{
delete [] this->array;
}