Programmation - Semestre 1

PART A - Presentation Generale du Cours

Contexte de la formation

La programmation est une competence fondamentale pour tout technicien ou ingenieur en GEII. Elle permet de controler des systemes embarques, automatiser des taches, traiter des donnees et developper des applications. Ce premier module de programmation, dispense en C++, pose les bases de la pensee algorithmique et de la programmation structuree, competences essentielles pour les projets futurs et la vie professionnelle.

Positionnement dans le cursus

• Semestre : S1 (1ere annee DUT GEII)
• Volume horaire : 60h (20h CM + 25h TD + 15h TP)
• Credits ECTS : 5
• Prerequis : Aucun prerequis en programmation (debutants acceptes)
• Continuite : Programmation S2 (C/C++ avance), puis S3-S4 (embarque, Python)

Public vise

Etudiants de premiere annee DUT GEII, debutants ou ayant quelques notions en programmation. Le cours s'adresse a tous les profils, avec une pedagogie progressive permettant a chacun de reussir.

PART B: EXPERIENCE, CONTEXTE ET FONCTION

Objectifs pedagogiques

Competences algorithmiques :

• Analyser un probleme et le decomposer en etapes
• Concevoir des algorithmes structures et efficaces
• Evaluer la complexite d'un algorithme
• Deboguer et tester son code

Competences techniques C++ :

• Maitriser la syntaxe de base du C++
• Utiliser les structures de controle (conditions, boucles)
• Manipuler les tableaux et les chaines de caracteres
• Creer et utiliser des fonctions
• Comprendre et utiliser les pointeurs (introduction)

Competences methodologiques :

• Utiliser un environnement de developpement (IDE)
• Compiler et executer un programme
• Deboguer avec des outils appropries
• Documenter son code
• Travailler en mode projet

Programme detaille

1. Introduction a la programmation (5h)

Concepts fondamentaux :

• Qu'est-ce qu'un programme ? Un algorithme ?
• Langages de programmation (compiles vs interpretes)
• Processus de compilation (source → compilation → executable)
• Structure d'un programme C++

Premier programme "Hello World" :

#include <iostream>
using namespace std;

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

Elements de syntaxe :

