Возвращаемый тип шаблона через std::common_type

template<typename V, typename U, size_t R, size_t C>
matrix</*U или V*/,R,C> operator+(const V& value, const matrix<U,R,C>& rhs)                      //!matrix+matrix
{
    std::cout<<"!matrix+matrix\n";
    std::cout<<"common_type<V,U>::type = "<<typeid(std::common_type<V,U>::type).name()<<std::endl;
    if (!std::is_fundamental<V>::value) throw std::logic_error ("Не совместимый тип при операции +\n");
    else
    {
        matrix<std::common_type<V,U>::type,R,C> ret_matrix(rhs);
        ret_matrix+=value;
        return ret_matrix;
    }
}

template<typename V, typename U, size_t R, size_t C>
matrix<std::common_type<V,U>::type,R,C> operator+(const V& value, const matrix<U,R,C>& rhs) {...}

if (!std::is_fundamental<V>::value) throw std::logic_error ("Не совместимый тип при операции +\n");

static_assert(std::is_fundamental<V>::value, "Не совместимый тип при операции +.");

matrix<typename std::common_type<U, V>::type, R, C>

template<typename V, typename U, size_t R, size_t C>
matrix<typename std::common_type<U, V>::type,R,C> operator+(const V& value, const matrix<U,R,C>& rhs)                       //!matrix+matrix
{
    //std::cout<<"!matrix+matrix\n";
    //std::cout<<"common_type<V,U>::type = "<<typeid(typename std::common_type<U, V>::type).name()<<std::endl;
    static_assert(std::is_fundamental<V>::value, "Не совместимый тип при операции +.");
    matrix<typename std::common_type<U, V>::type,R,C> ret_matrix(rhs);
    ret_matrix+=value;
    return ret_matrix;
}

template<class V, class U, size_t R, size_t C>
matrix<typeof(V() + U()),R,C> operator+(const V& value, const matrix<U,R,C>& rhs)
{
     // бла бла бла...
}

matrix<decltype(std::declval<V>() + std::declval<U>()), R, C>

template<class V, class U, size_t R, size_t C>
operator+(const V& value, const matrix<U,R,C>& rhs) -> matrix<typeof(value + rhs),R,C> 
{
     // бла бла бла...
}

//========================================================================
//========================================================================
//========================================================================
 
    /* demangle names ot types */
 
#include <typeinfo>
#include <string>
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
 
    #include <cxxabi.h>
    #include <memory>
    
    std::string demangle(const char* name) {
    
        int status = -1; 
        std::unique_ptr<char, void(*)(void*)> res {
            abi::__cxa_demangle(name, NULL, NULL, &status),
            std::free
        };
        return (status == 0) ? res.get() : name ;
    }
#else
 
    std::string demangle(const char* name) 
        { return name; }
 
#endif
 
template <class T> std::string type(const T& t) 
    { return demangle(typeid(t).name()); }
 
 
//========================================================================
//========================================================================
//========================================================================
 
#include <iostream>
 
template<class U, size_t R, size_t C>
struct matrix
{
    matrix(){}
    
    matrix(auto&& rsh)
        { std::cout << type(*this) << " was build!\n"; }
    
    matrix& operator+=(const auto& value) 
        { return *this; }
};
 
template<class V, class U>
    using common_t = 
        typename std::common_type<V,U>::type;
 
template<class V, class U, size_t R, size_t C>
    using matrix_t = 
        matrix< common_t<V,U>,R,C>;
 
 
template<class V, class U, size_t R, size_t C>
matrix_t<V,U,R,C> operator+(const V& value, const matrix<U,R,C>& rhs) 
{
    static_assert(
        std::is_fundamental<V>::value,
        "not compatible type for operator+"
    );
    
    std::cout <<"!matrix+matrix\n";
    
    std::cout << "common_type<V,U>::type = " 
        << type(common_t<V,U>{}) 
        << std::endl;
    
    matrix_t<V,U,R,C> ret_matrix(rhs);
    ret_matrix += value;
    return ret_matrix;
}
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    matrix<int, 10,20> matrixSample;
    auto result = 10.5 + matrixSample;
    
    std::cout << "type of result is " << type(result)<< std::endl;
    
}

common_type_t<V,U>

common_type_t<V,U>