# Template parameter used for configuration of classes [closed]

I am not sure if this good programming. I am not the well template programmer.

I have a big simulation framework (rigid body simulation). And so far I have one special include file "TypeDefs.hpp" which only defines (prototypes) of all classes in the framework to be used as types as a hirarchical struct:

What I mean I describe here for example for my DynamicsSystem<TDynamicsSystemConfig> class with template parameter TDynamicsSystemConfig.

template<typename TDynamicsSystemConfig>
class DynamicsSystem {
public:

typedef TDynamicsSystemConfig DynamicsSystemConfig;
DEFINE_DYNAMICSSYTEM_CONFIG_TYPES_OF(TDynamicsSystemConfig)

...

}


When I instance this class I input a struct ConfigDynamicsSystem for TDynamicsSystemConfig which is defined in "TypeDefs.hpp" and contains

template < typename _TRigidBody>
struct ConfigDynamicsSystem{
typedef _TRigidBody RigidBodyType;

... and more typedefs and constants

};


The macro then re-typedefs all types* and static const int and more to be able to use the types easily.

For this example the macro would expand:

typedef typename TDynamicsSystemConfig::RigidBodyType RigidBodyType;


This concept has the following ad/disvantages:

• One needs only one template parameter, makes the stuff readable
• One needs macros
• One needs templates everywhere in the framework, to make push in all defined types. So for my overall SimulationManager<TConfig> class the total config template parameter TConfig is a hierarchical built struct (structs with other structs in it with definitions) which inserts types and configuration stuff into the class SimulationManager<TConfig> and the members of this class use then sub config structs from TConfig which then propagates through the whole framework. Makes me able to have the same names and types available everywhere.

Questions:

1. Is this idea a usable setup, what is flawless about it?
2. What would be the disadvantage or maybe the better method of not using templates and using a "TypeDefs.hpp" file which is included everywhere which defines all these types in a namespace. So everywhere in the framework, the types and names are usable and defined.
-

## closed as off-topic by Jamal♦Feb 20 at 23:36

• This question does not appear to be a code review request within the scope defined in the help center.
If this question can be reworded to fit the rules in the help center, please edit the question.

You don't need the macro. You could just write your typedefs with the template parameter and you're fine. Every concrete instantiation then "picks" the proper subtypes of the concrete config type. (You would need a macro if you did somewhat like a "C struct template", where we write the whole template as one single macro to be expanded for every concrete version we want. But C++ handles this subtype scenario you want to have for you.) –  leemes Nov 8 '12 at 10:33
I have this macro to just write for me these typedefs as there are so many, the template parameter is a C struct containing types, what do you mean: like a "C struct template", where we write the whole template as one single macro ? –  Gabriel Nov 8 '12 at 12:27
I meant: In C we don't have templates, so we can write a struct as a macro with the "template parameter" as a macro argument. Let's say Vector(int) will expand to struct Vector_int and DEFINE_Vector(int) will expand to struct Vector_int { int* elements; ... };. Within the second macro we can introduce member variables of type T. I only wanted to say that you don't require this type of hack here, but it looks like that you wanted to use it. In a nutshell: You can avoid macros :) –  leemes Nov 8 '12 at 18:15
This question appears to be off-topic because it is about design and not code review. –  Jamal Feb 20 at 23:36