🚀 go-pugleaf

Folks,

Can derived functions overload each other instead of hiding
or (worse yet) producing ambiguity?  Trivial examples are:

Example 1:
---------

class A { public: void foo (int i); };
class B : public A { public: void foo (char c); };

Instead of overloading A::foo, B::foo hides it!

Example 2:
---------

class A { public: void foo (int i); }
class B { public: void foo (char c); }
class C : public A, public B {};

C exports both A::foo and B::foo but in a way that required fully-qualified 
naming (e.g. c.A::foo(3)) to resolve ambiguity.  Worse yet, one of the 
inheritance links could even be private with same effect...

This is the way the language is defined to behave.  Unfortunately, this 
single "feature" prevents many interesting idioms from working.  (I can 
elaborate
if any one is interested.)

Commonly proposed solutions are:
-------------------------------

(1) re-defining the operation and using call-through (e.g. in example 1, B 
would also define void foo (int i) that would call through to A::foo)

(2) Using fully qualified names (only helps in ambiguity with MI case)

However, for the situations I mentioned, these solutions are unacceptable.

My question is:
--------------

Does any one know of a way to make the above code (modified in some way) 
behave in the way intended, as opposed to "the C++ way?"

Thanks very much in advance for your comments.

sergey
---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]