Comment appeler un non-const méthode à partir d'un const méthode?

J'ai un const méthode dans ma classe, qui ne peut pas être modifié à la non-const. Dans cette méthode, je dois appeler un non-const méthode, mais le compilateur ne me permet pas de le faire.

Est-il un moyen de contourner cela? Ici est simplifiée exemple de mon code:

int SomeClass::someMethod() const {
    QColor saveColor = color();
    setColor(QColor(255,255,255)); //Calling non-const method

    //....

    setColor(saveColor); //restore color

    return 1;
}
Ne serait-il pas à l'encontre de la règle fondamentale de l'être const fonction ?
de l'extérieur, c'est un const fonction que rien de visible pour le client a été changé.
Le mutable mot-clé permet de modifier les données dans un const méthode, mais personne ne suggère de cesser d'utiliser mutable et de modifier la méthode de la non-const. En tant que programmeur, je sais que je suis en définissant une couleur, puis la restauration de cette couleur. Je sais que les données n'a pas été changé, donc je suis à la recherche d'un moyen d'indiquer que pour le compilateur.
ce que vous dites est vrai, mais si quelqu'un crée un const instance de SomeClass, alors il est défini comportement de modifier ses mutable membres, mais UB à modifier son non-mutable membres. Par conséquent, il existe une différence importante entre la situation vous avez réellement, et la situation que vous comparez. L'effet de marquage someMethod const est de permettre aux appelants de l'appeler sur const objets, ainsi que de l'appeler sur la non-const objets à l'aide de références-à-const, et vous ne pouvez pas séparer les deux. Jetant const repose sur l'appelant uniquement à l'aide de la fonction sur la non-const objets.
Une solution possible est de modifier le code dans // .... de sorte qu'il n'est pas nécessaire d'utiliser de l'objet courant "de couleur". Ajouter les versions de toutes les fonctions que vous utilisez, que de prendre un QColor paramètre à la place. Qui s'appuie sur le pouvoir de changer les interfaces utilisées dans le code caché, bien sûr. Elle peut aussi avoir un comportement différent dans votre code, si // .... jette alors l'objet de la couleur a été modifiée, alors que vous, vous perdrez cet effet, à ma suggestion.

OriginalL'auteur this.lau_ | 2011-11-30

  1. 8

    L'un des défis de faire const-l'exactitude est que vous ne pouvez pas le faire à moitié. C'est soit tout ou rien. Si vous essayez de le faire à mi-chemin, vous vous retrouvez dans un endroit difficile, comme vous êtes ici. Vous vous retrouvez avec une belle const-classe correcte utilisée par certains vieux fou, généralement héritage (ou écrit par un ancien crummudgeon) du code qui n'est pas const-correct et qu'il ne fonctionne tout simplement pas. Vous êtes de gauche demandais si const-correction vaut tous les ennuis.

    I need to call a non-const method [from a const method]

    Vous ne pouvez pas ... du moins pas directement. Vous ne devez. Cependant, il existe une alternative...

    Évidemment, vous ne pouvez pas appeler un non-const méthode à partir d'un const méthode. Sinon, const n'aurait pas de sens lorsqu'il est appliqué à des fonctions de membre du.

    Un const fonction membre peut modifier les variables membres marqué mutable, mais vous avez indiqué que ce n'est pas possible dans votre cas.

    Vous pouvez tenter de cast away constness en faisant quelque chose comme SomeClass* me = const_cast<SomeClass*>(this); mais) C'est en général le résultat de l'AC, ou 2) Il contrevient à l'idée de const-correction.

    Une chose que vous pourriez faire, si ce que vous êtes vraiment essayer d'accomplir aurait l'appui de cette, est de créer un non-const objet proxy, et nonconst-y des trucs avec que. À savoir:

    #include <iostream>
#include <string>
using namespace std;

class Gizmo
{
public:
    Gizmo() : n_(42) {};
    void Foo() const;
    void Bar() { cout << "Bar() : " << n_ << "\n"; }
    void SetN(int n) { n_ = n; };
    int GetN() const { return n_; }
private:
    int n_;
};

