MindMap Gallery Langage C
La carte mentale du langage C met en évidence ses éléments fondamentaux. Les types de données sont à la base du langage C et définissent le type de données qu'une variable peut stocker. La structure cyclique permet au Programme d'exécuter des blocs de code à plusieurs reprises, à condition que certaines conditions soient remplies, ce qui augmente considérablement l'efficacité de la programmation. Un programme C canonique se compose généralement de plusieurs sous - programmes ou fonctions qui sont chacun responsables de tâches spécifiques, permettant la décomposition logique et la conception modulaire de programmes complexes par des appels et des combinaisons.
Edited at 2024-09-25 07:43:22Langage C
Types de données
En C, les types de données fondamentaux définissent le type de valeur qu'une variable peut contenir.
Types de données entiers
int
Description : Utilisé pour stocker des nombres entiers (positifs, négatifs, ou zéro). Taille : Généralement 4 octets (32 bits) sur la plupart des systèmes modernes.
short
Description : Utilisé pour des entiers plus petits. Taille : Généralement 2 octets (16 bits).
long
Description : Utilisé pour des entiers plus grands. Taille : Généralement 4 octets (32 bits) ou 8 octets (64 bits), selon l'architecture.
unsigned
Description : Utilisé pour des entiers non signés (uniquement positifs).
Types de données à virgule flottante
float
Description : Utilisé pour stocker des nombres à virgule flottante (décimaux). Taille : Généralement 4 octets (32 bits).
double
Description : Comme float, mais avec une précision plus élevée. Taille : Généralement 8 octets (64 bits).
long double
Description : Utilisé pour des nombres à virgule flottante avec une précision encore plus grande. Taille : Généralement 8 octets ou plus, selon l'implémentation.
Boucles
En langage C, les boucles permettent de répéter l'exécution d'un bloc de code tant qu'une condition est remplie.
while
while (condition) { // Code à exécuter tant que la condition est vraie }
do + while (la condition est vérifier après au moins un passage)
do { // Code à exécuter } while (condition);
For
for (initialisation; condition; incrémentation) { // Code à exécuter }
Exemple: for (int i = 0; i < 10; i++) { printf("%d\n", i); }
Programme
Le programme répond au cahier des charges. Il est généralement décomposé en plusieurs sous-programmes.
Sous-Programmes/fonctions
En C, un sous-programme (appelé aussi fonction) est un bloc de code réutilisable qui effectue une tâche spécifique. Cela permet de structurer le code, de réduire la répétition, et de faciliter la maintenance.
Une fonction en C est composée de : 1. Type de retour : Le type de la valeur que la fonction renvoie (ex. int, void si elle ne renvoie rien). 2. Nom de la fonction : Un identifiant unique. 3. Paramètres : Les variables que la fonction reçoit (facultatif). 4. Corps de la fonction : Le bloc de code qui s'exécute lorsque la fonction est appelée.
Exemple de fonction
Fonctions avec plusieurs types de retour
Fonction void (qui ne renvoie rien) : void afficher_message() { printf("Bonjour, monde !\n"); }
Fonction qui retourne un réel (float) : float moyenne(float a, float b) { return (a + b) / 2; }
return
En C, l'instruction return permet de renvoyer une valeur depuis une fonction vers l'appelant et termine immédiatement l'exécution de la fonction.
Les sous-programmes permettent de : Réduire la duplication de code. Améliorer la lisibilité et la structure du programme. Réutiliser des blocs de code. Rendre le code plus facile à maintenir et à déboguer.
Pointeurs
En C, un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable. Les pointeurs sont puissants car ils permettent d'accéder directement à la mémoire et de manipuler des données de manière flexible.
Déclaration : Un pointeur est déclaré avec le symbole * avant son nom.
int *p; // Déclare un pointeur vers un entier
Initialisation : Un pointeur doit être initialisé avec l'adresse d'une variable, obtenue grâce à l'opérateur & (adresse).
int a = 10; int *p = &a; // p contient l'adresse de a
Déréférencement : Pour accéder à la valeur pointée par un pointeur, on utilise l'opérateur * (déréférencement).
printf("%d\n", *p); // Affiche la valeur de a via le pointeur p
Les pointeurs sont essentiels en C pour la gestion dynamique de la mémoire, la manipulation des chaînes de caractères, la gestion des tableaux, et pour passer des paramètres par référence aux fonctions.
Opérateurs logiques
Les opérateurs logiques en langage C sont utilisés pour évaluer des expressions logiques (vrai ou faux) et combiner plusieurs conditions
ET logique (&&)
Retourne vrai si toutes les conditions sont vraies. Exemple : if (a > 0 && b > 0).
OU logique (||)
Retourne vrai si au moins une des conditions est vraie. Exemple : if (a > 0 || b > 0).
NON logique (!
Inverse la valeur d'une expression logique (vrai devient faux, et inversement). Exemple : if (!a) (vrai si a est 0).
Les opérateurs de comparaison
Les opérateurs de comparaison en langage C permettent de comparer deux valeurs et renvoient un résultat booléen (vrai ou faux).
Égalité; ==
Strictement inférieur; <
Strictement supérieur; >
Inférieur ou égal; <=
Supérieur ou égal; >=
Différent; !=
Conditions
En langage C, une condition permet d'exécuter du code en fonction de l'évaluation d'une expression.
uniquement if
if (condition) { // Code à exécuter si la condition est vraie }
If + else
if (condition) { // Code si la condition est vraie } else { // Code si la condition est fausse }
If + else if (autant qu'on veut) + else
if (condition1) { // Code si condition1 est vraie } else if (condition2) { // Code si condition2 est vraie } else { // Code si aucune condition n'est vraie }
Switch case
Les tests switch case sont utilisés pour effectuer des tests par valeur exacte (==) sur une même variable. Ils remplacent les if(a == ...){...} else if(a == ...){...} else if(a == ...){...} else{...}
switch (variable) { case valeur1: // Code si variable == valeur1 break; case valeur2: // Code si variable == valeur2 break; default: // Code si aucune valeur ne correspond break; }
Les structures
Combinaison : Les tableaux peuvent être utilisés à l'intérieur des structures, ou des tableaux de structures peuvent être créés pour manipuler plusieurs objets du même type.
Exemple Tableaux dans une structure; struct Classe { char nom[50]; int notes[5]; // Tableau de notes }; int main() { struct Classe etudiant; strcpy(etudiant.nom, "Bob"); etudiant.notes[0] = 15; etudiant.notes[1] = 12; printf("Nom : %s\n", etudiant.nom); printf("Note 1 : %d\n", etudiant.notes[0]); return 0; }
Exemple Tableau de structures; struct Personne { char nom[50]; int age; }; int main() { struct Personne personnes[3] = { {"Alice", 25}, {"Bob", 30}, {"Charlie", 22} }; // Affichage des informations du tableau de structures for (int i = 0; i < 3; i++) { printf("Nom : %s, Age : %d\n", personnes[i].nom, personnes[i].age); } return 0; }
Une structure est un type de donnée personnalisé qui regroupe différentes variables (de types potentiellement différents) sous un même nom. Elle permet de regrouper des informations connexes dans une seule entité.
struct NomStructure { type champ1; type champ2; // ... };
Exemple concret; #include <stdio.h> // Déclaration de la structure struct Personne { char nom[50]; int age; float taille; }; int main() { // Déclaration d'une variable de type Personne struct Personne personne1; // Initialisation des champs strcpy(personne1.nom, "Alice"); personne1.age = 25; personne1.taille = 1.75; // Affichage des informations printf("Nom : %s\n", personne1.nom); printf("Age : %d\n", personne1.age); printf("Taille : %.2f\n", personne1.taille); return 0; }
Les tableaux
Un tableau est une collection de données du même type, organisées en mémoire de manière contiguë. Chaque élément du tableau est accessible via un index.
type nomTableau[taille];
Exempel concret; #include <stdio.h> int main() { int nombres[5] = {1, 2, 3, 4, 5}; // Tableau de 5 entiers // Affichage des éléments du tableau for (int i = 0; i < 5; i++) { printf("Element à l'indice %d : %d\n", i, nombres[i]); } return 0; }
Tableaux à paramètres
En C, vous pouvez passer un tableau en paramètre d'une fonction pour manipuler ses éléments à l'intérieur de celle-ci. Il est important de comprendre que les tableaux sont passés par référence, c'est-à-dire que la fonction reçoit l'adresse du tableau, ce qui permet de modifier ses éléments directement.
A dévellopper
Tableaux à plusieurs dimensions
En C, les tableaux à plusieurs dimensions permettent de stocker et de manipuler des données dans une grille ou un tableau multidimensionnel. Les plus courants sont les tableaux à deux dimensions, qui ressemblent à des matrices, mais il est possible de définir des tableaux avec plus de dimensions.
1. Tableau à deux dimensions Un tableau à deux dimensions est un tableau d'éléments disposés en lignes et colonnes, comme une matrice. Il est déclaré en spécifiant deux indices : un pour les lignes et un pour les colonnes.
type nomTableau[nb_lignes][nb_colonnes];
#include <stdio.h> int main() { // Déclaration et initialisation int tableau[2][3] = { {1, 2, 3}, // Ligne 1 {4, 5, 6} // Ligne 2 }; // Affichage des éléments for (int i = 0; i < 2; i++) { // Parcours des lignes for (int j = 0; j < 3; j++) { // Parcours des colonnes printf("%d ", tableau[i][j]); } printf("\n"); // Saut de ligne après chaque ligne } return 0; }
2. Tableau à trois dimensions Un tableau à trois dimensions est une extension du tableau 2D, où chaque élément du tableau est un tableau 2D.
Voire + tard