Re: is there a way to do this in C++?
On Aug 10, 4:27 am, James Kanze <james.ka...@gmail.com> wrote:
On Aug 10, 12:42 am, Jerry Coffin <jerryvcof...@yahoo.com> wrote:
In article <f53ee742-bdd4-4226-b436-315a4745f709
@z34g2000vbl.googlegroups.com>, alejandro.ara...@gmail.com says...
I was wondering if it is possible to do the following trick
in C++: let's say you have a class template the represents a
multi-dimensional array:
template <int d, typename T = double>
class Array {
// rest of the class
};
Now, you would like to have different interfaces depending
on the dimension of the array. For example, if I have Array
<2,T> we have a matrix and it may be convenient to have
functions "rows()" and "columns ()", which of course don't
make sense for Array<1,T>. I would like to know if there is
a way to change the interface of the Array class WITHOUT
having to inherit from another class. I was thinking of some
kind of template function defined in the body of the Array
class but is defined ONLY if you're instantiating
Array<2,T>.
Partial specialization is what you seem to need/want:
#include <cstddef>
// The base template
template <int d, typename T = double>
class Array {
T *data;
int dimensions;
public:
Array() : data(NULL), dimensions(d) {}
};
// A partial specialization for 2 dimensional Array's.
template <typename T>
class Array<2, T> {
T *data;
int dimensions;
int rows_, columns_;
public:
Array(int r, int c)
: data(NULL), dimensions(2), rows_(r), =
columns_(c)
{}
int rows() { return rows_; }
int columns() { return columns_; }
};
If I understand correctly, you're proposing a partial
specialization for each possible dimension. I think it should
be possible to implement with a partial specialization for d ==
1, and a generic specialization with Array<n> implemented in
terms of Array<n-1>. Something like:
template< size_t d, typename T = double >
class Array
{
std::vector< Array< d - 1 > > data ;
public:
Array< d - 1 >& operator[]( size_t n )
{
return data[ n ] ;
}
// ...
} ;
template< typename T = double >
class Array< 1, T >
{
std::vector< T > data ;
public:
T& operator[]( size_t n )
{
return data[ n ] ;
}
// ...
} ;
If you want to keep the fact that the data is actually in a
single vector, then it becomes more complicated---you'd probably
need a few helper classes. But I don't think it would be that
difficult for someone familiar with template programming.
--
James Kanze (GABI Software) email:james.ka...@gma=
il.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Dat=
enverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34
My array class is completely generic now. I have the data in a single
array (I need this since I'm interfacing also to the blas library). I
have provided access through operator[] using proxy classes and a
simple metaprogram. The same for printing the array, I coded another
simple metaprogram that uses template recursion and a template partial
specialization finishes the recursion.
To solve my problem, in the end I am just using inheritance. So I'm
basically deriving from a base class that provides the enriched
interface in the case of a 2D array. I just thought that there may be
a trick for doing what I wanted.
Alejandro Arag=F3n