在 C++ 中实现惰性赋值时出错

Question

我在实现 https://eigen.tuxfamily.org/dox/TopicInsideEigenExample.html 中的惰性分配和添加时遇到了一些奇怪的问题。

密码是

template<typename Derived> class Base;
template<typename Derived, typename OtherDerived> class SumOp;

template<typename Derived, typename OtherDerived>
class SumOp: public Base<SumOp<Derived, OtherDerived>>{
public:
    Derived & lhs;
    OtherDerived & rhs;

    SumOp(Derived & lhs_, OtherDerived & rhs_):lhs(lhs_), rhs(rhs_){}
    double  packet(size_t index, Base<OtherDerived>& src){
        return lhs.packet(index)+ rhs.packet(index);
    }
};
template<typename Derived, typename OtherDerived>
struct Assign{
    static Derived& run(Derived & dst, OtherDerived & src){
        size_t length = dst.size();
        for (size_t index =0; index < length; index++){
            dst.copyPacket(index, src);
        }
        return dst;
    }
};


template<typename Derived>
class Base{
public:
    Base(){}
    Derived& derived(){
        return *static_cast<Derived*>(this);
    }

    const Derived& derived() const{
        return *static_cast<const Derived*>(this);
    }

    template<typename OtherDerived>
            SumOp<Derived,OtherDerived> operator+(Base<OtherDerived> & other){
                return SumOp<Derived, OtherDerived>(this->derived(), other.derived());
    }

    template<typename OtherDerived>
       Derived & operator=(Base<OtherDerived>& other){
        return Assign<Derived, OtherDerived>::run(derived(), other.derived());
    }
    template<typename OtherDerived>
            void copyPacket(size_t index, Base<OtherDerived> & other){
        derived().writePacket(index, other.derived().packet(index));
    }
};


class Vector: public Base<Vector> {
public:
    double * data;
    size_t nRow;

    Vector(size_t nRow_):nRow(nRow_){
        data = (double *)malloc(sizeof(double)*nRow);
    }
    ~Vector(){
         free(data);
    }
    template<typename OtherDerived>
            Vector& operator=( Base<OtherDerived>& other){
        return Base<Vector>::operator=(other);
    }
    size_t size(){
        return nRow;
    }
    void writePacket(size_t index, double src){
        data[index] = src;
    }
    double packet(size_t index){
        return data[index];
    }
};

简而言之，问题在于当我在 Vector class 中调用 operator= 时，编译器抱怨我将左值 Base<SumOp<Vector, Vector>> 传递给运算符而不是 SumOp<Vector, Vector>&。后者是在调用 operator+ 时创建的，其中 returns SumOp<Vector, Vector>。

编译器错误是

no known conversion for argument 1 from ‘SumOp<Vector, Vector>’ to ‘Base<SumOp<Vector, Vector> >&’

我不确定为什么 Eigen 中的实现没问题以及如何解决这个问题。

感谢您的帮助。

编辑

调用以下函数时出现问题

void test_vector(){
    Vector a(10), b(10), c(10);
    for (int i=0;i<10;i++){
        a.data[i]=1.0;
        b.data[i]=1.0;
    }
    //This is very it goes wrong
    c = a+b;


    for (int i =0 ; i<10;i++){
       std::cout << c.data[i]  << std::endl;
    }

};

对于 g++-6，错误显示为

invalid initialization of non-const reference of type ‘Base<SumOp<Vector, Vector> >&’ from an rvalue of type ‘Base<SumOp<Vector, Vector> >’
     c = a+b;
         ~^~
In file included from /home/ran/Desktop/experiment/PointerMatrix/vector.cpp:6:0:
/home/ran/Desktop/experiment/PointerMatrix/vector.h:76:21: note:   initializing argument 1 of ‘Vector& Vector::operator=(Base<OtherDerived>&) [with OtherDerived = SumOp<Vector, Vector>]’
             Vector& operator=( Base<OtherDerived>& other){

Answer 1

问题是因为 operator 函数的参数不是常量引用。 operator+ returns 临时 SumOp 对象，不能作为非常量引用传递。（一些编译器可能支持这个作为扩展。）

将参数更改为 const & 类型应该可以解决此问题。

在 C++ 中实现惰性赋值时出错

Error in implementing lazy assign in C++

c++

lazy-evaluation

crtp