Bagaimana mencegah modifikasi untuk menyusun data?

Katakanlah saya memiliki kelas yang terlihat seperti ini (ini hanya sebuah contoh):

class A {
    double *ptr;
public:
    A() : ptr( new double[100] ) {}
    A( const A &other ) {
        other.ptr[7] = 15;
    }
    void doNotChangeMyData() const {
        ptr[43] = 14;
    }
    void changeMyData() {
        ptr[43] = 14;
    }
    ~A() { delete[] ptr; }
};

The constbaik konstruktor copy dan doNotChangeMyDatafungsi membuatnya sehingga ptrtidak dapat diubah; namun, ini masih memungkinkan saya untuk memodifikasi isi array yang ditunjuk oleh ptr.

Apakah ada cara untuk mencegah agar isi ptrarray tidak diubah consthanya dalam keadaan, kurang "hati-hati" (atau berganti dari pointer mentah)?

Saya tahu saya bisa melakukan sesuatu seperti

void doNotChangeMyData() const {
    const double *const ptr = this->ptr;
    ptr[43] = 14; // then this would fail to compile
}

Tapi saya lebih suka tidak harus ...

Pointer tidak diperbanyak const. Menambah constjenis double*hasil double* const, yang menghasilkan nilai yang tidak constbernilai ketika didereferensi.

Sebagai gantinya, Anda dapat menggunakan std::vector:

class A {
    std::vector<double> data(100);
public:
    // no explicit copy ctor or dtor
};

a std::array:

class A {
    std::array<double, 100> data{};
public:
    // no explicit copy ctor or dtor
};

atau array bawaan (tidak disarankan):

class A {
    double data[100] {};
public:
    // no explicit copy ctor or dtor
};

Ketiga opsi tersebut merambat const.

Jika Anda benar - benar ingin menggunakan pointer (sangat tidak disarankan), setidaknya gunakan a std::unique_ptruntuk menghindari manajemen memori manual. Anda dapat menggunakan std::experimental::propagate_constpembungkus dari dasar-dasar perpustakaan 2 TS:

class A {
    std::experimental::propagate_const<std::unique_ptr<double[]>> ptr;
public:
    A()
        : ptr{new double[100] {}}
    {
    }
    // manual copy ctor
    A(const A& other)
        : ptr{new double[100]}
    {
        std::copy_n(other.ptr.get(), 100, ptr.get());
    }
    // defaulted move ctor & dtor
    // assignment operator, etc.
    // ...
};

Ini belum dalam standar, tetapi banyak kompiler mendukungnya. Tentu saja, pendekatan ini lebih rendah daripada wadah yang tepat.