Annonce

Réduire
Aucune annonce.

Cours langage C n°3 - Les fonctions d'affichage

Réduire
Ceci est une discussion importante.
X
X
 
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Cours langage C n°3 - Les fonctions d'affichage

    LES FONCTIONS D'AFFICHAGE


    C'est bien beau d'avoir écris du code, mais ce qui est encore mieux est de regarder ce que donne ce code sur la console...

    On a vu la fonction puts, qui permet ce type d'affichage.

    Voici un exemple de code et son résultat

    Code:

    Code:
    #include <stdio.h>
    
    int main(void)
    {
        puts("Hello World!");
    
        return 0;
    }
    Résultat:

    stdout.png

    PLUSIEURS FONCTIONS D'AFFICHAGE

    On en verra trois, qui sont toutes les trois adapté pour des problèmes différents, il faut donc bien là choisir selon ses besoins.

    Ces 3 fonctions sont:
    1. puts
    2. putchar
    3. printf


    LA FONCTION PUTS

    Son objectif est d'afficher sur la console (stdout, on verra plus tard) une chaîne de caractères.

    Code:
    puts("Hello World!"); /* affiche "Hello World sur la console */
    Affichera donc "Hello World!" dans la console...

    On peut afficher aussi le contenu d'une variable, à partir du moment où notre variable est un tableau de caractères char ...[]

    Code:
    char chaine[] = "Hello World!";
    puts(chaine); /* affiche "Hello World sur la console */
    Fonction pas très difficile, n'est-ce pas ? On voit très bien que son objectif est d'afficher du texte brut... Imaginons que nous voulions écrire chaque ligne d'un fichier texte, on utilisera cette fonction, tout à fait adapté.

    LA FONCTION PUTCHAR

    Son objectif est d'afficher sur la console (stdout, on verra plus tard) un et un seul caractère.

    Code:
    putchar('H'); /* affichera 'H' */
    Affichera le caractère 'H' dans la console...

    Comme puts, on peut afficher le contenu d'une variable à partir du moment où l'on ne se trompe pas de type.

    Code:
    char letter = 'H';
    putchar(letter); /* affichera 'H' */
    Simple aussi, non ? Son objectif sera très souvent d'écrire un caractère de fin de ligne '\n'.

    LA FONCTION PRINTF

    Son objectif est d'afficher sur la console (stdout, on verra plus tard) une chaîne formatée.

    Une chaîne formatée est une chaîne de caractères, seulement on là modifiera selon des besoins en manipulant des variables et leurs types.

    Code:
    printf("Je suis majeur car j'ai %d ans", 18); /* affichera "Je suis majeur car j'ai 18 ans */
    %d est le format entier, il en existe d'autres selon nos besoins (tableau ci-dessous)

    formats.jpg

    Les formats qui nous intéresserons à l'heure actuelle sont:
    • %d entiers
    • %f flottants
    • %s tableau de caractères
    • %c caractère


    On peut ajouter plusieurs formats différents dans une même chaîne de caractères, mais attention de rester cohérent, on doit avoir le même nombre de valeurs que de formats ajoutés.

    Code:
    #include <stdio.h>
    
    int main(void)
    {
    
        printf("Je m'appelle %s, j'ai %d ans et je suis %s\n", "toto", 25, "majeur");
    
        return 0;
    }
    Affichera : Je m'appelle toto, j'ai 25 ans et je suis majeur (plus retour à la ligne)

    Et bien évidemment, utiliser des variables

    Code:
    #include <stdio.h>
    
    int main(void)
    {
        char nom[] = "toto";
        int age = 25;
        char droit[] = "majeur";
    
        printf("Je m'appelle %s, j'ai %d ans et je suis %s", nom, age, droit);
    
        return 0;
    }
    Donnera strictement le même résultat...

    Attention d'être toujours cohérent avec vos types de données (char, char ...[], int, float et double).

    EXERCICES

    Exercice n°1

    Compléter le code suivant

    Code:
    #include <stdio.h>
    
    int main(void)
    {
        char line[50];
        
        /* à compléter */
        
        
        
        
        /* fin du code */
    
        return 0;
    }
    • Dans ce code vous devrez affecter par indice chaque caractère de la ligne "Hello!" à la variable line.
    • Afficher le contenu de la variable line avec la fonction adaptée.


    Exercice n°2

    Utilisation de la fonction putchar,

    Pour des entiers allant de 97 à 99 inclus, que remarque-t-on (table ASCII à voir)?
    Que peut-on en déduire du type char en C (comparaison avec le type int) ?

    Compléter le code suivant en affectant les entiers ascii (97 à 99 inclus) à la variable line, puis afficher avec la fonction adaptée le contenu de la variable line en console.

    Code:
    #include <stdio.h>
    
    int main(void)
    {
        char line[50];
        
        /* à compléter */
        
        
        
        
        /* fin du code */
    
        return 0;
    }
    Rappel: Le caractère de fin de chaîne est '\0'.

    Exercice n°3

    Remplacer dans le code ci-dessous format1, format2, format3 et format4 par le format adapté selon les données indiquées par les types de variable, et var1, var2, var3 et var4 par le nom de ces variables.

    Code:
    #include <stdio.h>
    
    int main(void)
    {
    
        char hack[] = "Hackademics";
        char exo[] = "exercice";
        char letter = 97;
        char fin = '\n';
    
        printf("Je fais un format1 sur format2, j'(format3)pprend les bases...format4", var1, var2, var3, var4);
    
        return 0;
    }
    Retourner ce code afin que l'affichage soit correct.

    Merci de m'avoir lu et à bientôt pour le prochain cours
    Dernière modification par fred, 30 juin 2014, 12h11.

  • #2
    Salut, merci pour ton cour. Je te propose ma solution pour les différents exercices :
    Exercice 1 :

    #include <stdio.h>

    int main(void)
    {
    char line[50];
    line[0] = 'H';
    line[1] = 'e';
    line[2] = 'l';
    line[3] = 'l';
    line[4] = 'o';
    line[5] = '!';
    line[6] = '\0';

    puts(line);
    return 0;
    }
    Voici mon exercice 2, en faite pas très compliqué, je pensais qu'il fallait faire plus compliquer.

    Exercice 2
    #include <stdio.h>

    int main(void)
    {
    char line[50];
    line[0] = 97;
    line[1] = 98;
    line[2] = 99;
    line[3] = '\0';

    puts(line);
    return 0;
    }
    Et pour finir voici mon exercice 3. J'ai un résultat plutôt congrès dans ma console donc je pense qu'il est valide.
    #include <stdio.h>

    int main(void)
    {

    char hack[] = "Hackademics";
    char exo[] = "exercice";
    char letter = 97;
    char fin = '\n';

    printf("Je fais un %s sur %s, j'%cpprend les bases...%n", exo, hack, letter, fin);

    return 0;
    }
    PS : J'édite le post en fonction de mon avancement.
    Dernière modification par kent-de-champ, 30 juin 2014, 12h47.

    Commentaire


    • #3
      Voila pour moi l'exo 1
      je voulais le mettre tal mais c'étais encore en serveur surcharger

      Code:
      #include <stdio.h>
      
      int main(void)
      {
           char line[50];/* Déclaration */
           line[0] ='H'; /* Assignation */
           line[1]='e';
           line[2]='l';
           line[3]='l';
           line[4]='o';
           line[5]='!';
           line[6]='\0';/*fin de chaine*/
           puts(line);/*ecrire line*/
          return 0;
      }
      Exercice 2
      Question 1
      On remarque que les entiers 97,98 et 99 prennent respectivement la valeur des caractères suivants a,b et c.
      Donc par consèquent le code ASCII renvoie un caractère en fonction d'un entier.
      Une correspondance algorythmique peut être envisageable.
      Le type char désigne un caractère mais il proviens d'une correspondance int.
      En résumer on peut convertir un entier par un caractère et vice versa.
      J'espère que cela réponds à la question car j'ai du mal à comprendre où tu voulais en venir.
      D'ou la solution de l'exercice 2

      Code:
      #include <stdio.h>
      
      int main(void)
      {
          char line[50];
          line[0]=97;
          line[1]=98;
          line[2]=99;
          line[3]='\0';
          puts(line);
      
          return 0;
      }
      Voila CQFD un entier renvoie avec la fonction approprié à un caractère.

      Exercice 3:


      Code:
      #include <stdio.h>
      
      int main(void)
      {
      
          char hack[] = "Hackademics";
          char exo[] = "exercice";
          char letter = 97;
          char fin = '\n';
      
          printf("Je fais un %s sur %s, j'(%c)pprend les bases... %c", exo, hack, letter, fin);
      
          return 0;
      }
      Dernière modification par DreAmuS, 30 juin 2014, 12h59.

      Commentaire


      • #4
        En résumer on peut convertir un entier par un caractère et vice versa.
        Jusqu'à cette dernière phrase tout ce que tu disais était juste, seulement ce n'est pas convertir, mais la réelle valeur des lettres que vous lisez en console. En faisant simple, les caractères type char allant de 'a' à 'z' sont de type int.

        Commentaire


        • #5
          Merci de ta réponse effectivement j'ai mal exposé ma conclusion. Je comprends mieux avec ta réponse.

          Code:
          #include <stdio.h>
          
          int main(void)
          {
          
              char hack[] = "Hackademics";
              char exo[] = "exercice";
              char letter = 97;
              char fin = '\n';
          
              printf("Je fais un %s sur %s, j'(%s)pprend les bases... %s", exo, hack, letter, fin);
          
              return 0;
          }
          Bon j'ai un retour error sur la printf mais je ne vois pas pourquoi ?? La je suis dans une impasse.
          Dernière modification par DreAmuS, 30 juin 2014, 12h56.

          Commentaire


          • #6
            C'est pourtant la dernière phrase écrite en rouge et en gras

            Commentaire


            • #7
              Voici pour le dernier il n'affiche plus d'erreur
              Code:
              #include <stdio.h>
              
              int main(void)
              {
              
                  char hack[] = "Hackademics";
                  char exo[] = "exercice";
                  char letter = 97;
                  char fin = '\n';
              
                  printf("Je fais un %s sur %s, j'(%c)pprend les bases... %c", exo, hack, letter, fin);
              
                  return 0;
              }

              Commentaire


              • #8
                Bonjour à tous,

                Code:
                #include <stdio.h>
                
                
                int main(void)
                {
                
                    // === Exercice n°1 ===
                
                    char line[50];
                
                    line[0] = 'H';
                    line[1] = 'e';
                    line[2] = 'l';
                    line[3] = 'l';
                    line[4] = 'o';
                    line[5] = '\0';
                
                    puts(line);
                    putchar('\n');
                    putchar('\n');
                
                    // === Exercice n°2 ===
                
                    line[0] = 97;
                    line[1] = 98;
                    line[2] = 99;
                    line[3] = '\0';
                
                    puts(line);
                    putchar('\n');
                    putchar('\n');
                
                    // === Exercice n°3 ===
                
                    char hack[] = "Hackademics";
                    char exo[] = "exercice";
                    char letter = 97;
                    char fin = '\n';
                
                    printf("Je fais un %s sur %s, j'%cpprend les bases...%c", exo, hack, letter, fin);
                
                    putchar('\n');
                    putchar('\n');
                
                
                    return 0;
                }
                deux et deux font cinq

                Commentaire


                • #9
                  Exercice n°1:

                  Code:
                  #include <stdio.h>
                  
                  int main(void)
                  {
                      char line[50];
                  
                      /* à compléter */
                      line[0] = 'H';
                      line[1] = 'e';
                      line[2] = 'l';
                      line[3] = 'l';
                      line[4] = 'o';
                      line[5] = '\0';
                  
                      puts(line);
                  
                  
                  
                  
                      /* fin du code */
                  
                      return 0;
                  }
                  Exercice n°2 :

                  97,98 et 99 correspondent à 'a', 'b' et 'c' d'après la table ASCII.
                  On peut donc convertir un int en char, et inversement, dans la limite de la table ASCII ?

                  Code:
                  #include <stdio.h>
                  
                  int main(void)
                  {
                      char line[50];
                  
                      /* à compléter */
                      line[0] = 97; //a
                      line[1] = 98; //b
                      line[2] = 99; //c
                      line[3] = '\0';
                  
                      puts(line); // Affichera abc.
                      /* fin du code */
                  
                      return 0;
                  }
                  Exercice n°3 :
                  Code:
                  #include <stdio.h>
                  
                  int main(void)
                  {
                  
                      char hack[] = "Hackademics";
                      char exo[] = "exercice";
                      char letter = 97;
                      char fin = '\n';
                  
                      printf("Je fais un %s sur %s, j'%cpprend les bases...%c", exo, hack, letter, fin); //char[], char[], char, char -> %s,%s,%c,%c
                  
                      return 0;
                  }
                  Mon blog : http://rootsheep.info

                  Commentaire


                  • #10
                    @Sadik,

                    Tout est bon, juste une petite remarque, peux-tu écrire tes commentaires de cette façon

                    Code:
                    /* ... */
                    car je travaille avec la norme C89 qui est la plus rigoureuse à mon sens, et donc les commentaires que tu places sont reconnues comme des erreurs.

                    Merci par avance,

                    Commentaire


                    • #11
                      J'ai une question : Quand tu fait par exemple une déclaration d'un tableau de char et que tu lui donne par exemple 50 case en mémoire soit 50 caractère ou valeur possible sans oublier le caractère \0 qui dit la fin de la chaîne dans la mémoire si tu lui dit que ta chaine ce coupe a l'indice 27 par exemple es que les case suivante en mémoire ce qui suivent 28.29.30 les indice, sont détruite ?

                      Voici ce que j'ai fait :
                      Code:
                      #include <stdio.h>
                      
                      int main(void)
                      {
                          /************************************************
                          *               EXERCICE
                          *************************************************/
                          /* EXERCICE 1 et 2*/
                          char line[50];
                          /* FIN */
                      
                          /* EXERCICE 3 */
                          char hack[] = "Hackademics";
                          char exo[] = "exercice";
                          char letter = 97;
                          char fin = '\n';
                          /* FIN */
                      
                          /************************************************
                          *               EXERCICE
                          *************************************************/
                      
                          /* DECLARATION DE VARIABLE */
                          char pseudo[8];
                          char sexe;
                      
                          /* ASSIGNATION */
                          pseudo[0] = 'M';
                          pseudo[1] = 'a';
                          pseudo[2] = 'd';
                          pseudo[3] = 'z';
                          pseudo[4] = '_';
                          pseudo[5] = 'f';
                          pseudo[6] = 'r';
                          pseudo[7] = '\0'; /* NE PAS OUBLIER LE CARACTERE \0 pour dire la fin de la chaine */
                      
                          sexe = 'M';
                      
                          /* Utilisation de puts(const char* chaine_a_imprimer_dans_le_terminal_cmd) */
                          puts("Votre pseudo est :");
                          puts(pseudo);
                          puts("Votre sexe est :");
                      
                          /* Utilisation de putchar putchar(const char lettre_a_imprimer_dans_le_terminal_cmd)*/
                          putchar(sexe);
                          putchar(65); /* Un type char peut prendre les nombre de la table ASCII */
                          putchar('L');
                          putchar('E');
                          putchar('\n');
                          /* Utilisation du int printf(const char* chaine_formater, ... ) */
                          printf("\nHello je vais vous faire un resumer de vos information\n");
                          printf("Votre pseudo : %s\n", pseudo);
                          printf("Votre sexe   : %c\n", sexe);
                          printf("Votre age    : %d\n", 16);
                          printf("Votre poid   : %.1f\n", 131.7); /* C'est mon vrai poid a 16 ans oui... */
                      
                          putchar('\n');
                      
                          printf("Donc vous etes %s votre sexe est %c vous avez %d et vous pesez %.1f et vous faite %.2f cm\n", pseudo, sexe, 16, 131.7, 175.6666);
                      
                          putchar('\n');
                          putchar('\n');
                          putchar('\n');
                      
                          /************************************************
                          *               EXERCICE
                          *************************************************/
                          puts("EXERCICE 1");
                          line[0] = 'H';
                          line[1] = 'e';
                          line[2] = 'l';
                          line[3] = 'l';
                          line[4] = 'o';
                          line[5] = '!';
                          line[6] = '\0';
                      
                          puts(line);
                      
                          putchar('\n');
                      
                          puts("EXERCICE 2");
                          /*
                          ------------------------------------------------------------------------------------
                          Pour des entiers allant de 97 à 99 inclus, que remarque-t-on (table ASCII à voir)?
                          ------------------------------------------------------------------------------------
                          On remarque que chaque caractere est représenter par un nombre qui lui corespond
                          On voit les 4 base de codage : Decimale(base 10), Octal(base 8), hexadecimal(base 16), binaire(base 2)
                      
                          ------------------------------------------------------------------------------------
                          Que peut-on en déduire du type char en C (comparaison avec le type int) ?
                          ------------------------------------------------------------------------------------
                          Le type char n'est rien qu'un nombre ! cette a dire si je lui donne comme valeur
                          d'assignation un entier qui peut stocker alor il peut soit m'afficher
                          le caractere, soit sa valeur en base, 2, 8, 10, 16
                          */
                      
                          line[0] = 97;
                          line[1] = 98;
                          line[2] = 99;
                          line[3] = '\0';
                      
                          puts(line);
                          putchar('\n');
                      
                          puts("EXERCICE 3");
                      
                          printf("Je fais un %s sur %s, j'(%c)pprend les bases...%c", exo, hack, 97, fin);
                      
                          return 0;
                      }

                      Commentaire


                      • #12
                        Si tu coupes avec le caractère de fin de chaîne, non, les caractères suivant seront présent, par contre l'utilisation d'une fonction arrêtera au moment de la rencontre avec le caractère de fin de chaîne '\0'.

                        Commentaire


                        • #13
                          Envoyé par fred Voir le message
                          Si tu coupes avec le caractère de fin de chaîne, non, les caractères suivant seront présent, par contre l'utilisation d'une fonction arrêtera au moment de la rencontre avec le caractère de fin de chaîne '\0'.
                          Okay compris, je suppose avec l'allocation dynamique ont peut palier a ces case mémoire en trop.

                          Commentaire


                          • #14
                            Toujours pas,

                            Code:
                            #include <stdio.h>
                            #include <stdlib.h>
                            
                            int main(int argc, char *argv[]) {
                            
                                char *s = malloc(32);
                                if (s == NULL) exit(EXIT_FAILURE);
                            
                                s[0] = 'a';
                                s[1] = '\0';
                                s[2] = 'b';
                                s[3] = 'c';
                                s[4] = '\0';
                            
                                printf("%s\n", s+2); /* affiche bc */
                                printf("%s\n", s); /* affiche a */
                            
                                free(s);
                            
                                return 0;
                            
                            }
                            Comme tu le vois, quand on alloue, les cases mémoire existent, et la seule fonction à pouvoir libérer cette allocation est la fonction free.

                            Commentaire

                            Chargement...
                            X