What exactly is a function signature?

**linuxdude** · 07-01-2009

Originally Posted by laserlight

Because member names in the derived class hide corresponding member names in the base class, so you should use a using declaration to bring back the member names from the base class as necessary.

Would this be the appropriate solution

Code:

#include <iostream>

class A {
  public:
   virtual int oper(int x, int y) {
      return x + y;
   }
   virtual double oper(double x, double y) {
      return x + y;
   }
};

class B : public A {
  public:
   virtual double oper(double x, double y) {
      return x * y;
   }
};

int main(void) {
   A x;
   B y;
   std::cout << x.oper(1,2) << std::endl; // 3
   std::cout << x.oper(1.10,2.0) << std::endl; // 3.1
   std::cout << y.oper(1,2) << std::endl; // 2, not 3 because oper has derived class's member has overriden base class's name
   std::cout << dynamic_cast<A&>(y).oper(1,2) << std::endl; // 3, realizes to use base class's member function for ints
   std::cout << y.oper(1.10,2.0) << std::endl; // 2.2
   return 0;
}

I have never run into this before. Does it come up anywhere in typical development or in the standard libraries?

**cpjust** · 07-01-2009

Originally Posted by laserlight

That is not true. The virtual function override cannot have a different return type specified, unless that return type is a subtype. In such cases, it can actually be a good idea to make use of such covariant return types.

I think this is what I was referring to:
Chapter 38: Practice Safe Overriding
Although, the example they use is when changing default argument values.

**brewbuck** · 07-01-2009

Originally Posted by Sebastiani

But what about:

Code:

struct base
{
    virtual operator string ( void ) const;
    
    virtual operator int ( void ) const;
};

In one case the function name is "operator string" and in the other case "operator int". The two functions have different names and therefore do not overload each other.

**anon** · 07-01-2009

Would this be the appropriate solution

You could rather use:

Code:

y.A::oper(1,2)

Laserlight's suggestion probably makes more sense, since it would be very awkward having to know which base class's method should be called in one or another particular case, especially since the compiler won't tell you when you get it wrong.

**Sebastiani** · 07-01-2009

>> In one case the function name is "operator string" and in the other case "operator int". The two functions have different names and therefore do not overload each other.

Yes, but if you look at my second example it's clear that the practical implications are the same. The compiler finds an ambiguity that it can't resolve unless the "arguments" to the conversion (ie: float or double) are specified. In that sense, it's essentially as if the functions have the same name (although technically, you are probably correct). But as Laserlight pointed out, this isn't a matter of function overloading but of implicit conversion, so it doesn't even apply to the same section of the standard.

**linuxdude** · 07-01-2009

Originally Posted by anon

You could rather use:

Code:

y.A::oper(1,2)

Laserlight's suggestion probably makes more sense.

So for my example class B would be

Code:

class B : public A {
  public:
   using A::oper;
   virtual double oper(double x, double y) {
      return x * y;
   }
};

This does as I expect, but did the compiler bring both of A's oper functions and then override the oper(double, double) function?

**laserlight** · 07-01-2009

Originally Posted by cpjust

I think this is what I was referring to:
Chapter 38: Practice Safe Overriding
Although, the example they use is when changing default argument values.

I see. I am probably stating the obvious, but of course changing default arguments is different from changing return types.

Originally Posted by linuxdude

This does as I expect, but did the compiler bring both of A's oper functions and then override the oper(double, double) function?

Yes, the using declaration makes the name from the base class available in the derived class' scope, and both member functions have the same name.

Thread: What exactly is a function signature?

Thread Tools

Search Thread

Display

Similar Threads

Seg Fault in Compare Function

Another syntax error

In over my head

Including lib in a lib

string::find_last_of function signature