C++ volatile des fonctions de membre du

class MyClass
{
    int x, y;
    void foo() volatile {
        //do stuff with x
        //do stuff with y
    }   
};

Dois-je déclarer x et y comme volatile ou seront toutes les variables de membre traités comme des volatile automatiquement?

Je veux faire en sorte que les "choses" avec x" n'est pas réorganisée avec les "trucs avec y" par le compilateur.

EDIT:
Qu'advient-il si je suis en jetant un type normal pour un volatile type? Serait-ce de demander au compilateur de ne pas réorganiser l'accès à cet emplacement? Je veux passer une variable normale dans une situation spéciale, une fonction de paramètre qui est volatile. Je dois être sûr que le compilateur ne pas réorganiser cet appel préalable ou suivie de lectures et d'écritures.

InformationsquelleAutor 0xbadf00d | 2011-01-28
  1. 33

    Marquage d'une fonction membre volatile est comme marquant const; cela signifie que le récepteur de l'objet est traité comme s'il était déclaré comme un volatile T*. Par voie de conséquence, toute référence à x ou y sera traitée comme une volatile lire dans la fonction membre. En outre, un volatile objet ne peut appeler volatile des fonctions de membre du.

    Cela dit, vous pouvez marquer x et y volatile de toute façon si vous voulez que tous les accès à les traiter comme volatile.

    InformationsquelleAutor templatetypedef
  2. 9

    Vous ne pas devez déclarer les variables explicitement..

    De la Norme docs 9.3.2.3,

    De même, volatils sémantique (7.1.6.1) appliquer en période de volatilité des fonctions de membre lors de l'accès à l'objet et non statiques
    les membres de données.

    InformationsquelleAutor liaK
  3. 7

    Le code suivant:

    #include <iostream>

class Bar
{
    public:

        void test();
};

class Foo
{
    public:

        void test() volatile { x.test(); }

    private:

        Bar x;
};

int main()
{
    Foo foo;

    foo.test();

    return 0;
}

    Génère une erreur lors de la compilation avec gcc:

    main.cpp: In member function 'void Foo::test() volatile':
main.cpp:14:33: error: no matching function for call to 'Bar::test() volatile'
main.cpp:7:8: note: candidate is: void Bar::test() <near match>

    Et depuis un volatile instance ne peut pas appeler un non-volatile méthode, on peut supposer que, oui, x et y sera volatile dans la méthode, même si l'instance de MyClass n'est pas déclaré volatile.

    Remarque: vous pouvez supprimer le volatile qualificatif à l'aide d'un const_cast<> si jamais vous avez besoin, mais être prudent, car tout comme const cela peut conduire à un comportement indéfini dans certains cas.

    • Corrigez-moi si je me trompe à ce sujet, mais ne sont pas de la sémantique de la volatilité des fonctions comme celle de const fonctions que vous pouvez appeler une fonction volatile sur une mémoire non volatile de l'objet, mais pas un non volatile de la fonction à partir d'un objet volatile?
    • Un test rapide dans g++ suggère que vous pouvez en effet appel volatile fonctions de membre du sur-volatile objets. La raison que volatile std::strings sont inutiles, c'est parce que si la chaîne elle-même est volatile, il ne peut qu'appeler volatile fonctions de membre, ce qui n'est pas. $4.4.1 de la norme précise que vous pouvez convertir un T* pour un volatile T* implicitement, et $9.3.1.3 dit que le volatile qualificatif affecte la this pointeur, ce qui suggère que si vous avez un objet de type T, le this pointeur de type T* peut être convertie en un volatile T* pour l'appel.
    • J'ai inversé la logique (ce n'est que 7h du matin ici; j'ai encore besoin d'un peu de sommeil ;)). Merci, c'est maintenant corrigé. Vous pouvez faire appel à un volatile méthode à la fois d'un volatile et non-volatile instance. Mais si votre instance est volatile vous ne serez pas en mesure d'appeler non-volatile méthodes.
    • Donc, c'est exactement comme pour const, comme templatetypedef dit. La partie pertinente n'est bien sûr pas g++, mais la norme: Article 4.4.1 semble pour m'indiquer que la nécessaire conversion implicite de this de T* à volatile T* était tout à fait légale. Notez également que 9.3.2.4 explicitement dit que vous pouvez faire un appel à un cv qualifiés de la fonction si l'objet de l'expression que vous appelez il est “comme cv qualifiés ou moins de cv qualifiés de la fonction membre.” Aucune différence n'est faite entre const et volatile dans ce domaine.
    • Comme pour le casting: Si l'objet initial était réellement défini volatile, et que l'accès à cet objet ou de l'un de ses membres comme une lvalue (essentiellement, sur le côté gauche d'une affectation) comme quelque chose de non-volatile, la clause 7.1.5.1.7 de la norme dit que le programme de comportement est indéfini. Ne pas le faire, même si cela fonctionne avec la version actuelle de votre compilateur actuel sur les données de test. AFAICS, le casting serait bien pour l'accès en lecture seule, comme pour const.
    • Vous missunderstood moi, je voulais dire: Est-il possible de jeter un fait non-volatile déclaré objet d'un volatile de type. Le faire dans l'autre sens est clair pour moi.

    InformationsquelleAutor ereOn
  4. 1

    IBM implique il fonctionne exactement comme const fonctions.

    InformationsquelleAutor Flexo
  5. 1

    Donc, en utilisant l'exemple d'origine:

    class MyClass
{
    int x, y;
    void foo() volatile {
        //do stuff with x
        //do stuff with y
        //with no "non-volatile" optimization of the stuff done with x, y (or anything else)
    }   
    void foo() {
        //do stuff with x
        //do stuff with y
        //the stuff done with x, y (and anything else) may be optimized
    } 
};
    InformationsquelleAutor ianeperson