Wie kann eine Änderung an Array-Daten verhindert werden?

Angenommen, ich habe eine Klasse, die so aussieht (dies ist nur ein Beispiel):

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

Die constsowohl im Kopierkonstruktor als auch in der doNotChangeMyDataFunktion machen es so, dass ptres nicht geändert werden kann; Auf diese Weise kann ich jedoch weiterhin den Inhalt des Arrays ändern, auf das von verwiesen wird ptr.

Gibt es eine Möglichkeit zu verhindern, dass der Inhalt des ptrArrays nur in constInstanzen geändert wird , ohne "vorsichtig" zu sein (oder sich vom Rohzeiger zu entfernen)?

Ich weiß, ich könnte so etwas tun

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

Aber ich möchte lieber nicht ...

Zeiger verbreiten sich nicht const. Das Hinzufügen constzum Typ double*ergibt Ausbeuten double* const, die constbei Dereferenzierung zu einem Nichtwert führen.

Stattdessen können Sie Folgendes verwenden 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
};

oder ein eingebautes Array (nicht empfohlen):

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

Alle drei Optionen verbreiten sich const.

Wenn Sie wirklich Zeiger verwenden möchten (dringend nicht empfohlen), verwenden Sie mindestens a std::unique_ptr, um eine manuelle Speicherverwaltung zu vermeiden. Sie können den std::experimental::propagate_constWrapper aus den Grundlagen der Bibliothek verwenden. 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.
    // ...
};

Es ist noch nicht im Standard, aber viele Compiler unterstützen es. Natürlich ist dieser Ansatz den richtigen Behältern unterlegen.