C++Talk.NET

APokorny · Guest

Hi,
Two days ago I noticed a gcc bug, which provides a nice dispatch
feature. Actually I only believe that it is a bug, I am not really sure
about that. With this email I would like to verify that this really is
a bug, and whether there are alternative techniques, which
behave similar.

struct basic_strategy {

template<typename A,typename Dummy = void>
struct implementation;

template<typename A>
struct implementation<A, boost::enable_if<..> > {
};
// ...
// several further partial specialization could follow here,

};

struct extended_strategy : basic_strategy {

templatet<typename A>
struct implementation<A,enable_if {
// do something extended in here
};

};

I can then either pass extended_strategy or basic_strategy
as a template parameter to an algorithm, which will then call
something from the implementation struct:

template<typename Strategy,typename A>
void an_algorithm( A & parameters );
{
Strategy::template implementation<A>::do_something();
}

When using gcc, the algorithm will only notice the partial
specializations defined inside of basic_strategy, if Strategy is
basic_strategy. When extended_strategy is used, it will
pick specializations from both scopes with the ones from
extended_strategy overriding the ones from basic_strategy.
But after some reading I believe that these partial
specializations in extended_strategy are forbidden.

Comeau does not accept the code. If extended_strategy
and basic_strategy are in different namespaces gcc will also
refuse to build that code. So now I work on simulating
that behaviour with augmented tag based dispatching.

Regards,
Andreas Pokorny

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Albert Jin · Guest

Sounds that g++ allows specialization of a nested
internal template class at inherited class? I have no
idea then.

BTW. The best practice I have regarding to "simulating
that behaviour with augmented tag based dispatching"
is to use function overloading with a tag type. Some
code like this,

class foo {
private:
class my_tag1;
class my_tag2;

public:
void foo(my_tag1 *) {
// ...
}

void foo(my_tag2 *) {
// ...
}
};

The access of the two overloaded functions foo() are
actually controlled by the tag parameter, my_tag1
and my_tag2. The templated based implementation
for this is cumbersome and hard to make different
compilers happy.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]