Forum Programmation.c Type pour un chiffre

Posté par  (site web personnel) .
Étiquettes : aucune
0
17
août
2004
Bonjour,

Suite à mon post sur la recherche d'un livre d'algorithmie [1], j'ai acheté Algorithmes en langage c [2] de Robert Sedgewick [3].

Le livre est très bien et assez simple d'accès, par contre, je ne trouve pas les corrigés des exercices.

Sinon, ma question:

Je veut representer un chiffre (0,1,2,3,4,5,6,7,8,9)
Quel type est le plus adapté, pour l'instant j'utilise des int, mais n'est ce pas une depense de memoire inutile?

Bonne journée,

Julien



[1] http://linuxfr.org/forums/19/2571.html(...)
[2] http://www.eyrolles.com/Informatique/Livre/9782100053315/livre-algo(...)
[3] http://www.cs.princeton.edu/~rs/(...)

  • # En Java ?

    Posté par  (site web personnel) . Évalué à 2.

    Si tu es sur Paris ou RP, et que ça t'intéresse, je peux te donner "Algorithmique et programmation en Java", 2ème édition qui vient de sortir, de Vincent Granet, ed. Dunod, coll. Sciences Sup Cours et exercices corrigés... Au moins il servira à quelqu'un...

    • [^] # Re: En Java ?

      Posté par  (site web personnel) . Évalué à 2.

      C'est vraiment très sympa.

      Je te remercie mais en fait, le java... je sais pas trop, j'en ai fait un peu (pour aborder l'objet), ça à l'air bien, tout à l'air simple, mais ça ne me plait pas.

      Les exercices sont en java ou dans un pseudo langage ?

  • # unsigned short

    Posté par  . Évalué à 1.

    Et bien je dirais que ce serait :
    unsigned short chiffre = 0;
    le type qui se rapproche le plus de la definition d'un chiffre ([0;9]).

    Ensuite, au niveau de la depense de memoire :

    Type__________________________Size
    bool..........................................................1 byte
    char, unsigned char, signed char....1 byte
    short, unsigned short...........................2 bytes
    int, unsigned int....................................4 bytes
    long, unsigned long.............................4 bytes
    float..........................................................4 bytes
    double.....................................................8 bytes

    • [^] # Re: unsigned short

      Posté par  (site web personnel) . Évalué à 3.

      Et donc celui qui prendra le moins de place est un char, pas un short int.

      pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

      • [^] # Re: unsigned short

        Posté par  . Évalué à 1.

        Oui mais (et la j'atteins mon niveau d'incompetence) est-ce que les operateurs courants font bien ce qu'on pense qu'ils doivent faire ? (+,-,*,/,++,--,+=,etc)

        Et puis, est-ce qu'il faut aussi gerer le fait que 9+1 n'est plus un chiffre mais un nombre ?

        Bref... Faut faire attention :)

        • [^] # Re: unsigned short

          Posté par  . Évalué à 1.

          Oups : ++ et Cie en C ca le fait pas trop :P

          • [^] # Re: unsigned short

            Posté par  (site web personnel) . Évalué à 4.

            Ben ++ c'est un opérateur valide en C. En fait avec un char, ça va "overflower" seulement à 129 dans le pire des cas donc ça laisse de la marge. Et s'il ne faut pas de nombre négatif, un unsigned char ça peut aller aussi bien en allant jusqu'à 256. Normalement les opérations arithmétiques ne devraient pas poser problème. http://ccs.ucsd.edu/c/types.html#Basic%20Integer%20Types(...) Par ailleurs
            The First Rule of Program Optimization:
        Don't do it.

The Second Rule of Program Optimization (for experts only!):
        Don't do it yet.
                -- Michael Jackson

            pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

            • [^] # Re: unsigned short

              Posté par  (site web personnel) . Évalué à 1.

              Clur, l'exemple classique :


              
for (unsigned char i = 0 ; i < 255 ; i++) {
              
  printf("%d", i) ;
              
}


              Cherchez l'erreur...

              • [^] # L'erreur

                Posté par  . Évalué à 1.

                Tu declare ta variable dans la boucle: not good in C bien en C++

                • [^] # Re: L'erreur

                  Posté par  . Évalué à 3.

                  Ça ne serait pas par hasard acceptable en C99 ? Pour autant que je sache, C99 permet de déclarer les variables au milieu d'un bloc (alors que les versions plus anciennes du C ne le permettent qu'en début de bloc).

              • [^] # Re: unsigned short

                Posté par  . Évalué à 0.

                je crois que %d correspond a la valeur signee...

                for (unsigned char i = 0 ; i < 255 ; i++) {

                printf("%u", i) ;

                }

              • [^] # Re: unsigned short

                Posté par  (site web personnel) . Évalué à 2.

                Mmh, honte à moi, le code ci dessus marche très bien... Celui qui déconne est bien entendu :


                
