Comment empêcher la modification des données du tableau?

Disons que j'ai une classe qui ressemble à ceci (ce n'est qu'un exemple):

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

Le constconstructeur de copie et la doNotChangeMyDatafonction le rendent ptrimpossible à modifier; cependant, cela me permet toujours de modifier le contenu du tableau pointé par ptr.

Existe-t-il un moyen d'empêcher le contenu du ptrtableau de d'être modifié dans les constinstances uniquement, à moins de "faire attention" (ou de s'éloigner du pointeur brut)?

Je sais que je pourrais faire quelque chose comme

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

Mais je préfère ne pas avoir à ...

Les pointeurs ne se propagent pas const. L'ajout constau type double*donne double* const, ce qui entraîne une non- constvaleur lorsqu'il est déréférencé.

Au lieu de cela, vous pouvez utiliser 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 un tableau intégré (non recommandé):

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

Les trois options se propagent const.

Si vous voulez vraiment utiliser des pointeurs (fortement déconseillés), utilisez au moins un std::unique_ptrpour éviter la gestion manuelle de la mémoire. Vous pouvez utiliser l' std::experimental::propagate_constencapsuleur des principes fondamentaux de la bibliothèque 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.
    // ...
};

Ce n'est pas encore dans la norme, mais de nombreux compilateurs le prennent en charge. Bien sûr, cette approche est inférieure aux conteneurs appropriés.