Plan du Contenu :

• Types de Données
• Déclaration de Variables
• Entrée/Sortie
• Opérateurs
• Structures Conditionnelles
• Structures Répétitives
• Tableaux
• Chaînes de Caractères
• Fonctions
• Pointeurs
• Allocation Dynamique
• Programmation Orientée Objet (POO)
  • Classe et Objet
  • Encapsulation
  • Constructeur et Destructeur
  • Instanciation Statique et Dynamique
  • Accesseurs et Mutateurs
  • Héritage
  • Polymorphisme
  • Abstraction
  • Surcharge d'opérateurs
  • Fonctions amies (friend)
  • Membres statiques
  • Const et Références
• Bibliothèques Standard

---

Lien de Programmation en Language C

---

Lien de Programmation en Language Java

---

1. Types de Données

Type	Taille (en octets)	Description
int	4	Entier signé.
long	8 (64 bits) ou 4 (32 bits)	Entier long signé.
float	4	Nombre flottant simple précision.
double	8	Nombre flottant double précision.
long double	8, 10 ou 16	Nombre flottant avec une précision étendue.
char	1	Caractère ou petit entier signé (-128 à 127).
bool	1	Type booléen (true ou false).

---

2. Déclaration de Variables

Type nom_var = valeur;
const Type nom_const = valeur;  // Constante

---

3. Entrée/Sortie

#include <iostream>
using namespace std;

cout << "Message" << variable;  // Affichage
cin >> variable;                // Lecture

---

4. Opérateurs

• Opérateurs Arithmétiques

Opérateur	Description	Exemple
+	Addition	a + b
-	Soustraction	a - b
*	Multiplication	a * b
/	Division	a / b
%	Modulo (reste de la division)	a % b
++	Incrémentation (ajoute 1)	a++ ou ++a
--	Décrémentation (soustrait 1)	a-- ou --a

• Opérateurs de Comparaison (Relationnels)

Opérateur	Description	Exemple
==	Égal à	a == b
!=	Différent de	a != b
>	Supérieur à	a > b
<	Inférieur à	a < b
>=	Supérieur ou égal à	a >= b
<=	Inférieur ou égal à	a <= b

• Opérateurs Logiques

Opérateur	Description	Exemple
&&	ET logique	a && b
||	OU logique	a || b
!	NON logique (inverse)	!a

• Opérateurs d'Affectation

Opérateur	Description	Exemple
=	Affectation simple	a = b
+=	Ajoute et affecte	a += b (équivaut à a = a + b)
-=	Soustrait et affecte	a -= b (équivaut à a = a - b)
*=	Multiplie et affecte	a *= b (équivaut à a = a * b)
/=	Divise et affecte	a /= b (équivaut à a = a / b)
%=	Modulo et affecte	a %= b (équivaut à a = a % b)

---

5. Structures Conditionnelles

// Condition simple
if (condition) {
    instructions;
}

// Alternative
if (condition) {
    instructions;
} else {
    instructions;
}

// Imbriquée
if (condition1) {
    instructions;
} else if (condition2) {
    instructions;
} else {
    instructions;
}

// Choix multiple avec switch
switch(expression) {
    case valeur1:
        instructions;
        break;
    case valeur2:
        instructions;
        break;
    default:
        instructions;
        break;
}

---

6. Structures Répétitives

// Boucle for
for (initialisation; condition; incrément) {
    instructions;
}

// Boucle while
while (condition) {
    instructions;
}

// Boucle do...while
do {
    instructions;
} while (condition);

---

7. Tableaux

Type tableau[taille];                // Tableau 1D
Type matrice[lignes][colonnes];      // Tableau 2D

---

8. Chaînes de Caractères

char chaine[] = "texte";             // Chaîne C-style
#include <string>
string chaine = "texte";             // Chaîne C++

---

9. Fonctions

Type_retour nom_fonction(Type param1, Type param2) {
    // Code
    return valeur;
}

---

10. Pointeurs

• Déclaration d'un pointeur

type *ptr;

• Initialisation d'un pointeur

ptr = &variable;

• Accès à la valeur pointée

*ptr;

• Pointeur et tableaux

ptr = tableau;
ptr[i];   // ou *(ptr + i)

• Pointeur de pointeur

type **ptr;

• Pointeur et fonctions

void f(type *ptr);
return ptr;

---

11. Allocation Dynamique

Type *ptr = new Type;                // Allocation simple
delete ptr;                          // Libération

Type *arr = new Type[taille];        // Tableau dynamique
delete[] arr;                        // Libération

---

12. Programmation Orientée Objet (POO)

1. Classe et Objet :

