Preset template argument for specific constructor - c++

Question

I am currently in the process of implementing a scientific toolkit using C++. When i implemented the Matrix class i encountered a problem with the conversion constructor:
template<size_t ROWS, size_t COLS = ROWS>
class Matrix {
public:
...
/** \brief Creates a matrix from a vector */
Matrix<ROWS, 1> (const Vector<ROWS>& vector) {
for (size_t i = 0; i < ROWS; i++) {
(*this)[i][0] = vector[i];
}
...
}
This code compiles just fine with clang++, but fails using g++ with
matrix.h:43:18: error: invalid declarator before ‘(’ token
Matrix<ROWS, 1> (const Vector<ROWS>& vector) {
Is there any other way to force certain template arguments for specific constructors? Is the way i am doing it not standard-compliant or should i report a bug to gcc?

Answer 1

Use partial specialization like this:
template<size_t ROWS, size_t COLS = ROWS>
class Matrix {
// ... (regular ROWS x COLS matrix code)
};
template<size_t ROWS>
class Matrix<ROWS, 1u> {
// ... (more ROWS x 1 matrix code)
/// \brief Creates a matrix from a vector
Matrix(const Vector<ROWS> & vector) {
for (size_t i = 0u; i < ROWS; i++)
(*this)[i][0u] = vector[i];
}
// ... (more ROWS x 1 matrix code)
};
Or if this would result in too much code duplication, just declare a common base class for the specializations. For example something like this (in c++11):
template<size_t ROWS, size_t COLS = ROWS>
class MatrixBase {
// ... (regular ROWS x COLS matrix code)
};
template<size_t ROWS, size_t COLS = ROWS>
class Matrix: public MatrixBase<ROWS, COLS> {
public: /* Methods: */
using MatrixBase<ROWS, COLS>::MatrixBase;
};
template<size_t ROWS>
class Matrix<ROWS, 1u>: public MatrixBase<ROWS, 1u> {
public: /* Methods: */
using MatrixBase<ROWS, 1u>::MatrixBase;
Matrix(const Vector<ROWS> & vector) {
for (size_t i = 0u; i < ROWS; i++)
(*this)[i][0u] = vector[i];
}
};
For C++03 and earlier you can't use the using keyword this way and may still have to define constructors for all specializations which call the respective base class constructors, e.g. Matrix(SomeArg arg) : MatrixBase(arg) {}. And if you're using GCC 4.7 where this C++11 using statement is not supported, you can use perfect forwarding to avoid writing separate constructors in the specializations for all base class constructors, e.g. template <typename ... Args> Matrix(Args && ... args) : MatrixBase(std::forward<Args>(args)...) {}.

Answer 2

Is it necessary to reimplement all methods, or is it somehow possible to use unspecialized methods in the specialized template without duplicating code?
A partially-specialized class doesn't contain declarations of the primary template's member functions, static member functions, enumerations, member classes, etc. Therefore you would have to redefine the entire class and reimplement them if you want to use them. As an alternative, if you have C++11 support, you can use constructor delegation by calling a private constructor based on a given condition:
template<size_t ROWS, size_t COLS = ROWS>
class Matrix
{
public:
Matrix(const Vector<ROWS>& vector)
: Matrix(vector, std::integral_constant<bool, COLS == 1>())
{ }
private:
// Implementation for COLS == 1
Matrix(const Vector<ROWS>& vector, std::true_type)
{
}
// Implementation for COLS != 1
Matrix(const Vector<ROWS>& vector, std::false_type)
{
}
};