Providing a method only in a partial specialization - c++

Question

I have class Matrix and i want a specialized method of len() if R = 3 and C = 1.
I would like to have solution with the standard library.
Inheritance is not a solution because it wont work on the base class too.
Normal template specialization like
template<class T>
class Matrix<T, 3, 1> {
public:
T len() const {return 3;}
};
would force me to implement all other Matrix<T, R, C> methodes and stuff too. (?)
Ideas:
std::enable_if
constexpr
...
#include <vector>
template<class T, std::size_t R, std::size_t C>
class Matrix {
private:
std::vector <T> data;
public:
T len() const;
};
A dirty solution would be:
template<class T, std::size_t R, std::size_t C>
T Matrix<T, R, C>::len() const {
if constexpr (R == 3 && C == 1) {
return 3;
}
throw std::runtime_error("len not available");
}

Answer 1

A simple solution using std::enable_if.
#include <type_traits> // std::enable_if
#include <vector> // std::vector
template <class T, std::size_t R, std::size_t C>
class Matrix {
private:
std::vector<T> data;
public:
template <std::size_t C_ = C, typename = std::enable_if_t<C_ == 1>>
std::size_t len() const {
double res = 0;
for (const auto& x : data) {
res += std::pow(x, 2);
}
return std::sqrt(res);
}
};
Alternative out-of-line definition:
template <class T, std::size_t R, std::size_t C>
class Matrix {
private:
std::vector<T> data;
public:
template <std::size_t R_ = R,
std::size_t C_ = C,
typename E1 = std::enable_if_t<R_ == 3>,
typename E2 = std::enable_if_t<C_ == 1>>
double len() const;
};
template <class T, std::size_t R, std::size_t C>
template <std::size_t R_, std::size_t C_, typename E1, typename E2>
double Matrix<T, R, C>::len() const {
double res = 0;
for (const auto& x : data) {
res += std::pow(x, 2);
}
return std::sqrt(res);
}
Example:
#include <iostream> // std::cout, std::endl
int main(int argc, char* argv[]) {
Matrix<double, 3, 1> vec;
std::cout << "vec length: " << vec.len() << std::endl;
// output: vec length: 3
// Matrix<double, 3, 3> mat;
// std::cout << "mat length: " << mat.len() << std::endl; // does not compile
return 0;
}

Answer 2

One possible approach:
Explanation inline as comments:
#include <iostream>
template<class T, int R, int C>
struct Matrix;
namespace MatrixOperations
{
// default handling is to prevent compilation
template<class Mat>
auto len(Mat const&) -> void = delete;
// special case for a 3,1 matrix
template<class T>
auto len(Matrix<T, 3, 1> const&) -> T
{
return T(3);
}
};
template<class T, int R, int C>
struct Matrix
{
// ForceDeduce is a defaulted type.
// The argument of this type is defaulted
// It's purpose is to ensure that this function is not actually compiled until it is used
// This will prevent the call to MatrixOperations::len producing an error unless this function
// is called
template<class ForceDeduce = int*>
T len(ForceDeduce = nullptr) const
{
return MatrixOperations::len(*this);
}
};
int main()
{
Matrix <int, 3, 1> m31;
std::cout << m31.len() << std::endl;
Matrix <int, 3, 2> m32;
// fails to compile
// std::cout << m32.len() << std::endl;
}