c++ method call (lvalue) binding to function(rvalue) in derived class instead of function(lvalue) in base class

Question

I am new to C++ and trying to write a interface as below:

template <class T>
class Comparable
{
   protected:
      Comparable(){};
   public:
      virtual int compare(const T&&)=0;
      int compare(const T& o)
      {
         return this->compare(std::move(o));
      }
};

I did this to try to get the compare method to work with both l/r values. I derived the following class from Comparable:

class Monkey : Comparable<Monkey>
{
   private:
      char name[512];
   public:
      Monkey(const char*&& name)
      {
         strcpy(this->name, name);
      }
      const char *getName() { return name; }
      int compare(const Monkey&& m)
      {
         return strcmp(name, m.name);
      }
};

with the main() method as follows:

Monkey m1(argv[1]), m2(argv[2]);
printf("\"%s\" \"%s\" %d\n", m1.getName(), m2.getName(), m2.compare(m1));

But i get a compilation error:

cannot bind 'Tests::Monkey' lvalue to 'const Tests::Monkey&&' initializing argument 1 of 'virtual int Tests::Monkey::compare(const Tests::Monkey&&)' Build Failed

Why is the method call not binding to the compare method in the base class?

When i create them both as virtual in the base class and write them both in the derived class, the binding works fine, but it doesn't work and i get a compile error if I try to compile it as it's written here.

I don't really see why you use rvalue references everywhere. Normal const-reference for the `compare` function would work just fine. And passing an rvalue reference to `const char*`? That really doesn't make much sense. Lastly, constant rvalue references often makes no sense either. — Some programmer dude, Mar 14 '17 at 08:24
i'm new to c++. i think references prevent copying, which is the default behavior of function calls, so i thought it might be a good practice to get into the habit of using them and get accustomed to them. And i've seen const references before. Though the performance impact of it is probably negligible. — Joe Paul, Mar 14 '17 at 08:30
@JoePaul Reference introduces [overhead](http://stackoverflow.com/questions/8250932/what-is-the-overhead-of-passing-a-reference) too. const lvalue reference will do perferect in your case. rvalue reference is mainly used for perfect forwarding and move semantics. — felix, Mar 14 '17 at 08:44

songyuanyao · Accepted Answer · 2017-03-14T08:44:25.073

This is name hiding; name in the derived class hides name in the base class. In short, you can't overload functions through different scopes.

According to the rule of unqualified name lookup, for m2.compare(m1), m2 is of type Monkey, the name compare will be found at the scope of the derived class Monkey firstly, then name lookup stops. The compares in the base class won't be considered for the following overload resolution at all.

(emphasis mine)

For an unqualified name, that is a name that does not appear to the right of a scope resolution operator ::, name lookup examines the scopes as described below, until it finds at least one declaration of any kind, at which time the lookup stops and no further scopes are examined.

You can introduce the names of base class into the scope of the derived class by using:

class Monkey : Comparable<Monkey>
{
      ...

      using Comparable<Monkey>::compare;
      int compare(const Monkey&& m)
      {
         return strcmp(name, m.name);
      }
};

c++ method call (lvalue) binding to function(rvalue) in derived class instead of function(lvalue) in base class

1 Answers1