Je souhaite protéger une variable par un mutex, et j'ai une
interrogation sur l'ordre des actions exécutées lors de la sortie
d'une fonction.
Soit le code suivant :
class T {...};
class C
{
public:
T Get()
{
Lock lock (...);
return x;
}
private:
T x; // variable à protéger
};
En supposant qu'il y ait bien copie (J'ai un doute, tout à coup),
est-elle effectuée avant ou après la destruction de "lock" (et donc la
libération du mutex) ?
Est-ce que le code suivant donne l'assurance qu'il n'y aura aucun
accès à "x" après la destruction de "lock" ?
class C
{
public:
T Get()
{
Lock lock (...);
T reponse= x;
return reponse;
}
private:
T x;
};
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Jean-Marc Bourguet
Fabien LE LEZ writes:
Bonjour,
Je souhaite protéger une variable par un mutex, et j'ai une interrogation sur l'ordre des actions exécutées lors de la sortie d'une fonction.
Soit le code suivant :
class T {...};
class C { public: T Get() { Lock lock (...); return x; } private: T x; // variable à protéger };
En supposant qu'il y ait bien copie (J'ai un doute, tout à coup), est-elle effectuée avant ou après la destruction de "lock" (et donc la libération du mutex) ?
Il y a copie et tout effet observable de la copie doit être vu avant les effets observables de la destruction de lock.
Est-ce que le code suivant donne l'assurance qu'il n'y aura aucun accès à "x" après la destruction de "lock" ?
Oui.
class C { public: T Get() { Lock lock (...); T reponse= x; return reponse; } private: T x; };
Dans les deux cas, il y a l'optimisation de la valeur de retour (nommée ou non) qui peut intervenir. Telle que je comprends les règles son effet est pour moi d'éviter une (dans le premier cas) ou deux (cas le second) copies mais la copie restante doit avoir lieu avant la destruction de lock.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Fabien LE LEZ <gramster@gramster.com> writes:
Bonjour,
Je souhaite protéger une variable par un mutex, et j'ai une
interrogation sur l'ordre des actions exécutées lors de la sortie
d'une fonction.
Soit le code suivant :
class T {...};
class C
{
public:
T Get()
{
Lock lock (...);
return x;
}
private:
T x; // variable à protéger
};
En supposant qu'il y ait bien copie (J'ai un doute, tout à
coup), est-elle effectuée avant ou après la destruction de
"lock" (et donc la libération du mutex) ?
Il y a copie et tout effet observable de la copie doit être
vu avant les effets observables de la destruction de lock.
Est-ce que le code suivant donne l'assurance qu'il n'y aura aucun
accès à "x" après la destruction de "lock" ?
Oui.
class C
{
public:
T Get()
{
Lock lock (...);
T reponse= x;
return reponse;
}
private:
T x;
};
Dans les deux cas, il y a l'optimisation de la valeur de
retour (nommée ou non) qui peut intervenir. Telle que je
comprends les règles son effet est pour moi d'éviter une
(dans le premier cas) ou deux (cas le second) copies mais la
copie restante doit avoir lieu avant la destruction de lock.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Je souhaite protéger une variable par un mutex, et j'ai une interrogation sur l'ordre des actions exécutées lors de la sortie d'une fonction.
Soit le code suivant :
class T {...};
class C { public: T Get() { Lock lock (...); return x; } private: T x; // variable à protéger };
En supposant qu'il y ait bien copie (J'ai un doute, tout à coup), est-elle effectuée avant ou après la destruction de "lock" (et donc la libération du mutex) ?
Il y a copie et tout effet observable de la copie doit être vu avant les effets observables de la destruction de lock.
Est-ce que le code suivant donne l'assurance qu'il n'y aura aucun accès à "x" après la destruction de "lock" ?
Oui.
class C { public: T Get() { Lock lock (...); T reponse= x; return reponse; } private: T x; };
Dans les deux cas, il y a l'optimisation de la valeur de retour (nommée ou non) qui peut intervenir. Telle que je comprends les règles son effet est pour moi d'éviter une (dans le premier cas) ou deux (cas le second) copies mais la copie restante doit avoir lieu avant la destruction de lock.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
