Types de données en C

Bonjour là-bas, futurs programmeurs ! Bienvenue dans notre passionnante aventure dans le monde de la programmation C. Aujourd'hui, nous allons explorer le fascinant royaume des types de données en C. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je serai votre guide amical, et nous aborderons ce sujet pas à pas. Alors, prenez votre boisson favorite, asseyez-vous confortablement, et plongons dedans !

Types de données entières en C

Commençons par quelque chose avec lequel nous sommes tous familiers - les nombres entiers. En C, nous appelons cela des entiers, et ils viennent en différentes tailles et saveurs.

Les types d'entiers de base

Voici un tableau des types d'entiers les plus courants en C :

Type de données	Taille (octets)	Plage
char	1	-128 à 127 ou 0 à 255
short	2	-32,768 à 32,767
int	4	-2,147,483,648 à 2,147,483,647
long	4 ou 8	-2,147,483,648 à 2,147,483,647 ou -9,223,372,036,854,775,808 à 9,223,372,036,854,775,807

Voyons maintenant comment les utiliser :

#include <stdio.h>

int main() {
char my_char = 65;
short my_short = 32000;
int my_int = 2000000000;
long my_long = 9000000000L;

printf("char: %c\n", my_char);
printf("short: %d\n", my_short);
printf("int: %d\n", my_int);
printf("long: %ld\n", my_long);

return 0;
}

Lorsque vous exécutez ce code, vous verrez :

char: A
short: 32000
int: 2000000000
long: 9000000000

Décomposons cela :

• La valeur char 65 correspond à 'A' dans le tableau ASCII. Surprise ! char peut également stocker des nombres !
• short et int fonctionnent comme prévu pour les nombres de taille moyenne.
• Pour long, nous ajoutons un 'L' à la fin pour indiquer à C qu'il s'agit d'un grand nombre.

Entiers unsigned

Parfois, nous avons besoin uniquement de nombres positifs. C'est là que les entiers unsigned deviennent utiles :

unsigned char my_uchar = 255;
unsigned short my_ushort = 65000;
unsigned int my_uint = 4000000000U;

printf("unsigned char: %u\n", my_uchar);
printf("unsigned short: %u\n", my_ushort);
printf("unsigned int: %u\n", my_uint);

Sortie :

unsigned char: 255
unsigned short: 65000
unsigned int: 4000000000

En utilisant unsigned, nous pouvons stocker des nombres positifs plus grands dans la même quantité de mémoire. C'est comme de la magie, mais c'est juste une utilisation intelligente des bits !

Types de données à virgule flottante en C

Maintenant, plongons dans le monde des nombres décimaux. C fournit trois types à virgule flottante :

Type de données	Taille (octets)	Précision
float	4	6-7 digits décimaux
double	8	15-16 digits décimaux
long double	16	19-20 digits décimaux

Voyons-les en action :

#include <stdio.h>

int main() {
float pi_float = 3.14159265358979323846f;
double pi_double = 3.14159265358979323846;
long double pi_long_double = 3.14159265358979323846L;

printf("float: %.7f\n", pi_float);
printf("double: %.16f\n", pi_double);
printf("long double: %.20Lf\n", pi_long_double);

return 0;
}

Sortie :

float: 3.1415927
double: 3.1415926535897931
long double: 3.14159265358979323846

Notez comment float perd de la précision après 7 digits, tandis que double et long double conservent plus de précision. C'est comme zoomer sur une photo numérique - à un moment donné, vous commencez à voir des pixels !

Types de données définis par l'utilisateur en C

C nous permet de créer nos propres types de données. C'est comme être un chef et créer vos propres recettes !

Structures

Les structures nous permettent de regrouper des données liées ensemble :

#include <stdio.h>
#include <string.h>

struct Student {
char name[50];
int age;
float gpa;
};

int main() {
struct Student alice;
strcpy(alice.name, "Alice");
alice.age = 20;
alice.gpa = 3.8;

printf("Nom: %s\n", alice.name);
printf("Âge: %d\n", alice.age);
printf("GPA: %.1f\n", alice.gpa);

return 0;
}

Sortie :

Nom: Alice
Âge: 20
GPA: 3.8

Ici, nous avons créé un type Student qui regroupe un nom, un âge et un GPA. C'est comme créer un formulaire pour les informations des étudiants !

Enumérations

Les énumérations sont géniales pour créer un ensemble de constantes nommées :

#include <stdio.h>

enum Days {SUN, MON, TUE, WED, THU, FRI, SAT};

int main() {
enum Days today = WED;
printf("Aujourd'hui est le jour numéro %d\n", today);
return 0;
}

Sortie :

Aujourd'hui est le jour numéro 3

Les énumérations attribuent automatiquement des valeurs entières croissantes en partant de 0. C'est comme donner des surnoms aux nombres !

Le type de données void en C

void est un type spécial en C. C'est comme une toile blanche - il représente l'absence de données. Nous l'utilisons principalement dans trois scénarios :

1. Une fonction ne renvoie rien :

   void sayHello() {
   printf("Bonjour, le monde !\n");
   }

2. Une fonction ne prend pas de paramètres :

   int getRandomNumber(void) {
   return 4;  // chosen by fair dice roll. guaranteed to be random.
   }

3. Pointeurs génériques (nous couvrirons cela dans la section des pointeurs)

Type de données tableau en C

Les tableaux sont comme une ligne de cases à pigeon, chacune contenant une valeur du même type :

#include <stdio.h>

int main() {
int scores[5] = {85, 92, 78, 90, 88};

printf("Première note: %d\n", scores[0]);
printf("Dernière note: %d\n", scores[4]);

float average = 0;
for(int i = 0; i < 5; i++) {
average += scores[i];
}
average /= 5;

printf("Moyenne des notes: %.2f\n", average);

return 0;
}

Sortie :

Première note: 85
Dernière note: 88
Moyenne des notes: 86.60

N'oubliez pas, en C, les indices des tableaux commencent à 0. C'est comme les numéros d'étage en Europe - le rez-de-chaussée est 0 !

Type de données pointeur en C

Les pointeurs sont comme des pancartes qui pointent vers des emplacements en mémoire. Ils sont puissants mais peuvent être délicats :

#include <stdio.h>

int main() {
int x = 10;
int *p = &x;

printf("Valeur de x: %d\n", x);
printf("Adresse de x: %p\n", (void*)&x);
printf("Valeur de p: %p\n", (void*)p);
printf("Valeur pointée par p: %d\n", *p);

*p = 20;
printf("Nouvelle valeur de x: %d\n", x);

return 0;
}

Sortie (les adresses varieront) :

Valeur de x: 10
Adresse de x: 0x7ffd5e8e3964
Valeur de p: 0x7ffd5e8e3964
Valeur pointée par p: 10
Nouvelle valeur de x: 20

Ici, p est un pointeur qui stocke l'adresse de x. Nous pouvons utiliser *p pour accéder ou modifier la valeur à cette adresse. C'est comme avoir une télécommande pour x !

Et voilà ! Nous avons couvert les principaux types de données en C. Souvenez-vous, comprendre les types de données est crucial car cela vous aide à gérer la mémoire efficacement et à éviter les bugs. Continuez à vous entraîner, et bientôt vous serez capable de jongler avec ces types comme un pro ! Bonne programmation !

Credits: Image by storyset