Como evitar modificações nos dados da matriz?

Digamos que eu tenha uma classe parecida com esta (este é apenas um exemplo):

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

O constconstrutor de cópia e a doNotChangeMyDatafunção fazem com que isso ptrnão possa ser alterado; no entanto, isso ainda me permite modificar o conteúdo da matriz apontada por ptr.

Existe uma maneira de impedir que o conteúdo da ptrmatriz seja alterado constapenas em instâncias, sem "ter cuidado" (ou mudar o ponteiro bruto)?

Eu sei que eu poderia fazer algo como

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

Mas eu prefiro não ter que ...

Ponteiros não se propagam const. Adicionando constao tipo double*yield double* const, o que resulta em um não-valor constquando desreferenciado.

Em vez disso, você pode usar um 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
};

ou uma matriz incorporada (não recomendado):

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

Todas as três opções se propagam const.

Se você realmente deseja usar ponteiros (fortemente não recomendado), use pelo menos a std::unique_ptrpara evitar o gerenciamento manual de memória. Você pode usar o std::experimental::propagate_constwrapper nos fundamentos da biblioteca 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.
    // ...
};

Ainda não está no padrão, mas muitos compiladores o suportam. Obviamente, essa abordagem é inferior aos contêineres adequados.