ajouter 1 à un bitset de 32 bits

Question

J'ai un bitset de 32 bits et je souhaite y ajouter 1 en utilisant la méthode binaire d'addition. J'ai donc un format binaire et maintenant je veux y ajouter 1 en binaire, y at-il une méthode par défaut pour le faire ou devrais-je créer une fonction pour cela.

#include<string.h> 
    #include<iostream> 
    #include<bitset> 
    #include<cstlib> 
    int main(){ 
     int a; 
     cin >> hex >> a; 
     bitset<32> binary(a); 
     } 

Answer 1

std::bitset est assignable à partir d'un unsigned long ou unsigned long long.

Il a également des accesseurs pour ces types.

#include <bitset> 

auto get() -> std::bitset<32>; 
auto put(std::bitset<32>) -> void; 

int main(){ 
    auto bs = get(); 
    bs = bs.to_ulong() + 1; 
    put(bs); 
} 

exemple sortie assembleur:

main: 
    sub rsp, 8 
    call get() 
    lea edi, [rax+1] 
    call put(std::bitset<32ul>) 
    xor eax, eax 
    add rsp, 8 
    ret 

Notez que le compilateur est assez intelligent pour se rendre compte qu'il n'y a pas besoin de faire une copie ou de conversion.

Answer 2

Bien que la réponse en elle-même soit simple, je vais contribuer à un bon conseil en matière de style de codage.

Vous pouvez, compte tenu du code affiché, utiliser std::bitset::to_ulong(), puis ajouter ou faire ce que vous voulez avant de procéder à la conversion.

Mais il y a quelques problèmes de style sur votre code, et un qui pourrait casser une partie de la logique sur les architectures futures.

Le type de données int est et non garanti 32 bits par le standard. Il est garanti de représenter le type intégral pour lequel l'architecture pour laquelle vous compilez est la plus efficace.

uint32_t est ce dont vous avez besoin, il est garanti pour être 32 bits de long, sur toutes les architectures.

Et, std::bitset n'est pas vraiment bon dans son travail. Il n'est pas efficace du tout pour les tailles supérieures au type int, car l'indexation doit être effectuée, et pas plus efficace que le type int s'il est inférieur à la taille du type int. Et, par le fait que la façon de faire des opérations non binaires avec elle est de le lancer à long, c'est pas garanti que votre addition sera plus rapide ou même la même vitesse que si elle était avec int. Ainsi, pour votre utilisation, le type le plus efficace serait certainement uint32_t, étant non protégé le protégeant de certains comportements non définis sur les opérations de bits au niveau des types signés. Et, pendant que vous codez le code efficace et maintanable, vous pouvez lire ceci: Why is "using namespace std" considered bad practice?