for (unsigned char i = 0 ; i <= 255 ; i++) {
                

                
  printf("%d", i) ;
                

                
}


                qui boucle infiniment puisque une fois i arrivé à 255, il est incrémenté, et comme le unsigned char est limité à 255, i revient à 0, et la condition d'arrêt n'est pas vérifiée.

    • [^] # Re: unsigned short

      Posté par  . Évalué à 3.

      Unsigned char permet aussi de representer un entier contrairement a ce que son nom laisse supposer.
      Sinon, la plupart du temps, le compilateur arrivera a se debrouiller de maniere a ce que ton chiffre ne passe pas par la memoire et reste au niveau registre. A ce moment, mettre int marche tout aussi bien. Je conseillerai donc l'usage de int la plupart du temps et d'autre type seulement si tu les employes en grande quantites (typiquement un tableau d'entiers).

      Derniere chose, les valeurs precedentes sont justes la plupart du temps (x86) mais apres ca depend des processeurs et pas seulement de leur caractere 32/64 bits.

      • [^] # Re: unsigned short

        Posté par  . Évalué à 2.

        Et s'il choisissait un type énuméré?

        • [^] # Re: unsigned short

          Posté par  . Évalué à 1.

          il me semble qu'en interne, un enum, c'est juste une collection de int (ou unsigned int?)

        • [^] # Re: unsigned short

          Posté par  (site web personnel) . Évalué à 2.

          ou une collection de bits ;-)

        • [^] # Re: unsigned short

          Posté par  . Évalué à 2.

          Mais a ce moment la, il perdra les operations arithmetiques et la conversion facile vers/depuis int (qui est souvent utile pour lire/ecrire des nombres). Bref, c'est un choix a faire mais il me semble qu'il y a rarement a gagner a optimiser ce genre de choses (toujours hors tableau). Il y a plutot un risque de ne plus rien comprendre : par exemple, si ce nombre represente l'etat d'un automate et que tu utilises un unsigned char, le jour ou tu tombes sur un automate a plus de 256 etats, tu risques de mettre un certain temps avant de comprendre ou est le probleme (pas d'erreur a la compil ni a l'execution, juste un resultat faux).

    • [^] # Re: unsigned short

      Posté par  (site web personnel) . Évalué à 2.

      si le monsieur veut du C il me semble que bool sort un peu du cadre.. d'autre part il me semble que t'as oublié "long long" qui est sur 8 octets... sur un x86.

      parce que tout ce dont tu parles c'est sur x86, ce n'est pas du tout assuré d'être le cas sur d'autres architectures.

      si tu veux vraiment un entier non signé sur 32 bit il faut utiliser "uint32" (il me semble, je n'ai pas retrouvé la norme précise).

      si tu veux manipuler le type entier "naturel" pour le processeur, utilise "int" ou "unsigned int". ce sera 32 bit sur un x86, 64 bit sur un amd64... mais surtout ce sera quelque chose que le processeur manipule rapidement et efficacement.

      • [^] # Re: unsigned short

        Posté par  (site web personnel) . Évalué à 2.

        Le type bool est valide en C99 (cf stdbool.h).

        pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

      • [^] # Re: unsigned short

        Posté par  (site web personnel) . Évalué à 1.

        Et encore, à part dans les tableaux, le compilo optimise. Le plus souvent gcc pour un simple char ou short préfaire utiliser un int derrière. Il ne faut donc pas compter sur des effets d'overflow ou autre. L'effet est spécial :)

        "La première sécurité est la liberté"

    • [^] # Re: unsigned short

      Posté par  . Évalué à 1.

      Desoler mais:

      je crois plutot que un
      - int egal 2 octet donc 16 bit
      -un type char 1 octet donc 8 bit

      pour le reste je n' ai pas la correspondance ne tete.
      Me faire signe si je me gourre.
      Je planche justement sur la manipulation des bite donc si j'ai faut c'est grave pour moi !

      pour des petits chiffre qui ne depasent pas 15 tu peut coder sur 4 bit
      1111 = 15

  • # Alignement

    Posté par  . Évalué à 7.

    Pour des raison d'alignement de mot et de temps de calcul d'adresse de frontiere il souvant interressant de prendre le type "natif" du processeur (ici 32 bits)

  • # Y a pas assez de trolls Ada, ici

    Posté par  (site web personnel) . Évalué à 2.

    [troll]
    Ou alors tu codes en Ada et tu laisses le compilo se demerder avec un

    subtype CHIFFRE is NATURAL range 0..9

    Et prépare toi à te faire insulter quand tu voudras afficher un chiffre avec le "print" des flottants.
    [/troll]

    • [^] # Re: Y a pas assez de trolls Ada, ici

      Posté par  . Évalué à -1.

      tu peux utiliser les unsigned char et mettre deux chiffres par variables...
      unsigned char a, b, c[1000];
      //c'est dans c[1000] qui tu placeras tes chiffres
      //tu y accède comme ceci :

      a=c[i]%10;
      b=(c[i]-a)/10;

      //et tu affiches a et b mais tes nombres seront stoiqués dans c[]

      //et pour enregistrer, c'est :
      c[i]=a+b*10;

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.