CRR: Problema dependente do compilador com o Expression Template
correu um problema dependente do compilador com o seguinte código (armazenado em crtp.cc
#include <vector>
#include <cassert>
#include <iostream>
template < class Derived >
class AlgebraicVectorExpression {
public:
typedef std::vector<double>::size_type SizeType;
typedef std::vector<double>::value_type ValueType;
typedef std::vector<double>::reference ReferenceType;
SizeType size() const {
return static_cast<const Derived&>(*this).size();
}
ValueType operator[](SizeType ii) const {
return static_cast<const Derived&>(*this)[ii];
}
operator Derived&() {
return static_cast<Derived&>(*this);
}
operator const Derived&() const {
return static_cast< const Derived& >(*this);
}
};
template< class T1, class T2>
class AlgebraicVectorSum : public AlgebraicVectorExpression< AlgebraicVectorSum<T1,T2> > {
const T1 & a_;
const T2 & b_;
typedef typename AlgebraicVectorExpression< AlgebraicVectorSum<T1,T2> >::SizeType SizeType;
typedef typename AlgebraicVectorExpression< AlgebraicVectorSum<T1,T2> >::ValueType ValueType;
public:
AlgebraicVectorSum(const AlgebraicVectorExpression<T1>& a, const AlgebraicVectorExpression<T1>& b) :
a_(a), b_(b) {
assert(a_.size() == b_.size());
}
SizeType size() const {
return a_.size();
}
ValueType operator[](SizeType ii) const {
return (a_[ii] + b_[ii]);
}
};
template< class T1, class T2>
const AlgebraicVectorSum<T1,T2>
operator+(const AlgebraicVectorExpression<T1>& a, const AlgebraicVectorExpression<T2>& b) {
return AlgebraicVectorSum<T1,T2>(a,b);
}
class AlgebraicVector : public AlgebraicVectorExpression<AlgebraicVector>{
std::vector<double> data_;
public:
SizeType size() const {
return data_.size();
}
ValueType operator[](SizeType ii) const {
return data_[ii];
}
ValueType& operator[](SizeType ii) {
return data_[ii];
}
AlgebraicVector(SizeType n) : data_(n,0.0) {
};
template< class T>
AlgebraicVector(const AlgebraicVectorExpression<T>& vec) {
const T& v = vec;
data_.resize(v.size());
for( SizeType idx = 0; idx != v.size(); ++idx) {
data_[idx] = v[idx];
}
}
};
int main() {
AlgebraicVector x(10);
AlgebraicVector y(10);
for (int ii = 0; ii != 10; ++ii)
x[ii] = y[ii] = ii;
AlgebraicVector z(10);
z = x + y;
for(int ii = 0; ii != 10; ++ii)
std::cout << z[ii] << std::endl;
return 0;
}
Na verdade, quando eu compilar com:
$ g++ --version
g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$ g++ -O0 -g crtp.cc
Eu obtenho
$ ./a.out
0
2
4
6
8
10
12
14
16
18
qual é o comportamento esperado. Quando eu uso icpc:
$ icpc --version
icpc (ICC) 12.1.0 20110811
Copyright (C) 1985-2011 Intel Corporation. All rights reserved.
$ icpc -g -O0 crtp.cc
Eu obtenho umSegmentation fault
. Corrid
valgrind --tool=memcheck ./a.out
aponta para a linha 29 nas fontes
AlgebraicVectorExpression<AlgebraicVector>::operator AlgebraicVector const&() const (crtp.cc:29)
Como eu sou novato em C ++ e passei bastante tempo procurando um bug sem nenhum resultado, gostaria de pedir a opinião de alguém mais experiente para entender se esse problema é devido a algum erro que apresentei (como eu esperava) ou a um erro do compilado
Edita: Alterei o código como está agora, após a resposta de Mike Seymour. Agora não recebo avisos do compilador, mas continuo tendo o mesmo comportamento de antes (com a mesma resposta valgrind). Alguém tentou compilar com a Intel?
Edita: Tentei compilar o código no Modelos de expressão página da Wikipedia. Obtive o mesmo comportamento exato do exemplo que forneci.
Edita: Investiguei o problema mais detalhadamente e parece que a compilação com a Intelicpc
o operado
operator const Derived&() const {
return static_cast< const Derived& >(*this);
}
recursively chama a si mesmo. Uma solução alternativa que encontrei é substituir esse operador por um método:
const Derived& get_ref() const {
return static_cast< const Derived& >(*this);
}
e modifique os construtores das várias classes de acordo. Alguém pode dizer qual desses dois comportamentos está certo, possivelmente apontando para o padrão para explicar isso?