# CPP Modules - École 42

## Description
Les modules CPP constituent une série de 9 exercices progressifs de l'École 42 pour apprendre le C++ moderne. Chaque module (CPP00 à CPP08) introduit des concepts fondamentaux du langage avec une complexité croissante.

## Objectifs pédagogiques
- Maîtriser la **programmation orientée objet** en C++
- Comprendre les **spécificités du C++** par rapport au C
- Apprendre les **bonnes pratiques** de développement
- Maîtriser la **gestion mémoire** moderne (RAII)
- Découvrir les **design patterns** essentiels

## Modules détaillés

### CPP00 - Bases du C++
**Concepts abordés :**
- Namespaces, classes, fonctions membres
- stdio streams, listes d'initialisation
- static, const, et autres qualificateurs
- Exercices : Megaphone, PhoneBook

### CPP01 - Allocation mémoire, pointeurs, références
**Concepts abordés :**
- new/delete vs malloc/free
- Références en C++
- Pointeurs vers fonctions membres
- Exercices : Zombie horde, HarlFilter

### CPP02 - Forme canonique orthodoxe
**Concepts abordés :**
- Constructeur de copie
- Opérateur d'assignation
- Destructeur
- Exercices : Fixed point numbers, BSP

### CPP03 - Héritage
**Concepts abordés :**
- Héritage public/privé/protégé
- Classes abstraites
- Polymorphisme de base
- Exercices : ClapTrap, FragTrap, DiamondTrap

### CPP04 - Polymorphisme
**Concepts abordés :**
- Fonctions virtuelles
- Classes abstraites avancées
- Interfaces en C++
- Exercices : Animal, Brain, Materia

### CPP05 - Exceptions
**Concepts abordés :**
- Try/catch/throw
- Classes d'exception personnalisées
- RAII et exception safety
- Exercices : Bureaucrat, Form, Intern

### CPP06 - Casts C++
**Concepts abordés :**
- static_cast, dynamic_cast
- const_cast, reinterpret_cast
- Détection de types
- Exercices : Conversion, Serialize, Base

### CPP07 - Templates
**Concepts abordés :**
- Templates de fonctions
- Templates de classes
- Spécialisation
- Exercices : swap, iter, Array

### CPP08 - Conteneurs templés
**Concepts abordés :**
- STL containers (vector, list, stack)
- Itérateurs
- Algorithmes STL
- Exercices : easyfind, Span, MutantStack

## Technologies utilisées
- **C++98** (standard imposé par 42)
- **Compilation** : g++ avec flags stricts
- **Makefile** pour chaque exercice
- **Orthodox Canonical Form** obligatoire

## Structure globale
```
cpp/
├── cpp00/              # Module 00 - Bases
│   ├── ex00/          # Megaphone
│   ├── ex01/          # PhoneBook
│   └── ex02/          # Bonus
├── cpp01/              # Module 01 - Mémoire
│   ├── ex00/          # BraiiiiiiinnnzzzZ
│   ├── ex01/          # Moar brainz!
│   ├── ex02/          # HI THIS IS BRAIN
│   ├── ex03/          # Unnecessary violence
│   ├── ex04/          # Sed is for losers
│   ├── ex05/          # Harl 2.0
│   └── ex06/          # Harl filter
├── cpp02/              # Module 02 - Forme canonique
├── cpp03/              # Module 03 - Héritage
├── cpp04/              # Module 04 - Polymorphisme
├── cpp05/              # Module 05 - Exceptions
├── cpp06/              # Module 06 - Casts
├── cpp07/              # Module 07 - Templates
└── cpp08/              # Module 08 - Conteneurs
```

## Compilation et utilisation

### Compilation d'un exercice
```bash
cd cpp00/ex00
make
./megaphone
```

### Flags de compilation obligatoires
```makefile
CXXFLAGS = -Wall -Wextra -Werror -std=c++98
```

### Tests
```bash
# Chaque exercice inclut des tests
make test
```

## Concepts clés développés

### Programmation Orientée Objet
- **Encapsulation** : private/public/protected
- **Héritage** : public, private, multiple
- **Polymorphisme** : virtual, override, abstract

### Gestion mémoire C++
- **RAII** (Resource Acquisition Is Initialization)
- **Smart pointers** concepts de base
- **Exception safety** garantees

### Templates et généricité
- **Paramètres de templates** (type, non-type)
- **Spécialisation** partielle et totale
- **SFINAE** concepts de base

### STL et conteneurs
- **Itérateurs** et leur utilisation
- **Algorithmes** standards
- **Conteneurs** (vector, list, map, etc.)

## Exercices remarquables

### PhoneBook (CPP00)
Contact manager avec interface utilisateur
```cpp
class PhoneBook {
private:
    Contact contacts[8];
    int     index;
public:
    void addContact();
    void searchContact();
    void displayContacts();
};
```

### Fixed Point (CPP02)
Implémentation d'un type de nombre à virgule fixe
```cpp
class Fixed {
private:
    int                 fixedValue;
    static const int    fractionalBits = 8;
public:
    Fixed(const Fixed& other);
    Fixed& operator=(const Fixed& other);
    bool operator>(const Fixed& other) const;
    Fixed operator+(const Fixed& other) const;
};
```

### Bureaucrat (CPP05)
Gestion d'exceptions et hiérarchie de classes
```cpp
class Bureaucrat {
private:
    const std::string   name;
    int                 grade;
public:
    class GradeTooHighException : public std::exception {};
    class GradeTooLowException : public std::exception {};
    void incrementGrade();
    void decrementGrade();
};
```

## Normes et contraintes 42

### Contraintes de codage
- **Orthodox Canonical Form** obligatoire
- **Pas de STL** avant CPP08
- **Compilation** sans warning
- **Pas de memory leaks**

### Bonnes pratiques appliquées
- **RAII** pour la gestion de ressources
- **const correctness**
- **Exception safety**
- **Single Responsibility Principle**

## Compétences développées
- Maîtrise complète du C++ moderne
- Design patterns orientés objet
- Gestion mémoire avancée
- Programmation générique
- Architecture logicielle robuste

## Évaluation
Chaque module est évalué individuellement :
- Tests automatisés
- Code review par les pairs
- Défense orale du code

## Auteur
Alexandre Pommier (apommier) - École 42

## Note globale obtenue
**Tous les modules validés** ✅

## Licence
Projet académique - École 42