c++ - 封装ublas并重载对operator()的const引用

Question

考虑以下玩具示例，我在其中声明了一个封装 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_ 的值何时可以更改？

Answer 1

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

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

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_;
};

Live Demo

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