How to prevent modification to array data?

Question

Say I have a class that looks like this (this is just an example):

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 const in both the copy constructor and the doNotChangeMyData function make it so that ptr cannot be changed; however, this still allows me to modify the contents of the array pointed to by ptr.

Is there a way to prevent the contents of ptr's array from being changed in const instances only, short of "being careful" (or changing away from raw pointer)?

I know I could do something like

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

But I'd rather not have to ...

Answer 1

Pointers do not propagate const. Adding const to the type double* yields double* const, which results in a non-const lvalue when dereferenced.

Instead, you can use a 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
};

or a builtin array (not recommended):

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

All of the three options propagate const.

If you really want to use pointers (not recommended), consider using a std::unique_ptr to avoid manual memory management. You can use the std::experimental::propagate_const wrapper from the library fundamentals 2 TS: (using raw arrays with unique_ptr has some complications, as mentioned in a comment below)

#include <array>
#include <memory>
#include <experimental/propagate_const>

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

It's not in the standard yet, but many compilers support it. Of course, this approach is inferior to the proper containers.