如何为2D数组(私有成员）写入访问器

是否可以编写返回指向我的数组的指针的访问器方法？我该怎么做？

有一种方法：

#include <iostream>
#include <algorithm>
#include <iterator>
class myClass {
public:
    const int* operator[](size_t i) const {
        return mat[i];
    }
    int* operator[](size_t i) {
        return mat[i];
    }
    int* get_mat() {
        return &mat[0][0];
    }
    const int* get_mat() const {
        return &mat[0][0];
    }
private:
    int mat[3][3];
};
int main()
{
    using namespace std;
    myClass m;
    m[0][1] = 6;
    cout << m[0][1] << endl;
    fill(m.get_mat(), m.get_mat() + 9, 11);
    copy(m.get_mat(), m.get_mat() + 9, ostream_iterator<int>(cout, ", "));
    cout << endl;
    return 0;
}

但是，为数组的每个成员调用访问器不是效率很低吗？

令人高兴的是，没有。在一个发布版本中，你的编译器会比你想象的更好地优化所有这些。

优雅地表达你的意图。允许编译器为您编写最佳代码（它会）。

预期输出：

6
11, 11, 11, 11, 11, 11, 11, 11, 11,

当我们开始充实矩阵类时，我们可能希望开始构建一些针对缓冲区溢出的安全措施（这段代码可能需要c++14）。。。

#include <iostream>
#include <algorithm>
#include <iterator>
#include <functional>
#include <random>
#include <cassert>
template<class T, size_t N>
struct safe_array_ref
{
    constexpr safe_array_ref(T* data) : _data(data) {}
    constexpr T& operator[](size_t i) const noexcept {
        assert(i < N);
        return _data[i];
    }
    constexpr T* begin() const {
        return _data;
    }
    constexpr T* end() const {
        return _data + N;
    }
    constexpr size_t size() const {
        return N;
    }
private:
    T* _data;
};
class myClass {
public:
    auto operator[](size_t i) const {
        // provide some degree of safety
        assert(i < extent_1);
        return safe_array_ref<const int, extent_2>(mat[i]);
    }
    auto operator[](size_t i) {
        // provide some degree of safety
        assert(i < extent_1);
        return safe_array_ref<int, extent_2>(mat[i]);
    }
    int* get_mat() {
        return &mat[0][0];
    }
    const int* get_mat() const {
        return &mat[0][0];
    }
    const int* begin() const {
        return get_mat();
    }
    const int* end() const {
        return get_mat() + total_extent;
    }
    int* begin() {
        return get_mat();
    }
    int* end() {
        return get_mat() + total_extent;
    }
    constexpr size_t size() const {
        return total_extent;
    }

private:
    int mat[3][3];
public:
    constexpr static size_t extent_1 = std::extent<decltype(mat)>::value;
    constexpr static size_t extent_2 = std::extent<std::remove_extent_t<decltype(mat)>>::value;
    constexpr static size_t total_extent = extent_1 * extent_2;
};
int main()
{
    using namespace std;
    myClass m;
    m[0][1] = 6;
    cout << m[0][1] << endl;
    generate(m.begin(),
             m.end(),
             bind(uniform_int_distribution<int>(0,99),
                  default_random_engine(random_device()())));
    // copy the whole matrix to stdout
    copy(m.begin(),
         m.end(),
         ostream_iterator<int>(cout, ", "));
    cout << endl;
    // copy one row/column of the matrix to stdout        
    copy(m[1].begin(),
         m[1].end(),
         ostream_iterator<int>(cout, ", "));
    cout << endl;

    return 0;
}

样本输出：

6
76, 6, 39, 68, 40, 77, 28, 28, 76,
68, 40, 77,

是否可以编写返回指向我的数组的指针的访问器方法？

您可以使用这种难看的语法来返回对内部数组的引用

const int (&myClass::as_array())[3][3] const { return mat; }

可以用typedef:来简化

using int3x3 = int [3][3];
const int3x3& myClass::as_array() const { return mat; }

std::array也是一个很好的选择。

但是为数组的每个成员调用访问器不是效率很低吗。

int myClass::get_value(int i, int j) const { return mat[i][j]; }是完全有效的，应该由编译器内联。

如果必须访问数组中的每个int，那么几乎所有的备选方案都会产生相同的汇编代码。

这个getter的缺点是不能使用stl中的大多数算法，尽管stl使用迭代器而不是索引。

拥有更简单的iterator的一种简单方法是将数组的维度从[3][3]更改为[3*3]（并手动进行索引计算）。