Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- template <typename T> struct General {};
- struct EnumSpecific : General<any_enum_type> {};
- // A templated value holder:
- template <typename T>
- class Holder {
- public:
- Holder(T const& t) : _value(t) {};
- // generic methods
- void generics() {};
- // methods concerning the value:
- void set(T const& t /*, setInfo */) {
- // .. check for an actual change, notify buddies of the change..
- _value = t;
- };
- T value(/*readInfo*/) {
- // .. do stuff depending on how / why the value is read..
- return _value;
- };
- private:
- T _value;
- };
- // (in reality, all `generics` methods come from a parent, untemplated class)
- // A generic process involving such `Holder`s:
- template <typename T>
- class General {
- public:
- typedef bool /* or anything */ KnownReturnTypes;
- General(Holder<T>* const a
- , Holder<T>* const b)
- : _a(a)
- , _b(b)
- {};
- void methods() {
- // Use common behavior of all `Holder`'s
- _a->generics();
- // .. or methods that rely on the actual values:
- KnownReturnTypes knr( valuedMethods() );
- if (knr) {} else {}
- // ...
- };
- // Use polymorphism to adapt to each situation..
- virtual KnownReturnTypes valuedMethods() = 0;
- protected:
- Holder<T>* _a;
- Holder<T>* _b;
- };
- // Example of specialization for integral types (there might be others)
- class IntSpecific : General<int> {
- public:
- IntSpecific(Holder<int>* const a
- , Holder<int>* const b)
- : General<int>(a, b)
- {};
- // implement the valuedMethods:
- virtual KnownReturnTypes valuedMethods() {
- return _a->value() > _b->value(); // dummy
- }
- };
- // Specialization for enum types:
- // * * * class EnumSpecific : General<any_enum_type> { // does not exist * *
- class EnumSpecific : General<int> {
- public:
- EnumSpecific( Holder<int>* const a
- , Holder<int>* const b)
- : General<int>(a, b)
- {};
- // only use properties and methods offered by an enum type:
- virtual KnownReturnTypes valuedMethods() {
- return _a->value() == _b->value(); // dummy
- }
- };
- // One particular case
- typedef enum {One, Two, Three} Enum;
- typedef Holder<Enum> EnumHolder;
- int main() {
- // Check that `IntSpecific` works fine.
- Holder<int>* i( new Holder<int>(3) );
- Holder<int>* j( new Holder<int>(5) );
- IntSpecific is(i, j); // ok.
- // Try the `EnumSpecific`
- EnumHolder* a( new EnumHolder { One } );
- EnumHolder* b( new EnumHolder { Two } );
- EnumSpecific es(static_cast<Holder<int>*>(a) // invalid cast
- , static_cast<Holder<Enum>*>(b)); // unexpected type
- // This is because the compiler doesn't know enough about what
- // EnumSpecific actually *is*. How to tell him more about it?
- return EXIT_SUCCESS;
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement