Re: Partial Specialization Method
"MathStuf" <MathStuf@gmail.com> wrote in message
news:1178467870.720044.160990@h2g2000hsg.googlegroups.com...
I have a matrix class and I would like to add a method that is only
applicable when the template type is a of another class. How can I
specialize the class to allow for the new method and hide it with any
other type?
template<class T> class Matrix
{
public:
Matrix();
Matrix(Ini
&ini); // Only
applicable with MyClass
Matrix(unsigned w, unsigned h, T &d = T());
void ImportIni(Ini
&ini); // Only applicable
with MyClass
void ExportIni(std::ofstream &fout, const String &val);// Only
applicable with MyClass
void AddRow(T &d = T());
void AddCol(T &d = T());
bool InsertRow(unsigned pos, T &d = T());
bool InsertCol(unsigned pos, T &d = T());
bool DeleteRow(unsigned pos);
bool DeleteCol(unsigned pos);
bool Set(unsigned row, unsigned col, T &s);
T Get(unsigned row, unsigned col);
std::vector<T> GetRow(unsigned row);
std::vector<T> GetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();
T operator[](Point &p);
std::vector<T> operator[](int col);
private:
std::vector< std::vector<T> > matrix;
unsigned height;
unsigned width;
};
You can use SFINAE
template<class T> class Matrix
{
public:
/* ... */
template<class U>
Matrix(U yourIntParam,
typename enable_if_c<
is_same<T,MyClass>::value &&
is_convertible<U,int>::value
, int>::type = 0);
};
Now that constructor will only be considered by the compiler if T is MyClass
(and if the passed U is convertible to int, which, alas, is the downside for
making the constructor itself a template, as that is needed for SFINAE to be
able to work). Definitions of enable_if_c<>, is_same<> and is_convertible<>
can be found in boost, but I'll provide them here for completeness' sake.
template<bool B, class T> struct enable_if_c { };
template<class T> struct enable_if_c<true, T> { typedef T type; };
template<class T, class U> struct is_same { static const bool value =
false; };
template<class T> struct is_same<T,T> { static const bool value = true; };
template<class T, class U> struct is_convertible
{
private:
struct small { char c; };
struct large { char c[2]; };
static small foo(const U & u);
static large foo(...);
public:
static const bool value = (sizeof(foo(*(T*)1)) == sizeof(small));
};
- Sylvester Hesp