Dizi verilerinde değişiklik yapılmasını nasıl önleyebilirim?

Diyelim ki böyle bir sınıf var (bu sadece bir örnek):

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

constKopya kurucu ve hem de doNotChangeMyDataböylece fonksiyonu yapmak ptrdeğiştirilemez; ancak bu yine de işaret ettiği dizinin içeriğini değiştirmeme izin veriyor ptr.

Dizisinin içeriğinin yalnızca örnek ptrolarak değiştirilmesini önlemenin, const"dikkatli olmak" (veya ham işaretçiden uzaklaşmak) dışında bir yolu var mı?

Gibi bir şey yapabileceğimi biliyorum

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

Ama yapmak istemem ...

İşaretçiler yayılmaz const. constTip double*verimi eklenirse double* const, constkayıttan çıkarıldığında değer kaybı olmaz.

Bunun yerine aşağıdakileri kullanabilirsiniz 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
};

veya yerleşik bir dizi (önerilmez):

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

Üç seçeneğin tümü yayılır const.

Eğer varsa gerçekten (kuvvetle tavsiye edilmez) işaretçileri kullanmak istiyorum, en azından bir kullanma std::unique_ptrkılavuzu bellek yönetimini önlemek için. Sen kullanabilirsiniz std::experimental::propagate_constkütüphane temelleri 2 TS üzerindeki kağıdı:

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.
    // ...
};

Henüz standartta değil, ancak birçok derleyici bunu destekliyor. Tabii ki, bu yaklaşım uygun kaplardan daha düşüktür.