I have a C-header file with 100s of data structs. I want to make a superclass that each data struct inherits from. How to do that? Should I parse the header file? Reflection?
Because each C data struct is a public class, I could just make a superclass and... then what? I should not go in manually and explicitly make every struct inherit from the superclass?
For your particular use case, I would leave the C code as is, and just create whatever solution you need in C++ leveraging the C code. You can for example, create a parallel hierarchy with a base that defines the interface that includes serialize() and deserialize() and each derived type storing one of the C structs and implementing the serialization of that particular type.
You can also tackle this completely externally, by providing templated serialize/deserialize functions that are defined for each one of the C structs... Inheritance is one of the most often abused features of C++.
The best solution will depend on how you intend on using the code, but I would avoid rewriting the C code (i.e. scripting an editor to rewrite the C header into a C++ solution) as that will effectively branch out of the C library and you will need to maintain two separate branches if you ever need to extend it C side.
If you have a bunch of structs:
The obvious answer is to make clever use of search and replace to make them inherit from the new base class. It wouldn't be able to access the members of the structs, but you could store pointers to them all in containers
struct base {
int dostuff() const {std::cout << "thing";}
};
struct thing1 : public base {
int size;
};
//otherstructs inheriting from base
int main() {
std::vector<std::unique_ptr<base>> objects;
objects.push_back(std::unique_ptr<base>(new thing1()));
objects[1].dostuff();
}
If making the base class thing is too hard, you might try adding functions via a wrapper class instead. You won't be able to store pointers to these in a container, but they can access members, as long as the structs have similar members.
struct thing1 {
int size;
};
//other unchanged structs
template<class mystruct>
struct wrapper : mystruct {
int getsize() {return mystruct.size;}
};
int main() {
wrapper<thing1> mything1;
std::cout << mything1.size << mything1.getsize();
}
Or, if you're just adding methods, make them separate functions:
struct thing1 {
int size;
};
//other unchanged structs
template<class T>
int getsize(const T& obj) {return obj.size;}
int main() {
thing1 mything1;
std::cout << mything1.size << getsize(mything1);
}
There is no reflection in C/C++, and there is no one base class for other classes in C++, so this isn't an easy task. You can manually make every class you have inherit from the superclass as you suggested, or you can create a base class and then create a new structure for each data structs, which inherits it's concrete data struct and also the base class.
For example http://liveworkspace.org/code/7e06e0374ef41bc4aeeafd55ae143527 or http://liveworkspace.org/code/7e06e0374ef41bc4aeeafd55ae143527.
I think manually making each struct inherit from the base class in your C-header file is more efficient.
I have never heard of structs using inheritance - it might be standard practice somewhere but all the examples of inheritance have been using a class - will it create a hardship to change the struct to a class? This could be confusing as I tend to think "C" when I see a struct.
Also are you sure that with inheritance, you still need 100's of structs or classes? If they really don't have duplicate data, that is OK, but if there are duplicated fields, it might be a good idea to have them inherit from each other to remove the duplicate fields.
