Template deduction complaints ambiguous candidates

Question

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.

score 3 · Answer 1 · edited Nov 13 '18 at 11:14

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.

score 0 · Answer 2 · answered Nov 13 '18 at 06:40

0

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;
}

answered Nov 13 '18 at 06:40

Gaurav Sehgal

7,422
2
18
34

You beat me to it! – Francis Cugler Nov 13 '18 at 06:47
Thanks. This suggestion does work. For the deeper discussion, is it possible to make the two cases both work as no operands precedence need to be cared about for the user? – Rubin Nov 13 '18 at 06:57
Nice answer. However, this works only because you play with the order of the parameters (with an operator that is assumed to be commutative). – Christophe Nov 13 '18 at 07:06
@Rubin I think the term you are looking for is commutate and not precedence. The commutative property says that `a*b` is equal to `b*a`. Precedence is used to decide in which order several operators are executed: `a + b * c` where multiplication has a higher precedence and will be calculated before the addition. Also here a link to a question about commutative property in the non-templated case: https://stackoverflow.com/questions/3764604/commutative-oprator-overloading-of-2-different-objects – Philipp Nov 13 '18 at 07:41
@Philipp Thanks for the correction. The **commutative property** is indeed what I need. – Rubin Nov 13 '18 at 07:49
@Rubin yes it is possible to solve the ambiguity without forcing the user to decide the right order to use. Because having a semantic that relies on the order of arguments in a commutative operation goes against POLA. – Christophe Nov 13 '18 at 08:31
The member function is prefered because the **implied object paramenter is not const**!!! Declares spv as const, and you will get the same error message. – Oliv Nov 13 '18 at 10:03

Template deduction complaints ambiguous candidates

2 Answers2