Question

I haven’t worked with c++ in a while, but I just started a project with it. This may not be possible, but Im trying to create a template class with an array that sets its size to the value of a constant which i’m trying to set with the constructor.

This is the code of the constructor:

Tarray(int s): start_size(s){
    }

This is the code that sets the array size:

const int start_size;
T this_array[start_size];

This is the entire file:

#ifndef TARRAY_H_
#define TARRAY_H_


template<typename T>
class Tarray {
private:
    const int start_size;
    T this_array[start_size];
    int array_size;
public:
    Tarray(int s): start_size(s){
    }
    ~Tarray(){
        delete[] this_array;
    }
    T & operator[](int i){
        return this_array[i];
    }
};



#endif /* TARRAY_H_ */

These are the errors I get:

..\/template_array/Tarray.h:16:24: error: 'Tarray<T>::start_size' cannot appear in a constant-expression
..\/template_array/Tarray.h:16:34: error: 'new' cannot appear in a constant-expression
..\/template_array/Tarray.h:16:34: error: ISO C++ forbids initialization of member 'this_array' [-fpermissive]
..\/template_array/Tarray.h:16:34: error: making 'this_array' static [-fpermissive]
..\/template_array/Tarray.h: In instantiation of 'Tarray<Person>':
..\Human.cpp:17:24:   instantiated from here
..\/template_array/Tarray.h:16:34: error: invalid in-class initialization of static data member of non-integral type 'Person*'
Build error occurred, build is stopped
Time consumed: 343  ms. 

The error messages have been changing as I try to tweak the code, but these are the errors from this particular build.

Thanks for any help

Answer 1

The reason you’re getting compiler errors is this line:

T this_array[start_size];

This line would make your Tarray actually contain start_size instances of T. It wouldn’t hold a pointer or reference to these instances – they would be part of same block of memory that contains the Tarray’s other instance variables.
This would make the class’ size depend on start_size, and start_size is not known at compile time. The size of any C++ class must be known at compile time, this isn’t possible.

There are two ways to solve this:

1. Allocate the array of T instances on the heap, using array new. This is what std::vector does. Writing such a class and getting it to behave right when it’s copied/moved/expanded/etc is difficult and tedious, so I’d recommend just using std::vector instead.
2. Make the number of T instances fixed, and pass it as a template parameter

i.e.:

template<typename T, std::size_t N>
class TArray
{
    ...
    T this_array[N];
    ...
}

This is what std::array (C++11 only) and boost::array do. Again, I’d recommend using one of these instead of writing your own. Unless this is homework, of course…

Lastly, it’s worth noting that this is an error:

~Tarray(){
    delete[] this_array;
}

this_array wasn’t allocated with new, so you shouldn’t delete it. If the array is part of the class as it is here (rather than being separately heap-allocated and owned by the class), then it will be destroyed along with the rest of the class by default. Calling delete is not only unnecessary, it will almost certainly cause a crash.