Wsrtjtyk

I intend to implement the multiplication operator of my "Sparse Vector" and "Vector" classes. The following simplified code demo shows my problem

The Vector class in Vector.hpp

#pragma once



template <typename T>

class Vector 

{

public:

    Vector() {}



    template <typename Scalar>

    friend Vector operator*(const Scalar &a, const Vector &rhs)     // #1

    {

        return Vector();

    }

};

The Sparse Vector class in SpVec.hpp

#pragma once

#include "Vector.hpp"



template <typename T>

class SpVec 

{

public:

    SpVec() {}



    template <typename U>

    inline friend double operator*(const SpVec &spv, const Vector<U> &v)   // #2

    {

        return 0.0;

    }

};

The test code in main.cpp:

#include "Vector.hpp"

#include "SpVec.hpp"





#include <iostream>



int main() 

{

    Vector<double> v;



    SpVec<double> spv;



    std::cout << spv * v;

    return 0;

}

I build the test program with

g++ main.cpp -o test

which gives the ambiguous template deduction error

main.cpp: In function ‘int main()’:

main.cpp:13:26: error: ambiguous overload for ‘operator*’ (operand types are ‘SpVec<double>’ and ‘Vector<double>’)

        std::cout << spv * v;

                    ~~~~^~~

In file included from main.cpp:2:0:

SpVec.hpp:12:26: note: candidate: double operator*(const SpVec<T>&, const Vector<U>&) [with U = double; T = double]

    inline friend double operator*(const SpVec &spv, const Vector<U> &v)   // #2

                        ^~~~~~~~

In file included from main.cpp:1:0:

Vector.hpp:10:19: note: candidate: Vector<T> operator*(const Scalar&, const Vector<T>&) [with Scalar = SpVec<double>; T = double]

    friend Vector operator*(const Scalar &a, const Vector &rhs)     // #1

I expect the #2 method definition is more close to my calling.

Please help me understand how the ambiguous error comes out and how to resolve the issue.

I come up with another idea that the prior type information Scalar can be used with the SFAINE feature enabled by the c++11 standard library struct std::enable_if.

The codes:

Vector.hpp

#pragma once



#include <iostream>

#include <type_traits>



template <typename T>

class Vector

{

public:

    Vector() {}



    template <typename Scalar>

    typename std::enable_if<std::is_arithmetic<Scalar>::value, Vector<T>>::type

    operator*(const Scalar &rhs) const// #1

    {

        std::cout << "Vector * Scalar called." << std::endl;

        return Vector();

    }



    template <typename Scalar>

    inline friend typename std::enable_if<std::is_arithmetic<Scalar>::value, Vector<T>>::type

    operator*(const Scalar &lhs, const Vector &rhs)

    {

        std::cout << "Scalar * Vector called." << std::endl;

        return Vector();

    }

};

SpVec.hpp

#pragma once

#include "Vector.hpp"



#include <iostream>



template <typename T>

class SpVec

{

public:

    SpVec() {}



    template <typename U>

    inline double operator*(const Vector<U> &rhs) const // #2 as member function

    {

        std::cout << "SpVec * Vector called" << std::endl;

        return 0.0;

    }



    template <typename U>

    inline friend double operator*(const Vector<U> &lhs, const SpVec &rhs)

    {

        std::cout << "Vector * SpVec called" << std::endl;

        return 0.0;

    }

};

main.cpp

#include "SpVec.hpp"

#include "Vector.hpp"



#include <iostream>



int main()

{

    Vector<double> v;

    SpVec<double> spv;



    double a = spv * v;

    a = v * spv;



    Vector<double> vt;

    vt = v * 2.0;

    vt = 2.0 * v;



    return 0;

}

Build the program with c++11

g++ -std=c++11 main.cpp -o test

The result:

SpVec * Vector called.

Vector * SpVec called.

Vector * Scalar called.

Scalar * Vector called.

The argument to operator* are SpVec<double> and Vector<double>. It could be resolved to

operator*(const Scalar &a, const Vector &rhs) with scalar as SpVec<double> and rhs as Vector<double>.

It could also resolve to

operator*(const SpVec &spv, const Vector<U> &v) with spv as SpVec<double> and U as double.

One way of resolving this is to turn Vector::operator* to non-friend function.

Vector operator*(const Scalar &a)     // #1

{

    //The other argument here will be accessed using this pointer.

    return Vector();

}

and you can call it as

int main() 

{

   Vector<double> v;

   SpVec<double> spv;

   std::cout << spv * v; // will call #2

   v * spv;              //will call #1

   return 0;

}