Thread: 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

>> 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

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)

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

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?

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

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

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

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...