bitset :: operator [] == false/true ou bitset :: test?

Question

L'utilisation de bitset :: operator [] est-elle équivalente à l'utilisation de bitset :: test ou existe-t-il une optimisation sous-jacente?

Autrement dit, ces deux boucles sont-elles équivalentes?

En utilisant bitset :: operator []:

static const int UP = 0; 
static const int DOWN = 1; 

for(int i = 1; i < KEY_MAX; ++i) { 
    if(_handler && (_prevKey[i] == UP && _curKey[i] == DOWN)) { 
     _handler->EnqueueEvent(new KeyboardKeyDownEvent(i)); 
    } 
    if(_handler && (_prevKey[i] == DOWN && _curKey[i] == DOWN)) { 
     _handler->EnqueueEvent(new KeyboardKeyPressEvent(i)); 
    } 
    if(_handler && (_prevKey[i] == DOWN && _curKey[i] == UP)) { 
     _handler->EnqueueEvent(new KeyboardKeyUpEvent(i)); 
    } 
} 

En utilisant bitset :: test():

static const bool UP = false; 
static const bool DOWN = true; 

for(int i = 1; i < KEY_MAX; ++i) { 
    if(_handler && (_prevKey.test(i) == UP && _curKey.test(i) == DOWN)) { 
     _handler->EnqueueEvent(new KeyboardKeyDownEvent(i)); 
    } 
    if(_handler && (_prevKey.test(i) == DOWN && _curKey.test(i) == DOWN)) { 
     _handler->EnqueueEvent(new KeyboardKeyPressEvent(i)); 
    } 
    if(_handler && (_prevKey.test(i) == DOWN && _curKey.test(i) == UP)) { 
     _handler->EnqueueEvent(new KeyboardKeyUpEvent(i)); 
    } 
} 

Answer 1

de la norme C++ 03, §23.3.5.2/39-41 :

bool test(size_t pos) const; 

Nécessite:pos est valide
Lève:out_of_range si pos ne correspond pas à une position de bit valide.
Renvoie:true si le bit à la position pos dans a la valeur 1.

§23.3.5.2/46-48:

bool operator[](size_t pos) const; 

Nécessite:pos est valide.
Jette: rien.
Renvoie:test(pos).

§23.3.5.2/49-51:

bitset<N>::reference operator[](size_t pos); 

Nécessite:pos est valide.
Jette: rien.
Renvoie: Un objet de type bitset<N>::reference tel que (*this)[pos] == this- test(pos), et tel que (*this)[pos] = val est équivalent à this->set(pos, val).

Ainsi, lorsque l'objet est const, ils retournent la même valeur, sauf que lorsque pos est invalide test lancers francs out_of_range tout operator[] lancers francs rien. Lorsque l'objet est et nonconst, l'opérateur renvoie un objet proxy permettant de muter les données de l'objet.

Answer 2

Contrairement à l'opérateur d'accès ([]), la fonction de test effectue une vérification de plage avant de récupérer la valeur du bit. out_of_range est renvoyé si la position n'est pas une position de bit valide.

Vous pouvez trouver des références sur:

http://www.cplusplus.com/reference/stl/bitset

Answer 3

J'optimiser cette façon:

int nPrevKey, nCurKey; 

for(int i = 1; i < KEY_MAX; ++i) 
{ 
    if(_handler) 
    { 
     nPrevKey = _prevKey[i]; 
     nCurKey = _curKey[i]; 

     if(nPrevKey == UP && nCurKey == DOWN) 
     { 
      _handler->EnqueueEvent(new KeyboardKeyDownEvent(i)); 
     } 
     if(nPrevKey == DOWN && nCurKey == DOWN) 
     { 
      _handler->EnqueueEvent(new KeyboardKeyPressEvent(i)); 
     } 
     if(nPrevKey == DOWN && nCurKey == UP) 
     { 
      _handler->EnqueueEvent(new KeyboardKeyUpEvent(i)); 
     } 
    } 
} 

Et De même, l'autre mise en œuvre.