Le complément à 2 en C est généré à partir du complément à 1 en C. Comme nous le savons, le complément à 1 d'un nombre binaire est créé en transformant le bit 1 en 0 et 0 en 1 ; le complément à 2 d'un nombre binaire est généré en ajoutant un au complément à 1 d'un nombre binaire.

En bref, on peut dire que le complément à 2 dans C est défini comme la somme du complément à un dans C et de un.

Dans la figure ci-dessus, le nombre binaire est égal à 00010100, et son complément à un est calculé en transformant le bit 1 en 0 et 0 en 1 vice versa. Par conséquent, le complément à un devient 11101011. Après avoir calculé le complément à un, nous calculons le complément à deux en ajoutant 1 au complément à un, et son résultat est 11101100.

Créons un programme de complément à 2.

 #include int main() { int n; // variable declaration printf('Enter the number of bits do you want to enter :'); scanf('%d',&n); char binary[n+1]; // binary array declaration; char onescomplement[n+1]; // onescomplement array declaration char twoscomplement[n+1]; // twoscomplement array declaration int carry=1; // variable initialization printf('
Enter the binary number : '); scanf('%s', binary); printf('%s', binary); printf('
The ones complement of the binary number is :&apos;); // Finding onescomplement in C for(int i=0;i<n;i++) { if(binary[i]="=&apos;0&apos;)" onescomplement[i]="1" ; else } onescomplement[n]="" printf('%s',onescomplement); printf('
the twos complement of a binary number is : '); finding twoscomplement in c for(int i="n-1;">=0; i--) { if(onescomplement[i] == &apos;1&apos; &amp;&amp; carry == 1) { twoscomplement[i] = &apos;0&apos;; } else if(onescomplement[i] == &apos;0&apos; &amp;&amp; carry == 1) { twoscomplement[i] = &apos;1&apos;; carry = 0; } else { twoscomplement[i] = onescomplement[i]; } } twoscomplement[n]=&apos;&apos;; printf(&apos;%s&apos;,twoscomplement); return 0; } </n;i++)>

Sortir

Analyse du programme ci-dessus,

• Tout d'abord, nous saisissons le nombre de bits, et il est stocké dans le fichier ' n ' variable.
• Après avoir entré le nombre de bits, nous déclarons un tableau de caractères, c'est-à-dire : char binaire[n+1], qui contient le nombre binaire. Le ' n ' est le nombre de bits que nous avons entré à l'étape précédente ; il définit essentiellement la taille du tableau.
• Nous déclarons deux autres tableaux, c'est-à-dire uncomplément[n+1] , et deuxcomplément[n+1]. Le uncomplément[n+1] le tableau contient le complément à un d'un nombre binaire tandis que le deuxcomplément[n+1] array contient le complément à deux d'un nombre binaire.
• Initialisez le porter variable et attribuez 1 valeur à cette variable.
• Après les déclarations, nous saisissons le nombre binaire.
• Maintenant, nous calculons simplement le complément à un d’un nombre binaire. Pour ce faire, nous créons un boucle qui parcourt tout le tableau binaire, pour (int je = 0; je. Dans la boucle for, la condition est vérifiée si le bit est 1 ou 0. Si le bit est 1 alors uncomplément[i]=0 autre uncomplément[i]=1 . De cette façon, le complément à un d’un nombre binaire est généré.
• Après avoir calculé son complément, nous générons le complément à 2 d'un nombre binaire. Pour ce faire, nous créons un boucle qui itère du dernier élément à l'élément de départ. Dans la boucle for, nous avons trois conditions :
  • Si le bit de un complément [i] est 1 et que la valeur de carry est 1 alors nous mettons 0 dans deux compléments [i].
  • Si le bit de onescomplement[i] est 0 et que la valeur de carry est 1 alors nous mettons 1 dans twoscomplement[i] et 0 dans carry.
  • Si les deux conditions ci-dessus sont fausses, alors un complément [i] est égal à deux compléments [i].

Entiers signés sont fréquemment représentés en C en utilisant le notation du complément à deux . Utiliser le même représentation binaire offre un mécanisme pour exprimer à la fois positif et entiers négatifs . Le bit le plus significatif (MSB) est utilisé comme signe peu dans un représentation en complément à deux , où 0 désigne un entier positif , et 1 désigne un nombre négatif .

En commençant par un nombres négatifs valeur absolue sous forme binaire, vous pouvez prendre la son complément (négation au niveau du bit) de cette valeur pour obtenir le complément à deux représentation de la entier négatif . Vous ajoutez 1 au valeur résultante acquérir la représentation du complément à deux .

Le codage en complément à deux en C peut représenter entiers signés et peut effectuer des opérations arithmétiques rapides. L'un des avantages de l'emploi du complément à deux est la capacité de faire ajout et soustraction en utilisant les mêmes opérations binaires que pour les nombres non signés.

Le nombres binaires s'additionnent comme entiers non signés lors de l'ajout du complément à deux. Un emport à partir de l'emplacement du élément critique principal est tout simplement ignoré. De ce fait, la manipulation numéros signés différemment n’est pas nécessaire et l’addition devient simple.

Pensez à ajouter -5 et -3 en utilisant le Complément à deux 8 bits représentation, par exemple :

Nombre binaire pour -5 est 11111011.

Nombre binaire pour -3 est 11111101 .

en effectuant l'ajout :

 11111011 (-5) + 11111101 (-3) ------------- 111110100 (-8) 

La réponse est 111110100 , qui dans complément à deux est égal à -8 .

Semblable à l'addition, la soustraction peut être effectuée en traitant le deuxième opérande complément à deux comme s'il s'agissait d'une addition. En d’autres termes, vous ajoutez le complément à deux d’un nombre négatif au premier opérande pour le supprimer.

Par exemple, quand -3 est soustrait de -5 :

En binaire, -5 est représenté par 11111011 et -(-3) par 00000011 (complément à deux de -3 )

Réaliser la soustraction

 11111011 (-5) + 00000011 (+3) ------------- 11111110 (-8) 

Le résultat est 11111110 , qui en complément à deux est égal à -8 .

Conclusion:

En C, le complément 2s est une représentation binaire d'un nombre négatif créé en ajoutant un au Complément de 1 . Les systèmes informatiques utilisent fréquemment cette idée pour représenter des nombres signés et effectuer efficacement des opérations arithmétiques.

Pour obtenir le complément 2s d'un entier binaire, il faut d'abord déterminer le Complément de 1 du nombre en retournant les bits. Après cela, la représentation du complément 2s est obtenu par en ajouter un au Complément de 1 . Le bit le plus significatif (MSB) fonctionnera comme un bit de signe en exprimant si un nombre est positif ou négatif .

Le calcul du complément 2s pour un entier binaire donné est affiché dans le programme C ci-joint. L'utilisateur est invité à saisir à la fois le nombre binaire et le nombre de bits. Après cela, le programme effectue les procédures requises pour acquérir le complément à 1, puis le complément 2s . Les résultats sont ensuite présentés.

En informatique et en programmation, il est crucial de comprendre les complément 2s représentation car elle permet de gérer efficacement les valeurs négatives exprimées en binaire. Cela fait addition soustraction , et opérations logiques plus simple sur les deux positif et nombres négatifs . La gamme de entiers représentables est symétrique par rapport à zéro en raison de complément 2s représentation, ce qui la rend appropriée pour diverses opérations numériques.

Les programmeurs peuvent effectuer des opérations arithmétiques, travailler avec des données binaires et concevoir des algorithmes utilisant des entiers signés en C et dans d'autres langages de programmation en comprenant l'idée du complément à 2 et en l'utilisant correctement.