C++Talk.NET

dkouroun@cc.uoi.gr · Guest

Dear experts,
when I compile the following code with g++-4.1,
the latest version, or with g++-3.4.4 I get really
strange errors. It seems that the compiler cannot
understand the explicit specialization and somehow
it reinterprets it like operator '<'. On the other hand
intel's icpc compiler compile this code really smoothly.
Does anybody have any idea what the problem might
be here? Code follows:

****************************************************

enum Color
{
_A = 0,
_B = 1,
};

enum Brand
{
BrA = 1,
BrB = 2,
};

enum Tire
{
Pirelli = 0,
BRIDGESTON = 1
};

enum MACHINE
{
AUDI = 0,
};

template Brand D1,
Tire P1,
Brand D2,
Tire P2>
class Speed;

template<>
class Speed<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>
{
public:
Speed() {}

template<Color C>
double RunFast(int i, int k);
};

template<> inline double
Speed<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>::RunFast<_A>(int i, int
k)
{
return 0.3*i*i*k;
}

template<> inline double
Speed<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>::RunFast<_B>(int i, int
k)
{
return
0.5*k*k*i;
}

template<long int N, MACHINE S, typename Expr>
class Breaks;

template<typename Expr>
class Breaks<3, AUDI, Expr>
{
private:
Expr& expr_;

public:
Breaks(Expr& expr)
: expr_(expr)
{
}

template<Color C>
double speadup(const int i)
{
return (
expr_.speadup<C>(i, 0) +
( expr_.speadup<C>(i, 1) +
expr_.speadup<C>(i, 2) +
expr_.speadup<C>(i, 3) ));
}
};

template<Brand D, MACHINE S, Tire P>
class Accel
{
public:
typedef Speed<S, D, P, D, P> SpeedType;

public:
SpeedType& speed;

Breaks<3, S, Accel> run;

public:
~Accel();
Accel(SpeedType& rspeed);

void calculate();

template<Color C> inline double
speadup(const int i, const int k);
};

template<Brand D, MACHINE S, Tire P>
Accel<D, S, P>::~Accel()
{
}

template<Brand D, MACHINE S, Tire P>
Accel<D, S, P>::Accel(SpeedType& rspeed)
: speed(rspeed), run(*this)
{
}

template<Brand D, MACHINE S, Tire P>
template<Color C> inline double
Accel<D, S, P>::speadup(const int i, const int k)
{
return speed.RunFast<C>(i, k);
}

template<> inline void
Accel<BrB, AUDI, BRIDGESTON>::calculate()
{
int i, j;
i = 10;
j = 20;
double a = 0.0;
a += run.speadup<_A>(i);
a += run.speadup<_B>(i);
}

int main()
{
Speed<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON> speed;
Accel<BrB, AUDI, BRIDGESTON> poi(speed);

return 0;
}

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

dkouroun@cc.uoi.gr · Guest

In what you see above there is a typo in 'speedup' which
has been written as 'speadup'. This is not the problem in
the code.

The correct code follows:
---------------------------------
enum Color
{
_A = 0,
_B = 1,
};

enum Brand
{
BrA = 1,
BrB = 2,
};

enum Tire
{
Pirelli = 0,
BRIDGESTON = 1
};

enum MACHINE
{
AUDI = 0,
};

template<MACHINE S,
Brand D1,
Tire P1,
Brand D2,
Tire P2>
class Car;

template<>
class Car<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>
{
public:
Car() {}

template<Color C>
double Paint(int i, int k);
};

template<> inline double
Car<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>::Paint<_A>(int i, int k)
{
return 0.3*i*i*k;
}

template<> inline double
Car<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON>::Paint<_B>(int i, int k)
{
return
0.5*k*k*i;
}

template<long int N, MACHINE S, typename Expr>
class Accelaration;

template<typename Expr>
class Accelaration<3, AUDI, Expr>
{
private:
Expr& expr_;

public:
Accelaration(Expr& expr)
: expr_(expr)
{
}

template<Color C>
double speedup(const int i)
{
return (
expr_.speedup<C>(i, 0) +
( expr_.speedup<C>(i, 1) +
expr_.speedup<C>(i, 2) +
expr_.speedup<C>(i, 3) ));
}
};

template<Brand D, MACHINE S, Tire P>
class Accel
{
public:
typedef Car<S, D, P, D, P> CarType;

public:
CarType& car;

Accelaration<3, S, Accel> run;

public:
~Accel();
Accel(CarType& rcar);

void calculate();

template<Color C> inline double
speedup(const int i, const int k);
};

template<Brand D, MACHINE S, Tire P>
Accel<D, S, P>::~Accel()
{
}

template<Brand D, MACHINE S, Tire P>
Accel<D, S, P>::Accel(CarType& rcar)
: car(rcar), run(*this)
{
}

template<Brand D, MACHINE S, Tire P>
template<Color C> inline double
Accel<D, S, P>::speedup(const int i, const int k)
{
return car.Paint<C>(i, k);
}

template<> inline void
Accel<BrB, AUDI, BRIDGESTON>::calculate()
{
int i, j;
i = 10;
j = 20;
double a = 0.0;
a += run.speedup<_A>(i);
a += run.speedup<_B>(i);
}

int main()
{
Car<AUDI, BrB, BRIDGESTON, BrB, BRIDGESTON> car;
Accel<BrB, AUDI, BRIDGESTON> poi(car);

return 0;
}

and when I try to compile with:
g++-4.1 or g++-3.4.4

I get
main.cc: In member function 'double Accel<D, S, P>::speedup(int, int)
[with Color C = _A, Brand D = BrB, MACHINE S = AUDI, Tire P =
BRIDGESTON]':
main.cc:79: instantiated from 'double Accelaration<3l, AUDI,
Expr>::speedup(int) [with Color C = _A, Expr = Accel<BrB, AUDI,
BRIDGESTON>]'
main.cc:129: instantiated from here
main.cc:119: error: no match for 'operator<' in '((Accel BRIDGESTON>*)this)->Accel<BrB, AUDI, BRIDGESTON>::car->Car<AUDI, BrB,
BRIDGESTON, BrB, BRIDGESTON>::Paint < _A'
main.cc: In member function 'double Accel [with Color C = _B, Brand D = BrB, MACHINE S = AUDI, Tire P =
BRIDGESTON]':
main.cc:79: instantiated from 'double Accelaration<3l, AUDI,
Expr>::speedup(int) [with Color C = _B, Expr = Accel<BrB, AUDI,
BRIDGESTON>]'
main.cc:130: instantiated from here
main.cc:119: error: no match for 'operator<' in '((Accel BRIDGESTON>*)this)->Accel<BrB, AUDI, BRIDGESTON>::car->Car<AUDI, BrB,
BRIDGESTON, BrB, BRIDGESTON>::Paint < _B'

while icpc compiles the code as usual.

What is wrong here?

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

Alberto Ganesh Barbati · Guest