Fiche de Révision – C & C++ (Détaillée)

1. Types de base & Variables

• Entiers : int, short, long, long long
• Réels : float, double, long double
• Caractères : char
• Booléens : bool (C++)
• Constantes : const int x = 5;
• Modificateurs : signed, unsigned, volatile, static
• Astuce : sizeof(type) donne la taille en octets

int a = 5;
float pi = 3.14;
char c = 'A';
const double e = 2.718;
bool flag = true; // C++
        

2. Opérateurs

• Arithmétiques : +, -, *, /, %
• Incrémentation : ++, --
• Comparaison : ==, !=, >, <, >=, <=
• Logiques : &&, ||, !
• Bit à bit : &, |, ^, ~, <<, >>
• Assignation : =, +=, -=, *=, /=, %=

int x = 5;
x += 2; // x = 7
if(x > 5 && x < 10) {
    printf("Ok\n");
}
        

3. Structures de contrôle

• Condition : if, else if, else, switch
• Boucles : for, while, do-while
• Break/Continue : sortir ou sauter un tour

for(int i = 0; i < 5; i++) {
    if(i == 3) continue; // saute 3
    printf("%d\n", i);
}

int j = 0;
while(j < 5) {
    printf("%d\n", j);
    j++;
}
        

4. Fonctions

• Déclaration : type nom(paramètres)
• Retour avec return
• Passage par valeur (C) ou par référence (C++)

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

void swap(int &x, int &y) { // C++ référence
    int tmp = x; x = y; y = tmp;
}

int main() {
    int a = 2, b = 3;
    printf("%d\n", somme(a,b));
}
        

5. Tableaux (Arrays)

• Tableaux statiques : int tab[5] = {1,2,3,4,5};
• Accès : tab[i], index de 0 à n-1
• Tableaux multidimensionnels :

int mat[2][3] = {
    {1,2,3},
    {4,5,6}
};
printf("%d\n", mat[1][2]); // 6
        

• Tableaux dynamiques en C :

int *dyn = (int*)malloc(5 * sizeof(int));
dyn[0] = 10;
free(dyn);

• Tableaux dynamiques en C++ :

int* arr = new int[5];
arr[0] = 10;
delete[] arr;

• Pointeurs et tableaux : tab[i] == *(tab + i)
• STL : std::vector<int> v = {1,2,3};

6. Pointeurs

• Déréférencement : *p
• Adresse : &a
• Pointeurs sur tableau : int *p = tab;
• Allocation dynamique : malloc/free (C), new/delete (C++)

int a = 10;
int *p = &a;
printf("%d\n", *p); // 10

int tab[3] = {1,2,3};
printf("%d\n", *(tab+1)); // 2
        

7. Structures et typedef

• Struct : regrouper plusieurs variables
• typedef ou using : créer un alias de type

struct Point {
    int x;
    int y;
};

typedef struct Point Point2D; // C
using Point3D = Point; // C++
        

8. C++ : Classes & Objets

• Encapsulation : public, private, protected
• Constructeur / Destructeur
• Méthodes et attributs
• Héritage : class Fille : public Mere
• Polymorphisme : virtual, override

class Personne {
private:
    int age;
public:
    std::string nom;
    Personne(std::string n, int a) : nom(n), age(a) {}
    void afficher() { std::cout << nom << " a " << age << " ans\n"; }
};

class Etudiant : public Personne {
    int note;
public:
    Etudiant(std::string n,int a,int nte) : Personne(n,a), note(nte) {}
};
        

9. STL (C++)

• Vecteurs : std::vector<int> v;
• Listes : std::list<int> l;
• Map : std::map<clé, valeur>
• Itérateurs pour parcourir

#include <vector>
#include <iostream>

std::vector<int> v = {1,2,3};
v.push_back(4);
for(auto x : v) std::cout << x << " ";
        

10. Exceptions (C++)

• try { ... } catch(exception &e) { ... }
• throw "message";

try {
    throw "Erreur!";
} catch(const char* msg) {
    std::cout << "Erreur attrapée: " << msg << "\n";
}
        

11. Astuces & Bonnes pratiques

• Initialiser toutes les variables
• Libérer la mémoire dynamique
• Utiliser const & references pour passer les gros objets
• Commentaires clairs et noms explicites
• Préférer STL (vector) aux tableaux dynamiques bruts en C++