Introduction au C++

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 Vraiment bien comprendre la programmation objet en C++ (avec exemple) - Tuto débutant

  Formation facile fr · 33:52 · 83k vues — Rejoignez cette chaîne pour bénéficier d'avantages exclusifs :https://www.youtube.com/channel/UCL37KTVyVCQnjQtNzbv_1EQ/joinDévelopper des jeux en C++ : https

• 🇫🇷 Classes, objets, attributs et méthodes en C++

  MOOC EPFL Introduction à la programmation orientée objet (en C++) · 16:08 · 51k vues — Enjoy the videos and music you love, upload original content, and share it all with friends, family, and the world on YouTube.

• 🇬🇧 C++ OOP - Introduction to classes and objects for beginners

  CodeBeauty · 12:06 · 416k vues — Object-oriented programming is a programming paradigm that is based on the concept of objects from the real world, and it is used to represent those real wor...

1. Pourquoi C++ ?

C++ versus C

• C est un sous-ensemble de C++ — presque tout code C compile en C++
• C++ ajoute : programmation orientée objet, programmation générique (templates), type checking plus strict

C++ versus Java

2. Outils & projet C++

Outils nécessaires

• Éditeur de texte — VSCode, Sublime, Vim…
• Compilateur — g++, clang++, cl.exe (MSVC)…
• Débogueur — gdb, lldb
• 3-en-1 = IDE (Environnement de Développement Intégré) — Code::Blocks, CLion, Visual Studio

Structure d'un projet C++

source.cpp ──→ [compile] ──→ object.o ──→ [link] ──→ executable

Compilation avec g++

g++ -Wall -std=c++11 -c file.cpp     # compile (warning all, C++11) -> file.o
g++ -o prog file1.o file2.o          # link les objets -> executable

Un Makefile automatise ce processus pour les projets multi-fichiers.

Architecture d'un projet OO

L'en-tête .h sert d'interface : à la fois utilisée par les clients (user.cpp) et par l'implémentation (Vector.cpp).

3. Premier programme

#include <iostream>    // bibliothèque d'entrées/sorties

using namespace std;  // raccourci sur l'espace de noms std

int main()
{
   cout << "Hello world!" << endl;
   return 0;
}

• #include <iostream> inclut la bibliothèque d'entrées/sorties
• using namespace std; évite de devoir préfixer chaque appel par std::
• int main() est le point d'entrée du programme — comme en C
• cout + opérateur << envoie sur la sortie standard
• endl = retour à la ligne

4. Spécificités C++ (hors objet)

Types

• Types C classiques : int, char, float, double…
• Booléen natif : bool (avec true / false)
• Inférence de type : auto — auto z = sqrt(y); infère le type
• String : type natif via #include <string>

Variables — convention de nommage

Initialisation

// Syntaxe historique (C)
int i = 7;

// Syntaxe avec parenthèses (préférée en C++)
int ageUser(18);
double pi(3.14159);
bool estMonAmi(true);
char lettre('a');
string nomUser("leVolontaire");

// Brace initialization (C++11) — plus stricte
double d2 {2.3};        // OK
int i {7.2};            // ERROR : narrowing interdit
int i = 7.2;           // OK silencieusement (perte de précision)

Fonctions inline

inline int Max(int i, int j) {
   if (i > j) return i;
   else      return j;
}

Le compilateur inline le code de la fonction à l'endroit de l'appel — pas d'overhead de l'appel. Réservé aux petites fonctions, pas de récursivité, pas de pointeur.

const et volatile

const int cst1 = 42;
const char* f();        // retourne const
void g(const int tab);  // param const
void methodClass() const; // méthode const

5. Références (&) et pointeurs

int prixRevient(16);            // déclaration d'une variable
int& prixAchat(prixRevient);    // alias
prixAchat = 20;                  // modifie aussi prixRevient !

Pointeur vs Référence — choisir le plus sûr

int i = 0;
int* pi = &i;       // pointeur sur i
*pi = *pi + 1;     // déréférencement

int i = 0;
int& ri = i;       // alias
ri = ri + 1;       // modifie i

Passage par référence

void test(int& i) {
   i = 2;        // modifie la variable d'origine
}

int x = 5;
test(x);          // après cet appel : x == 2

Le passage par référence est plus efficace que par valeur (pas de copie) et permet à la fonction de modifier l'argument.

6. Namespaces

namespace first {
   int x;
}
namespace second {
   int x;          // pas de collision : first::x ≠ second::x
}

int main() {
   first::x = 1;     // résolution explicite
   using namespace first;  // ouverture du namespace
   x = 1;             // désigne first::x
   second::x = 2;    // résolution explicite
}

7. Entrées / sorties standards

C++ redéfinit les I/O pour les simplifier. Tout est dans <iostream> et le namespace std.

#include <iostream>
using namespace std;

int main() {
   int a;
   cout << "saisir a ";
   cin >> a;
   cout << "le carré de " << a << " vaut " << a*a << endl;
}

8. Première classe — exemple Point

Une classe C++ se déclare typiquement dans un fichier d'en-tête .h et s'implémente dans un .cpp.

point.h — déclaration

#ifndef _POINT_HPP_
#define _POINT_HPP_

class Point {
   private:
      int x;
      int y;

   public:
      void setX(int);
      void setY(int);
      int getX();
      int getY();
};

#endif

point.cpp — implémentation

#include "point.h"

void Point::setX(int px) { x = px; }
void Point::setY(int py) { y = py; }
int Point::getX() { return x; }
int Point::getY() { return y; }

main.cpp — utilisation

#include <iostream>
#include "point.h"
using namespace std;

int main() {
   Point p;
   p.setX(3);
   p.setY(4);
   cout << "x = " << p.getX() << " y = " << p.getY();
   return 0;
}

Cette structure de base sera enrichie en SE2 avec les constructeurs et destructeurs.

★ Réviser le chapitre

Pour vérifier ta compréhension

🃏 Flashcards

↻ Tout retourner

✎ Quiz éclair