void Gizmo::Foo() const
{
    //we want to do non-const'y things, so create a proxy...
    Gizmo proxy(*this);
    int save_n = proxy.GetN();
    proxy.SetN(save_n + 1);
    proxy.Bar();
    proxy.SetN(save_n);
}

int main()
{
    Gizmo gizmo;
    gizmo.Foo();
}
    Comment est-il utile? Je suis confus. Le proxy n'est pas ici un proxy, car il ne représente pas l'objet d'origine. C'est juste un objet local sans pouvoir extraordinaire. Travailler avec proxy n'est pas équivalent à travailler avec l'objet original.
    si elle contribue à l'op exécuter son travail dans un standard conforme manière utile.

    OriginalL'auteur John Dibling

  2. 14

    Vous pouvez utiliser const_cast sur this pointeur,

    int SomeClass::someMethod() const {
    const_cast<SomeClass*>( this )->setColor(...);//Calling non-const method
    //whatever
}

    mais si vous le faites pour un objet qui a été déclaré à l'origine const vous exécutez dans un comportement indéfini.

    Donc:

    SomeClass object;
object.someMethod();

    est d'accord, mais c':

    const SomeClass object;
object.someMethod();

    rendements comportement indéfini.

    La vraie solution est que votre const fonction ne doit pas être const en premier lieu.

    Je suppose que l'on pourrait utiliser une usine et les constructeurs privés, pour s'assurer qu'il n'y a pas const instances de SomeClass. Mais à moins que ce soit déjà là, c'est un changement beaucoup plus grand à l'interface de classe que les modifications que l'interlocuteur est interdit de faire, de manière sans doute pas beaucoup d'aide.

    OriginalL'auteur sharptooth

  3. 7

    Si vous avez besoin de modifier certains état interne à l'intérieur d'un const-méthode, vous pouvez aussi déclarer l'état affecté mutable:

    class Foo {
public:
    void doStuff() const { bar = 5; }
private:
    mutable int bar;
};

    C'est prévu pour le cas où vous avez des trucs comme mutex en tant que membres de votre classe. L'acquisition et la libération d'un mutex n'affecte pas les client-visible de l'état, mais est techniquement interdit dans un const-méthode. La solution est de marquer le mutex mutable. Votre cas est similaire, bien que je pense de votre classe exige de remaniement pour que cette solution soit applicable.

    Aussi, vous voudrez peut-être lire cette réponse pour voir comment vous pouvez faire de cette temporaire de changement d'état d'exception-safe à l'aide de RAII.

    OriginalL'auteur Björn Pollex

  4. 7

    Comment appeler un non-const méthode à partir d'un const méthode?

    Vous ne devriez pas. Vous pourriez avoir un comportement indéterminé si vous rejetez loin de la const-ness de this, à l'aide de const_cast. L'utilisation deconst_cast ferme le compilateur de la bouche, mais ce n'est pas une solution. Si vous avez besoin de le faire, alors cela signifie que la const fonction ne doit pas être const en premier lieu. Le rendre non-const.

    Ou, vous devriez faire quelque chose d'autre, qui ne serait pas vous obliger à appeler non-const fonction de const fonction. Comme, ne pas appeler setColor fonction? Comme, de diviser le const fonction en plus de l'une des fonctions (si vous pouvez le faire)? Ou quelque chose d'autre?

    Dans votre cas particulier, si setColor seulement quelques membre de la variable, par exemple m_color, alors vous pouvez le déclarer mutable:

     mutable QColor m_color;

    et puis le mettre dans votre const fonction, sans appel setColor fonction, et sans faire const_cast.

    Ce n'est pas une réponse à la question que je viens d'écrire je ne peux pas le changer pour non-const.
    Voir la modifier.
    potentiellement, vous pouvez, si vous pouviez faire les membres touché dans cette fonction mutable?
    Si ce n'est pas une réponse à votre question, votre question est sans réponse.
    si il est fermé, comment savoir quel est le problème avec la question? Ne de fermeture veuillez vous avez plus de essayer pour votre réponse?

    OriginalL'auteur Nawaz