Partial Specialization Method

[MathStuf]

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 Tclass 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<TGetRow(unsigned row);
std::vector<TGetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();

T operator[](Point &p);
std::vector<Toperator[](int col);
private:
std::vector< std::vector<T matrix;
unsigned height;
unsigned width;
};

[Markus Schoder]

On Sun, 06 May 2007 09:11:10 -0700, MathStuf wrote:

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 Tclass Matrix
{
public:
Matrix();
Matrix(Ini
&ini); // Only
applicable with MyClass
Matrix(unsigned w, unsigned h, T &d = T());

It is illegal to bind a rvalue to a non-const reference. Make this a
const T & if possible.

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<TGetRow(unsigned row);
std::vector<TGetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();

T operator[](Point &p);
std::vector<Toperator[](int col);
private:
std::vector< std::vector<T matrix; unsigned height;
unsigned width;
};

You can do it with template specialization, like so:

template<class Tstruct Base
{
// all common stuff from above
// ...
};

template<class Tstruct Matrix : Base<T>
{
Matrix();
Matrix(unsigned w, unsigned h);
};

class MyClass;
class Ini;

template<struct Matrix<MyClass: Base<MyClass>
{
Matrix();
Matrix(unsigned w, unsigned h);

// additional stuff
Matrix(Ini &ini);
// ...
};
There is some unavoidable duplication for the constructors unfortunately.

--
Markus

[MathStuf]

On May 6, 12:56 pm, Markus Schoder <[e-mail]:

On Sun, 06 May 2007 09:11:10 -0700, MathStuf wrote:

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 Tclass Matrix
{
public:
Matrix();
Matrix(Ini
&ini); // Only
applicable with MyClass
Matrix(unsigned w, unsigned h, T &d = T());

It is illegal to bind a rvalue to a non-const reference. Make this a
const T & if possible.

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<TGetRow(unsigned row);
std::vector<TGetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();

T operator[](Point &p);
std::vector<Toperator[](int col);
private:
std::vector< std::vector<T matrix; unsigned height;
unsigned width;
};

You can do it with template specialization, like so:

template<class Tstruct Base
{
// all common stuff from above
// ...

};

template<class Tstruct Matrix : Base<T>
{
Matrix();
Matrix(unsigned w, unsigned h);

};

class MyClass;
class Ini;

template<struct Matrix<MyClass: Base<MyClass>
{
Matrix();
Matrix(unsigned w, unsigned h);

// additional stuff
Matrix(Ini &ini);
// ...

};

There is some unavoidable duplication for the constructors unfortunately.

--
Markus

Would it just be easier to make methods that throw() for the other
types then?

--MathStuf

[Markus Schoder]

On Sun, 06 May 2007 10:01:57 -0700, MathStuf wrote:

On May 6, 12:56 pm, Markus Schoder <[e-mail]:

>On Sun, 06 May 2007 09:11:10 -0700, MathStuf wrote:

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 Tclass Matrix
{
public:
Matrix();
Matrix(Ini
&ini); // Only
applicable with MyClass
Matrix(unsigned w, unsigned h, T &d = T());

It is illegal to bind a rvalue to a non-const reference. Make this a
const T & if possible.

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<TGetRow(unsigned row);
std::vector<TGetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();

T operator[](Point &p);
std::vector<Toperator[](int col);
private:
std::vector< std::vector<T matrix; unsigned height; unsigned
width;
};

You can do it with template specialization, like so:

template<class Tstruct Base
{
// all common stuff from above
// ...

};

template<class Tstruct Matrix : Base<T{
Matrix();
Matrix(unsigned w, unsigned h);

};

class MyClass;
class Ini;

template<struct Matrix<MyClass: Base<MyClass{
Matrix();
Matrix(unsigned w, unsigned h);

// additional stuff
Matrix(Ini &ini);
// ...

};

There is some unavoidable duplication for the constructors
unfortunately.

--
Markus

Would it just be easier to make methods that throw() for the other types
then?

Yes probably, but I would rather not implement these methods for the
other types at all or even better use a compile time assertion. That way
the linker resp. compiler will tell you if someone tries to use these
methods with the wrong class.

--
Markus

[Sylvester Hesp]

"MathStuf" <Ma******@gmail.comwrote in message
news:11**********************@h2g2000hsg.googlegro ups.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 Tclass 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<TGetRow(unsigned row);
std::vector<TGetCol(unsigned col);
unsigned GetHeight();
unsigned GetWidth();

T operator[](Point &p);
std::vector<Toperator[](int col);
private:
std::vector< std::vector<T matrix;
unsigned height;
unsigned width;
};

You can use SFINAE

template<class Tclass 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 Tstruct enable_if_c { };
template<class Tstruct enable_if_c<true, T{ typedef T type; };

template<class T, class Ustruct is_same { static const bool value =
false; };
template<class Tstruct is_same<T,T{ static const bool value = true; };

template<class T, class Ustruct 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