Question

I have some generic code which implements Pareto rule. It seems like well-formed code.

GCC 4.4 compiler messages about errors for newResult.set<Criterion>( criterion() ); expression. But I can’t found problem.

Full error log:

trunk$ g++ -std=c++0x -o test test.cpp 
t6.cpp: In member function ‘bool Pareto<Minimize<T>, Types ...>::operator()(Map&, Map&)’:
t6.cpp:24: error: expected primary-expression before ‘>’ token
t6.cpp:26: error: expected primary-expression before ‘>’ token
t6.cpp:26: error: expected primary-expression before ‘)’ token
t6.cpp:26: error: expected primary-expression before ‘>’ token
t6.cpp:26: error: expected primary-expression before ‘)’ token
t6.cpp: In member function ‘bool Pareto<Maximize<T>, Types ...>::operator()(Map&, Map&)’:
t6.cpp:43: error: expected primary-expression before ‘>’ token
t6.cpp:45: error: expected primary-expression before ‘>’ token
t6.cpp:45: error: expected primary-expression before ‘)’ token
t6.cpp:45: error: expected primary-expression before ‘>’ token
t6.cpp:45: error: expected primary-expression before ‘)’ token

Full code listing:

// TypeMap
template < typename ... Tail >
struct Holder;

template <typename ValueType, typename Head, typename ... Tail >
struct Holder<ValueType, Head, Tail ... > :
    public Holder<ValueType, Head>,
    public Holder<ValueType, Tail ... >
{};

template <typename ValueType, typename Head >
struct Holder<ValueType, Head>
{
    ValueType value;
};

template < typename ... Types >
struct TypeMap;

template <typename ValueType, typename ... Types >
struct TypeMap<ValueType, Types ... > :
    public Holder<ValueType, Types ... >
{
    template <typename T>
    void set(const ValueType& value)
    {
        ((Holder<ValueType, T>*)this)->value = value;
    }

    template <typename T>
    ValueType get()
    {
        return ((Holder<ValueType, T>*)this)->value;
    }
};

// Objectives
template <typename Criterion> struct Maximize : public Criterion {};
template <typename Criterion> struct Minimize : public Criterion {};

// Criteria
struct Criterion1{ double operator()(){ return 0; }};
struct Criterion2{ double operator()(){ return 0; }};

// Pareto rule
template < typename ... Types > struct Pareto;

template < typename T, typename ... Types >
struct Pareto<Minimize<T>, Types ... >
{
    template< typename Map >
    bool operator()(Map& oldResult, Map& newResult)
    {
        typedef Minimize<T> Criterion;
        Criterion criterion;

        // ERROR HERE !!!
        newResult.set<Criterion>( criterion() );

        if(newResult.get<Criterion>() >= oldResult.get<Criterion>())
            return false;

        Pareto<Types ... > pareto;
        return pareto(oldResult, newResult);
    }
};

template < typename T, typename ... Types >
struct Pareto<Maximize<T>, Types ... >
{
    template< typename Map >
    bool operator()(Map& oldResult, Map& newResult)
    {
        typedef Maximize<T> Criterion;
        Criterion criterion;

        // ERROR HERE !!!
        newResult.set<Criterion>( criterion() );

        if(newResult.get<Criterion>() <= oldResult.get<Criterion>())
            return false;

        Pareto<Types ... > pareto;
        return pareto(oldResult, newResult);
    }
};

template<>
struct Pareto<>
{
    template<typename Map>
    bool operator()(Map& oldResult, Map& newResult)
    {
        oldResult = newResult;
        return true;
    }
};

int main()
{
    TypeMap<double, Minimize<Criterion1>, Maximize<Criterion2>> oldResult, newResult;

    Pareto<Minimize<Criterion1>, Maximize<Criterion2>> pareto;
    pareto(oldResult, newResult);
}

Answer 1

Found it:

newResult.template set<Criterion>( criterion() );

if(newResult.template get<Criterion>() >= oldResult.template get<Criterion>())
    return false;

You have to qualify the member function templates for the compiler in this case.
The lexer wouldn’t be able to decide (at the time of template declaration, not instantiation) whether <Criterion means the start of a template parameter list or, instead, a comparison operator.

See

• Using the template keyword as qualifier

• What is the .template and ::template syntax about? (Comeau)

• Standard, § 14.2, sub 4. and 5., noteworthy:

  [ Note: As is the case with the typename prefix, the template prefix is allowed in cases where it is
  not strictly necessary; i.e., when the nested-name-specifier or the expression on the left of the -> or . is not
  dependent on a template-parameter, or the use does not appear in the scope of a template. —end note ]