Compiler Warning C4373 about virtual methods

Hello everyone,


The following code will result in C4373 warning message. In MSDN,

http://msdn2.microsoft.com/en-us/library/bb384874.aspx

I do not quite understand the following statement,

1. What means "bind"? Putting function pointer into the vtable of the related class?

2. const is ignored in derived class?

--------------------
This means the compiler must bind a function reference to the method in either the base or derived class.

Versions of the compiler prior to Visual C++ 2008 bind the function to the method in the base class, then issue a warning message. Subsequent versions of the compiler ignore the const or volatile qualifier, bind the function to the method in the derived class, then issue warning C4373. This latter behavior complies with the C++ standard.
--------------------

Code:

---

class Base {
public:
        virtual int goo (const int input) {return 200;}
};

class Derived : public Base {
public:
                virtual int goo (int input) {return 200;} // change const property of input parameter
};

int main()
{
        Derived d;
        const int a = 1000;
        d.goo (a); // pass const to non-const

        return 0;
}

---

Compile warning message,

1>d:\visual studio 2008\projects\test_overriding1\test_overriding1\ma in.cpp(8) : warning C4373: 'Derived::goo': virtual function overrides 'Base::goo', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
1> d:\visual studio 2008\projects\test_overriding1\test_overriding1\ma in.cpp(3) : see declaration of 'Base::goo'


regards,
George

In the Derived class, the int parameter to goo() is missing the const keyword.

There are now two functions; one taking a const int argument and another a int argument. You are basically rendering the virtual keyword useless.

When deriving from a base class and wanting to implement a virtual function, you must declare the function exactly as it was declared in the base class. i.e. the function headers must match. The only exception is when the base class function returns a reference to a some object base class. In that case you are allowed to return a reference to a derived object of that class.

This process entails only the redefinition of a function. By changing the argument type you in fact creating a new function. The compiler is warning that might not be what you intended.

>> This latter behavior complies with the C++ standard.
Correct. It's just a warning for people who upgrade their compiler and may get different results with the same code.

gg

Well, I take that back - it's not about getting different results. It's a new warning that MS added - but for some reason they decided to let you know that the previous version "did the right thing" as well.

Here's a sample I just tried on VC 6.0 and 2005:

Code:

---

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void goo (const int input)
        {cout << "Base(" << input << ")" << endl;}
};

class Derived : public Base
{
public:
        virtual void goo (int input)
            {cout << "Derived(" << input << ")" << endl;}
};

int main()
{
    const int ci = 1;
    int i = 2;

    Derived d;
    d.goo(ci);
    d.goo(i);

    Base *b = &d;
    b->goo(ci);
    b->goo(i);

    return 0;
}

---

Both versions returned:

Code:

---

Derived(1)
Derived(2)
Base(1)
Base(2)

---

gg

Hi Mario,


Could you let me know if we change the const property of overridden method, which expected effect of virtual function or other aspects of expected effect is broken please?

From MSDN, seems all virtual function related expected results are maintained.

http://msdn2.microsoft.com/en-us/library/bb384874.aspx

Quote:

---

Originally Posted by Mario F.

There are now two functions; one taking a const int argument and another a int argument. You are basically rendering the virtual keyword useless.

When deriving from a base class and wanting to implement a virtual function, you must declare the function exactly as it was declared in the base class. i.e. the function headers must match. The only exception is when the base class function returns a reference to a some object base class. In that case you are allowed to return a reference to a derived object of that class.

This process entails only the redefinition of a function. By changing the argument type you in fact creating a new function. The compiler is warning that might not be what you intended.

---

Hi Codeplug,

For your code below, the ouput in Visual Studio 2008 is,

Derived(1)
Derived(2)
Derived(1)
Derived(2)

Quote:

---

Originally Posted by Codeplug

Well, I take that back - it's not about getting different results. It's a new warning that MS added - but for some reason they decided to let you know that the previous version "did the right thing" as well.

Here's a sample I just tried on VC 6.0 and 2005:

Code:

---

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void goo (const int input)
        {cout << "Base(" << input << ")" << endl;}
};

class Derived : public Base
{
public:
        virtual void goo (int input)
            {cout << "Derived(" << input << ")" << endl;}
};

int main()
{
    const int ci = 1;
    int i = 2;

    Derived d;
    d.goo(ci);
    d.goo(i);

    Base *b = &d;
    b->goo(ci);
    b->goo(i);

    return 0;
}

---

Both versions returned:

Code:

---

Derived(1)
Derived(2)
Base(1)
Base(2)

---

gg

---

regards,
George

It seems the warning makes sense now. The previous versions did the right thing, but 2008 fixes your little mistake for you.

Hmm... does it? I sure hope it doesn't.

Am I reading the standard wrong? I'd expect dynamic binding to not happen when I add the const qualifier to one of the arguments of a virtual function in the derived class.

Overriding is determined by equivalent parameter lists according to the overloading rules. 13.1/3 says that top-level cv qualifiers on parameter types do not make for distinct parameter lists. foo(int) and foo(const int) are the same function.

Thus, the function Derived::foo(const int) overrides Base::foo(int). In MSVC++ versions prior to .Net 2008, the compiler was non-compliant and had the functions be distinct. In 2008, they fixed this bug and made one function override the other. Then they added to the warning so that people who relied on the old behaviour know that they must fix their programs.

The solution to the whole problem is of course to stop random experiments with adding const qualifiers in random places where they don't have an effect anyway.

Nice. Well then - I take back my take-back :)

Put too much faith in 2005....

gg

Great, CornedBee!


But I do not quite understand what your below solution means. Any pseudo code please?

Quote:

---

Originally Posted by CornedBee

The solution to the whole problem is of course to stop random experiments with adding const qualifiers in random places where they don't have an effect anyway.

---

regards,
George

It is not a solution - It is an advice.
Stop writing random code to see what you get.

Learn the proper syntax for what you need - and write the correct code instead.

Thanks vart, random code means the code which I think and create from my mind and does not follow the best practices?

Quote:

---

Originally Posted by vart

It is not a solution - It is an advice.
Stop writing random code to see what you get.

Learn the proper syntax for what you need - and write the correct code instead.

---

regards,
George

yes. The programmer when writing code whats to achieve some goal

Code:

---

char* strcpy(char* dst, const char* src);

---

When I put const here I know, that I want to notify the caller, that src string will not be modified inside my function

When I just start adding additional const without knowing what is the affect - I call it random code

Code:

---

char* const strcpy(char* const dst, const char* const src);

---

That is what you are do, so it seems. You are putting different parts of the code here and there, just to see if it will compile, without reading previously, what it will do, and without setting some goal, except to get some strage compiler warning...

Why are you trying to change the interface in the first place?
It's bad practice and confuses people when they expect the parameter to be const, but then in the derived class it's not const...

Thanks vart,


Question answered.

Quote:

---

Originally Posted by vart

yes. The programmer when writing code whats to achieve some goal

Code:

---

char* strcpy(char* dst, const char* src);

---

When I put const here I know, that I want to notify the caller, that src string will not be modified inside my function

When I just start adding additional const without knowing what is the affect - I call it random code

Code:

---

char* const strcpy(char* const dst, const char* const src);

---

That is what you are do, so it seems. You are putting different parts of the code here and there, just to see if it will compile, without reading previously, what it will do, and without setting some goal, except to get some strage compiler warning...

---

regards,
George