Pourquoi les bits identiques ne sont-ils pas convertis en bits ulong identiques

Question

Je traite des données dans un vecteur de std::bitset<16>, que je dois convertir depuis et vers unsigned long (through std::bitset::to_ulong()) et vers et à partir de chaînes en utilisant une fonction self-made les conversions entre vecteur et chaîne de bitset semblent tout d'abord fonctionner correctement, puisque si je convertis d'abord un vecteur de bitsets en chaîne puis en bitet, il est identique; que j'ai prouvé en faisant un programme qui comprend ceci:

for (std::bitset<16>& B : my_bitset16vector) std::cout<<B<<std::endl;//print bitsets before conversion 

bitset_to_string(my_bitset16vector,my_str); 
string_to_bitset(my_bitset16vector,my_str); 

std::cout<<std::endl 
for (std::bitset<16>& B : my_bitset16vector) std::cout<<B<<std::endl;//print bitsets after conversion 

la sortie pourrait ressembler un peu comme celui-ci (dans ce cas, avec seulement 4 bitsets):

1011000011010000 
1001010000011011 
1110100001101111 
1001000011001111 

1011000011010000 
1001010000011011 
1110100001101111 
1001000011001111 

juger par ce fait, les bitsets avant et après la conversion sont clairement identiques, mais malgré cela, les bitsets convertit complètement différemment quand je leur dis de convertir en unsigned long; dans un programme qui pourrait ressembler à ceci:

for (std::bitset<16>& B : my_bitset16vector) std::cout<<B<<".to_ulong()="<<B.to_ulong()<<std::endl;//print bitsets before conversation 

bitset_to_string(my_bitset16vector,my_str); 
string_to_bitset(my_bitset16vector,my_str); 

std::cout<<std::endl 
for (std::bitset<16>& B : my_bitset16vector) std::cout<<B<<".to_ulong()="<<B.to_ulong()<<std::endl;//print bitsets after conversion 

la sortie pourrait ressembler à quelque chose comme ceci:

1011000011010000.to_ulong()=11841744 
1001010000011011.to_ulong()=1938459 
1110100001101111.to_ulong()=22472815 
1001000011001111.to_ulong()=18649295 

1011000011010000.to_ulong()=45264 
1001010000011011.to_ulong()=37915 
1110100001101111.to_ulong()=59503 
1001000011001111.to_ulong()=37071 

tout d'abord, il est évident que les bitsets encore au-delà de tout doute raisonnable sont identiques lorsqu'ils sont affichés comme binaire, mais une fois converti en unsigned long, les bits identiques retournent des valeurs complètement différentes (ruinant complètement mon programme)

Pourquoi t le sien? peut-il être que les bitsets sont non identiques, même si elles impriment en tant que la même chose? l'erreur peut-elle exister dans mon ensemble de bits vers et à partir de convertisseurs de chaîne, malgré que les bitsets soient identiques? Edit: tous les programmes incluant mes conversations n'ont pas ce problème, ça n'arrive que lorsque j'ai modifié le bitset après l'avoir créé (à partir d'une chaîne), dans mon cas pour essayer de chiffrer le bitset, ce qui ne peut tout simplement pas être réduit à quelque chose de simple et court, mais à ma façon la plus comprimée de l'écrire ressemble à ceci:

(et qui est même sans inclure la défintion de la struct clé publique et la fonction d'alimentation modulaire)

int main(int argc, char**argv) 
{ 
    if (argc != 3) 
    { 
     std::cout<<"only 2 arguments allowed: plaintext user"<<std::endl; 
     return 1; 
    } 

    unsigned long k=123456789;//any huge number loaded from an external file 
    unsigned long m=123456789;//any huge number loaded from an external file 


    std::vector< std::bitset<16> > data;  
    std::string datastring=std::string(argv[1]); 

    string_to_bitset(data,datastring);//string_to_bitset and bitset_to_string also empties string and bitset vector, this is not the cause of the problem 

    for (std::bitset<16>& C : data) 
    { 
     C =std::bitset<16>(modpow(C.to_ulong(),k,m));//repeated squaring to solve C.to_ulong()^k%m 
    } 

    //and now the problem happens  


    for (std::bitset<16>& C : data) std::cout<<C<<".to_ulong()="<<C.to_ullong()<<std::endl; 

    std::cout<<std::endl; 

    bitset_to_string(data,datastring); 
    string_to_bitset(data,datastring); 
    //bitset_to_string(data,datastring); 

    for (std::bitset<16>& C : data) std::cout<<C<<".to_ulong()="<<C.to_ullong()<<std::endl; 

    std::cout<<std::endl; 
return 0; 
} 

Je suis bien conscient que vous pensez maintenant que je fais mal la fonction de puissance modulaire (qui je guara Je ne suis pas), mais ce que je fais pour que cela arrive n'a pas d'importance, car ma question n'était pas: qu'est-ce qui ne va pas dans mon programme? ma question était: pourquoi les bitsets identiques (qui impriment des 1 et des 0 binaires identiques) ne se convertissent pas en des longs non signés identiques.

autre modification: je dois également souligner que les premières valeurs printet des longs non signés sont "correctes" dans la mesure où elles me permettent de décrypter le bitset parfaitement, alors que les valeurs des longs non signés imprimés après sont "fausses" dans qu'il produit un résultat complètement faux.

Answer 1

La valeur "11841744" est correcte dans les 16 bits inférieurs, mais possède quelques bits supplémentaires au-dessus du 16ème. Cela pourrait être un bug dans votre implémentation STL où to_long accède aux bits au-delà des 16 qu'il devrait utiliser.

Ou (à partir de votre commentaire ci-dessus) vous ajoutez plus de bits au bitset qu'il ne peut contenir et vous rencontrez un comportement indéterminé.