Codage binaire - 1 octets = 28 informations?

Bonsoir,

Après avoir lu JML (tutos…), J’ai attaqué la lecture de livres sur le langage C.

Dans le premier livre lu, il est écrit que dans le monde du binaire la plupart des machines regroupent les bits en octets.

Bien évidemment 1 octet est composé de 8 bits, c’est d’ailleurs sur cette base qu’est stockée la variable de type char. Un octet peut donc prendre 256 valeurs décimales de 0 à 255 soit en binaire : de 00000000 à 11111111.

Par exemple, pour convertir le chiffre binaire 10010001 et obtenir le chiffre 145 en décimal, je procède donc ainsi :

Sans titre

J’en suis à mon deuxième livre et j’attaque la partie binaire mais là je ne comprends plus :

Page 101 dans Codage et mesure de l’information, l’auteur explique qu’un bit peut stocker 2 informations (0) ou (1) et ça pas de problème mais il rajoute 21 informations. Idem pour 2 bits et 3 bits … A quoi peuvent bien correspondrent ces 21 informations pour 2 bits, 23 pour 3 … ?

De même page 102 je ne comprends pas la notation étendue du nombre décimal 8542 :

8*103 + 5*102 + 4*101 + 2*100 ?

Ni celle du nombre binaire 110101 :

1*25 + 1*24 + 0*23 + 1*22 + 0*21 + 1*20 ?


Merci par avance.

lire là : 21 comme 2 puissance 1 et 23 comme 2 puissance 3

Merci Artouste, là je comprends. C'est logique ! j'aurai du comprendre ...
Merci beaucoup.

Oui sauf que dans un livre pour débutant , les choses doivent être clair. ça m'a pris quelques dizaines secondes pour voir la subtilité.

oui c'est anormal qu'ils n'aient pas mis en forme correctement...

1 * 25 + 1 * 24 + 0 * 23 + 1 * 22 + 0 * 21 + 1 * 20

Merci à tous.
J'en avais marre de recopier des bouts de code pour faire tourner mes programmes. Je les comprenais superficiellement, juste ce qu'il fallait pour mettre en œuvre un projet ! J'ai décidé de retrousser mes manches pour me mettre au travail et comprendre les subtilités du langage C mais comme vous pouvez le voir, la route est encore longue pour moi :wink:

Malgré tout j'ai acquis des bases concernant les fondamentaux du binaire (opérateurs OU, ET ; opérateurs de décalage binaire...) mais surtout concernant les pointeurs qui en fait ne sont que des variables contenant une adresse mémoire.
J'ai compris également que le tableau n'est qu'un mirage, un objet qui n'existe pas, en fait, il s'agit d'un pointeur. Les tableaux peuvent être traités directement par des pointeurs comme dans cet exemple (celui de JML) :

long t[3] = {100, 200, 300};
int tablo[5] = {2,3,5,7,11};

void setup() {
  Serial.begin(115200);
  Serial.println(F("Avec un index"));
  for (int i = 0; i < 3; i++) Serial.println(t[i]);

  Serial.println(F("\nAvec le nom du tableau"));
  for (int i = 0; i < 3; i++) Serial.println(*(t+i)); // * dit d'aller chercher le contenu, et t+i ça dit au compilateur de sauter i cases de la bonne taille (ici un long donc 4 octets)

  Serial.println(F("\nAvec un pointeur"));
  long *tPtr = t;
  for (int i = 0; i < 3; i++, tPtr++) Serial.println(*tPtr); // * dit d'aller chercher le contenu de tPtr qu'on incrémente dans la boucle for

  Serial.println(F("\nAdresse de tablo"));
  Serial.println((uint16_t) &tablo);

  Serial.println(F("\nAdresse de tablo"));
  Serial.println((uint16_t) tablo);  // sans le &, c'est l'adresse du tableau qui est affichée
}

void loop() {}

ou encore celui là (le mien) :

int nombres[10]; // Tableau de type int à 10 éléments
int x;
int *ptr; // déclaration d'un premier pointeur
int *mem; // déclaration d'un deuxième pointeur
    

void setup() {
  Serial.begin(9600);

  ptr = nombres; // mémorise l'adresse de départ du tableau
  mem = nombres; // l'adresse de départ du tableau nombres dans la varaible ptr devant changer au fur et à mesure, je mémorise l'adresse de départ du tableau dans une deuxième variable
  
  for (x=0;x<10;x++) // remplissage du tableau
    {
        *ptr= x+1; // à l'adresse ptr on place le contenu de x, 
        ptr++; // l'adresse s'incremente - sur un uno un int vaut 2 octets, on va donc de deux octets en deux octets
    }

    for (x=0;x<10;x++) // affichage du tableau
    {
     Serial.print (*(mem+x)); 
     
    }

}

void loop() {

Il y a aussi les listes liées et bien plus encore. Tout ça est passionnant :grinning:
j'écris sous le contrôle des champions du forum et surtout pour donner l'envie aux débutants de ne pas se contenter de recopier des bouts de code.

Bonne journée.

1 Like

Je plussoie. Bravo.

+1

c'est gratifiant quand on arrive à faire son code et que ça fonctionne comme on veut que l'effort vaut le coup. On ne construit pas bien sur du sable. Il faut des fondations solides.

Il est loin d'être évident que les débutants copieurs/colleurs lisent les sujets d'autres demandeurs.

Copier/coller sans avoir appris le langage n'est pas une méthode qui peut mener bien loin. Malgré tout, quand on maîtrise le langage, cela peut apporter un gain de temps précieux.

Lire et comprendre le CDA (Code Des Autres) est l'exercice le plus difficile, surtout si l'on a affaire à du code poilu.