Le char en C

Bonsoir,

J’apprend le C, on dit qu’un signed char va entre -128 et 127 mais j’ai testé le code suivant et il compile, même avec l’option -Wall.

#include <stdio.h>

int main()
{
    signed char m1 = -128;
    signed char m2 =  200; // On s'attend à une erreur ici
    
    printf("m1 : %c\n", m1);
    printf("m2 : %c\n", m2);
    
    return 0;
}

Comment expliquer cette différence entre la pratique et la théorie ?

Il n’y a pas de différence entre la pratique et la théorie

Le C est un langage faiblement typé. Par là, j’entends qu’il est capable de faire des convertions sans qu’elles soit explicites ni évidente. Ici, 200 ou -128 sont des valeurs de type int qui sont converties à l’initialisation en char.

Pour t’en convaincre tu peux essayer d’affichier directement les valeurs avec printf et le format %d

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    signed char m1 = -128;
    signed char m2 =  200; // On s'attend à une conversion implicite ici
    
    printf("m1 : %d\n", m1);
    printf("m2 : %d\n", m2);
    
    return EXIT_SUCCESS;
}

Ce comportement n’est pas universel d’autres langages demandent d’expliciter les conversions, d’autres langages sont encore plus souple que le C. En C, les conversions implicites se font entre les types numériques (int, usize, …) et les addresses (void, char, int*, …). Pour le C++, c’est uniquement entre les types numériques.

Salut,

En C, un dépassement de capacité ne conduit pas à une erreur de compilation, même s’il est détecté par le compilateur. Il s’agit d’un comportement indéfini, c’est-à-dire que la norme du langage ne précise pas le comportement qui est obtenu dans cette situation. Dans les faits, il y a trois possibilités :

1. Dans 99% des cas (parce que quasiment tous les processeurs modernes fonctionnent ainsi), la valeur boucle, c’est-à-dire qu’une fois le maximum atteint, on retombe au minimum et inversement. Dans ton exemple, la valeur 200 va devenir -56.
2. La valeur sature (elle reste bloquée au maximum ou au minimum).
3. Le processeur émet une exception et l’exécution du programme est arrêtée.

C’est probablement un peu tôt si tu commences l’apprentissage du C, mais c’est expliqué dans ce chapitre du cours C.

4. Dans le cas des expressions le compilateur fusionne la valeur qui dépasse avec une autre qui fait revenir dans les bornes. Exemple bidon: dans le cas des signés, le compilateur est autorisé à transformer (2 * x + 10) / 2 en x+5 — bon après, les calculs se font sur des int, du coup ça se teste avec INT_MAX-5 p.ex.

(Le compilateur est autorisé parce que les dépassements ne sont justement pas définis.)

Merci pour vos réponses, ça m’aide à en apprendre plus sur le C.
Existe-t-il un site officiel qui référence les fonctions en C (documentation) ?
J’ai beau chercher, je tombe sur des sites bizarres ou peu fiables avec Google.

Effectivement le nombre renvoie -56.

Par ailleurs un autre cas limite similaire en jouant avec INT_MAX :

#include <stdio.h>
#include <limits.h>

int somme(int a, int b)
{
    return a+b;
}

int main()
{
    int res = somme(INT_MAX, 1);
    printf("Résultat : %i\n", res);       // Résultat : -2147483648   
    
    return 0;
}

@ache à quoi sert le void en tant qu’argument de la fonction main ?

Existe-t-il un site officiel qui référence les fonctions en C (documentation) ?

cppreference?

@ache à quoi sert le void en tant qu’argument de la fonction main ?

En C, à dire que la fonction ne prend aucun paramètres. Si on ne met rien (en C; le C++ a changé pour le choix plus intuitif précédent), cela veut dire: infinité de paramètres.

Comme l’a cité @lmghs, cppreference est un bon site de référence et t’évitera de te farcir la lecture de la norme. Maintenant, pour le côté « officiel », le seul document (’fin les seuls documents) à l’être est la norme. La dernière en date est la C18, (il y a un lien vers un PDF dans les référence de l’article, c’est un « brouillon », pas le document final validé, mais cela revient quasiment au même) et la partie qui t’intéresse est la 7 qui décrit la bibliothèque standard.

Ahah ! Tu remarques tout
C’est très bien.

En C, il n’y a que deux prototypes normalisé de la fonction main.

int main(void);
// et 
int main(int argc, char *argv[]);

En C++, ne rien mettre est équivalent à mettre void en C. Bref, si une fonction ne prend pas d’argument, il faut mettre void.

En C, l’overflow d’un unsigned est correctement défini par la norme du langage. Ce n’est pas le cas pour l’overflow d’un signed, comme expliqué par Taurre, c’est un comportement indéfini.

Bref, si une fonction ne prend pas d’argument, il faut mettre void.

Par curiosité, que se passe-t-il dans mon code lorsque je ne mets pas de void comme argument ? Le compilateur semble accepter des comportements non standard aux normes, du coup comment coder proprement et éviter les erreurs ?

Si tu ne mets rien alors la fonction accepte un nombre indéfini d’argument.

Exemple:

#include<stdlib.h>

int foo() {
  return 11;
}
int main(void) {
  foo(12, 13, "qsdqd");
  return EXIT_SUCCESS;
}

C’est totalement standard mais pas très utile. Par contre, pour la fonction main, effectivement, le compilateur accepte des points d’entrés non standard. :/

Petite questions toujours avec le char en C et les pointeurs.
Lorsqu’on déclare un pointeur, pourquoi a-t-on besoin de préciser le type du pointeur ?

Par exemple, l’exemple suivant fonctionne très bien et compile :

#include <stdio.h>

int main()
{
    char  c  =  'E';
    int*  p  =  &c;
    
    printf("%c", *p);  // Affiche : E
    return 0;
}

Même résultat en inversant les types char et int.
Dans ma tête, un pointeur contient une adresse mémoire, peut importe le type du contenu adressé.

Merci bien !

Mmm… Convertir ou non vers un pointeur sur void ou char entre les deux ne change a priori rien au problème, tu ne fais qu’ajouter une étape. Faire char * -> void * -> int * est identique à char * -> int *, puisque la conversion vers et depuis le type void * garantit simplement que ton pointeur restera identique.

Par ailleurs, la norme permet un petit peu plus en ce qui concerne les conversions entre pointeurs.

Toutefois, ça c’est pour la conversion, l’accès à l’objet référencé est en revanche une autre question.

Pour faire bref, la norme proscrit l’accès à un objet via un pointeur d’un type différent, sauf exceptions (la plus emblématique étant l’emploi d’un pointeur sur char).

N’oublie pas que printf() est une fonction à nombre variable d’arguments et qu’elle reçoit un int en argument, pas une adresse. Elle n’affiche donc pas « le premier byte » de ce int, mais converti cette valeur en unsigned char pour l’afficher. Étant donné que le pointeur p référence en fait un char, on peut donc observer un affichage hasardeux sur une architecture littel endian également (sans compter qu’il s’agit d’un comportement indéfini).