1

考虑以下玩具示例，我在其中声明了一个ublas从boost 库中封装的类：

#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <iostream>

namespace ublas = boost::numeric::ublas;

class UblasEncapsulated {
public:
    ublas::compressed_matrix<float>::reference operator()(int i, int j){
        std::cout << "Non const reference" << std::endl;
        MtrUpdated_ = true;
        return mtr_(i, j);
    }

    ublas::compressed_matrix<float>::const_reference operator()(
        int i, int j) const {
        std::cout << "Const reference" << std::endl;
        return mtr_(i, j);
    }

    UblasEncapsulated() { MtrUpdated = false; }

private:
    ublas::compressed_matrix<float> mtr_(3, 3);
    bool MtrUpdated_;
};

int main() {
    UblasEncapsulated foo;

    foo(2, 0) =  1.0f;
    float const foo_float = foo(2, 0);

    return 0;
}

我期待输出

Non constant reference
Constant reference

但我得到了

Non constant reference
Non constant reference

我究竟做错了什么？如何正确跟踪何时mtr_可以更改其值？

4

1 回答 1

1

foo是非常量的，因此foo.operator()将调用非常量版本的。如何使用它返回的值并不重要。

如果您真的想知道MtrUpdated_仅在实际分配元素时才设置为 true，则需要使用代理类：

class UblasEncapsulated {
public:
    class proxy {
    public:
        proxy(UblasEncapsulated* ptr, int i, int j)
            : ptr_(ptr), i_(i), j_(j)
        {}

        proxy& operator=(float f) {
            ptr_->MtrUpdated_ = true;
            ptr_->mtr_(i_, j_) = f;
            return *this;
        }

        operator float() {
            return ptr_->mtr_(i_, j_);
        }

    private:
        UblasEncapsulated* ptr_;
        int i_;
        int j_;
    };      

    proxy operator()(int i, int j) {
        return proxy(this, i, j);
    }

    ublas::compressed_matrix<float>::const_reference operator() (int i, int j) const {
        return mtr_(i, j);
    }

    UblasEncapsulated()
        : mtr_(3, 3),
          MtrUpdated_(false)
    {}

private:
    ublas::compressed_matrix<float> mtr_;
    bool MtrUpdated_;
};

现场演示

请注意，如果可以避免使用代理类，则应避免使用它，因为它不能很好地处理诸如auto模板参数推导之类的事情。

于 2018-03-20T00:17:51.630 回答