Linking issue

class InterfaceClass
{
virtual void method1() = 0;
virtual void method2() = 0;
};

class BaseClass : public InterfaceClass
{
void method1(){}
void method2(){}
};

class DerivedClass : public BaseClass
{
};

not sure why you are doing this, seems like a design flaw to me.

So you have a bunch of interface classes all of which have method1 and method2.

You have decided that you do not want to implement these functions but have
a problem because they are pure virtual. (design flaw)

You are trying to find a way to provide a bass class that "implements" these functions so you don't have to think about them when coding derived classes.

Is this correct?

PS:
what is going on here
void method3a() { BaseClass::method3a() }
void method4a() { BaseClass::method4a() }
void method3b() { BaseClass::method3b() }
void method4b() { BaseClass::method4b() }

I figured it had to do with code that you could not easily change

class InterfaceClass1
{
virtual void method1() = 0;
virtual void method2() = 0;
virtual void method3a() = 0;
virtual void method4a() = 0;
};

class InterfaceClass2
{
virtual void method1() = 0;
virtual void method2() = 0;
virtual void method3b() = 0;
virtual void method4b() = 0;
};

template<class K>
class BaseClass : public K
{
void method1(){}
void method2(){}
};

class DerivedClass1 : public BaseClass<InterfaceClass1>
{
virtual void method3a(){}
virtual void method4a(){}
};

class DerivedClass2 : public BaseClass<InterfaceClass2>
{
virtual void method3b(){}
virtual void method4b(){}
};

still don't understand
void method3a() { BaseClass::method3a() }
void method4a() { BaseClass::method4a() }
void method3b() { BaseClass::method3b() }
void method4b() { BaseClass::method4b() }
since BaseClass does not implement these methods.
I think maybe you are just mixing notation.

I understand what you are trying to do now. I apologize that you had stated your question in a confusing manner. Using multiple inheritance is not
going to solve your problem since the vtables for the interface classes and BaseClass
are not related.

Templates will solve your problem and you will not have to implement A, B, C and D
in BaseClass. Why don't you try it.

I did and it compiled fine, at least with VC++ 6.0 (which is not very complient with the
standard)

remember that a template class is "ignored" until it is used. At the point when it is used
here, overides for all pure virtual functions are provided, either by BaseClass or by the derived class.

The design as OP suggests in flawed, not because of the interfaces but because of non-virtual functions in the BaseClass and repeatition of names. They have the same name as the pure virtual functions in the interfaces. This will create a lot of confusions (visible this time as well as in future). The functions in BaseClass are non-virtual.. their names should not appear in a derived class (and it appears in both the interface as well as the derived classes). What this does is - hides all the base versions of the functions (base versions to the names appearing in the derived one) - the versions in BaseClass.

Hence you "have" to use what you are calling a stub.. you will "have" to qualify the functions name as BaseClass::method1() etc.

Run this code and you shall see that it results in a stack overflow.. because it is not able to see the implementation of method1 as in BaseClass and hence ends up in a infinite recursive call to itself.
#include<iostream>
class InterfaceClass1{
public:
virtual void method1() = 0;
virtual void method2() = 0;
virtual void method3a() = 0;
virtual void method4a() = 0;
};

class InterfaceClass2{
public:
virtual void method1() = 0;
virtual void method2() = 0;
virtual void method3b() = 0;
virtual void method4b() = 0;
};

class BaseClass{
public:
void method1(){std::cout << "Baseclass method1() called\n"; }
void method2(){std::cout << "Baseclass method2() called\n"; }
};

class DerivedClass1 : public InterfaceClass1, public BaseClass {
// How can I remove these "stubs" so that the B::method1 and B::method2 automatically
// detected?
public:
void method1() { method1(); }
void method2() { method2(); }
void method3a() { std::cout << "method3a() called\n"; }
void method4a() { std::cout << "method4a() called\n"; }
};

class DerivedClass2 : public InterfaceClass2, public BaseClass {
// How can I remove these "stubs" so that the B::method1 and B::method2 automatically
// detected?
public:
void method1() { BaseClass::method1(); }
void method2() { BaseClass::method2(); }
void method3b() { std::cout << "method3b() called\n"; }
void method4b() { std::cout << "method4b() called\n"; }
};

int main(){
DerivedClass1 obj;
obj.method1();
obj.method2();
obj.method3a();
obj.method4a();
InterfaceClass1& ref = obj;
ref.method1();
ref.method2();
ref.method3a();
ref.method4a();
return 0;
}To fix this issue - you need to keep the calls well qualified by their full names.
class DerivedClass1 : public InterfaceClass1, public BaseClass {
// How can I remove these "stubs" so that the B::method1 and B::method2 automatically
// detected?
public:
void method1() { BaseClass::method1(); }
void method2() { BaseClass::method2(); }
void method3a() { std::cout << "method3a() called\n"; }
void method4a() { std::cout << "method4a() called\n"; }
};However, there is no simple solution to this when you are inheriting from multiple classes (and more than one of those bases has a repeating name for a function). You will have to qualify the full name even if those BaseClass versions have been made virtual functions. Also, I must say the need seems pretty wierd to me.. what is your problem? What do you want to do? Can you write a small program stating what you want and what you are doing ... how you want to achieve that.. Make the program such that it is compilable. Regards.

As the op has stated, he is trying to overcome a limitation in an automatic code generator.
The condition, googler, is that the interface classes can not be modified. If they could
then the obvious thing to do is to change them to meet the ops design goals.

Exterminator, it is true that multiple inheritance is not the way to go here and
your explanation is apt.

It seems to me that the only good solution is to inject a class into the heirarchy between
the interface classes and the derived classes that has the default methods implemented, but does not need to implement the rest of the virtual methods.

Did you guys try the template method.

googler, I think maybe you should actually read the thread.
The ops problem has already been solved

googler, I think maybe you should actually read the thread. The ops problem has already been solved
Right. I guess I should follow my own ( http://www.dev-archive.com/forum/showpost.php?p=1324577&postcount=21) advice, but there were just so many words to read. :wave:

I was curious if there was some problem with the template method that I am not aware of...
I'd give the templates a protected default constructor to protect them from unintended use (make them pseudo-abstract), but that's not a problem per se, just a design quirk.