Question on Virtual and default arguments

Question

I wanted to have confirmation about the following things:

Virtual Mechanism:

I f I have a base class A and it has a Virtual method, then in the derived class generally, we do not include the virtual statement in the function declaration. But what does a virtual mean when included at the dervied class definition.

class A
{
public: 
virtual void something();
}

class B:public A
{
public:
virtual void something();
}

Does, that mean that we want to override the method somethign in the classes that derive from the class B?

Also, another question is,

I have a class A, which is derived by three different classes.Now, there is a virtual method anything(), in the base class A.

Now, if I were to add a new default argument to that method in the base class, A::anything(), I need to add it in all the 3 classes too right.

My pick for the answers:

1. If a method which is virtual in the base class is redefined in the derived class as virtual then we might mean that it shall be overridden in the corresponding derived classes which uses this class as base class.
2. Yes.If not overriding does not have any meaning.

Pls let me know if what I feel(above 2) are correct.

Thanks, Pavan Moanr.

Answer 1

The virtual keyword can be omitted on the override in the derived classes. If the overridden function in the base class is virtual, the override is assumed to be virtual as well.

This is well covered in this question: In C++, is a function automatically virtual if it overrides a virtual function?

---

Your second question is about default values and virtual functions. Basically, each override can have a different default value. However, usually this will not do what you expect it to do, so my advice is: do not mix default values and virtual functions.

Whether the base class function is defaulted or not, is totally independent from whether the derived class function is defaulted.

The basic idea is that the static type will be used to find the default value, if any is defined. For virtual functions, the dynamic type will be used to find the called function.

So when dynamic and static type don't match, unexpected results will follow.

e.g.

#include <iostream>

class A
{
public:
  virtual void foo(int n = 1) { std::cout << "A::foo(" << n << ")" << std::endl; }
};

class B : public A
{
public:
  virtual void foo(int n = 2) { std::cout << "B::foo(" << n << ")" << std::endl; }
};

int main()
{
  A a;
  B b;

  a.foo(); // prints "A::foo(1)";
  b.foo(); // prints "B::foo(2)";

  A& ref = b;
  ref.foo(); // prints "B::foo(1)";
}

If all your overrides share the same default, another solution is to define an additional function in the base class that does nothing but call the virtual function with the default argument. That is:

class A
{
public:
   void defaultFoo() { foo(1); }
   virtual void foo(int n) { .... }
};

If your overrides have different defaults, you have two options:

• make the defaultFoo() virtual as well, which might result in unexpected results if a derived class overload one but not the other.
• do not use defaults, but explicitly state the used value in each call.

I prefer the latter.

Answer 2

As someone pointed out, a function in a derived class with the same name and type signature as a virtual function in the base class is automatically always a virtual function.

But your second question about default arguments is interesting. Here is a tool for thinking through the problem...

class A {
  public:
   virtual void do_stuff_with_defaults(int a = 5, char foo = 'c');
};

is nearly equivalent to this:

class A {
  public:
   virtual void do_stuff_with_defaults(int a, char foo);

   void do_stuff_with_defaults() { // Note lack of virtual keyword
      do_stuff_with_defaults(5, 'c'); // Calls virtual function
   }

   void do_stuff_with_defaults(int a) { // Note lack of virtual keyword
      do_stuff_with_defaults(a, 'c'); // Calls virtual functions
   }
};

Therefore you are basically having virtual and non-virtual functions with the same name but different type signatures declared in the class if you give your virtual function default arguments.

On way it isn't equivalent has to do with being able to import names from the base class with the using directive. If you declare the default arguments as separate functions, it's possible to import those functions using the using directive. If you simply declare default arguments, it isn't.

Answer 3

Here is a little experiment to test out what you want to know:

class A {
public:
        virtual void func( const char* arg = "A's default arg" ) {
                cout << "A::func( " << arg << " )" << endl;
        }
};

class B : public A {
public:
        void func( const char* arg = "B's default arg" ) {
                cout << "B::func( " << arg << " )" << endl;
        }
};

class C : public B {
public:
        void func( const char* arg ) {
                cout << "C::func( " << arg << " )" << endl;
        }
};

int main(int argc, char* argv[])
{
        B* b = new B();
        A* b2 = b;
        A* c = new C();
        b->func();
        b2->func();
        c->func();
        return 0;
}

result:

B::func( B's default arg )
B::func( A's default arg )
C::func( A's default arg )

conclusion:

1- virtual keyword before A's func declaration makes that function virtual in B and C too.

2- The default argument used is the one declared in the class of pointer/reference you are using to access the object.

Answer 4

It doesn't matter whether you write virtual in derived class or not, it will always be virtual because of the base class, however it is still better to include virtual to explicitly state that it is virtual and then if you accidentally remove that keyword from base class it will give you compiler error (you cannot redefine non-virtual function with a virtual one). EDIT >> sorry, I was wrong. You can redefine non-virtual function with a virtual one however once it's virtual all derived classes' functions with same signature will be virtual too even if you don't write virtual keyword. <<

If you don't redefine virtual function then the definition from base class will be used (as if it were copied verbatim).

If you wish to specify that a virtual function should be redefined in dervied class you should not provide any implementation i.e. virtual void something() = 0; In this case your class will be an abstract base class (ABC) and no objects can be instantiated from it. If derived class doesn't provide it's own implementetian it will also be an ABC.

I'm not sure what do you mean about default arguments but function signatures should match so all parameters and return values should be the same (it's best to not mix overloading/default arguments with inheritance because you can get very surprising results for example:

class A
{
public: 
void f(int x);
};

class B:public A
{
public:
void f(float x);
};

int main() {
B b;
b.f(42); //this will call B::f(float) even though 42 is int
}