Getting error “array bound is not an integer constant before ']' token”

Question

I am trying to implement a stack using an array but I receive an error.

class Stack{
private:
    int cap;
    int elements[this->cap]; // <--- Errors          


        

Answer 1

Change

int elements[this->cap];

to

int* elements=new int[cap]

Answer 2

Since other have already explained the cause of this issue, here is a possible solution to resolve it. Since it seems you may not know the array size at compile time and the assignment may restrict the use of std::vector<int> consider using a pointer implementation.

#include <algorithm>

class Stack{
private:
    int cap;
    int* elements; // use a pointer
    int top;
public:
    Stack(){
        this->cap=5;
        this->top=-1;
        elements = new int[this->cap];
    }

    Stack(const Stack& s) 
         : cap(s.cap) , top(s.top), elements(NULL)
    {
         if(cap > 0) {
             elements = new int[cap];
         }

         std::copy(s.elements , s.elements + cap, elements );
    }

    Stack& operator=(Stack s) {
         swap(s, *this);
         return  *this;
    }

    ~Stack() {delete [] elements;}

    friend void swap(Stack& first, Stack& second)
    {
        using std::swap; 
        swap(first.top, second.top);
        swap(first.cap, second.cap);
        swap(first.elements, second.elements);
    }
};

Answer 3

You cannot use this in the declaration like that. this is a constant pointer passed to non-static methods in your class. It does not exist outside of that scope.

Such array declarations need constant values/expressions for the size. You don't want that, you want a dynamicly sized container. The solution is to use a std::vector.

Answer 4

In C++, the size of an array must be a constant known at compile-time. You'll get an error if that isn't the case.

Here, you have

int elements[this->cap];

Notice that this->cap isn't a constant known at compile-time, since it depends on how big cap is.

If you want to have a variably-sized array whose size is determined later on, consider using std::vector, which can be resized at runtime.

Hope this helps!