struct avec const membre

Je vais avoir quelques problèmes avec un template struct.

template<typename T>
struct A{
    const int v1;
    T* v2;
};

Mon but est de faire v1 toujours pas modifiable, tout en v2 devrait être modifiable si j'utilise T et non modifiable si j'utilise const T type.

Si je créer constructeur pour initialiser A, la structure devient:

template<typename T>
struct A{
    const int v1;
    T* v2;
    A() : v1(-1) { v2=NULL; }
    A(int value) : v1(value) { v2=NULL; }
};

Mais alors g++ dit que j'ai besoin d'un opérateur d'affectation:

erreur: non-static const membre ‘const int A::v1’, ne peut pas utiliser l'affectation par défaut de l'opérateur

Mais mon opérateur d'affectation doit également permettre la modification de v1. La seule chose que je voudrais éviter, c'est une modification de l'extérieur, quelque chose comme:

A a;
a.v1=10;

Est-il possible de mettre en œuvre des ce (sans créer de getter/setter ou à l'aide d'un pointeur vers un nouveau(int) avec la valeur souhaitée)?

Ce que si je déclare v1 comme const int * ? Il peut faire référence qu'à une certaine valeur, mais il ne peut pas le modifier.

  • "sans la conversion de structure de classe (...)" Ce que vous avez est déjà une classe.
  • Vous devez comprendre qu'en C++, une structure EST une classe, il suffit d'un type très précis de la classe. Une structure est une classe où tout est public.
  • Si l'opérateur d'affectation est en mesure de modifier const membres alors vous avez encore le problème de la modifier à partir de l'extérieur parce que je peux, il suffit de faire une cession de l'ensemble de l'objet au lieu de modifier obj.v1 par lui-même
  • Exactement pourquoi ne voulez-vous pas ajouter des accesseurs/mutateurs, par le chemin?
  • const mutable serait très utile 🙂
  • parce que l'Un doit être un struct, donc je ne peut pas utiliser les données privées.
  • Ce que si je supprime les constructeurs et les déclarer v1 comme const int*, alors je pourrais changer l'adresse v1 points, mais pas la valeur de la valeur indiquée.
  • struct est une classe où tout est public". Non, une structure est une classe où les membres et les bases sont publiques par défaut. Les structures peuvent encore avoir privé les membres. Essentiellement, il n'est pas question que vous utilisez de struct et class, aussi longtemps que vous êtes cohérent tout cela affecte est l'endroit où vous devez taper des spécificateurs d'accès. Elle peut également affecter la façon dont le nom est mutilé.
  • "Mon but est de faire de la v1 toujours pas modifiable" ... "ma mission à l'opérateur doit également permettre la modification de v1" -- il est votre problème, en contradiction directe avec les exigences. Choisissez l'un d'entre eux à abandonner.
  • Je suis en train de penser à déclarer v1 comme const int* , de sorte que je peux changer v1 (adresse et la valeur v1 points), mais je ne peux pas le modifier.
  • mais alors, qui que ce soit que vous essayez d'éviter de modifier la valeur de v1 quand il était un const int, peut modifier la valeur du pointeur maintenant que c'est un const int *. De Plus, vous avez la question de savoir comment la ints sont allouées et libéré. Il n'y a pas de bonne façon de permettre à l'opérateur d'assignation de copie pour modifier la valeur, tout en empêchant d'autres fonctions membre de le modifier. Ni est-il une bonne façon d'exposer un non-const membre du public d'une manière qui les empêche de l'écrire. C++ n'ont pas cette fine encapsulation intégré, vous avez passer votre propre.
  • laissez-nous continuer cette discussion dans le chat

InformationsquelleAutor Vektor88 | 2012-02-09
  1. 2

    Voici un moyen de les "exposer" un public, des données en lecture seule membre qui est modifiable par la classe des fonctions membres (y compris la cession):

    template <typename T>
class Helper {
    friend class A;
    T *ptr;
    Helper &operator=(const Helper &rhs) = default; //in C++11
    Helper &operator=(const Helper &rhs) { ptr = rhs.ptr; } //in C++03
  public:
    Helper(T *ptr) : ptr(ptr) {}
    operator const int &() const { return *ptr; }
};

class A {
    int v1_;
  public:
    Helper<int> v1;
    A() : v1(&v1_) {} //although `A` should have a constructor that sets `v1_`
    A(const A &rhs) { v1_ = rhs.v1_; v1 = Helper<int>(&v1_); }
    A &operator=(const A &rhs) { v1_ = rhs.v1_; v1 = Helper<int>(&v1_); }
};

    Maintenant, n'importe qui en dehors de la classe A peut utiliser v1, mais la seule chose qu'ils peuvent utiliser pour obtenir un const int& référence à v1_.

    Il est beaucoup plus facile de donner A un getter fonction qui renvoie const int &, mais si vous voulez vraiment le membre de données syntaxe alors cette offre, il...

    • C'est mieux que ma solution. Merci!!!!
    InformationsquelleAutor Steve Jessop
  2. 2

    Il est dit que vous ne pouvez pas utiliser le par défaut opérateur d'affectation. Rien ne vous empêche de rédiger votre propre operator= et l'utilisation d'un const_cast. Malheureusement, ce sera un comportement indéfini comme v1 est déclarée const. Donc, je vous suggère d'utiliser des accesseurs et des données privées.

    • Est-il encore un comportement indéfini si vous utilisez const_cast?
    • Le standard est tout à fait clair ici: const_cast résultats dans un comportement indéterminé iff de l'objet déclarée const. C'est le cas pour la variable membre. Je peux creuser les citations, si elle vous fait vous sentir mieux.
    • Oh, je vois. Bon pensez vous de mettre l'accent sur le "déclaré", je ne l'aurais pas remarqué.
    InformationsquelleAutor pmr
  3. 1

    Vous pourriez juste faire une classe avec tout le public (c'est tout un struct est) et d'utiliser une initialisation de la liste, pas besoin de getters/setters

    • Qui serait encore de ne pas autoriser la cession, droit?
    • Correct, mais si c'est un const, je préférerais vraiment de le mettre à ctor temps de toute façon. Votre solution est la meilleure pour sa question
    InformationsquelleAutor Martin Beckett
  4. 0

    J'ai résolu mon problème en changeant le type de v1 à partir de int const int *, en faisant cela, je peux changer l'adresse de v1 et par conséquent de modifier la valeur de v1 points, mais la prévention de tout type de montage.

    Donc, voici mon nouveau simple struct

    template<typename T>
struct A{
    const int* v1;
    T* v2;
};

    Lorsque j'utilise Un type T, je laisse v2 pour être édité, et lorsque j'utilise Un type T const-je empêcher toute tentative de modifier la v2 de la valeur indiquée.

    InformationsquelleAutor Vektor88