Come impedire la modifica dei dati dell'array?

Supponiamo che io abbia una classe simile a questa (questo è solo un esempio):

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

L' constsia il costruttore di copia e la doNotChangeMyDatafunzione di fare in modo che ptrnon può essere modificato; tuttavia, ciò mi consente ancora di modificare il contenuto dell'array indicato da ptr.

Esiste un modo per impedire che il contenuto ptrdell'array venga modificato constsolo nelle istanze, a meno di "stare attenti" (o passare dal puntatore non elaborato)?

So che potrei fare qualcosa del genere

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

Ma preferirei non dover ...

I puntatori non si propagano const. L'aggiunta constal tipo double*produce double* const, il che si traduce in un non- constvalore quando non referenziato.

Invece, puoi usare un 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
};

o un array incorporato (non consigliato):

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

Tutte e tre le opzioni si propagano const.

Se vuoi davvero usare i puntatori (fortemente sconsigliato), almeno usa a std::unique_ptrper evitare la gestione manuale della memoria. È possibile utilizzare il std::experimental::propagate_constwrapper dalle basi della libreria 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.
    // ...
};

Non è ancora nello standard, ma molti compilatori lo supportano. Naturalmente, questo approccio è inferiore ai contenitori adeguati.