• Classe : Structure qui définit un type de données en regroupant des attributs (variables) et des méthodes (fonctions).
• Objet : Instance d'une classe, représentant une entité concrète.

class NomClasse {       // Déclaration d'une classe
    int attribut;      // Attribut privé par défaut
public:
    void methode() {   // Méthode publique
        // Code
    }
};

NomClasse objet;        // Création d'un objet
objet.methode();       // Appel d'une méthode

2. Encapsulation :

Mécanisme qui regroupe les données et les méthodes dans une classe, et contrôle l'accès via public, private et protected.

• Spécificateurs d’accès :

class nomClasse {
private:  // Accessible uniquement à l’intérieur de la classe
    type attribut1;
    type attribut2;

protected:  // Accessible à la classe et aux classes dérivées (héritage)
    type attribut3;

public:  // Accessible depuis l’extérieur de la classe
    void methode1();
    void methode2();
};

3. Constructeur et Destructeur :

• Constructeur : Méthode spéciale appelée à la création d'un objet pour initialiser ses attributs.
• Destructeur : Méthode spéciale appelée à la destruction d'un objet pour libérer les ressources.

class NomClasse {
    int attribut;
public:
    // Constructeur par défaut
    NomClasse() {
        // Initialisation
    };

    // Constructeur paramétré
    NomClasse(type1 param1, type2 param2, ...) {
        // Initialisation
    };

    // Constructeur de copie
    NomClasse(const NomClasse& autre) {
        // Initialisation
    };

    // Destructeur
    ~NomClasse() {
        // Libération des ressources
    }
};

4. Instanciation Statique et Dynamique :

• Instanciation Statique : Création d’un objet dont la durée de vie est automatiquement gérée par le compilateur. L’objet est alloué sur la pile.

NomClasse objet;       // Instanciation statique
objet.methode();      // Utilisation directe

• Instanciation Dynamique : Création d’un objet à l’exécution avec le mot-clé new. L’objet est alloué sur le tas, et sa mémoire doit être libérée manuellement avec delete.

NomClasse* ptr = new NomClasse();  // Instanciation dynamique
ptr->methode();                  // Utilisation via pointeur
delete ptr;                      // Libération de la mémoire

5. Accesseurs et Mutateurs :

• Accesseurs (gets) : Un accesseur (ou getter) est une méthode publique qui retourne la valeur d’un attribut privé.

// Déclaration d'une méthode getter constante
Type getNomAttribut() const {
    return nomAttribut;
}

Remarque : Le mot-clé const garantit que la méthode ne modifie pas l’objet.

• Mutateurs (setters) : Un mutateur (ou setter) est une méthode publique qui permet de modifier un attribut privé.

// Déclaration d'une méthode setter
void setNomAttribut(Type nouvelleValeur) {
    nomAttribut = nouvelleValeur;
}

6. Héritage :

L’héritage est un mécanisme permettant à une classe (dérivée) d’hériter des attributs et méthodes d’une autre classe (de base), favorisant la réutilisation et la modularité du code.

// Classe de base
class ClasseBase {
public:
    // membres accessibles aux classes dérivées
protected:
    // membres accessibles aux classes dérivées uniquement
private:
    // membres accessibles uniquement dans ClasseBase
};

// Héritage
class ClasseDerivee : [modificateur] ClasseBase {
    // Membres spécifiques à la classe dérivée
};

• Modificateur peut être :

  • public : les membres publics/protégés restent accessibles.
  • protected : les membres publics deviennent protégés.
  • private : les membres publics/protégés deviennent privés.

• Types d’héritage :

Héritage Simple : Une classe dérivée hérite d’une seule classe de base.

class A { /* ... */ };
class B : public A { /* ... */ };

Héritage Multiple : Une classe dérivée hérite de plusieurs classes de base.

class A { /* ... */ };
class B { /* ... */ };
class C : public A, public B { /* ... */ };

Héritage Hiérarchique : Plusieurs classes dérivent d’une même classe de base.

class A { /* ... */ };
class B : public A { /* ... */ };
class C : public A { /* ... */ };

Héritage Hybride : Combinaison de plusieurs types d’héritage (souvent multiple + hiérarchique).

class A { /* ... */ };
class B : public A { /* ... */ };
class C : public A { /* ... */ };
class D : public B, public C { /* ... */ };

7. Polymorphisme :

Capacité d'un objet à prendre plusieurs formes, permettant à une méthode de se comporter différemment selon le contexte (via virtual et override).

class Base {
public:
    // Méthode virtuelle
    virtual void methode() { /* Base */ }
};

class Derivee : public Base {
public:
    // Redéfinition
    void methode() override { /* Derivee */ }
};

