| Topic: |
DEVELOP > c-Plus-Plus |
| User: |
"Chameleon" |
| Date: |
04 Jan 2007 10:07:32 AM |
| Object: |
MI and ambiguous members |
Can anyone explain me why the code below produce (with mingw-g++) the
following error message:
---------------------------------------------------------------
main10.cpp: In function `int main()':
main10.cpp:23: error: request for member `getZero' is ambiguous
main10.cpp:12: error: candidates are: virtual int B::getZero(int)
main10.cpp:6: error: virtual int A::getZero()
---------------------------------------------------------------
No! member getZero is not ambiguous at all because
int A::getZero()
is completelly different from
int B::getZero(int a)
Compiler can exactly decide what member to call when I say
c.getZero()
it is A::getZero() because B::getZero(int) has parameters.
Is this a compiler (gcc) or a language limitation?
Thanks!
-----------------------------------------------------
#include <cstdio>
class A
{
public:
virtual int getZero() { return 0; }
};
class B
{
public:
virtual int getZero(int a) { return a - a; }
};
class C : public A, public B {};
int main()
{
C c;
printf("%d", c.getZero());
return 0;
}
------------------------------------------------------
.
|
|
| User: "Chameleon" |
|
| Title: Re: ambiguous members |
04 Jan 2007 10:57:33 AM |
|
|
Simpler paradigm with no Multiple Inheritance
Can anyone explain me why the code below produce (with mingw-g++) the
following error message:
---------------------------------------------------------------
main10a.cpp: In function `int main()':
main10a.cpp:19: error: no matching function for call to `C::getZero()'
main10a.cpp:12: note: candidates are: virtual int C::getZero(int)
---------------------------------------------------------------
No! member getZero is not ambiguous at all because
int A::getZero()
is completelly different from
int C::getZero(int a)
Compiler can exactly decide what member to call when I say
c.getZero()
it is A::getZero() because C::getZero(int) has parameters.
Is this a compiler (gcc) or a language limitation?
Thanks!
-----------------------------------------------------
#include <cstdio>
class A
{
public:
virtual int getZero() { return 0; }
};
class C : public A
{
public:
virtual int getZero(int a) { return a-a; }
};
int main()
{
C c;
printf("%d", c.getZero());
return 0;
}
------------------------------------------------------
.
|
|
|
| User: "John Carson" |
|
| Title: Re: ambiguous members |
04 Jan 2007 08:25:17 PM |
|
|
"Chameleon" <cham_gss@hotmail.com> wrote in message
news:enjbla$pph$1@volcano1.grnet.gr
Simpler paradigm with no Multiple Inheritance
Can anyone explain me why the code below produce (with mingw-g++) the
following error message:
---------------------------------------------------------------
main10a.cpp: In function `int main()':
main10a.cpp:19: error: no matching function for call to `C::getZero()'
main10a.cpp:12: note: candidates are: virtual int C::getZero(int)
---------------------------------------------------------------
No! member getZero is not ambiguous at all because
int A::getZero()
is completelly different from
int C::getZero(int a)
Compiler can exactly decide what member to call when I say
c.getZero()
it is A::getZero() because C::getZero(int) has parameters.
Is this a compiler (gcc) or a language limitation?
Thanks!
-----------------------------------------------------
#include <cstdio>
class A
{
public:
virtual int getZero() { return 0; }
};
class C : public A
{
public:
virtual int getZero(int a) { return a-a; }
};
int main()
{
C c;
printf("%d", c.getZero());
return 0;
}
------------------------------------------------------
As Yan points out regarding the second example, getZero in C hides getZero
in A. They are not treated as overloads.
You can get them treated as overloads, however, by adding
using A::getZero;
to the declaration of C.
As for your first multiple inheritance example, once again, overloads are
not made across classes. As Stroustrup points out: "When combining
essentially unrelated classes...similarity in naming typically does not
indicate a common purpose."
Because overloading is not done across classes, C++ just looks at the names
and hence reports ambiguity.
You can resolve the problem in the same way by bringing both functions into
a common scope. Change class C to:
class C : public A, public B
{
public:
using A::getZero;
using B::getZero;
};
--
John Carson
.
|
|
|
|
| User: "Yan" |
|
| Title: Re: ambiguous members |
04 Jan 2007 03:01:56 PM |
|
|
Chameleon wrote:
Simpler paradigm with no Multiple Inheritance
Can anyone explain me why the code below produce (with mingw-g++) the
following error message:
---------------------------------------------------------------
main10a.cpp: In function `int main()':
main10a.cpp:19: error: no matching function for call to `C::getZero()'
main10a.cpp:12: note: candidates are: virtual int C::getZero(int)
---------------------------------------------------------------
No! member getZero is not ambiguous at all because
int A::getZero()
is completelly different from
int C::getZero(int a)
Compiler can exactly decide what member to call when I say
c.getZero()
it is A::getZero() because C::getZero(int) has parameters.
Is this a compiler (gcc) or a language limitation?
Thanks!
-----------------------------------------------------
#include <cstdio>
class A
{
public:
virtual int getZero() { return 0; }
};
class C : public A
{
public:
virtual int getZero(int a) { return a-a; }
};
int main()
{
C c;
printf("%d", c.getZero());
return 0;
}
------------------------------------------------------
Name hiding rules in C++ is the reason for that. Function(s) in derived
class hide function(s) with the same name in the base class, whether
virtual or not. In your case C::getZero hides A::getZero. Doesn't
matter that they have different signatures - they don't get overloaded
as someone might expect.
.
|
|
|
|
| User: "bjeremy" |
|
| Title: Re: ambiguous members |
04 Jan 2007 01:43:04 PM |
|
|
Chameleon wrote:
Simpler paradigm with no Multiple Inheritance
Can anyone explain me why the code below produce (with mingw-g++) the
following error message:
---------------------------------------------------------------
main10a.cpp: In function `int main()':
main10a.cpp:19: error: no matching function for call to `C::getZero()'
main10a.cpp:12: note: candidates are: virtual int C::getZero(int)
---------------------------------------------------------------
No! member getZero is not ambiguous at all because
int A::getZero()
is completelly different from
int C::getZero(int a)
Compiler can exactly decide what member to call when I say
c.getZero()
it is A::getZero() because C::getZero(int) has parameters.
Is this a compiler (gcc) or a language limitation?
Thanks!
-----------------------------------------------------
#include <cstdio>
class A
{
public:
virtual int getZero() { return 0; }
};
class C : public A
{
public:
virtual int getZero(int a) { return a-a; }
};
int main()
{
C c;
printf("%d", c.getZero());
return 0;
}
------------------------------------------------------
You're trying to use polymorphism with with the object, not a pointer
or reference to the object. Also, A::getZero() is not overridden in C,
so simply changing your definition to new a C pointer or reference
will not help you out. Your Declaration of "C c" simply has no way of
knowing A::getZero(), so it thinks you really mean C::getZero(int).
I'm not sure of your actual semantics or what you wish to do.. but two
ways to get around your error
1. Try changing your definition "C c" to "A *c = new C;" (and use ->
instead of . or=f course)
2. Keep your current declaration, and override A::getZero() in C
also... you may want to use std::cout instead of printf... but thats
not relevent to your original question.
.
|
|
|
|
|
|
Related Articles |
|
|