• Directives du preprocesseur (#include)
• Fonction main()
• Instructions et point-virgule
• Entrees/sorties (cin, cout)
• Commentaires (// et /* */)

2. Variables et types de donnees (8h)

Types de base (primitifs) :

int age = 20;              // Entier signe (4 octets)
unsigned int count = 100;  // Entier non signe
float temperature = 25.5;  // Flottant simple precision
double pi = 3.14159265359; // Flottant double precision
char letter = 'A';         // Caractere (1 octet)
bool isValid = true;       // Booleen (true/false)

Declaration et initialisation :

• Declaration : int x;
• Initialisation : int x = 10;
• Affectation : x = 20;
• Constantes : const double PI = 3.14159;

Operateurs :

• Arithmetiques : +, -, *, /, % (modulo)
• Comparaison : ==, !=, <, >, <=, >=
• Logiques : && (AND), || (OR), ! (NOT)
• Incrementation : ++, --
• Affectation composee : +=, -=, *=, /=

Conversions de types (cast) :

int a = 10;
float b = 3.7;
int result = a + (int)b;  // Cast explicite
float average = (float)a / 3;  // Division flottante

Entrees/sorties utilisateur :

int age;
cout << "Entrez votre age : ";
cin >> age;
cout << "Vous avez " << age << " ans" << endl;

3. Structures de controle (10h)

Instructions conditionnelles :

if / else if / else :

if (temperature > 30) {
    cout << "Il fait chaud" << endl;
}
else if (temperature > 20) {
    cout << "Il fait bon" << endl;
}
else {
    cout << "Il fait froid" << endl;
}

Operateur ternaire :

int max = (a > b) ? a : b;  // Si a>b alors max=a sinon max=b

Switch / case :

int choice;
cin >> choice;

switch (choice) {
    case 1:
        cout << "Option 1" << endl;
        break;
    case 2:
        cout << "Option 2" << endl;
        break;
    default:
        cout << "Option invalide" << endl;
}

Boucles :

Boucle for (nombre d'iterations connu) :

// Afficher les nombres de 1 a 10
for (int i = 1; i <= 10; i++) {
    cout << i << " ";
}

Boucle while (condition en entree) :

int i = 1;
while (i <= 10) {
    cout << i << " ";
    i++;
}

Boucle do-while (condition en sortie, au moins 1 iteration) :

int number;
do {
    cout << "Entrez un nombre positif : ";
    cin >> number;
} while (number <= 0);

break et continue :

for (int i = 0; i < 10; i++) {
    if (i == 5) continue;  // Passer a l'iteration suivante
    if (i == 8) break;     // Sortir de la boucle
    cout << i << " ";
}
// Affiche : 0 1 2 3 4 6 7

4. Tableaux et chaines de caracteres (10h)

Tableaux statiques (arrays) :

// Declaration et initialisation
int notes[5] = {12, 15, 10, 18, 14};

// Acces aux elements (index commence a 0)
cout << "Premiere note : " << notes[0] << endl;
notes[2] = 16;  // Modification

// Parcours avec boucle
float somme = 0;
for (int i = 0; i < 5; i++) {
    somme += notes[i];
}
float moyenne = somme / 5;

Tableaux multidimensionnels :

int matrice[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Parcours avec boucles imbriquees
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        cout << matrice[i][j] << " ";
    }
    cout << endl;
}

Chaines de caracteres (C-style strings) :

char nom[50];
cout << "Entrez votre nom : ";
cin >> nom;

// Fonctions de <cstring>
#include <cstring>
strlen(nom);        // Longueur
strcpy(dest, src);  // Copie
strcat(s1, s2);     // Concatenation
strcmp(s1, s2);      // Comparaison (0 si egales)

Chaines C++ (std::string) :

#include <string>

string prenom = "Jean";
string nom = "Dupont";
string complet = prenom + " " + nom;  // Concatenation

cout << complet.length() << endl;  // Longueur
cout << complet[0] << endl;        // Premier caractere
complet += " Jr.";                 // Ajout a la fin

5. Fonctions (12h)

Declaration et definition :

// Declaration (prototype)
int addition(int a, int b);

// Definition
int addition(int a, int b) {
    return a + b;
}

// Utilisation
int main() {
    int resultat = addition(5, 3);
    cout << "5 + 3 = " << resultat << endl;
    return 0;
}

Passage de parametres :

Par valeur (copie) :

void incrementer(int x) {
    x++;  // Modification locale, pas d'effet sur l'original
}

int main() {
    int a = 5;
    incrementer(a);
    cout << a << endl;  // Affiche 5 (inchange)
}

Par reference (modification de l'original) :

void incrementer(int& x) {  // Notez le &
    x++;  // Modifie l'original
}

int main() {
    int a = 5;
    incrementer(a);
    cout << a << endl;  // Affiche 6
}

Fonctions void (sans retour) :

void afficherMessage() {
    cout << "Bonjour !" << endl;
    // Pas de return (ou return; sans valeur)
}

Surcharge de fonctions (overloading) :

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

double addition(double a, double b) {
    return a + b;
}

// Le compilateur choisit selon les types des arguments

Valeurs par defaut :

void afficher(string texte, int repetitions = 1) {
    for (int i = 0; i < repetitions; i++) {
        cout << texte << endl;
    }
}

afficher("Bonjour");      // Utilise 1 par defaut
afficher("Bonjour", 3);   // Affiche 3 fois

6. Structures (struct) (8h)

Definition et utilisation :

struct Point {
    double x;
    double y;
};

int main() {
    Point p1;
    p1.x = 10.5;
    p1.y = 20.3;

    Point p2 = {5.0, 7.0};  // Initialisation

    cout << "Point 1 : (" << p1.x << ", " << p1.y << ")" << endl;
}

Structures imbriquees :

struct Adresse {
    string rue;
    int codePostal;
    string ville;
};

struct Personne {
    string nom;
    int age;
    Adresse adresse;
};

Personne p;
p.nom = "Dupont";
p.adresse.ville = "Toulouse";

Tableaux de structures :

struct Etudiant {
    string nom;
    float moyenne;
};

Etudiant classe[30];
classe[0].nom = "Alice";
classe[0].moyenne = 15.5;

7. Introduction aux pointeurs (7h)

Concept de pointeur :

int x = 10;
int* ptr = &x;  // ptr contient l'adresse de x

cout << "Valeur de x : " << x << endl;
cout << "Adresse de x : " << &x << endl;
cout << "Valeur de ptr : " << ptr << endl;
cout << "Valeur pointee : " << *ptr << endl;  // Dereferencement

Modification via pointeur :

int a = 5;
int* p = &a;
*p = 10;  // a vaut maintenant 10

Pointeurs et tableaux :

int tab[5] = {10, 20, 30, 40, 50};
int* p = tab;  // Pointeur sur le premier element

for (int i = 0; i < 5; i++) {
    cout << *(p + i) << " ";  // Acces par arithmetique de pointeurs
}

Pointeurs et fonctions :

void echanger(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    echanger(&x, &y);
    cout << "x = " << x << ", y = " << y << endl;  // x=10, y=5
}

Semaine intensive de programmation

Projet integratif (40h sur 1 semaine) :

Realisation d'un projet complet mobilisant toutes les competences :

• Analyse et decomposition du probleme
• Conception de l'algorithme (organigramme ou pseudo-code)
• Implementation en C++
• Tests et debogage
• Documentation et presentation

Exemples de projets :

1. Jeu du pendu : Gestion de chaines, structures de controle
2. Gestion de contacts : Tableaux de structures, fichiers
3. Calculatrice scientifique : Fonctions mathematiques, switch/case
4. Jeu de la vie (Conway) : Tableaux 2D, algorithmique
5. Gestionnaire de notes : Calculs statistiques, tri

Organisation :

• Travail en binome
• Suivi quotidien par les enseignants
• Presentation finale (demo + code)
• Rapport technique

PART C: ASPECTS TECHNIQUES

Environnements de developpement (IDE)

Code::Blocks (recommande pour debutants)

Installation :

• Telecharger sur codeblocks.org
• Version avec MinGW (compilateur GCC inclus)
• Configuration automatique

Fonctionnalites :

• Coloration syntaxique
• Auto-completion
• Compilation en un clic (F9)
• Debogueur integre
• Gestion de projets

Creation d'un projet :

1. File → New → Project → Console Application
2. Choisir C++
3. Nommer le projet et choisir l'emplacement
4. Code genere automatiquement

Visual Studio (Windows)

Avantages :

• IDE professionnel puissant
• Excellent debogueur
• IntelliSense (auto-completion avancee)
• Outils de profilage

Creation d'un projet :

• File → New → Project → Empty Project (C++)
• Ajouter un fichier .cpp
• Build → Build Solution (Ctrl+Shift+B)
• Debug → Start Debugging (F5)

VS Code (multiplateforme)

Configuration pour C++ :

1. Installer VS Code
2. Installer extension "C/C++"
3. Installer MinGW (Windows) ou GCC (Linux/Mac)
4. Configurer tasks.json pour compilation

Avantages :

• Leger et rapide
• Tres personnalisable
• Extensions nombreuses
• Integration Git native

Compilation et debogage

Processus de compilation

Etapes :

Code source (.cpp) → Preprocesseur → Compilateur →
Assembleur → Linker → Executable (.exe ou binaire)

Compilation en ligne de commande :

# Compilation simple
g++ programme.cpp -o programme

# Avec warnings et optimisation
g++ -Wall -Wextra -O2 programme.cpp -o programme

# Avec informations de debug
g++ -g programme.cpp -o programme

# Execution
./programme  # Linux/Mac
programme.exe  # Windows

Debogage avec GDB

Commandes de base :

gdb ./programme

(gdb) break main       # Point d'arret sur main
(gdb) run             # Lancer le programme
(gdb) next            # Ligne suivante (sans entrer dans fonctions)
(gdb) step            # Ligne suivante (en entrant dans fonctions)
(gdb) print variable  # Afficher valeur d'une variable
(gdb) continue        # Continuer jusqu'au prochain breakpoint
(gdb) quit            # Quitter GDB

Debogage dans IDE :

• Placer des breakpoints (clic marge gauche)
• F5 : Lancer en mode debug
• F10 : Passer a la ligne suivante
• F11 : Entrer dans une fonction
• Inspecter les variables dans la fenetre "Watch"

Bonnes pratiques de programmation

Style et conventions

Nommage :

// Variables : camelCase ou snake_case
int nombreEtudiants;  // camelCase
int nombre_etudiants;  // snake_case

// Constantes : MAJUSCULES
const int MAX_SIZE = 100;

// Fonctions : verbes d'action
void calculerMoyenne();
bool estPair(int n);

// Noms explicites (pas de x, y, z sauf cas mathematiques)
int age;  // Bien
int a;    // A eviter (sauf contexte clair)

Indentation et lisibilite :

// Mauvais
if(a>b){cout<<a;}else{cout<<b;}

// Bon
if (a > b) {
    cout << a << endl;
} else {
    cout << b << endl;
}

Commentaires :

// Commentaire ligne simple

/*
 * Commentaire
 * multi-lignes
 */

/**
 * Documentation fonction (style Doxygen)
 * @param rayon : rayon du cercle
 * @return surface du cercle
 */
double surfaceCercle(double rayon) {
    return 3.14159 * rayon * rayon;
}

Gestion des erreurs

Validation des entrees :

int age;
cout << "Entrez votre age : ";
cin >> age;

if (cin.fail()) {
    cout << "Erreur : entree invalide" << endl;
    cin.clear();  // Reinitialiser le flux
    cin.ignore(1000, '\n');  // Vider le buffer
}

if (age < 0 || age > 150) {
    cout << "Erreur : age non valide" << endl;
}

Tests et assertions :

#include <cassert>

assert(diviseur != 0);  // Arrete le programme si faux (mode debug)

PART D: ANALYSE ET REFLEXION

Evaluation des competences

Modalites d'evaluation

Controle continu (40%) :

• QCM theoriques (2 dans le semestre) - 10%
• Tests pratiques sur machine (2x1h) - 30%

Travaux pratiques (30%) :

• 8 TP notes
• Evaluation : code fonctionnel, methodologie, documentation
• Presence obligatoire

Projet semaine intensive (20%) :

• Code source commente
• Fonctionnalites implementees
• Presentation et demo
• Rapport technique

Examen terminal (10%) :

• Epreuve theorique (1h)
• Questions de cours, analyse de code, algorithmique

Grille d'evaluation TP (exemple)

Competences acquises

Savoirs theoriques

• Comprendre les concepts de la programmation structuree
• Connaitre la syntaxe et les structures du langage C++
• Maitriser l'algorithmique de base
• Comprendre la notion de complexite algorithmique

Savoir-faire techniques

• Ecrire, compiler et executer un programme C++
• Utiliser un IDE et des outils de debogage
• Concevoir des algorithmes structures
• Manipuler tableaux, fonctions, structures
• Deboguer et tester son code
• Documenter son travail

Savoir-etre

• Rigueur et methode dans la resolution de problemes
• Autonomie dans l'apprentissage
• Perseverance face aux bugs
• Travail en equipe sur des projets
• Curiosite et veille technologique

Progression et liens avec le cursus

Suite du parcours Programmation

Liens avec les autres matieres

Indicateurs de reussite

Statistiques

Taux de reussite : 90% (moyenne ≥ 10/20)
Moyenne generale : 13/20

Profils d'etudiants :

• Debutants complets : 60%
• Ayant fait de la programmation au lycee (NSI, ISN) : 30%
• Ayant programme en autonomie : 10%

Difficultes frequentes

Problemes courants :

• Confusion entre = (affectation) et == (comparaison)
• Oublier les accolades {} ou points-virgules ;
• Boucles infinies (condition mal formulee)
• Depassement d'indices de tableaux
• Oubli du & dans passage par reference
• Confusion pointeurs/valeurs

Solutions et conseils :

• Compiler frequemment (eviter d'accumuler les erreurs)
• Utiliser le debogueur au lieu de cout partout
• Dessiner les structures de donnees sur papier
• Tester avec des cas simples d'abord
• Commenter son code au fur et a mesure
• Refaire les TP chez soi

Debouches et applications

Applications professionnelles

Metiers utilisant le C/C++ :

• Developpeur embarque (IoT, automobile, aeronautique)
• Programmeur de microcontroleurs
• Developpeur systemes temps reel
• Automaticien (interfaces, supervision)
• Developpeur logiciel industriel

Industries :

• Electronique grand public
• Automobile (systemes embarques)
• Aeronautique et spatial
• Robotique
• Automatisation industrielle
• Telecommunications

Ressources complementaires

Ouvrages de reference

Pour debutants :

1. Programmer en langage C++ - Claude Delannoy (Eyrolles) - LE classique francais
2. C++ pour les Nuls - Stephen Randy Davis (First)
3. Apprendre la programmation - Sebastien Rohaut (Eyrolles)

Pour approfondir :

• The C++ Programming Language - Bjarne Stroustrup (createur du C++)
• Effective C++ - Scott Meyers (bonnes pratiques)

Sites web et tutoriels

Cours en ligne (gratuits) :

• OpenClassrooms : Cours C++ tres complet en francais
• Codecademy : Exercices interactifs
• SoloLearn : Application mobile ludique
• cplusplus.com : Documentation complete + tutoriels

References C++ :

• cppreference.com : Documentation officielle
• Stack Overflow : Forum Q&A (chercher avant de poster)

Exercices en ligne :

• France-IOI : Exercices progressifs d'algorithmique
• CodinGame : Apprendre en jouant
• HackerRank / LeetCode : Defis algorithmiques
• Project Euler : Problemes mathematiques a resoudre par programmation

Outils en ligne

Compilateurs en ligne (pour tester rapidement) :

• OnlineGDB (onlinegdb.com) : IDE complet dans le navigateur
• Compiler Explorer (godbolt.org) : Voir le code assembleur genere
• Repl.it : Environnement collaboratif

Visualisation d'algorithmes :

• PythonTutor (pythontutor.com) : Visualiser l'execution pas a pas
• VisuAlgo : Animations d'algorithmes (tri, recherche, graphes)

Conseils methodologiques

Pour reussir en programmation

Pendant les cours/TD :

• Taper le code soi-meme (ne pas juste regarder)
• Experimenter : modifier le code pour voir ce qui se passe
• Poser des questions immediatement
• Noter les erreurs frequentes et comment les corriger

En TP :

• Lire entierement le sujet avant de commencer
• Decomposer le probleme en petites etapes
• Tester chaque fonction individuellement
• Compiler souvent (toutes les 5-10 lignes)
• Demander de l'aide si bloque >15 min

Travail personnel (3-4h/semaine recommandees) :

• Refaire les exercices de TD sans regarder la correction
• Creer ses propres petits programmes
• Lire des codes d'autres personnes (GitHub, forums)
• Participer a des defis (CodinGame, HackerRank)

Methodologie de resolution de problemes

Etapes systematiques :

1. Comprendre : Lire et reformuler le probleme
2. Decomposer : Identifier les sous-problemes
3. Algorithme : Ecrire en pseudo-code ou organigramme
4. Coder : Traduire en C++
5. Tester : Cas normaux, limites, erreurs
6. Deboguer : Si ca ne marche pas, identifier l'erreur
7. Optimiser : Ameliorer si necessaire

Exemple : Calculer la moyenne d'un tableau

1. Comprendre : Somme des elements / nombre d'elements
2. Decomposer :
   - Parcourir le tableau
   - Additionner les valeurs
   - Diviser par la taille
3. Pseudo-code :
   somme = 0
   POUR chaque element du tableau
       somme = somme + element
   moyenne = somme / taille
4. Coder en C++
5. Tester avec {10, 15, 20} -> moyenne = 15

Bienvenue dans le monde de la programmation !

"Everybody should learn to program a computer, because it teaches you how to think." - Steve Jobs

N'ayez pas peur de faire des erreurs : les bugs font partie de l'apprentissage. Chaque erreur corrigee est une lecon apprise !

Ressources complementaires

• Documentation C++ standard
• Exercices en ligne (France-IOI, CodinGame)
• Livres de reference sur le C++