c – 如何为2D数组编写访问器(私有成员)

我有一个名为mat [3] [3]的类的私有成员,我希望能够在我的课程之外访问这个3×3数组(只读它,而不是更改).是否可以编写返回指向我的数组的指针的访问器方法？我怎样才能做到这一点？请提供代码示例.

这是我的班级：

class myClass {
private:
    int mat[3][3];
public:
    return_value get_mat(void);
};

我知道我可以用类似的东西

int get_mat(int i,int j);

逐个访问数组中的每个int,但为数组的每个成员调用访问器是不是很低效？

解决方法

Is it possible to write accessor method that returns pointer to my array? How can I do this?

这是一种方式：

#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(),ostream_iterator<int>(cout,","));
    cout << endl;

    return 0;
}

but wouldn’t it be inefficient to call the accessor for every member of the array?

幸运的是,没有.在发布版本中,您的编译器将比您可能想象的更好地优化所有这些.

优雅地表达你的意图.允许编译器为您编写最佳代码(它会).

预期产量：

6
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(),"));
    cout << endl;

    // copy one row/column of the matrix to stdout        
    copy(m[1].begin(),m[1].end(),"));
    cout << endl;


    return 0;
}

样本输出：

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

原文地址：https://www.jb51.cc/c/111386.html