Overloading methods with identical content in lot of derived classes
-
Following problem: I have a base class "B" in which there are some methods M1(),M2... Mn().
class B {
public
//... some other methods
//
virtual void M1();
virtual void M2();
// ...
virtual void Mn();
};now I have multiple derived classes:
class Ca1 : public B { .... };
class Ca2 : public B { .... };
//...
class Can : public B { .... };and again derived each from above
class Cb1 : public Ca1 { .... };
class Cb2 : public Ca2 { .... };
//...
class Cbn : public Can { .... };And at last another deriving step by
class Cc1 : public Cb1 { .... };
class Cc2 : public Cb2 { .... };
//...
class Ccn : public Cb3 { .... };Now the Question: each of the derived last classes will override the methods M1, M2, M3 ...Mn... with the same functional content!
class Cc1 : public Cb1 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};
class Cc2 : public Cb2 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};... this identical with identical code m1, m2 ... forall classes derived Cc1, Cc2, ... Ccn! How to best avoid to copy this M1, ... Mn block for method overriding into each derived class? The existing code packed everthing into a macro and copied this into the classes like
#define DRIVED_METHODS \
virtual void M1 { /* code m1 */ } \and so on which results in horrible undebugable code! Using multiple inheritance does not work:
class Cc1 : public Cb1, public CMpack
{};
class Mpack { void M1 {}; ... };The only idea was to "map" each method to a class that collects these common methods
class Mcommon {
virtual void m_M1() { };
virtual void m_M2() {};
// ... etc
}class Cc1 : public Mcommon
{
virtual void M1() { Mcommon::m_M1() ; } override
// ... M2 and so on
};I know that there must be a mistake in the whole design but Im not allowed to change much because nobody knows why the anchestor did such a design and sideeffects on changing code may happen. Have searched the web but best solution I got is the "Mapping" parameters, return types in M1...Mn have been simplyfied to void, empty in the text above
-
Following problem: I have a base class "B" in which there are some methods M1(),M2... Mn().
class B {
public
//... some other methods
//
virtual void M1();
virtual void M2();
// ...
virtual void Mn();
};now I have multiple derived classes:
class Ca1 : public B { .... };
class Ca2 : public B { .... };
//...
class Can : public B { .... };and again derived each from above
class Cb1 : public Ca1 { .... };
class Cb2 : public Ca2 { .... };
//...
class Cbn : public Can { .... };And at last another deriving step by
class Cc1 : public Cb1 { .... };
class Cc2 : public Cb2 { .... };
//...
class Ccn : public Cb3 { .... };Now the Question: each of the derived last classes will override the methods M1, M2, M3 ...Mn... with the same functional content!
class Cc1 : public Cb1 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};
class Cc2 : public Cb2 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};... this identical with identical code m1, m2 ... forall classes derived Cc1, Cc2, ... Ccn! How to best avoid to copy this M1, ... Mn block for method overriding into each derived class? The existing code packed everthing into a macro and copied this into the classes like
#define DRIVED_METHODS \
virtual void M1 { /* code m1 */ } \and so on which results in horrible undebugable code! Using multiple inheritance does not work:
class Cc1 : public Cb1, public CMpack
{};
class Mpack { void M1 {}; ... };The only idea was to "map" each method to a class that collects these common methods
class Mcommon {
virtual void m_M1() { };
virtual void m_M2() {};
// ... etc
}class Cc1 : public Mcommon
{
virtual void M1() { Mcommon::m_M1() ; } override
// ... M2 and so on
};I know that there must be a mistake in the whole design but Im not allowed to change much because nobody knows why the anchestor did such a design and sideeffects on changing code may happen. Have searched the web but best solution I got is the "Mapping" parameters, return types in M1...Mn have been simplyfied to void, empty in the text above
-
Quote:
each of the derived last classes will override the methods M1, M2, M3 ...Mn... with the same functional content!
What's the purpose of that?
some history I found out: they had a collection of B*
typedef vector arrayB
then they stored Ca1* ... Can* in such a collection later they stored Cc1* ... Ccn* in such a collection because all derived from B ...
arrayB1 my_collection;
my_collection.push_back(Cc1* ... ) //... etcthis is valid because the Cc´s are derived from B B<--Cc1 , ... if it is a B* the B::M1() was called if it is a Ca1*, ...Can* the B::M1() was called if it is a Cb1*, ...Cbn* the B::M1() was called But if it is a Cc1*, ...Ccn* the overloaded Cc1::M1() etc. of the derived classes were called and do something different than the B::M1() I dont know further what its good for, but its the way it was it was implemented
-
some history I found out: they had a collection of B*
typedef vector arrayB
then they stored Ca1* ... Can* in such a collection later they stored Cc1* ... Ccn* in such a collection because all derived from B ...
arrayB1 my_collection;
my_collection.push_back(Cc1* ... ) //... etcthis is valid because the Cc´s are derived from B B<--Cc1 , ... if it is a B* the B::M1() was called if it is a Ca1*, ...Can* the B::M1() was called if it is a Cb1*, ...Cbn* the B::M1() was called But if it is a Cc1*, ...Ccn* the overloaded Cc1::M1() etc. of the derived classes were called and do something different than the B::M1() I dont know further what its good for, but its the way it was it was implemented
-
OK, I misunderstood your original question. Could you possibly insert another derivation layer? Why the 'mapping' solution is not appealing?
Mapping means: to copy the same method mapping declaration to each class Cc1 ... Ccn so class Cc1: { ... list of M1() ...Mn()- mappings } class Cc2: { ... list of M1() ...Mn() mappings } .... class Ccn: { ... list of M1() ...Mn() mappings } this is lot of code ... isn´t there any way to say: class Cc1..n - overload "the punch of M1...Mn defined in a common set" layer in between does not work because: - Cc1...Ccn is derived from Cb1...Cbn - Cc_::M1() used some data of Cc_
-
Mapping means: to copy the same method mapping declaration to each class Cc1 ... Ccn so class Cc1: { ... list of M1() ...Mn()- mappings } class Cc2: { ... list of M1() ...Mn() mappings } .... class Ccn: { ... list of M1() ...Mn() mappings } this is lot of code ... isn´t there any way to say: class Cc1..n - overload "the punch of M1...Mn defined in a common set" layer in between does not work because: - Cc1...Ccn is derived from Cb1...Cbn - Cc_::M1() used some data of Cc_
-
Quote:
- Cc1...Ccn is derived from Cb1...Cbn - Cc_::M1() used some data of Cc_
I don't get that. Either the methods are identical or not. If they are identical then they access variables with identical names.
The code in that form usually had a function to push/pull the class or object into and back off a stream. You would know the process if you are familiar with C# as serialization. Microsoft has provided a bit more support and safety doing in C++ with the DECLARE_SERIAL macro which I think is the macro you are talking about. Serialization: Making a Serializable Class[^] It's still pretty much done the same way. Just look into the code is the serialization still used?
In vino veritas
-
Mapping means: to copy the same method mapping declaration to each class Cc1 ... Ccn so class Cc1: { ... list of M1() ...Mn()- mappings } class Cc2: { ... list of M1() ...Mn() mappings } .... class Ccn: { ... list of M1() ...Mn() mappings } this is lot of code ... isn´t there any way to say: class Cc1..n - overload "the punch of M1...Mn defined in a common set" layer in between does not work because: - Cc1...Ccn is derived from Cb1...Cbn - Cc_::M1() used some data of Cc_
The code in that form usually had a function to push/pull the class or object into and back off a stream. You would know the process if you are familiar with C# as serialization. Microsoft has provided a bit more support and safety doing in C++ with MFC and the DECLARE_SERIAL macro which is the same as your MACRO. Serialization: Making a Serializable Class[^] It's still pretty much done the same way, you should have two constructors on the objects one of which has no parameters? Just look into the code and check if the serialization is still used?
In vino veritas
-
Quote:
- Cc1...Ccn is derived from Cb1...Cbn - Cc_::M1() used some data of Cc_
I don't get that. Either the methods are identical or not. If they are identical then they access variables with identical names.
sorry its tricky but: Cc1::M1() is identical to Cc2::M1() ... the only "data" some Mi() uses is the "this" pointer Cc1::M1() { code m1 } Cc2::M1() { code m1 } ... etc.. Cc1::M3() { f_calculate(this); ... } Cc2::M3() { f_calculate(this); ... } ...
-
The code in that form usually had a function to push/pull the class or object into and back off a stream. You would know the process if you are familiar with C# as serialization. Microsoft has provided a bit more support and safety doing in C++ with MFC and the DECLARE_SERIAL macro which is the same as your MACRO. Serialization: Making a Serializable Class[^] It's still pretty much done the same way, you should have two constructors on the objects one of which has no parameters? Just look into the code and check if the serialization is still used?
In vino veritas
?? stream? don´t understand because I don´t us a stream but do ou mean, that these horrible MFC macros came up because of th same problem?
-
sorry its tricky but: Cc1::M1() is identical to Cc2::M1() ... the only "data" some Mi() uses is the "this" pointer Cc1::M1() { code m1 } Cc2::M1() { code m1 } ... etc.. Cc1::M3() { f_calculate(this); ... } Cc2::M3() { f_calculate(this); ... } ...
-
?? stream? don´t understand because I don´t us a stream but do ou mean, that these horrible MFC macros came up because of th same problem?
What is written looks very much like the way you do serialization in C++ Serialization - Wikipedia, the free encyclopedia[^] Read the article there are a number of reasons why you may want to serialize code from transmission thru, time based processing thru to encryption protection of code. You will note within the article they talk about C and C++ not having serialization but you can do it with a sort of standard form. Your code looks to me like that standard form. MFC has the same setup because it has serialized classes and even that is discussed in the wiki article. Note MFC's main reason for serialization: "The technique is called differential execution. It is useful in the programming of user interfaces whose contents are time-varying — graphical objects can be created, removed, altered, or made to handle input events without necessarily having to write separate code to do those things." You were saying you don't know why the original code was written like that and they won't let you change it. If you need the serialization it would indeed break the program if you write it a different way. So I am suggesting you check if the code is indeed doing serialization. If it is and that serialization is still needed you can not change it even if you wanted to.
In vino veritas
-
Since
Cc1::M1is identical toCc2::M1, bothCc1andCc2could inheritM1from an intermediate class.Problem is inheritance to base of Cc1 Cc2 etc B<-Ca1<-Cb1<-Cc1 B<-Ca2<-Cb3<-Cc2 if I use an intermediate class e.g D and declare D:M1() then following problem arises: class B { virtual M1() }; class Ca1 : public B class Cb1 : public Ca1 class D : { virtual M1() } ; class Cc1: public Cb1 , public D class Cc2 : public Cb2 , public D ... if I call now x->M1() with x is a Cc1* which method will be used? Does D::M1() overload B::M1(), what I like to have?
-
What is written looks very much like the way you do serialization in C++ Serialization - Wikipedia, the free encyclopedia[^] Read the article there are a number of reasons why you may want to serialize code from transmission thru, time based processing thru to encryption protection of code. You will note within the article they talk about C and C++ not having serialization but you can do it with a sort of standard form. Your code looks to me like that standard form. MFC has the same setup because it has serialized classes and even that is discussed in the wiki article. Note MFC's main reason for serialization: "The technique is called differential execution. It is useful in the programming of user interfaces whose contents are time-varying — graphical objects can be created, removed, altered, or made to handle input events without necessarily having to write separate code to do those things." You were saying you don't know why the original code was written like that and they won't let you change it. If you need the serialization it would indeed break the program if you write it a different way. So I am suggesting you check if the code is indeed doing serialization. If it is and that serialization is still needed you can not change it even if you wanted to.
In vino veritas
maybe I got now what you talk about "Changing the class is not possible when transfered via serial... because of reconstruction is dependent of class structure"? OK, this doesnt happen here, there is an extra struct that holds data to store and load. What I know is, that the code was extended within years, adding more and more features to the software. The derived classes have more features and do some different calculations e.g. B::M1() ... used in B, Ca1, Cb1 also Ca2, Cb2 ... ect is different to Cc1::M1(), Cc2::M1() ... etc.
-
Quote:
each of the derived last classes will override the methods M1, M2, M3 ...Mn... with the same functional content!
What's the purpose of that?
an example: We have animals, cats and dogs
class animal()
{
OpenMouth() ;
breath_in();
breath_out();
}
class cat() : public animal
{
play_with_wool();
}
class dog() : public animal
{
hunt_cats();
}
class mops1() : public dog
{
get_fat_and_fart()
}
class mops2() : public dog
{
get_fat()
}
class greyhound1() : public dog
{
run()
}
class specialdog() : public dog
{
run_fast()
}now we want to extent _some_ dogs to know how to barf() for barf() we need some unctions of animal() (not all)
barf() { breath_in(); OpenMouth(); dosomething(); }
How can we add barf() to some (eg. 20 different dogs, and also some wolfs) without changing parent class structure?
class greyhound1() : public dog
{
run()
barf(); // added ...
}
class specialdog() : public dog
{
run_fast()
barf(); // added ...
}
class greywolf() : public wolf
{
barf(); // added
}and next step: we have not only barf() we have 20 new extends for these aimals. It would mean: add these 20 functions to each animal seperately?
-
Following problem: I have a base class "B" in which there are some methods M1(),M2... Mn().
class B {
public
//... some other methods
//
virtual void M1();
virtual void M2();
// ...
virtual void Mn();
};now I have multiple derived classes:
class Ca1 : public B { .... };
class Ca2 : public B { .... };
//...
class Can : public B { .... };and again derived each from above
class Cb1 : public Ca1 { .... };
class Cb2 : public Ca2 { .... };
//...
class Cbn : public Can { .... };And at last another deriving step by
class Cc1 : public Cb1 { .... };
class Cc2 : public Cb2 { .... };
//...
class Ccn : public Cb3 { .... };Now the Question: each of the derived last classes will override the methods M1, M2, M3 ...Mn... with the same functional content!
class Cc1 : public Cb1 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};
class Cc2 : public Cb2 {
virtual void M1() { /* code m1 */ } override;
virtual void M2() { /* code m2 */ } override;
...
virtual void M3() { /* code m3 */ } override;
};... this identical with identical code m1, m2 ... forall classes derived Cc1, Cc2, ... Ccn! How to best avoid to copy this M1, ... Mn block for method overriding into each derived class? The existing code packed everthing into a macro and copied this into the classes like
#define DRIVED_METHODS \
virtual void M1 { /* code m1 */ } \and so on which results in horrible undebugable code! Using multiple inheritance does not work:
class Cc1 : public Cb1, public CMpack
{};
class Mpack { void M1 {}; ... };The only idea was to "map" each method to a class that collects these common methods
class Mcommon {
virtual void m_M1() { };
virtual void m_M2() {};
// ... etc
}class Cc1 : public Mcommon
{
virtual void M1() { Mcommon::m_M1() ; } override
// ... M2 and so on
};I know that there must be a mistake in the whole design but Im not allowed to change much because nobody knows why the anchestor did such a design and sideeffects on changing code may happen. Have searched the web but best solution I got is the "Mapping" parameters, return types in M1...Mn have been simplyfied to void, empty in the text above
-
If I understood the question, the best method is using macro at header in derived classes and implementation in those cpp side (these must be different right?).
yes, they are different or use one member in this functions that is diffrent. The functions to add itself are same to all, but refer to prior defined methods, functions or class members macros is the :wtf: WORST madhog (method) ever. I know this because im now in task to remove all these mass of macros (1 - 10 pages long) not debugable, now intllisense, you wont find anything. in addition the advantage of OOD /OOP has been destroyed with these macros because a lot of not used things were copied because the developer didn´t know whats in there anymore (stupid copying) Ther must be a smarter better way, hopefully
-
Problem is inheritance to base of Cc1 Cc2 etc B<-Ca1<-Cb1<-Cc1 B<-Ca2<-Cb3<-Cc2 if I use an intermediate class e.g D and declare D:M1() then following problem arises: class B { virtual M1() }; class Ca1 : public B class Cb1 : public Ca1 class D : { virtual M1() } ; class Cc1: public Cb1 , public D class Cc2 : public Cb2 , public D ... if I call now x->M1() with x is a Cc1* which method will be used? Does D::M1() overload B::M1(), what I like to have?
sorry its tricky but: Cc1::M1() is identical to Cc2::M1() ... the only "data" some Mi() uses is the "this" pointer Cc1::M1() { code m1 } Cc2::M1() { code m1 } ... etc.. Cc1::M3() { f_calculate(this); ... } Cc2::M3() { f_calculate(this); ... } ...
