Lorsque vous utilisez L'acquisition des ressources est l'initialisation (RIAA) En C++, il est courant d'avoir quelque chose comme ceci :
class CriticalSection {
public:
void enter();
void leave();
};
class SectionLocker {
public:
SectionLocker(CriticalSection& cs)
: mCs(cs) {
cs.enter();
}
~SectionLocker() {
cs.leave();
}
private:
CriticalSection& mCs;
};
CriticalSection gOperationLock; // Global lock for some shared resource
void doThings(int a, int b) {
SectionLocker locker(gOperationLock);
int c = doOtherThings(a);
doMoreThings(b);
doOneMoreThing(a, b, c);
}
Je sais que dans certains langages à ramassage d'ordures (comme le CLR), l'une des nombreuses raisons pour lesquelles cette méthode n'est pas sûre est que l'objet locker dans doThings() peut être ramassé avant le retour de doThings(), car locker n'est jamais référencé après sa création.
Le comportement attendu, à savoir que le destructeur de locker ne soit appelé qu'après l'appel à doOneMoreThing(), est-il bien défini en C++ ?
Si c'est le cas, y a-t-il des garanties sur le moment où le destructeur sera appelé (et où gOperationLock sera libéré) ? Ou est-ce seulement à un moment donné après qu'il soit sorti du champ d'application ?