ok donc je lis ce livre: Le langage de programmation C - par Kernighan et Ritchie (deuxième édition) et l'un des exemples, j'ai du mal à comprendre comment les choses fonctionnent.
#include <stdio.h>
#define MAXLINE 1000
int getline(char line[], int maxline);
void copy(char to[], char from[]);
int main(int argc, char *argv[])
{
int len;
int max;
char line[MAXLINE];
char longest[MAXLINE];
max = 0;
while((len = getline(line, MAXLINE)) > 1)
{
if(len > max)
{
max = len;
copy(longest, line);
}
}
if(max > 0)
printf("%s", longest);
getchar();
getchar();
return 0;
}
int getline(char s[], int lim)
{
int c, i;
for(i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
s[i] = c;
if(c == '\n')
{
s[i] = c;
++i;
}
s[i] = '\0';
return i;
}
void copy(char to[], char from[])
{
int i;
i = 0;
while((to[i] = from[i]) != '\0')
++i;
}
la ligne: for(i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
où il est dit c = getchar (), comment un entier = caractères peut-il être entré depuis la ligne de commande? Entiers oui mais comment sont stockés les caractères que je tape?
Merci d'avance
Contrairement à certains autres langages que vous avez pu utiliser, les caractères en C sont des entiers . char
est juste un autre type entier, généralement 8 bits et plus petit que int
, mais toujours un type entier.
Ainsi, vous n'avez pas besoin des fonctions ord()
et chr()
qui existent dans d'autres langues que vous avez pu utiliser. En C, vous pouvez convertir entre char
et d'autres types entiers à l'aide d'un transtypage, ou simplement en les affectant.
À moins que EOF se produise, getchar()
est défini pour retourner "un caractère non signé converti en int" ( identique à fgetc ), donc si cela aide vous pouvez imaginer qu'il lit des caractères, c
, puis renvoie (int)(unsigned char)c
.
Vous pouvez le reconvertir en unsigned char
uniquement par un cast ou une affectation, et si vous êtes prêt à subir une légère perte de portabilité théorique, vous pouvez le convertir en char
avec un cast ou en l'affectant à un char
.
La fonction getchar()
renvoie un entier qui est la représentation du caractère entré. Si vous entrez le caractère A
, vous obtiendrez 'A'
ou 0x41
retourné (mis à niveau vers un int
et en supposant que vous êtes sur un système ASCII bien sûr).
La raison pour laquelle il renvoie un int
plutôt qu'un char
est parce qu'il doit être capable de stocker n'importe quel caractère plus le EOF indicateur où le flux d'entrée est fermé.
Et, pour ce que ça vaut, ce n'est pas vraiment un bon livre pour les débutants. C'est de l'époque où l'efficacité importait plus que la lisibilité et la maintenabilité.
Bien que cela montre à quel point les goûts de K&R étaient intelligents, vous devriez probablement envisager quelque chose de plus ... convivial pour les débutants.
En tout cas, sa dernière édition couvrait C89 et beaucoup de choses ont changé depuis. Nous avons parcouru C99 et avons maintenant C11 et le livre n'a pas été mis à jour pour refléter l'un ou l'autre, il est donc horriblement obsolète.
Le type C char
est de 8 bits, ce qui signifie qu'il peut stocker la plage d'entiers à partir de (selon qu'il est signé ou non et que la norme C ne dicte pas ce que c'est si vous ne le spécifiez pas) soit -128 à 127 ou 0 à 255 (255 valeurs distinctes; il s'agit de la plage ASCII). getchar()
renvoie int
, qui sera d'au moins 16 bits (généralement 32 bits sur les machines modernes). Cela signifie qu'il peut stocker la plage de char
, ainsi que plusieurs valeurs.
La raison pour laquelle le type de retour est int
est que la valeur spéciale EOF
est renvoyée lorsque la fin du flux d'entrée est atteinte. Si le type de retour était char
, il n'y aurait aucun moyen de signaler que la fin du flux a été rencontrée (sauf s'il a fallu un pointeur sur une variable où cette condition a été enregistrée).