titres
4
Home.md
4
Home.md
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Informatique Industrielle
|
||||
---
|
||||
# Informatique Industrielle
|
||||
|
||||
> Le langage C reste aujourd'hui très utilisé, notamment pour le développement du noyau des systèmes d'exploitation, des logiciels embarqués et des applications nécessitant des performances élevées. Sa simplicité, sa proximité avec le matériel et sa portabilité sont les principales raisons de son succès durable.
|
||||
{class=definition}
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Opérateurs d'affectation
|
||||
---
|
||||
# Opérateurs d'affectation
|
||||
|
||||
Les opérateurs d'affectation en C sont utilisés pour assigner des valeurs à des variables. Le plus basique est l'opérateur =, mais il existe plusieurs autres opérateurs d'affectation combinés qui effectuent des opérations mathématiques tout en affectant une valeur à la variable.
|
||||
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Anatomie d'un programme en C
|
||||
---
|
||||
# Anatomie d'un programme en C
|
||||
|
||||
Un programme en langage C est constitué des éléments suivants :
|
||||
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Opérateurs arithmétiques
|
||||
---
|
||||
# Opérateurs arithmétiques
|
||||
|
||||
Les opérateurs arithmétiques en C sont utilisés pour effectuer des opérations mathématiques de base telles que l'addition, la soustraction, la multiplication.
|
||||
|
||||
|
||||
4
bit.md
4
bit.md
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Opérateurs bit-à-bit
|
||||
---
|
||||
# Opérateurs bit-à-bit
|
||||
|
||||
Les opérateurs bit-à-bit travaillent sur chacun des bits des opérandes.
|
||||
|
||||
|
||||
77
bloc.md
Normal file
77
bloc.md
Normal file
@@ -0,0 +1,77 @@
|
||||
---
|
||||
title: Les fichiers blocs
|
||||
---
|
||||
|
||||
### Lecture :
|
||||
|
||||
```c
|
||||
// Déclaration
|
||||
int *fread(void *pointeur_Tampon,size-t taille,size_t nombre,FILE *point_fic);
|
||||
```
|
||||
|
||||
La fonction fread lit un bloc de données de taille x nombre octets et le range à l'emplacement référencé par pointeur_tampon. Elle retourne le nombre d'octets lus. Si la valeur est inférieur à
|
||||
nombre alors erreur.
|
||||
|
||||
```c
|
||||
struct client k[5];
|
||||
...
|
||||
fread(k, sizeof(struct client), 5, fp);
|
||||
```
|
||||
|
||||
### Ecriture :
|
||||
|
||||
```c
|
||||
// Déclaration
|
||||
int * fwrite(void *pointeur_Tampon,size-t taille,size_t nombre,FILE *point_fic);
|
||||
```
|
||||
|
||||
La fonction fwrite écrit un bloc de données de taille x nombre octets rangé à l'emplacement référencé par pointeur_tampon dans
|
||||
|
||||
le fichier pointé par point_fic. Elle retourne le nombre d'objets complétement écrits. Si la valeur est inférieur à nombre alors erreur.
|
||||
|
||||
### Positionnement dans un fichier:
|
||||
|
||||
Jusqu'à présent on a supposé un accès séquentiel aux données
|
||||
|
||||
Si on veut accéder à la valeur C5 : il faut un accès direct aux données donc positionner le pointeur de fichier au bon endroit
|
||||
|
||||
Positionnement dans un fichier:
|
||||
|
||||
```c
|
||||
// Déclaration
|
||||
int fseek(FILE *pointeur_fichier, long offset, int base);
|
||||
```
|
||||
|
||||
La fonction fseek permet de placer le pointeur de position sur un octet quelconque d'un fichier. Le paramètre offset impose le nombre d'octets dont il faut décaler le pointeur relativement à la base. Si l'offset est négatif le déplacement s'effectue vers le début du fichier. base précise l'origine du déplacement dans le fichier.
|
||||
|
||||
La fonction retourne 0 si pas d'erreur sinon un nombre non nul.
|
||||
|
||||
```c
|
||||
fseek(fp,0,0); // on se place au début du fichier
|
||||
fseek(fp,0,SEEK_END); // on se place à la fin du fichier
|
||||
fseek(fp,-3,SEEK_END); // on se place 3 octets avant la fin du fichier
|
||||
```
|
||||
|
||||
### Lecture de la position du pointeur dans un fichier
|
||||
|
||||
```c
|
||||
// Déclaration
|
||||
long ftell(FILE *pointeur_fichier);
|
||||
```
|
||||
|
||||
La fonction ftell permet de connaitre l'octet du fichier sur lequel pointe le pointeur de fichier.
|
||||
|
||||
La fonction retourne dans un entier long la position courante dans le fichier à partir du début du fichier. Retourne -1 en cas d'erreur.
|
||||
|
||||
```c
|
||||
long position ;
|
||||
position = ftell(fp);
|
||||
```
|
||||
|
||||
Exemple recherche de la taille d'un fichier (on considère le fichier ouvert)
|
||||
|
||||
```c
|
||||
long taille;
|
||||
fseek(fp, 0, SEEK_END); // on se place en fin de fichier
|
||||
taille = ftell(fp); // lecture de la position dans le fichier
|
||||
```
|
||||
76
boucles.md
Normal file
76
boucles.md
Normal file
@@ -0,0 +1,76 @@
|
||||
---
|
||||
title: Instructions conditionnelles
|
||||
---
|
||||
|
||||
Les instructions de boucles en C permettent de répéter l'exécution d'un bloc de code tant qu'une condition donnée est vraie. Elles sont particulièrement utiles lorsque vous avez besoin d'exécuter plusieurs fois le même code ou un ensemble d'instructions.
|
||||
|
||||
## while
|
||||
|
||||
L'instruction while exécute un bloc de code tant qu'une condition est vraie. La condition est vérifiée avant chaque itération, donc si elle est fausse au départ, le bloc de code n'est jamais exécuté.
|
||||
|
||||
```c
|
||||
int i = 0;
|
||||
while (i < 5) {
|
||||
printf("%d\n", i);
|
||||
i++;
|
||||
}
|
||||
```
|
||||
|
||||
## do-while
|
||||
|
||||
L'instruction do-while est similaire à while, mais la différence principale est que la condition est vérifiée **après** l'exécution du bloc de code. Cela garantit que le bloc de code est exécuté **au moins une fois**, même si la condition est fausse dès le début.
|
||||
|
||||
```c
|
||||
int i = 0;
|
||||
do {
|
||||
printf("%d\n", i);
|
||||
i++;
|
||||
} while (i < 5);
|
||||
```
|
||||
|
||||
## for
|
||||
|
||||
L'instruction for est souvent utilisée lorsque le nombre d'itérations est connu à l'avance. Elle permet d'initialiser une variable, de définir une condition, et d'incrémenter ou de décrémenter la variable dans une seule ligne de code.
|
||||
|
||||
```c
|
||||
for (initialisation; condition; opération) {
|
||||
// Code à exécuter tant que la condition est vraie
|
||||
}
|
||||
```
|
||||
|
||||
## Boucle infinie
|
||||
|
||||
Une boucle infinie est une boucle qui ne se termine jamais parce que sa condition est toujours vraie. Les boucles infinies peuvent être utiles dans certains contextes, comme les serveurs ou les systèmes embarqués qui doivent toujours fonctionner jusqu'à ce qu'une interruption externe survienne.
|
||||
|
||||
```c
|
||||
while (1) {
|
||||
// Cette boucle ne se terminera jamais
|
||||
}
|
||||
```
|
||||
|
||||
ou
|
||||
|
||||
```c
|
||||
for (;;) {
|
||||
// Cette boucle ne se terminera jamais
|
||||
}
|
||||
```
|
||||
|
||||
## Sortir des boucles
|
||||
|
||||
Il est possible de contrôler le comportement des boucles avec les [instructions de débranchement](debranchement) :
|
||||
|
||||
- break : Pour sortir immédiatement de la boucle.
|
||||
- continue : Pour sauter à l'itération suivante sans exécuter le reste du bloc de code.
|
||||
|
||||
## Boucles imbriquées
|
||||
|
||||
Il est possible d'imbriquer des boucles, c'est-à-dire de placer une boucle à l'intérieur d'une autre. Cela est souvent utilisé pour parcourir des structures de données en plusieurs dimensions comme des tableaux.
|
||||
|
||||
```c
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
printf("i = %d, j = %d\n", i, j);
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Chaines de caracteres
|
||||
---
|
||||
# Chaines de caracteres
|
||||
|
||||
En langage C le tableau se comporte comme un pointeur aux différences suivantes :
|
||||
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Opérateurs de comparaison
|
||||
---
|
||||
# Opérateurs de comparaison
|
||||
|
||||
### Égalité
|
||||
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Compilation
|
||||
---
|
||||
# Compilation
|
||||
|
||||
**Prétraitement** : Le traitement par le préprocesseur : le fichier source est analysé par le préprocesseur qui effectue des transformations textuelles dans le fichier source. Substitution de chaine de caractère, des constantes, prise en compte des directives de compilation, inclusion des autres fichiers sources...
|
||||
|
||||
|
||||
65
conditions.md
Normal file
65
conditions.md
Normal file
@@ -0,0 +1,65 @@
|
||||
# Instructions conditionnelles
|
||||
|
||||
> Les instructions conditionnelles en C permettent d'exécuter des blocs de code spécifiques en fonction de conditions. Elles permettent de prendre des décisions logiques dans un programme.
|
||||
|
||||
## if
|
||||
|
||||
L'instruction _if_ permet d'exécuter un bloc de code uniquement si une condition est vraie.
|
||||
|
||||
```c
|
||||
int a = 10;
|
||||
|
||||
if (a > 5) {
|
||||
printf("a est supérieur à 5.\n");
|
||||
}
|
||||
```
|
||||
|
||||
## else
|
||||
|
||||
L'instruction _else_ permet de définir un bloc de code qui sera exécuté si la condition du if est fausse.
|
||||
|
||||
```c
|
||||
int a = 3;
|
||||
|
||||
if (a > 5) {
|
||||
printf("a est supérieur à 5.\n");
|
||||
} else {
|
||||
printf("a est inférieur ou égal à 5.\n");
|
||||
}
|
||||
```
|
||||
|
||||
## else if
|
||||
|
||||
L'instruction _else if_ permet de tester une nouvelle condition si la première _if_ est fausse.
|
||||
|
||||
```c
|
||||
int a = 8;
|
||||
|
||||
if (a > 10) {
|
||||
printf("a est supérieur à 10.\n");
|
||||
} else if (a > 5) {
|
||||
printf("a est supérieur à 5 mais inférieur ou égal à 10.\n");
|
||||
} else {
|
||||
printf("a est inférieur ou égal à 5.\n");
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
Voir les [opérateurs de comparaison](../opérateurs/comparaison) et les [opérateurs logiques](../opérateurs/logique).
|
||||
|
||||
## switch
|
||||
|
||||
L'instruction switch est une alternative aux multiples else if. Elle compare une variable avec différentes valeurs possibles et exécute le code correspondant.
|
||||
|
||||
```c
|
||||
switch (variable) {
|
||||
case valeur1:
|
||||
// Code si variable == valeur1
|
||||
break;
|
||||
case valeur2:
|
||||
// Code si variable == valeur2
|
||||
break;
|
||||
default:
|
||||
// Code si aucune correspondance
|
||||
}
|
||||
```
|
||||
53
debranchement.md
Normal file
53
debranchement.md
Normal file
@@ -0,0 +1,53 @@
|
||||
# Instructions de débranchement
|
||||
|
||||
## break
|
||||
|
||||
L'instruction break permet de quitter immédiatement une boucle (for, while, do-while) ou une structure switch. Dès que le programme rencontre un break, il sort du bloc de code en cours.
|
||||
|
||||
```c
|
||||
for (int i = 0; i < 10; i++) {
|
||||
if (i == 5) {
|
||||
break; // Sort de la boucle dès que i vaut 5
|
||||
}
|
||||
printf("%d\n", i);
|
||||
}
|
||||
```
|
||||
|
||||
Le break permet ici de sortir du bloc switch après avoir exécuté le code correspondant à la valeur testée
|
||||
|
||||
## continue
|
||||
|
||||
L'instruction continue permet de sauter à l'itération suivante d'une boucle, sans terminer l'exécution du bloc de code courant.
|
||||
|
||||
```c
|
||||
for (int i = 0; i < 10; i++) {
|
||||
if (i == 5) {
|
||||
continue; // Saute l'itération lorsque i vaut 5
|
||||
}
|
||||
printf("%d\n", i);
|
||||
}
|
||||
```
|
||||
|
||||
## return
|
||||
|
||||
L'instruction return permet de quitter une fonction et de retourner une valeur (si la fonction n'est pas de type void). Elle interrompt l'exécution de la fonction en cours et retourne éventuellement une valeur à la fonction appelante.
|
||||
|
||||
## goto
|
||||
|
||||
L'instruction goto permet de sauter directement à une autre partie du programme marquée par une étiquette (label). Son utilisation est généralement déconseillée car elle rend le code difficile à suivre et à maintenir. Cependant, dans certains cas spécifiques, elle peut être utile pour sortir de plusieurs niveaux d'imbrication ou dans la gestion de sortie d'erreur.
|
||||
|
||||
Une étiquette se définie avec un nom suivi d'un caractère :. Normalement, une étiquette est placée en colonne 0 du fichier de texte.
|
||||
|
||||
Pour les autres instructions, les choses sont contrôlée par le compilateur, mais ce qui n'est pas le cas avec goto. Effectivement, si l'étiquette de destination n'est pas placée dans le même bloc que l'instruction goto, alors vous pouvez désynchroniser la pile d'exécution et donc aboutir à un crash de l'application. C'est pour cette raison qu'il est très fortement conseillé de ne pas utiliser l'instruction goto au profit des autres instructions.
|
||||
|
||||
```c
|
||||
int a = 10;
|
||||
if (a > 5) {
|
||||
goto fin; // Saute directement à l'étiquette "fin"
|
||||
}
|
||||
|
||||
printf("Ce message ne sera pas affiché.\n");
|
||||
|
||||
fin:
|
||||
printf("Fin du programme.\n");
|
||||
```
|
||||
44
histoire.md
Normal file
44
histoire.md
Normal file
@@ -0,0 +1,44 @@
|
||||
# Histoire du langage C
|
||||
|
||||
Le langage C a été créé au début des années 1970 par Dennis Ritchie et Ken Thompson aux laboratoires Bell (AT&T) pour réécrire le système d'exploitation UNIX, qui était initialement en langage d'assemblage.
|
||||
|
||||
### Langage C original
|
||||
|
||||
La première version du C sort en 1972. Elle était étroitement liée au développement d'UNIX. Son adoption rapide a fait de C le langage privilégié pour développer des systèmes d’exploitation et des logiciels nécessitant des performances et une gestion fine de la mémoire.
|
||||
|
||||
### K & R C
|
||||
|
||||
En 1978, Brian Kernighan et Dennis Ritchie publient le livre de référence "The C Programming Language". C'est la première formalisation du langage C. Ce standard a dominé jusqu'au milieu des années 1980. Il introduisait des concepts tels que les types de données, les structures.
|
||||
|
||||
### ANSI C ou C89
|
||||
|
||||
Dans les années 1980, le besoin d'un standard plus formel s'est fait sentir, car plusieurs versions divergentes de C étaient utilisées. En 1989, l'ANSI (American National Standards Institute) publie le standard ANSI C ou C89. Cette version standardise plusieurs éléments du langage.
|
||||
|
||||
### C90
|
||||
|
||||
Le standard C89 a été adopté par l'ISO (International Organization for Standardization) en 1990, sous le nom de C90. Les deux versions, ANSI C et C90, sont donc pratiquement identiques.
|
||||
|
||||
### C99
|
||||
|
||||
En 1999, une révision majeure du langage a été publiée sous le nom de C99. Cette version introduit de nombreuses améliorations, dont :
|
||||
|
||||
- La prise en charge des variables déclarées à n’importe quel endroit du code, pas seulement au début d'un bloc.
|
||||
- Les tableaux dynamiques et les types entiers plus précis.
|
||||
- Les boucles for avec des variables locales.
|
||||
- De nouvelles fonctions mathématiques et des améliorations sur la précision des nombres flottants.
|
||||
|
||||
### C11
|
||||
|
||||
En 2011, le standard C11 apporte des améliorations pour le rendre plus moderne tout en conservant sa simplicité. Il introduit :
|
||||
|
||||
- Le support des threads avec une bibliothèque standard pour le multi-threading.
|
||||
- La gestion des alignements mémoire.
|
||||
- De nouvelles fonctionnalités de sécurité
|
||||
|
||||
### C18
|
||||
|
||||
En 2018, C18 qui est une version mineure qui clarifie et corrige certaines ambiguïtés du C11 sans ajouter de nouvelles fonctionnalités significatives. Elle se concentre essentiellement sur la correction de bugs et des révisions formelles du langage.
|
||||
|
||||
### C2x (à venir)
|
||||
|
||||
La prochaine version majeure du langage est en cours de développement sous le nom provisoire C2x. Elle vise à apporter des améliorations sur la sécurité, la simplicité et la compatibilité avec les versions précédentes.
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Les opérateurs logiques
|
||||
---
|
||||
# Les opérateurs logiques
|
||||
|
||||
Ces opérateurs permetent de vérifier si plusieurs conditions sont vraies. Les valeurs renvoyés sont 0 pour faux et 1 pour vrai.
|
||||
|
||||
|
||||
45
math.md
Normal file
45
math.md
Normal file
@@ -0,0 +1,45 @@
|
||||
---
|
||||
title: Fonctions mathématiques
|
||||
---
|
||||
|
||||
### Arrondi
|
||||
|
||||
3 déclinaisons de la fonction ***round*** en fonction du type de données utilisé pour le paramètre et la valeur de retour : double, float ou long double.
|
||||
|
||||
```c
|
||||
double round(double)fichie;
|
||||
float roundf(float);
|
||||
long double roundl(long double);
|
||||
```
|
||||
|
||||
Ces trois fonctions renvoient l'arrondi entier au plus proche de la valeur spécifiée en paramètre.
|
||||
|
||||
### Ceil : Arrondi supérieur
|
||||
|
||||
3 déclinaisons de la fonction ***ceil*** en fonction du type de données utilisé pour le paramètre et la valeur de retour : double, float ou long double.
|
||||
|
||||
```c
|
||||
double ceil(double);
|
||||
float ceilf(float);
|
||||
long double ceill(long double);
|
||||
```
|
||||
|
||||
Ces trois fonctions retournent l'arrondi entier supérieur (en anglais ceil signifiant plafond) de la valeur spécifiée en paramètre.
|
||||
|
||||
>Attention aux valeurs négatives ! La valeur plafond de -5.82 est -5 car -5 est supérieur à -5.42.
|
||||
{class=warning}
|
||||
|
||||
### Floor : Arrondi inférieur
|
||||
|
||||
3 déclinaisons de la fonction ***floor*** en fonction du type de données utilisé pour le paramètre et la valeur de retour : double, float ou long double.
|
||||
|
||||
```c
|
||||
double floor(double);
|
||||
float floorf(float);
|
||||
long double floorl(long double);
|
||||
```
|
||||
|
||||
Ces trois fonctions retournent l'arrondi entier inférieur (en anglais floor signifiant plancher) de la valeur spécifiée en paramètre.
|
||||
|
||||
>Attention aux valeurs négatives ! La valeur plancher de -5.21 est -6 car -6 est inférieure à -5.21.
|
||||
{class=warning}
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Operateurs
|
||||
---
|
||||
# Opérateurs
|
||||
|
||||
>Un **opérateur** est un symbole qui indique au programme qu'il faut effectuer des opérations mathématiques ou logiques spécifiques.
|
||||
{class=definition}
|
||||
|
||||
38
pointeur.md
Normal file
38
pointeur.md
Normal file
@@ -0,0 +1,38 @@
|
||||
---
|
||||
title: Les pointeurs
|
||||
---
|
||||
|
||||
Les pointeurs avec une fonction.
|
||||
Solution plus efficace : on passe en paramètre deux pointeurs.
|
||||
|
||||
```c
|
||||
void carre(int *A, int *Res)
|
||||
{
|
||||
*Res = (*A) * (*A); // équivalent à : *A**A ou * A * * A
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int *X,*Y;
|
||||
X = (int*)malloc(1*sizeof(int));
|
||||
Y = (int*)malloc(1*sizeof(int));
|
||||
*X = 2;
|
||||
carre(X,Y);
|
||||
free(X);
|
||||
free(Y); // on libère la mémoire allouées aux pointeurs
|
||||
```
|
||||
|
||||
Pointeur de pointeur:
|
||||
Un pointeur de pointeur est un pointeur pointant sur un pointeur, pointant sur
|
||||
un pointeur, . . . , pointant sur une variable. Cela permet de gérer des
|
||||
tableaux sans aucune dimension prédéfinie.
|
||||
Exemple : tableau de chaine de caractère
|
||||
char *Tab[] = { "UN" , "DEUX", "TROIS", "QUATRE", "CINQ"} ;
|
||||
char **p // déclaration d'un pointeur de pointeur
|
||||
p = &Tab[0] // p pointe sur le début du tableau de chaines de caractères
|
||||
// * chaine ** caractère
|
||||
*p pointe sur "UN"
|
||||
*(p+1) pointe sur "DEUX"
|
||||
**p retourne sur 'U' de "UN"
|
||||
*(*p + 1) retourne sur 'N' de "UN"
|
||||
*( *(p+1) + 2) retourne sur 'U' de "DEUX"
|
||||
@@ -1,6 +1,4 @@
|
||||
---
|
||||
title: Pointeurs
|
||||
---
|
||||
# Pointeurs
|
||||
|
||||
> Un pointeur est une variable de type **référence**, dont la valeur est l'**adresse** d'une autre variable appelée cible.
|
||||
|
||||
|
||||
267
string.md
Normal file
267
string.md
Normal file
@@ -0,0 +1,267 @@
|
||||
---
|
||||
title: chaîne de caractères
|
||||
---
|
||||
|
||||
Les chaînes de caractères en C sont des séquences d'octets terminées par un caractère spécial appelé le caractère nul (\0). Contrairement à d'autres langages de programmation qui ont des types dédiés pour les chaînes (comme string en Python ou Java), en C, les chaînes de caractères sont simplement des **tableaux de caractères** (type char).
|
||||
|
||||
Les tableaux étant aussi des pointeurs, les chaînes de caractères sont des pointeurs.
|
||||
|
||||
### Tableau de caractères
|
||||
|
||||
Une chaîne de caractères est déclarée comme un tableau de type char, où chaque élément représente un caractère, et la dernière position du tableau contient le caractère nul (\0).
|
||||
|
||||
```c
|
||||
char nom[10] = "Alice"; // Déclare un tableau de 10 caractères
|
||||
```
|
||||
#### Accès aux caractères
|
||||
|
||||
Les caractères individuels d'une chaîne peuvent être accédés via leur index, comme pour tout tableau :
|
||||
|
||||
```c
|
||||
printf("%c", nom[0]); // Affiche 'A'
|
||||
```
|
||||
|
||||
### Fonctions de manipulation
|
||||
|
||||
La bibliothèque standard de C (<string.h>) fournit plusieurs fonctions pour manipuler les chaînes de caractères, telles que :
|
||||
|
||||
- strlen() : Calculer la longueur de la chaîne (sans compter le caractère nul).
|
||||
- strcpy() : Copier une chaîne dans une autre (=).
|
||||
- strcmp() : Comparer deux chaînes (==).
|
||||
- strcat() : Concaténer deux chaînes (+).
|
||||
|
||||
> NE JAMAIS faire d'opération sur les chaines de caractère = + ==. Il faut utiliser les fonctions prévues pour la manipulation des chaînes.
|
||||
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
int main() {
|
||||
char chaine1[20] = "Bonjour";
|
||||
char chaine2[20] = " le monde";
|
||||
strcat(chaine1, chaine2); // Concatène chaine2 à la fin de chaine1
|
||||
printf("%s\n", chaine1); // Affiche "Bonjour le monde"
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Mémoire : Il est important de noter que les chaînes de caractères en C **ne sont pas redimensionnables dynamiquement** (comme les chaînes en Python). Vous devez allouer une taille suffisante lors de la déclaration ou utiliser l'allocation dynamique avec malloc pour gérer les chaînes plus grandes.
|
||||
|
||||
En résumé, bien que les chaînes de caractères en C soient simples, elles nécessitent une gestion **explicite** de la mémoire et une **compréhension approfondie** des tableaux et des pointeurs.
|
||||
|
||||
## Saisie de chaine de caractères
|
||||
|
||||
La fonction ***scanf*** est prévue pour faire de la saisie de valeurs formatée. C’est à dire que l’on précise dans quel format doivent être saisies les variables.
|
||||
|
||||
```c
|
||||
# include < stdio .h >
|
||||
int main (int argc , char *argv[])
|
||||
{
|
||||
int nombre ,* pNombre ;
|
||||
pNombre = (int *) malloc ( sizeof (int) );
|
||||
|
||||
scanf ("%d", &nombre);
|
||||
scanf ("%d", pNombre);
|
||||
|
||||
printf (" Nombre 1 : %d\ nNombre 2 : %d",nombre ,* pNombre ) ;
|
||||
}
|
||||
```
|
||||
|
||||
Pour que la fonction scanf puisse s’occuper de la saisie des chaînes de caractères, il faut utiliser le format %s.
|
||||
|
||||
Une chaîne de caractères étant définie comme un pointeur, on ne met pas le & devant la variable à saisir.
|
||||
|
||||
```c
|
||||
# include < stdio .h >
|
||||
int main (int argc , char *argv[])
|
||||
{
|
||||
char texte[20];
|
||||
scanf ("%s",texte ) ;
|
||||
printf (" Texte saisi : %s",texte ) ;
|
||||
}
|
||||
```
|
||||
|
||||
A la fin de la saisie, le caractère ’\0’ est ajouté automatiquement.
|
||||
|
||||
|
||||
> ATTENTION : scanf ne permet pas la saisie d'une chaîne comportant des espaces.
|
||||
⇒ Les caractères saisis à partir de l’espace ne sont pas pris en compte mais restent rangés dans le tampon
|
||||
d’entrée.
|
||||
{class=warning}
|
||||
|
||||
|
||||
### Le tampon d’entrée ?
|
||||
|
||||
Lorsque vous tapez au clavier, chaque caractère est écrit dans un tampon (buffer en anglais). C’est dans ce tampon que scanf ira lire ;
|
||||
|
||||
Tout ce qui n’est pas lu sera lu au prochain appel d’une fonction de lecture. Ainsi, si le tampon est plein, le scanf prend le contenu comme ci cela venait d’une saisie opérateur ;
|
||||
|
||||
Le buffer d’entrée en langage C se nomme stdin.
|
||||
|
||||
Le tampon est géré par le système d’exploitation
|
||||
La mémoire est géré par le programme. Elle ne
|
||||
contient que ce qui est lu par le scanf scanf va lire le tampon et placer ce qu’elle a lu en mémoire.
|
||||
|
||||
#### Utilisation particulière
|
||||
|
||||
On utilise un format particulier de la fonction scanf
|
||||
|
||||
On peut faire suivre le symbole % d’une liste de caractères entre crochets à la place du s. Celle-ci peut être une liste de caractères interdits.
|
||||
|
||||
Ainsi, scanf lit alors jusqu’à ce qu’elle tombe sur un caractère interdit. Ce caractère est principalement le retour chariot.
|
||||
|
||||
```c
|
||||
# include < stdio .h >
|
||||
|
||||
int main (int argc , char *argv[])
|
||||
{
|
||||
char nom[20];
|
||||
scanf (" %[ˆ\n]", nom) ; // lecture des caractères ( espace compris ) jusqu ’au retour chariot
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
On peut aussi ajouter une plage de caractères autorisés.
|
||||
|
||||
```c
|
||||
char formule [];
|
||||
scanf (" %[[0123456789/* -+=() ]ˆ\n]",formule ) ; // pour saisir des formules
|
||||
|
||||
char voyelles [];
|
||||
scanf ("%[[ aeiouy ]ˆ\n]",voyelles ) ; // pour saisir uniquement des voyelles
|
||||
|
||||
char nom [];
|
||||
scanf ("%[[a-z]ˆ\n]",voyelles ) ; // les lettres de l’alphabet en minuscule
|
||||
|
||||
char nom [];
|
||||
scanf ("%[[A-Z]ˆ\n]",voyelles ) ; // les lettres de l’alphabet en majuscule
|
||||
|
||||
int main (int argc , char *argv[])
|
||||
```
|
||||
|
||||
Dans ce cas, la saisie s’arrête avec le retour chariot mais la phrase mise en mémoire par le scanf sera stoppée au premier caractère en dehors de la plage.
|
||||
|
||||
|
||||
|
||||
## Manipulation
|
||||
|
||||
Pour manipuler les chaînes de caractères et faire les opérations courantes de traitement, il existe des fonctions prédéfinies qui nécessitent des inclusions de bibliothèques.
|
||||
Les principales fonctions standards sont les suivantes :
|
||||
|
||||
string.h : fonctions pour calculer la longueur des chaînes, gérer la concaténation, la copie, la recherche et la comparaison ;
|
||||
|
||||
stdlib.h : fonctions pour gérer la conversion de type numérique en chaîne de caractères et vice-versa.
|
||||
|
||||
#### Longueur d’une chaîne de caractères
|
||||
|
||||
size t strlen(const char *str);
|
||||
|
||||
Cette fonction va nous permettre de récupérer la taille de n’importe quelle chaîne de caractères sans compter le ’\0’ final.
|
||||
La fonction retourne un size t (entier long non signé) et prend en paramètre une chaîne de caractères.
|
||||
|
||||
```c
|
||||
char chaine[] = "Combien de pièces à fabriquer ?";
|
||||
int longueur ;
|
||||
longueur = strlen (chaine) ;
|
||||
printf (" Taille de la chaîne = %d\n", longueur ) ;
|
||||
```
|
||||
|
||||
#### Copie de chaînes de caractères
|
||||
|
||||
char *strcpy(char *dest, const char *src);
|
||||
|
||||
Cette fonction copie une chaîne dans une autre chaîne et renvoie un pointeur sur cette dernière. Elle copie tous les caractères, y compris le ’\0’.
|
||||
Le problème est qu’elle ne fait aucune vérification sur les longueurs des chaînes source et destination.
|
||||
|
||||
```c
|
||||
char chaineSrc [20] , chaineDest [20];
|
||||
scanf (" %[ˆ\ n]",chaineSrc ) ;
|
||||
chaineDest = strcpy ( chaineDest , chaineSrc ) ;
|
||||
printf (" Chaîne 1 : %s - Chaîne 2 : %s\n",chaineSrc , chaineDest ) ;
|
||||
```
|
||||
|
||||
#### Comparaison de chaînes de caractères
|
||||
|
||||
int strcmp(const char *chaine1, const char *chaine2);
|
||||
|
||||
Cette fonction permet de comparer deux chaînes de caractères, lettre par lettre.
|
||||
Elle renvoie un entier qui sera :
|
||||
|
||||
- positif si chaine1 est supérieure à chaine2 (au sens de lexicographique) ;
|
||||
- négatif si chaine1 est inférieure à chaine2 ;
|
||||
- nul si les chaînes sont identiques.
|
||||
|
||||
```c
|
||||
char chaine1 [] = " Bonjour ";
|
||||
char chaine2 [] = " Bonsoir ";
|
||||
if ( strcmp ( chaine1 , chaine2 ) == 0)
|
||||
{
|
||||
printf ("Les chaines sont identiques .") ;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf ("Les chaines sont differentes .") ;
|
||||
}
|
||||
```
|
||||
|
||||
#### Concaténation de chaînes de caractères
|
||||
|
||||
char *strcat(char *dest, const char *src);
|
||||
|
||||
Cette fonction sert à concaténer deux chaînes, c’est à dire simplement coller deux chaînes l’une à la suite de l’autre. Elle renvoie un pointeur sur la nouvelle chaîne ainsi construite.
|
||||
|
||||
Pour éviter les problèmes, il faut s’assurer que la chaîne destination soit suffisamment grande (taille de dest + taille de src).
|
||||
|
||||
```c
|
||||
char dest [50] = "bon ";
|
||||
const char *src = " jour ";
|
||||
|
||||
printf (" Avant : %s\n", dest ) ;
|
||||
dest = strcat (dest , src ) ;
|
||||
printf (" Apres : %s\n", dest ) ;
|
||||
```
|
||||
|
||||
#### Recherche dans les chaînes de caractères
|
||||
|
||||
Ces fonctions renvoient l’adresse de l’information recherchée en cas de succès, sinon le pointeur NULL.
|
||||
|
||||
- char *strchr(const char *s, int c); : elle permet de rechercher un caractère dans une chaîne. Elle renvoie un pointeur sur ce caractère. Si le caractère est présent plusieurs fois, elle renvoie un pointeur sur la première occurrence ;
|
||||
- char *strrchr(const char *s, int c); : la même que précédemment mais retourne un pointeur sur la dernière occurrence ;
|
||||
- char *strstr(const char *s1, const char *s2); : elle permet de savoir si s2 est inclue dans s1. Si elle trouve elle renvoie un pointeur sur la position dans s1. Son rˆole est donc de rechercher des sous-chaînes.
|
||||
|
||||
#### Conversion de chaîne de caractères en valeur numérique
|
||||
|
||||
- int atoi(const char *s); : conversion d’une chaîne de caractères en entier ;
|
||||
- long atol(const char *s); : conversion d’une chaîne de caractères en entier long ;
|
||||
- double atof(const char *s); : conversion d’une chaîne de caractère en double.
|
||||
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main (int argc , char *argv[])
|
||||
{
|
||||
char chaine[20];
|
||||
int conv ;
|
||||
printf ("\n\n\ nSaisir un entier : ") ;
|
||||
scanf (" %[[0123456789]ˆ\ n]",chaine ) ;
|
||||
conv = atoi ( chaine ) ;
|
||||
printf (" chiffre saisie : %d\n\n\n",conv ) ;
|
||||
}
|
||||
```
|
||||
|
||||
#### Conversion de valeur numérique en chaîne de caractères
|
||||
|
||||
int sprintf(char *str, const char *format, ...);
|
||||
|
||||
Cette fonction crée une chaîne de caractères qui sera stockée dans la variable str. La constitution de cette chaîne reprend le fonctionnement de printf, c’est à dire une chaîne formatée avec insertion des valeurs numériques.
|
||||
|
||||
```c
|
||||
int main (int argc , char *argv[])
|
||||
{
|
||||
char chaine[20];
|
||||
int chiffre = 145;
|
||||
sprintf (chaine ,"%d",chiffre ) ;
|
||||
sprintf (chaine ," repeat %d times ",chiffre ) ;
|
||||
}
|
||||
```
|
||||
@@ -1,9 +1,6 @@
|
||||
---
|
||||
title: Structure
|
||||
---
|
||||
# Structure
|
||||
|
||||
>Un structure permet de regrouper plusieurs types de données dans un seul bloc logique pour les associer à une super variable.
|
||||
{class=definition}
|
||||
> Une structure permet de regrouper plusieurs types de données dans un seul bloc logique pour les associer à une super variable.
|
||||
|
||||
Exemple de variables indépendantes representant des conditions météorologiques.
|
||||
|
||||
|
||||
@@ -1,3 +1 @@
|
||||
---
|
||||
title: Tableaux
|
||||
---
|
||||
# Tableaux
|
||||
|
||||
@@ -1,11 +1,8 @@
|
||||
---
|
||||
title: Variables
|
||||
---
|
||||
# Variables
|
||||
|
||||
> Une variable est un élément qui associe un **identifiant** à une **valeur**.
|
||||
{class=definition}
|
||||
|
||||
### Caractéristiques
|
||||
## Caractéristiques
|
||||
|
||||
Une variable possède plusieurs caractéristiques ou propriétés.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user