Template Specialization pointer to pointer and array passing template deduction - c++

Question

I have the following code I was writing to test template specialization. Is there a way to have the pointer decay to the type so that I can use template parameter deduction to get my M and N so I can have the rows and cols of the two dimensional array? I know I can vector of vector for a 2d array, but this is an exercise in template specialization. The following code works as is, but see if you uncomment the following and comment out the current T** constructor it doesn't work. As a result the constructor currently hard codes the number of rows to be used for deleting the data_ member, this is not ideal and ideally I would get this parameter from the template deduction. I was wondering if there is a way to make this work in the following code shown below.
//doesn't like this constructor
// template <unsigned int M, unsigned int N>
// Data ( T (&d)[M][N] ): data_(d), rows_(M), cols_(N) {};
#include <iostream>
template <typename T>
class Data
{
public:
Data ( const T& d ): data_(d) {};
Data ( T&& d ): data_(std::move(d)) {};
std::string getType() { return "Plain Data Type"; }
private:
T data_;
};
template <typename T>
class Data<T**>
{
public:
//doesn't like this constructor
// template <unsigned int M, unsigned int N>
// Data ( T (&d)[M][N] ): data_(d), rows_(M), cols_(N) {};
Data ( T** d ): data_(d), rows_(25) {};
~Data() {
for ( unsigned int i = 0; i < rows_; ++i)
{
delete [] data_[i];
}
delete [] data_;
}
std::string getType() { return "Pointer to Pointer Data Type"; }
private:
T** data_;
unsigned int rows_;
unsigned int cols_;
};
template <typename T>
class Data<T*>
{
public:
Data ( T* d ): data_(d) {};
~Data() { delete data_; }
std::string getType() { return "Pointer Data Type"; }
private:
T* data_;
};
int main ( int argc, char *argv[])
{
float f(9.65);
Data<int> d1(f);
std::cout << d1.getType() << std::endl;
int *i = new int(5);
Data<int*> d2(i);
std::cout << d2.getType() << std::endl;
int **j = new int*[25];
for ( int i = 0 ; i < 25; ++i)
j[i] = new int[50];
Data<int**> d3(j);
std::cout << d3.getType() << std::endl;
}
output:
Plain Data Type
Pointer Data Type
Pointer to Pointer Data Type

Answer 1

T** and T[n][m] are not equivalent (and I curse the collegiate professors that refuse to teach this). One is a pointer-to-pointer, the other is an array of T[m] of size n.
You can specialize your 2D array type like this:
template<typename T, size_t N, size_t M>
class Data<T[N][M]>
{
public:
Data(const T(&ar)[N][M])
{
for (size_t i=0;i<N;++i)
std::copy(std::begin(ar[i]), std::end(ar[i]), std::begin(data[i]));
}
std::string getType() { return "2D-Fixed Array Data Type"; }
private:
T data[N][M];
};
And one way to use it is like this:
float fdat[10][20];
Data<decltype(fdat)> d4(fdat);
std::cout << d4.getType() << std::endl;
Output
2D-Fixed Array Data Type