¿Cómo evitar la modificación de los datos de la matriz?

Digamos que tengo una clase que se ve así (esto es solo un ejemplo):

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

El consttanto en el constructor de copia y la doNotChangeMyDatafunción de hacerlo de modo que ptrno se puede cambiar; sin embargo, esto todavía me permite modificar el contenido de la matriz a la que apunta ptr.

¿Hay alguna manera de evitar que el contenido de ptrla matriz se constmodifique solo en instancias, salvo "tener cuidado" (o cambiar el puntero sin formato)?

Sé que podría hacer algo como

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

Pero prefiero no tener que ...

Los punteros no se propagan const. Agregar constal tipo double*rendimientos double* const, lo que resulta en un valor no constl cuando se desreferencia.

En cambio, puede usar 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 una matriz integrada (no recomendado):

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

Las tres opciones se propagan const.

Si realmente desea utilizar punteros (no se recomienda encarecidamente), al menos utilice a std::unique_ptrpara evitar la gestión manual de la memoria. Puede usar el std::experimental::propagate_constcontenedor de la biblioteca fundamentos 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.
    // ...
};

Todavía no está en el estándar, pero muchos compiladores lo admiten. Por supuesto, este enfoque es inferior a los contenedores adecuados.