no match for ‘operator=

Question

I am able to perform operations on points of like types together but not able to perform operations on points of unlike types. I think I need some way of casting the vector coordinates of point int into a vector coordinate of vector double.

#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>

#if 1
    #define log(x) std::cout << x << std::endl;
#else
    #define log(x)
#endif

template<typename type>
std::vector<type> operator+(const std::vector<type> l, const std::vector<type> r){
    std::vector<type> ans;
    std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::plus<type>());
    return ans;
};
template<typename type>
std::vector<type> operator*(const std::vector<type> l, const std::vector<type> r){
    std::vector<type> ans;
    std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::multiplies<type>());
    return ans;
};
template<typename type>
std::vector<type> operator-(const std::vector<type> l, const std::vector<type> r){
    std::vector<type> ans;
    std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::minus<type>());
    return ans;
};
template<typename type>
std::vector<type> operator/(const std::vector<type> l, const std::vector<type> r){
    std::vector<type> ans;
    std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::divides<type>());
    return ans;
};

template<class type> struct point{

    template<typename a = type, typename... b> point(a coordinate, b... coordinates){
        this->coordinates = {coordinate, coordinates...};
    };std::vector<type> coordinates;

    template<typename a = type> point(std::vector<a> coordinates){
        this->coordinates = coordinates;
    };
    friend point<type> operator+(const point<type>& l, const point<type>& r){
        point<type> ans(l.coordinates + r.coordinates);
        return ans;
    };
    friend point<type> operator*(const point<type>& l, const point<type>& r){
        point<type> ans(l.coordinates * r.coordinates);
        return ans;
    };
    friend point<type> operator-(const point<type>& l, const point<type>& r){
        point<type> ans(l.coordinates - r.coordinates);
        return ans;
    };
    friend point<type> operator/(const point<type>& l, const point<type>& r){
        point<type> ans(l.coordinates / r.coordinates);
        return ans;
    };
    friend std::ostream& operator<<(std::ostream& stream, const point& p){
        switch(p.coordinates.size()){
        case 1:
            std::cout << "(" << p.coordinates[0] << ")";
            break;
        default:    
            std::cout << "("; 
            for(int i = 0; i < p.coordinates.size(); ++i){
                if(i == (p.coordinates.size() - 1))
                    std::cout << p.coordinates[i];
                else
                    std::cout << p.coordinates[i] << ", ";
            }
            std::cout << ")";
            break;
        }
    }
};
int main(){
    point<int> a(2,5,5,4,3);
    point<int> b(3,5,3,5,7);
    point<double> c(a/b);
    log(c);
    return 0;
}

Answer 1

You either need to write implementations of operator= that accept the appropriate right hand sides or you can use a templated<> operator=. This is the C++11 implementation, if you don't have C++11 you'll want version 2

template<typename T>
struct Point {
    using value_type = T;
    using self_type = Point<T>;

    value_type m_value;

    Point(value_type value) : m_value(value) {}

    template<typename RhsT> self_type& operator = (const Point<RhsT>& rhs) {
        m_value = static_cast<value_type>(rhs.m_value);
        return *this;
    }
};

int main() {
    Point<int> a1(4);
    Point<int> a2(5);
    Point<double> a3(6.0);

    a1 = a2;
    a2 = a3;

    return 0;
}

http://ideone.com/csATfH Pre-C++11 version:

#include <string>
#include <type_traits>

template<typename T>
struct Point {
    typedef T value_type;
    typedef Point<T> self_type;

    value_type m_value;

    Point(value_type value) : m_value(value) {}

    template<typename RhsT>
    self_type& operator = (const Point<RhsT>& rhs) {
        m_value = static_cast<value_type>(rhs.m_value);
        return *this;
    }
};

int main() {
    Point<int> a1(4);
    Point<int> a2(5);
    Point<double> a3(6.0);

    a1 = a2;
    a2 = a3;

    return 0;
}

http://ideone.com/w24O9s

Fancy version with enable_if:

#include <string>
#include <type_traits>

template<typename T>
struct Point {
    using value_type = T;
    using self_type = Point<T>;

    value_type m_value;

    Point(value_type&& value) : m_value(std::forward<value_type>(value)) {}

    template<typename RhsT,
        typename std::enable_if<
            std::is_arithmetic<value_type>::value
            && std::is_arithmetic<RhsT>::value, int>::type = 0>
    self_type& operator = (Point<RhsT>&& rhs) {
        m_value = static_cast<value_type>(rhs.m_value);
        return *this;
    }
};

int main() {
    Point<int> a1(4);
    Point<int> a2(5);
    Point<double> a3(6.0);
    Point<std::string> a4("hello");

    a1 = a2;
    a2 = a3;

    a3 = a4;

    return 0;
}

http://ideone.com/OtD24Y