Base* obj = new Derivee();
obj->methode(); // Appel de la méthode redéfinie

8. Abstraction (Classe Abstraite) :

Concept qui masque les détails complexes et expose uniquement les fonctionnalités essentielles, souvent via des classes abstraites et des méthodes virtuelles pures.

class Abstract {
public:
    virtual void methode() = 0; // Méthode virtuelle pure
};

class Concrete : public Abstract {
public:
    void methode() override { /* Implémentation */ }
};

9. Surcharge d'opérateurs :

La Surcharge d’Opérateurs permet de redéfinir le comportement des opérateurs standards afin qu’ils puissent être utilisés avec des objets de classes personnalisées. Cela rend le code plus lisible et naturel.

TypeRetour operatorSymbole(Paramètres);

Elle peut être déclarée à l'intérieur d'une classe (comme méthode membre) ou à l'extérieur (comme fonction amie ou libre).

• Opérateurs qu’on peut surcharger :

  Catégorie	Opérateurs surchargeables
  Arithmétiques	+, -, *, /, %
  Relationnels	==, !=, <, >, <=, >=
  Logiques	&&, !
  Affectation	=, +=, -=, *=, /=, %= etc.
  Incrément/Décrément	++, --
  Bit à bit	&
  Autres	[], (), ->, <<, >>, new, delete

• Types de surcharge :

  • Fonction membre : Définie à l'intérieur de la classe. Le premier opérande est l'objet courant.

  •   TypeRetour operatorOp(TypeParamètre);

  • Fonction amie (friend) : Définie à l’extérieur mais autorisée à accéder aux membres privés.

  •   friend TypeRetour operatorOp(const Classe& a, const Classe& b);

  • Fonction libre : Définie à l’extérieur, sans accès direct aux membres privés.

  •   TypeRetour operatorOp(const Classe& a, const Classe& b);

• Opérateurs qu’on ne peut pas Surcharger :

  • :: (opérateur de portée)
  • . (accès aux membres)
  • .* (pointeur vers membre)
  • sizeof
  • typeid
  • alignof
  • noexcept
  • static_cast, dynamic_cast, const_cast, reinterpret_cast

10. Fonctions amies (friend) :

Une fonction amie est une fonction déclarée avec le mot-clé friend à l’intérieur d’une classe, qui n’est pas membre de cette classe mais qui peut accéder à ses membres privés et protégés.

• Utilité principale :

  • Permet à une fonction extérieure à la classe d’accéder à ses données privées, sans être une méthode.
  • Souvent utilisée pour la surcharge d’opérateurs binaires lorsque le premier opérande n’est pas un objet de la classe.

• Déclaration dans la classe :

friend TypeRetour NomFonction(Paramètres);

• Définition hors de la classe :

TypeRetour NomFonction(Paramètres) {
    // Accès aux membres privés de la classe
}

• Caractéristiques :

  • Elle n’appartient pas à la classe (appelée comme une fonction normale).
  • Peut être une fonction normale, une fonction d’une autre classe, ou même une classe entière (dans ce cas, on parle de classe amie).
  • Doit être explicitement déclarée dans la classe avec friend.

11. Membres statiques :

Attributs ou méthodes appartenant à la classe elle-même plutôt qu'à ses instances, partagés par tous les objets de la classe.

// Déclaration d'une classe avec un membre et une méthode statiques
class nomClasse {
private:
    static Type nomMembre;       // Membre statique

public:
    static void nomMethode();    // Méthode statique
};

// Définition du membre statique (obligatoire en dehors de la classe)
Type nomClasse::nomMembre = valeurInitiale;

// Définition de la méthode statique
void nomClasse::nomMethode() {
    // Accès uniquement aux membres statiques
}

12. Const et Références :

• const : Mot-clé pour indiquer qu'une méthode ne modifie pas l'objet ou qu'une variable ne peut pas être modifiée.
• Références : Alias d'une variable, permettant de manipuler des données sans copie inutile.

class ConstRef {
public:
    void methodeConst() const { /* pas de modification */ }
    void modifier(int& ref) { ref = 42; } // passage par référence
};

---

13. Bibliothèques Standard

#include <iostream>  // Entrée/sortie (cin, cout)
#include <string>    // Chaînes de caractères (string)
#include <vector>    // Tableaux dynamiques (vector)
#include <algorithm> // Algorithmes (sort, find)
#include <cmath>     // Fonctions mathématiques (sqrt, pow)
#include <fstream>   // Manipulation des fichiers (ifstream, ofstream)

---

🧑🏻‍💻 | Made By : Mohamed Talhaoui