IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Pascal Discussion :

L'écriture binaire pour les débutants


Sujet :

Langage Pascal

  1. #1
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut L'écriture binaire pour les débutants
    Bonjour!

    Je propose une discussion à l'usage des débutants autour de l'écriture binaire.

    Il n'est pas mauvais, de temps en temps, de revenir aux choses fondamentales dont on n'a pas toujours une connaissance très distincte. Par exemple, je viens d'apprendre ce que veut dire le mot bit. Je ne le savais pas, et peut-être ne suis-je pas le seul dans ce cas. Ça veut dire binary digit, c'est-à-dire un chiffre binaire.

    Dès lors j'ai pu comprendre (enfin je crois) ce que c'était qu'un octet! J'en étais si content que j'en ai fait un programme.

    @Paul TOTH

    J'ai inséré la modification que tu m'avais montrée, mais je ne suis pas venu à bout de la comprendre. C'est pourquoi j'ai conservé les deux versions de la fonction.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    (*--------------------------------------------------------------------------*)
    (* Etude à l'usage des débutants:                                           *)
    (* Ecriture binaire et écriture décimale                                    *)
    (* d'un nombre compris entre 0 et 255,                                      *)
    (* pour comprendre ce qu'est un octet.                                      *)
    (*--------------------------------------------------------------------------*)
     
    program Octet;
    uses Crt;
     
    type
      TOctetChaine = string[8];
     
    (*--------------------------------------------------------------------------*)
    (* 1. De l'écriture décimale à l'écriture binaire                           *)
    (*--------------------------------------------------------------------------*)
     
    function ByteToOctet(b: Byte): TOctetChaine;
      const
        temp: TOctetChaine = '';
      begin
        repeat
          if (b mod 2 = 1)
          then
            temp := '1' + temp
          else
            temp := '0' + temp;
          b := b div 2;
        until b=0;
        ByteToOctet := temp;
      end;
     
    (*--------------------------------------------------------------------------*)
    (* 2. De l'écriture binaire à l'écriture décimale                           *)
    (*--------------------------------------------------------------------------*)
     
    (* version longue *)
     
    function DeuxPuissance(n: Byte): LongInt;
    var
      i: Byte;
      temp: LongInt;
    begin
      if n=0 then temp:=1
      else
        begin
          if n=1 then temp:=2
          else
            begin
              temp:=2;
              for i:=2 to n do temp:=2*temp;
            end;
        end;
      DeuxPuissance := temp;
    end;
     
    function OctetToByte(o: TOctetChaine): Byte;
      var
        i, temp: Byte;
      begin
        temp:=0;
        for i := Length(o) downto 1 do
          begin
            if o[i] = '1' then temp := temp + DeuxPuissance(Length(o)-i);
          end;
        OctetToByte := temp;
      end;
     
    (* version courte *)
     
    function OctetToByte2(o: TOctetChaine): Byte;
      var
        i, temp: Byte;
      begin
        temp := 0;
        for i := 1 to Length(o) do
          begin
            temp := 2 * temp;
            if o[i] = '1' then
              Inc(temp);
          end;
        OctetToByte2 := temp;
      end;
     
    (*--------------------------------------------------------------------------*)
    (* Programme principal                                                      *)
    (*--------------------------------------------------------------------------*)
     
    begin
      TextBackground(Blue);
      ClrScr;
      TextColor(White);
      WriteLn;
      WriteLn('Binaire(77) = ', ByteToOctet(77));
      WriteLn;
      WriteLn('Decimale(''1001101'') = ', OctetToByte('01001101'));
      WriteLn;
      WriteLn('Decimale(''1001101'') = ', OctetToByte2('01001101'));
      ReadKey;
    end.
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  2. #2
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    Novembre 2002
    Messages
    8 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2002
    Messages : 8 964
    Points : 28 430
    Points
    28 430
    Par défaut
    Alors on va ajouter une petite info

    en primaire on apprend les bases, notion qui semble bien obscure à cet âge là et qu'on oublie ensuite pendant longtemps...puis on fait de l'informatique et on nous parle de binaire, décimal, hexadécimal...ça va en Pascal on échappe à l'octal...et tout cela ce n'est rien d'autre que des bases:
    binaire = base 2
    décimal = base 10
    hexadécimal = base 16
    octal = base 8

    On retrouve aussi dans le codage des mails le codage Base64 qui lui est plus explicite, c'est de la base 64.

    Alors c'est quoi une base ? et bien ce sont les "chiffres" qu'on utilise pour écrire un nombre, en base 10 on a "0123456789", pour le 10ième nombre on utilise 2 chiffres "1" et "0". C'est à dire que le "0" implicite devant "09" passe à "1" et le "9" revient à "0"; c'est comme ça qu'on passe de "9" (ou "09") à "10".
    Quand on était petit on faisait des paquets de 10 allumettes et des paquets de paquets pour savoir combien on en avait en tout, 1 paquet + 2 allumettes = 12 allumettes

    Dans les autres bases on utilise d'autres chiffres

    base 2 = "01"
    base 10 = "0123456789"
    base 16 = "0123456789abcdef"
    base 8 = "01234567"
    base 64 = "A..Z","a..z","0..9","+/"

    et le principe est le même, quand on n'a plus assez de chiffre pour compter un nombre on ajoute le "1" devant et on repasse au "0" (en base 64 c'est B et A)

    du coup on peut faire un traitement de conversion d'un nombre dans un base assez facilement (en dehors de la base 64 qui n'utilise pas les chiffres classiques)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
     
    function IntToBase(i, base: Integer): string;
    const
    // tous les chiffres de la base 2 à 16
      Digits :array[0..15] of Char = '0123456789ABCDEF';
    begin
      Result := '';
      while i > 0 do // tant que le nombre est > 0
      begin
       Result := Digits[i mod base] + Result; // ajouter un chiffre à hauteur de la base
       i := i div base; // diviser par la base
      end;
    end;
     
    procedure TForm1.FormCreate(Sender: TObject);
    begin
    // je reprend ici la notation & pour binaire, $ pour hexa et un préfixe 0 pour l'octal
      ShowMessage(IntToBase(10,10));
      ShowMessage('&&'+IntToBase(10,2));
      ShowMessage('$'+IntToBase(10,16));
      ShowMessage('0'+IntToBase(10,8));
    end;
    petit exercice pas très compliqué, écrire la fonction BaseToInt qui s'utilise comme ceci et doit afficher 10 à chaque fois
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    function BaseToInt(const Str: string; Base: Integer): Integer;
    begin
      // ???
    end;
     
    begin
      ShowMessage(IntToStr(BaseToInt('10', 10)));
      ShowMessage(IntToStr(BaseToInt('1010', 2)));
      ShowMessage(IntToStr(BaseToInt('A', 16)));
      ShowMessage(IntToStr(BaseToInt('12', 8)));
    end;
    NB: dans ma modification de la fonction OctetToByte, je ne fais que multiplier par la base 2 le nombre à chaque itération tout comme on multiplie par 10 un nombre décimal pour lui ajouter des unités. "12" -> 1 * 10 + 2, "123" = "(1 * 10 + 2) * 10 + 3
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Le Store Excute Store

  3. #3
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut
    Merci pour la leçon et pour l'exercice.
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  4. #4
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut
    Voici la fonction IntToBase dans sa version Turbo Pascal.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    program Demo_IntToBase; { Turbo Pascal }
    uses Crt;
     
    function IntToBase(i, base: Integer): string;
    const
      { tous les chiffres de la base 2 à 16 }
      Digits: array[0..15] of Char = '0123456789ABCDEF';
    var
      Result: string;
    begin
      Result:='';
      while i > 0 do { tant que le nombre est plus grand que zéro }
        begin
          { ajouter un chiffre à hauteur de la base }
          Result := Digits [i mod base] + Result;
          { diviser le nombre par la base }
          i := i div base;
        end;
      IntToBase:=Result;
    end;
     
    begin
      TextBackground(Blue);
      TextColor(White);
      ClrScr;
      WriteLn('Diverses fa‡ons d''‚crire le nombre dix');
      WriteLn('--------------------------------------');
      WriteLn;
      WriteLn('Ecriture d‚cimale     : ', IntToBase(10,10));
      WriteLn('Ecriture binaire      : ', IntToBase(10,2));
      WriteLn('Ecriture hexad‚cimale : ', IntToBase(10,16));
      WriteLn('Ecriture octale       : ', IntToBase(10,8));
      ReadKey;
    end.
    Maintenant je passe à l'exercice.
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  5. #5
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut
    Citation Envoyé par Paul TOTH Voir le message
    petit exercice pas très compliqué, écrire la fonction BaseToInt qui s'utilise comme ceci et doit afficher 10 à chaque fois
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    function BaseToInt(const Str: string; Base: Integer): Integer;
    begin
      // ???
    end;
     
    begin
      ShowMessage(IntToStr(BaseToInt('10', 10)));
      ShowMessage(IntToStr(BaseToInt('1010', 2)));
      ShowMessage(IntToStr(BaseToInt('A', 16)));
      ShowMessage(IntToStr(BaseToInt('12', 8)));
    end;
    Trouvé, m'sieur !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    program Demo_BaseToInt; { Turbo Pascal }
    uses Crt;
     
    function BaseToInt(const Str: string; Base: Integer): Integer;
    const
      Digits: array[0..15] of Char = '0123456789ABCDEF';
    var
      i, temp: Integer;
    begin
      temp := 0;
      for i := 1 to Length(Str) do
      begin
        temp := Base * temp;
        Inc(temp, Pos(Str[i], Digits) - 1);
      end;
      BaseToInt := temp;
    end;
     
    begin
      ClrScr;
      WriteLn(BaseToInt('10', 10));
      WriteLn(BaseToInt('1010', 2));
      WriteLn(BaseToInt('A', 16));
      WriteLn(BaseToInt('12', 8));
      ReadKey;
    end.
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  6. #6
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    Novembre 2002
    Messages
    8 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2002
    Messages : 8 964
    Points : 28 430
    Points
    28 430
    Par défaut
    Parfait
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Le Store Excute Store

  7. #7
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 939
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 939
    Points : 5 648
    Points
    5 648
    Par défaut
    Joe,
    [QUOTE=Paul TOTH;6721930]
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    function IntToBase(i, base: Integer): string;
    const
    // tous les chiffres de la base 2 à 16
      Digits :array[0..15] of Char = '0123456789ABCDEF';
    begin
      Result := '';
      while i > 0 do // tant que le nombre est > 0
      begin
       Result := Digits[i mod base] + Result; // ajouter un chiffre à hauteur de la base
       i := i div base; // diviser par la base
      end;
    end;
    Je ne suis pas vraiment d'accord avec cette fonction, car elle oublie tout simplement de gérer les nombres négatifs.

    1 - Généralement, pour écrire dans une base autre que 10, on considère que la donnée est un format non signé (donc BYTE, WORD, DWORD... pour Pascal), il faudrait donc un cast si tu gardes l'entête de la fonction.

    2 - en base 10, il faudra tenir compte du fait qu'un nombre peut être négatif, et donc ajouter le signe dans la représentation en chaîne.

    Je réagis, car en l'état, ta fonction est incapable de montrer la représentation de tout entier < 0, d'où problème manifeste, et qu'il faudra aussi tenir compte de la remarque 1 ci-dessus.

    Si les cons volaient, il ferait nuit à midi.

  8. #8
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    Novembre 2002
    Messages
    8 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2002
    Messages : 8 964
    Points : 28 430
    Points
    28 430
    Par défaut
    Remarque judicieuse

    j'ai utilisé Integer comme type générique et non pour autoriser les valeurs négatives sinon base aurait été déclaré TBase = 2..16; sous peine d'avoir des résultats inattendus

    Ceci dit la notation "-$5" est acceptable, il est donc relativement simple d'introduire le support des négatifs sans passer par la forme $FFFFFFFFFFFFFFFB.
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Le Store Excute Store

  9. #9
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 939
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 939
    Points : 5 648
    Points
    5 648
    Par défaut
    Hie,

    Oui, MAIS :

    - tu ne tiens pas compte des valeurs négatives pour créer la représentation et tu te prives donc de la moitié des valeurs possibles.

    - "-$5" ne sert qu'à entrer une valeur exprimée en hexa. Quid des bases 2 et 8 ?

    Bref, je maintiens ma remarque. Un type générique, ok, mais il faut tenir compte de toutes les possibilités, ce qui n'est pas du tout le cas de ta fonction.

    Comme apparemment ça sert à notre ami Roland Chastain pour apprendre à gérer les différentes représentations, et que la fonction proposée ne permet pas de représenter les données négatives, qui sont "spéciales" pour les nombres signés, je me demande s'il sait comment ça fonctionne ?
    Si les cons volaient, il ferait nuit à midi.

  10. #10
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut
    Dans ma carrière de programmeur du dimanche, je n'ai jamais vu une écriture binaire ou hexadécimale utilisée pour noter un nombre négatif. Donc je n'ai pas cru devoir approfondir le sujet. Mais s'il y a des choses à apprendre, je vous écoute.

    Autrement, pour l'en-tête qui ne correspond pas exactement à l'usage de la fonction, je rencontre souvent ce problème, mais j'ai fini par me dire qu'on ne pouvait pas le résoudre rigoureusement. Ou alors il faudrait redéfinir tous les types à chaque fois en fonction des besoins !

    Par exemple cette fonction qui calcule les puissances de 2:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    program P2; (* puissances de deux *)
    uses crt;
     
    function deux_puissance(n: byte): longint;
    var i: byte; tmp: longint;
    begin
      if n=0 then tmp:=1
      else
        begin
          if n=1 then tmp:=2
          else
            begin
              tmp:=2;
              for i:=2 to n do
                tmp:=2*tmp;
            end;
        end;
      deux_puissance:=tmp;
    end;
     
    var j: byte;
     
    begin
      clrscr;
      for j:=0 to 5 do
        writeln(deux_puissance(j));
      repeat until keypressed;
    end.
    Même avec un résultat de type LongInt, on voit tout de suite qu'il y a des valeurs pour lesquelles le résultat ne sera pas correct, c'est-à-dire qu'il sera supérieur à la limite du type LongInt. Mais que faire pour éviter cela, sinon calculer la valeur maximale de type Byte pour laquelle le résultat est de type LongInt; puis définir un type limité à cette valeur. On n'est pas sorti de l'auberge!
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  11. #11
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    Novembre 2002
    Messages
    8 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2002
    Messages : 8 964
    Points : 28 430
    Points
    28 430
    Par défaut
    Ceci dit, LongInt (qui est strictement équivalent à Integer sous Delphi) est un entier signé...ce que ne sera jamais (signé) une puissance de 2

    pour ce qui est de la remarque de droggo il faut savoir que pour des entiers sur 32bits:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
      0 = $00000000 // jamais signé
      1 = $00000001
      ...
      32767 = $7FFFFFFF // le plus grand non signé sur 32 bits
      Integer(32768) = -32768 // $80000000 plus grand nombre négatif
      ..
      ...
      Cardinal(-3) = $FFFFFFFD;
      Cardinal(-2) = $FFFFFFFE;
      Cardinal(-1) = $FFFFFFFF; // car "0 - 1" allume tous les bits et donne bien -1
    Pour moi il est tout à fait acceptable de considérer le signe quelque soit la base.

    "-012" est un nombre négatif en base 8, c'est en fait implicitement la différence "0 - 012".

    Mais si on prend la fonction IntToHex(-1, 8) de Delphi (où 8 est le nombre caractères à retourner et non la base) on obtient FFFFFFFF, soit une représentation hexadécimale "non signée".

    A mon avis, ce qui joue en faveur de la représentation avec le signe "-" c'est qu'elle est indépendante du nombre de bits. '-$5' reste négatif qu'on le place dans un entier (signé) 16, 32 ou 64 bits, alors que 'FFFFFFFF' sera positif en 64 bits (signés ou pas) et négatif en 32bits signés.

    On peut aussi considérer que 'FFFFFFFF' représente -1 car la longueur de la chaîne représente 32bits, mais il est tout de même plus sympa d'écrire "-&1" ou "-$1", que leur équivalent non signé sur 32 ou 64 bits

    Autre solution:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    type
      TBase = 2..16;
    function UInt32ToStringWithBaseFrom2To16(i: Cardinal; base: TBase): string;
    mais je trouve ça moins pratique
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Le Store Excute Store

  12. #12
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 939
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 939
    Points : 5 648
    Points
    5 648
    Par défaut
    Joe,

    Je veux bien que tu utilises les différentes de cette manière, après tout, c'est ton problème.

    Mais, quand je regarde mon parcours de programmeur, je n'ai eu besoin de travailler avec des bases autres que 10 que pour 2 cas, toujours parce qu'il est utile de visualiser les bits :

    - travailler avec un type qui utilise différents champs de bits dans une même variable (à l'époque, je me suis bien amusé avec le type real de TP)

    - travailler sur une variable destinée à positionner des bits sur un port

    Dans les deux cas, on se fout complètement de savoir si une valeur se retrouve négative ou pas en fonction des données, et on considère donc toujours qu'on est en non signé (avec ta méthode, ça va modifier les bits si la valeur résultante est négative).

    Un seul autre cas est d'utiliser de telles fonctions pour expliquer aux débutants comment on représente les données, base 2 ou 16, qui sont parfaitement équivalentes.
    Là encore, ce qui compte, c'est la représentation des bits telle qu'elle est effectivement en mémoire.

    Pour Roland Chastain : Si tu veux voir comment on représente les valeurs négatives sur la plupart des processeurs, cherche pour complément à 2.
    Ce n'est pas la seule méthode possible, mais ses avantages ont conduit à son usage quasi universel (il doit bien encore exister quelques systèmes qui en utilisent une autre, mais je ne les connais pas).

    Si les cons volaient, il ferait nuit à midi.

  13. #13
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    Décembre 2011
    Messages
    4 058
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Décembre 2011
    Messages : 4 058
    Points : 15 339
    Points
    15 339
    Billets dans le blog
    9
    Par défaut
    Pendant mes insomnies je lis les anciennes discussions du forum. J'y apprends des tas de choses.
    Voyez, au sujet des bases numériques, l'excellente notice de droggo.
    Cela m'a donné l'idée de faire un programme qui montrerait les étapes du calcul au lieu de donner simplement le résultat.
    Mon site personnel consacré à MSEide+MSEgui : msegui.net

  14. #14
    Expert confirmé

    Inscrit en
    Août 2006
    Messages
    3 939
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 3 939
    Points : 5 648
    Points
    5 648
    Par défaut
    Koe,

    Effectivement, tu es remonté assez loin.

    C'est en fait le petit fichier d'explication que je donne aux élèves qui ont "oublié" comment faire une conversion de base (ça revient régulièrement comme exercice, donc au moins quelques élèves par an ).
    Si les cons volaient, il ferait nuit à midi.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Un document pour les débutants
    Par alza dans le forum VB 6 et antérieur
    Réponses: 6
    Dernier message: 21/02/2007, 00h02
  2. Y a t il un exemple d'application a suivre pour les débutants ?
    Par jlassiramzy dans le forum Services Web
    Réponses: 1
    Dernier message: 24/11/2006, 22h26

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo