Question

I’m trying to learn more about templates and have come across a problem I can’t seem to solve. At the moment the class below works fine.

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;

template <class T, int s>
class myArray{
public:
    T* data;
    inline T& operator[](const int i){return data[i];}
    myArray(){
        data=new T[s];
    }
    myArray(const myArray& other){
        data=new T[s];
        copy(other.data,other.data+s,data);
    }
    myArray& operator=(const myArray& other){
        data=new T[s];
        copy(other.data,other.data+s,data);
        return *this;
    }
    ~myArray(){delete [] data;}
};  

If I use it:

myArray<myArray<myArray<int,10>,20>,30> a;

a is now 30x20x10 array that I can access with the normal array brackets e.g. a[5][5][5]. I wish to add a feature so that I could write:

myArray<myArray<myArray<int,10>,20>,30> a(10);

and initialise all of the entries to 10 for example. I can’t work out how to do this. As I understand, each layer of myArray is constructed using the default constructor. If I changed this to something like:

myArray(int n=0){
        data=new T[s]; 
        fill(data,data+s,n); //T might not be of type int so this could fail.
}

I think this should fail when data is not of type int (i.e. on any array on dimensions > 1), however it doesn’t. It works when the array is square, but if not then some of the entries aren’t set to 10. Does anyone have an idea how the standard vectors class achieves this? Any help would be amazing. Thanks!

Answer 1

std::vector uses placement new on memory blocks. It constructs the data.after allocating the memory in a second line of code.

This technique would work for you as well. Be careful with placement new as it requires you to call destructors manually as well.

Here is a half-assed route without placement new:

template<typename U>
explicit MyArray( U const& constructFromAnythingElse )
{
  AllocateSpace(N); // write this, just allocates space
  for (int i = 0; i < N; ++i)
  {
    Element(i) = T( constructFromAnythingElse );
  }
}

with placement new, you have to allocate the memory first, then construct in-place, and then remember to destroy each element at the end.

The above is half-assed compared to a placement new route, because we first construct each element, then build another one, and use operator= to overwrite it.

By making it a template constructor on an arbitrary type, we don’t rely on multiple conversion to get multiple levels down into the array. The naive version (where you take a T const&) doesn’t work because to construct an array of arrays of arrays of T, the outermost one expects an array of arrays of T as an argument, which expects an array of T as an argument, which expects a T — there are too many levels of user defined construction going on there.

With the above template constructor, the array of array of array of T accepts any type as a constructor. As does the array of array of T, as does the array of T. Finally, the T is passed in whatever you constructed the outermost array of array of array of T, and if it doesn’t like it, you get a compiler error message that is nearly completely unreadable.