Discussion :

[white_tentacle]

Bonjour,

J’ai une classe (non copiable). Dedans cette classe, il y a un gros tableau, qui est un std::vector. Je voudrais m’assurer que ce vecteur n’est pas copié implicitement (par erreur, soit parce qu’on le passe en paramètre de fonction par copie et pas par ref).

J’aimerai donc faire un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class A
{
private:
    noncopyable std::vector<Data> m_data;
…
public:
    noncopyable std::vector<Data>& data() { return m_data; }
…
}

Y a-t-il une solution standard à ce problème ?

Je suis parfaitement conscient que si on veut copier le vecteur, on le copiera. L’idée est plutôt ici de détecter à la compilation une copie accidentelle (operator=, passage de paramètre…), qui me plomberait mes perfs. La copie explicite étant toujours possible via itération sur le vecteur.

[r0d]

Comme ça à chaud et sans plus de détails, je dirais que la solution est l'encapsulation: empêcher l'accès au conteneur, et se débrouiller pour mettre de code qui utilise ce conteneur à l'intérieur de la classe qui le possède.

[cob59]

A priori je verrais bien quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class A
{
private:
    std::vector<Data> m_data;
…
public:
    std::vector<Data>::iterator begin() { return m_data.begin(); }
    std::vector<Data>::const_iterator begin() const { return m_data.begin(); }
 
    std::vector<Data>::iterator end() { return m_data.end(); }
    std::vector<Data>::const_iterator end() const { return m_data.end(); }
…
}

[Bousk]

Bonsoir,

Ne peux-tu pas passer le vector en private et ne fournir qu'un getter const& ?
C'est cheap, mais ça peut être un compromis simple.

[white_tentacle]

BousK : j’ai déja mon vecteur en membre privé et l’accesseur en const ref, mais ça ne change rien : si je l’expose tel quel, je ne peux pas empêcher qu’on le copie par erreur.

r0d & cob59 : yep, ça marche. Mais ça m’oblige à redéfinir toute l’interface de std::vector, juste pour ça. Je cherchais justement une solution qui m’évite cela. À la limite, je peux surcharger l’opérateur ->, mais ça ne me satisfait pas vraiment.

[r0d]

r0d & cob59 : yep, ça marche. Mais ça m’oblige à redéfinir toute l’interface de std::vector, juste pour ça. Je cherchais justement une solution qui m’évite cela. À la limite, je peux surcharger l’opérateur ->, mais ça ne me satisfait pas vraiment.

La solution que je proposais est différente de celle de cob. Moi je propose de masquer totalement l'existence du vecteur (donc pas d'accesseurs, contrairement à ce que propose cob). Ce qui implique que tout le code qui utilise ce vecteur sera dans la classe qui le possède.
Par contre je ne sais pas si c'est applicable dans le contexte de ton programme.

[Kalith]

T'es-t-il possible de rendre Data non copiable ? Si oui, tu peux avoir un std::vector fonctionnel mais non copiable, à la seule condition que ton constructeur de mouvement soit déclaré noexcept (pour des raisons subtiles, mais bien expliquées ici) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
struct Data {
    Data() = default;
    Data(const Data&) = delete;
    Data(Data&&) noexcept { ... }
    Data& operator=(const Data&) = delete;
    Data& operator=(Data&&) noexcept { ... return *this; };
};

Sinon tu peux wrapper Data dans une classe proxy qui elle est non copiable.