Thread: why redeclare virtual functions for overloading?

O_o

Those aren't overloads; those are overrides.

You need them to tell the compiler about them.

Soma

You don't need to redeclare them in most cases. See the following:

Code:

#include <iostream>

struct base
{
    virtual void foo()
    { std::cout << "base" << std::endl; }
};

struct derived1 final : base 
{ }; // derived1 is-a base, so foo() is available

struct derived2 final : base 
{
    /* can be used to assign a new protection level of base members
        (from protected -> public, for example) or explicitly forward */
    using base::foo;
};

struct derived3 final : base 
{
    /* override added in C++11 but not required for this to work */
    void foo() override 
    { std::cout << "derived3" << std::endl; }
};

int main()
{
    derived1 d1;
    d1.foo();
    
    derived2 d2;
    d2.foo();
    
    derived3 d3;
    d3.foo();
}

Just because the compiler could in principle deduce that you are overriding a virtual function, doesn't mean such function definitions should act inherently different than other function definitions.

Imagine two possible rules:

1. All functions which are part of a class must be declared.

2. All functions which are part of a class must be declared, unless that function is an override of a virtual function in a base class.

Which of these rules is easier to remember? Which of these rules is simpler? Which of these rules provides more consistency in the language?

For one thing, consumers of code don't necessarily get to see the source. They only need the declarations. It is valuable, as a user of class B, to know that B overrides a virtual function. Why would we hide this information from the user of the class?

If we go this route, where should we stop? Maybe we don't need to declare variables, because their types can often be inferred from their usage...

You don't need to redeclare them in most cases.

O_o

You do in the situations invoked.

override added in C++11 but not required for this to work

That is because the `override' specifier doesn't enable the option to override a virtual function; the `override' specifier instead guarantees that a matching virtual function exists to override.

Soma

I should also note that you can use the override specifier in VS2010, although it generates a warning by default, which is easily disabled.

Originally Posted by iMalc

I should also note that you can use the override specifier in VS2010, although it generates a warning by default, which is easily disabled.

but i continue with re-declaration, and i need avoid that
my big objective is avoid the re-declaration
how can i declare functions, in base, for be changed in another class derived from base without re-declare them?

Originally Posted by joaquim

but i continue with re-declaration, and i need avoid that
my big objective is avoid the re-declaration
how can i declare functions, in base, for be changed in another class derived from base without re-declare them?

You can't.

A base class determines if a derived class is permitted to override a member function. It does that by declaring the function virtual.

It is the derived class that determines if it does an override. The purpose of the declaration in the derived class is to alert the compiler that it is doing so.

Originally Posted by joaquim

my big objective is avoid the re-declaration
how can i declare functions, in base, for be changed in another class derived from base without re-declare them?

Does it really matter? You are going to define the override anyway, and that is more work than a forward declaration. Perhaps you are concerned about names from the base class becoming hidden (e.g., because you added an overload instead of or in addition to an override), but that can be fixed by a using declaration.

Originally Posted by joaquim

"Does it really matter?"
depends for what you need... in my case, yes.
sorry if don't make sence to some of you.. realy.. sorry. but i need these.
the question can be stupid, but make sence: why re-declare virtual functions, if they can be overrrided?

Because the purpose of the redeclaration, as I said in previous post, is to specify that the inherited function is being overridden. The declaration in the base class is only specifying that it can be, not that it will be.


There are times when you have to accept "you can't" as an answer. That is the case here.

Originally Posted by joaquim

depends for what you need... in my case, yes.

What is your case?

Originally Posted by joaquim

convert a new language to C\C++ language. that's why i need avoid the re-declaration of functions that need be overrrided(if i want).

Then the converter (e.g. a compiler for your language) needs to implement machinery so it outputs correct C/C++ code even in such a case.

I think you'll find that, unless the rules of your "new language" are rather proscriptive, that it will not be possible. The fact you haven't thought thought all the potential cases in your language does not mean that C++ does things wrong.