Array as a data member

Question

I want to have a class that contains an array as it's data member. The size of the array is declared during construction. I know that the size of an array needs to be known at compile-time, but is there no way to work around this by using a const int to define the size and subsequently using constructor initializer list? I'm not allowed to use vectors. This is my futile attempt:

#include <iostream>

using namespace std;

class myArray {
    public:
        myArray(int size) : capacity(size) {}
    private:
        const int capacity;
        int a[capacity];
};

int main() {
    myArray ar(25); 
    return 0;     
}

It gives the following error: 'capacity' was not declared in this scope

Answer 1

Try to use pointer instead

#include <iostream>
using namespace std;
class myArray {
public:
    myArray(int size) : capacity(size) {array = new int[capacity];}
    ~myArray() {delete [] array;}

private:
    const int capacity;
    int* array;
};

int main() {
    myArray ar(25); 
    return 0;     
}

And don't forget to release in the destructor.

Answer 2

All of the above answers are "technically correct", but none actually show the usage of a smart pointer which makes all of the additional memory management unnecessary.

class my_array
{
public:
   my_array (size_t sz)
     : arr {new int [sz]} {}

pirvate:
   std::unique_ptr <int[]> arr;
};

Now you needn't concern yourself with the rule of (3 or 5), and the code is correct and (mostly) exception safe.

Answer 3

It could work with a static const but you would lose the constructor argument setting. You have to allocate it dynamically for it to work:

class myArray {
    public:
        myArray(int size) : capacity(size) 
        {
            a = malloc(size * sizeof(int));
        }
        ~myArray() { free(a); }
    private:
        int capacity;
        int* a;
};

int main() {
    myArray ar(25); 
    return 0;     
}

Although allocating with new [] and freeing with delete [] is probably more C++ than malloc and free.

As stated in some comments, if you dynamically allocate and don't use automatic resource management objects like shared_ptr or unique_ptr, you have to follow the rule of three.

Answer 4

The problem with your original class is that it allows for different values to be passed in as the capacity. Hence, you cannot create an array with that value, in the way you want. It makes no difference that you only create one instance with a size of 25, that's a property of the program, and the class itself doesn't know it's only used that way.

---

Now I'm not going to question why you can't use a vector but it seems a shame to not use the full capabilities of the language/library.

However, given your restrictions, you can create an array dynamically rather than trying to create a fixed array:

#include <iostream>

using namespace std;

class myArray {
    public:
        myArray(int size) : capacity(size) {
            a = new int[capacity];
        }
        ~myArray() {
            delete[] a;
        }
        // Also need all those other things, mandated by the
        // rule of 3/5, to allow proper deep copy/move:
        // - copy constructor.
        // - copy assignment operator.
        // - move constructor (C++11).
        // - move assignment operator (C++11).

    private:
        const int capacity;
        int *a;
};

int main() {
    myArray ar1(25);
    myArray ar1(42);
    return 0;
}

Answer 5

By passing in capacity as a variable, you have a dynamically sized array (whose size is only known at runtime). This means that sizeof(myArray) is unknown to the compiler, which will cause problems.

Instead, you will need to store a pointer to an array.

Another (ugly) approach would be to use a placement strategy, place the array at the end of the struct/class, and give it a constant size of 1, as shown here

Answer 6

constness is insufficient, because you can even take a value that's provided by the user during execution of the program and make it const:

int x;
std::cin >> x;
const int y = x;

It's insufficient because the array dimensions must be known when the program is compiled.

Historically, if you were to initialise a static const "variable" at the point of declaration, then this would be enough to convince the compiler that it could use that value for an array dimension:

static const unsigned int N = 5;

because there's no way that can go wrong.

Nowadays, we have constexpr for the purpose of making this absolutely explicit.

Answer 7

You can use Template non-type arguments (only works for C++). Take a look at this page and example:

https://www.ibm.com/docs/en/zos/2.1.0?topic=arguments-template-non-type.