S'il vous plaît, lisez Comment créer un exemple minimal, complet et vérifiable .

afin de tester Votre émission de programme, j'ai d'abord dû compléter votre fragment de code afin de le rendre compilable. Probablement votre erreur est passée avec cette modification, comme mon exécution indique (sur votre texte d'entrée) cette sortie: p>

prun.c h1> xxx pré>

et en cours d'exécution: p> xxx pré>

quelle est la réponse correcte. P>

Malgré cela, votre fragment de programme montre une erreur non visible em >, comme vous l'avez dit dans les commentaires de votre question: Type de C CODE> La variable doit être int code> et non char code>, mais pourquoi?

parce que char code> est le type que vous souhaitez recevoir, toutes les valeurs disponibles sont possibles, afin d'indiquer que une condition spéciale forte> a été détectée dans votre fichier ( la fin des données dans le flux ou EOF code> n'est pas une de ces valeurs, mais une condition spéciale) une valeur supplémentaire est nécessaire em>, donc en faisant le type Char code> insuffisante pour inclure toutes les valeurs de retour possibles de Fgec (3) code>. C'est la raison pour faire fonctionner fgetc. 3) code> pour renvoyer un int code>. P>

vérifier la documentation de Fgec (3) Code> Comme votre programme fonctionne presque bien, alors que vous devez avoir une raison de savoir pourquoi: p>

Lorsque le programme lit un caractère, il est mappé dans les valeurs int code> 0 code> à 255 code>, de sorte que tous les octets différents convertissent comme des valeurs entières positives, tandis que normalement (presque chaque implémentation le fait) EOF code> est mappé dans la valeur entière -1 code>. Ce qui se passe ici, c'est que toutes vos valeurs sont converties en un char code>, rendant eof code> pour être mappé dans l'un de ces 0 code> à 256 code> valeurs strong> (lequel dépend de la mise en œuvre, mais c'est normalement la valeur 255 code> --- ou -1 code> si Char CODE> arrive à être signé) Donc: P>

• Si votre Char code> est représenté sous la forme d'un type de complément de deux ( signé code>) vos valeurs 0 code> à 255 code > sont mappés dans 0 code> à 127 code> et -128 code> à -1 code> et le eof code> la valeur est mappée sur certains d'entre eux (principalement -1 code>). li>
• Si votre Char code> est représenté sous la forme d'un type non signé, vos valeurs 0 code> à 255 code> sont mappées dans 0 Code> to 255 code> et la valeur code> EOF code> est mappé sur l'un d'entre eux (le plus probablement 255 code>) li>
• Peu importe la valeur que le EOF code> est converti en, car vous faites votre comparaison dans un système de type cohérent, donc le converti em> char Code> La valeur est comparée à la valeur convertie em> EOF CODE> La valeur "CODE> EOF code> est convertie en la valeur convertie de EOF code>. Mais cela rend une autre valeur code> Char code> pour montrer le même comportement, ce qui rendrait l'une de ces caractéristiques d'entrée de ce type d'entrée, comme EOF code> et permettra à votre programme de s'arrêter prématurément. li> ul>

  dans les deux cas ci-dessus, si un octet avec la même valeur mappée em> de EOF code> est entrée, votre programme finira, croyant qu'il a atteint la fin du fichier et votre compte sera erroné. Ce n'est pas le cas ici, mais vous pouvez obtenir une surprise avec un fichier qui a un tel caractère. P>

  Votre programme final (corrigé) serait le suivant: P>

  #include <stdio.h>
  
  int main()
  {
          int c;
          long count = 0;
          FILE *fp = stdin; /* probably you dont have intialized this
                             * field in your code, but who knows, if 
                             * you have not posted a complete 
                             * sample */
  
          // fp is the pile pointer
          while ((c = getc(fp)) != EOF) 
                if (c == '\n') // Increment count if this character is newline 
                   count++; // this is another  frequently used idiom :)
  
          printf("%d\n", count);
  
          return 0;
  }