Re: How to avoid complex switches?
* none:
I have a class that takes a few template parameters:
template<typename A, typename B, typename C,typename D>
class MyClass {
// ...
};
The types A,B,C and D are selected from a user specified input file
(properties file):
A = 1
B = 2
C = 1
D = 3
I then parse this file an need to create MyClass with the correct types:
[snip]
But this is not supported in C++. Any ideas on how to solve this
combinatorics problem?
Well, the best would be to do as Leigh Johnston has suggested else-thread, to
use run time polymorphism. Also to replace your use of types, with plain values.
But it's an interesting problem.
The monkey solution below just cries out for some elegant generalization...
Oh my, looking at it now I've forgotten to define default constructors.
I wonder how this code (the 'static const' bits) passed compilation, but, it did.
<code>
#include <iostream>
#include <typeinfo>
template<typename A, typename B, typename C,typename D>
class MyClass
{
// ...
};
template< typename T >
void foo( T const& )
{
std::cout << typeid( T ).name() << std::endl;
}
class A1{}; class A2{}; class A3{}; class A4{};
class B1{}; class B2{}; class B3{}; class B4{};
class C1{}; class C2{}; class C3{}; class C4{};
class D1{}; class D2{}; class D3{}; class D4{};
struct IBoundD
{
virtual void instantiate() const = 0;
};
template< typename A, typename B, typename C, typename D >
struct BoundD: IBoundD
{
virtual void instantiate() const
{
// For example, whatever.
foo( MyClass<A, B, C, D>() );
}
};
struct IBoundC
{
virtual IBoundD const& bindD( int const d ) const = 0;
};
template< typename A, typename B, typename C >
struct BoundC: IBoundC
{
virtual IBoundD const& bindD( int const d ) const
{
static const BoundD<A, B, C, D1> d1;
static const BoundD<A, B, C, D2> d2;
static const BoundD<A, B, C, D3> d3;
static const BoundD<A, B, C, D4> d4;
switch( d )
{
case 1: return d1;
case 2: return d2;
case 3: return d3;
case 4: return d4;
}
assert( false );
}
};
struct IBoundB
{
virtual IBoundC const& bindC( int const b ) const = 0;
};
template< typename A, typename B >
struct BoundB: IBoundB
{
virtual IBoundC const& bindC( int const c ) const
{
static const BoundC<A, B, C1> c1;
static const BoundC<A, B, C2> c2;
static const BoundC<A, B, C3> c3;
static const BoundC<A, B, C4> c4;
switch( c )
{
case 1: return c1;
case 2: return c2;
case 3: return c3;
case 4: return c4;
}
assert( false );
}
};
struct IBoundA
{
virtual IBoundB const& bindB( int const b ) const = 0;
};
template< typename A >
struct BoundA: IBoundA
{
virtual IBoundB const& bindB( int const b ) const
{
static const BoundB<A, B1> b1;
static const BoundB<A, B2> b2;
static const BoundB<A, B3> b3;
static const BoundB<A, B4> b4;
switch( b )
{
case 1: return b1;
case 2: return b2;
case 3: return b3;
case 4: return b4;
}
assert( false );
}
};
struct Instantiator
{
IBoundA const& bindA( int const a ) const
{
static const BoundA<A1> a1;
static const BoundA<A2> a2;
static const BoundA<A3> a3;
static const BoundA<A4> a4;
switch( a )
{
case 1: return a1;
case 2: return a2;
case 3: return a3;
case 4: return a4;
}
assert( false );
}
};
int main()
{
int a = 1;
int b = 2;
int c = 1;
int d = 3;
Instantiator()
.bindA( a )
.bindB( b )
.bindC( c )
.bindD( d )
.instantiate();
}
</code>
Cheers & hth.,
- Alf