Editer C++


Des pense-bêtes.
La plupart des exemples ont été écrits en suivant le tutorial sur Open Classroom, merci à Mathieu Nebra et Matthieu Schaller !


La base


Installer Code::Blocks comme IDE.

Nouveau, projet, console, C++.

Récupérer les entrées de l'utilisateur



//utilise la bibliothèque iostream, les commandes Input/output stream, la base pour utiliser le C et traiter des entrées utilisateur et faire des sorties écran. #include <iostream> //biblio pour utiliser des lignes de texte #include <string> //indique qu'on utilise les commandes dans l'espace de nom std (dans iostream) using namespace std; //boucle principale int main() { //declare une var texte vide (une var string est en réalité un objet, tableau de var "char") string nomUtilisateur(""); //ici, un exemple d'alias ("reference") de la var nomUtilisateur string& a(nomUtilisateur); //déclare des variales int (nombre entier) int ageUtilisateur(0); int pauseUtilisateur(0); int calcul1(0); int calcul2(0); //affiche un message en sortie cout << "Quel est votre age ?"<< endl;; //cin pour récupérer un chiffre. Attention, si on entre pas un chiffre, le programme se comportera bizarrement. cin >> ageUtilisateur; //Il faut mettre ça si on utilise getline après un cin, pour éviter que les entrées suivantes soient sauvés en mémoire. //Ca signifie un peu "arrête d'écouter les entrées". cin.ignore(); cout << "Quel est votre nom ?"<< endl; //pour récupérer un texte, utiliser getline getline(cin, nomUtilisateur); //affichage des résultats cout << "Vous avez " << ageUtilisateur << " ans, vous vous appelez"<< nomUtilisateur<< endl;cin.ignore(); cout << "Premier chiffre pour le calcul ?"<< endl; cin >> calcul1; cout << "2e chiffre pour le calcul ?"<< endl;; cin >> calcul2; cout << calcul2 << " et " << calcul1 << " font " << calcul2+calcul1; //dispensable, pour quitter proprement return 0; }


Tests conditionnels


Exemples de if, while, else if, for.

#include <iostream> using namespace std; //POUR TESTER PLUSIEURS CHOSES A LA FOIS : //if (adulte && nbEnfants >= 1) //if (nbEnfants == 1 || nbEnfants == 2) //on pourrait utiliser do while afin d'éviter de devoir mettre la var nbEnfants en négatif pour entrer dans la boucle //do {...} while (nbEnfants < 0); //for (initialisation ; conditions qui font que la boucle se répête ; incrémentation) int main() { int nbEnfants(-1); while (nbEnfants <0){ cout << "Combien d'enfants avez vous ? Merci de ne pas entrer de chiffre négatif !"; cin >> nbEnfants; cin.ignore(); if (nbEnfants == 1){ cout << "Vous avez un enfant, bravo !" << endl; } else if (nbEnfants > 1){ cout << "Vous avez des enfants, bravo !" << endl; } else{ cout << "Vous n'avez pas d'enfant, ou alors vous avez entré un chiffre négatif." << endl; } } for (int compteur = 0 ; compteur < nbEnfants ; compteur++){ cout << compteur << endl; } cout << nbEnfants << " enfants !" << endl << "Fin du programme" << endl; return 0; }


Exemple d'utilisation d'une fonction




#include <iostream> using namespace std; double multiplieSept(double nombreAMultiplier) { nombreAMultiplier*=7; return nombreAMultiplier; } int main() { double nombreSaisi; cout << "Entrez un nombre pour le multiplier par 7." << endl; cin >> nombreSaisi; nombreSaisi=multiplieSept(nombreSaisi); cin.ignore(); cout << nombreSaisi << endl << endl; cout << "Pour rappel, voici la table de 7 :" << endl; for (int i=1 ; i<11 ; i++) { cout << "7 x " << i << "=" << multiplieSept(i) << endl; } return 0; }


Notez que la fonction est avant le main. Il est possible de mettre la fonction après, à condition de l'avoir signalée. Dans l'exemple ci-dessous, la ligne double multiplieSept(double nombreAMultiplier); signale qu'on va utiliser cette fonction. C'est ce qu'on appelle le "prototype" d'une fonction.

#include <iostream> using namespace std; double multiplieSept(double nombreAMultiplier); int main() { double nombreSaisi; cout << "Entrez un nombre pour le multiplier par 7." << endl; cin >> nombreSaisi; nombreSaisi=multiplieSept(nombreSaisi); cin.ignore(); cout << nombreSaisi << endl << endl; cout << "Pour rappel, voici la table de 7 :" << endl; for (int i=1 ; i<11 ; i++) { cout << "7 x " << i << "=" << multiplieSept(i) << endl; } return 0; } double multiplieSept(double nombreAMultiplier) { nombreAMultiplier*=7; return nombreAMultiplier; }


Notez qu'on peut se servir du prototype pour donner une valeur par défaut : double multiplieSept(double nombreAMultiplier=10) (mais dans cet exemple ça n'a pas de sens).

Tableau à taille fixe (avec envoie à une fonction)



#include <iostream> using namespace std; double moyenne (double notes[],int nombreNotes) { double moyenne(0); for(int i(0); i<nombreNotes; ++i) { moyenne += notes[i]; //On additionne toutes les notes } moyenne /= nombreNotes; return moyenne; } int main() { int const nombreNotes(6); double notes[nombreNotes]; notes[0] = 12.5; notes[1] = 19.5; //Bieeeen ! notes[2] = 6.; //Pas bien ! notes[3] = 12; notes[4] = 14.5; notes[5] = 15; cout << moyenne(notes,nombreNotes) << endl; return 0; }


Tableau dynamique



#include <iostream> #include <vector> using namespace std; int main() { int moyenne(0); vector<int> notes; notes.push_back(12.5); //On ajoute des cases avec les notes notes.push_back(19.5); notes.push_back(6); notes.push_back(12); notes.push_back(14.5); notes.push_back(15); for(int i=0;i<5;i++) { moyenne+=notes[i]; } cout << "Moyenne des "<< notes.size() << " notes :" << moyenne/5 << endl; return 0; } //pour envoyer à une fonction : //void fonction(vector<int> a)


Lire, écrire, modifier un fichier



#include <iostream> #include <fstream> #include <string> using namespace std; int main() { string const nomFichier("test.txt"); //output file stream //on dit "output" car on dirige *vers* le fichier (fichier << truc à diriger) //un peu comme quand on dirige vers l'écran (cout << truc à ecrire à l'écran) ofstream monFlux(nomFichier.c_str()); //pour append, faire //ofstream monFlux("test.txt", ios::app); //Pour savoir la position du curseur : monFlux.tellp //pour écrire à la position X : monFlux.seekp(nombreCaracteres, position); if(monFlux) { monFlux << "test écriture dans un fichier" << endl; monFlux << 15.236 << endl; int age(18); monFlux << "J'ai " << age << " ans." << endl; } else { cout << "ERREUR: Impossible d'ouvrir le fichier." << endl; } monFlux.close(); //LECTURE //pour lire un nombre à virgule depuis le fichier //double nombre;monFlux >> nombre; //Pour lire un mot depuis le fichier //string mot;monFlux >> mot; //lettre par lettre //char a;monFlux.get(a); ifstream monFluxLecture("test.txt"); //Ouverture d'un fichier en lecture string ligne; if(monFluxLecture) { while(getline(monFluxLecture, ligne)) { cout << "Position du curseur :" << monFluxLecture.tellg() << "Contenu : " << ligne << endl; } } else { cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl; } //on ferme proprement monFluxLecture.close(); monFluxLecture.clear(); //exemple de lecture à la position X //on réouvre le flux monFluxLecture.open("test.txt"); int positionSouhaitee; cout << "A quelle position voulez vous lire ?"; cin >> positionSouhaitee; cin.ignore(); //On s'y déplace depuis le début du fichier //("ios::beg" pour le début, "ios::end" pour la fin, "ios::cur" pour se déplacer depuis la pos actuelle) monFluxLecture.seekg(positionSouhaitee, ios::beg); //on met ce qu'on voit dans la variable ligne. if(getline(monFluxLecture, ligne)){ cout << "Position du curseur :" << monFluxLecture.tellg() << "Contenu : " << ligne << endl; }else{ cout << "Ne peut pas lire."; } return 0; }


TP jeu, trouver le mot aléatoire




#include <iostream> #include <string> #include <ctime> #include <cstdlib> using namespace std; string melangerMot(string motATrouver){ string motMelange; srand(time(0)); int pif(0); //tant que le mot a trouver a encore une lettre while(motATrouver.size()>0){ //on choisit un nombre au pif entre 0 et le nombre total de lettre pif = rand() % motATrouver.size(); //on ajoute la lettre correspondant au n° de la lettre de motATrouver à motMelange motMelange+=motATrouver[pif]; //on supprime la lettre correspondant au n° de la lettre motATrouver.erase(pif, 1); cout << motATrouver; } return motMelange; } int main() { string motATrouver; string motPourDeviner; cout << "Saisissez un mot :"<< endl; getline(cin, motATrouver); do{ cout << endl << "Remettez les lettres '"<< melangerMot(motATrouver) << "' dans le bon ordre :" << endl; getline(cin, motPourDeviner); }while(motPourDeviner!=motATrouver); cout << "Bravo !" << endl; return 0; }


Pointeur


Les variables sont stockés à des endroits précis dans la mémoire de l'ordinateur, par exemple "0x28ff0c".
Pour trouver où une variable est stockée, on la précède de "&" : &ageUtilisateur.
Pour stocker cette information, on utilise un type de variable spéciale : un pointeur. Ce type de variable sera précédé de "*".


#include <iostream> using namespace std; int main() { int ageUtilisateur(18); //mettre une étoile pour indiquer qu'on veut pointer vers une adresse mémoire int *ptr(&ageUtilisateur); cout << "L'adresse de 'ageUtilisateur' est : " << &ageUtilisateur << endl; cout << "La valeur de pointeur est : " << ptr << endl; cout << "La valeur pointée est : " << *ptr << endl; return 0; }


Dans l'exemple ci-dessus on a besoin du nom de la variable pour trouver où elle est stockée. On peut aussi directement pointer vers une adresse mémoire avec pointeur = reinterpret_cast<int*>(0x590d); mais si on pointe n'importe où ça fait surtout crasher le programme.

Dans cet exemple on pointe directement vers l'adresse 0x28ff1c, utilisé par "on ne sait quoi", ça peut fonctionner et donner la valeur de l'adresse mémoire, ou bien ça peut planter :

#include <iostream> using namespace std; int main() { int *pointeur(reinterpret_cast<int*>(0x28ff1c)); cout << "La valeur de pointeur est : " << pointeur << endl; cout << "La valeur pointée est : " << *pointeur << endl; return 0; }


Plusieurs fichiers


En général on découpe un projet en plusieurs fichiers pour éviter qu'on ait toutes les fonctions dans un même fichier et les avoir tout le temps sous le nez.

Par exemple, fichier main.cpp

#include <iostream> //appelle la librairie math.h qui permet de déclarer la fonction ajouteDeux #include "math.h" using namespace std; int main(){ int a(2); cout << ajouteDeux(a) << a << endl; return 0; }


La librairie qui va définir les fonctions (on voit ici les prototypes des fonctions, c'est à dire qu'on annonce les futures fonction) :

#ifndef MATH_H_INCLUDED #define MATH_H_INCLUDED int ajouteDeux(int nombreRecu); #endif // MATH_H_INCLUDED


On pourrait faire "int ajouteDeux(int nombreRecu=10)" si on voulait que le nombre reçu soit 2 par défaut.

Enfin, le fichier avec la fonction "ajoutedeux" :

#include "math.h" int ajouteDeux(int nombreRecu){ int valeur(nombreRecu + 2); return valeur; }


Dans les .h, ne pas utiliser "namespace std;" dans les .h pour éviter l'erreur "string does not name a type". Quand on utilisera une fonction, il faudra la préfixer de std, par exemple : std::cout.

Attention, quand on ajoute un nouveau fichier, il faut bien cocher "Add file" "in buld target" au moment de la création pour éviter une erreur "undefined reference to" (qui signifie que notre fichier n'est pas lié à la publication du programme).

Objets


Explication


Un objet est un morceau de code qui est généré à partir d'une classe (la classe est le plan de cet objet). Les objets ont des attributs (des variables, qui ne sortent en général pas de l'objet) et des méthodes (des fonctions, pour manipuler l'objet ou obtenir des infos sur l'objet). Par exemple, l'objet "string" a la méthode "substr", qu'on appelle ainsi :

int main() { string texte("Texte à couper"); cout << texte.substr(3) << endl; return 0; }

On ne peut pas modifier les attributs de l'objet string, à moins de modifier sa classe.

Exemple


Exemple avec la création d'une classe "oiseau" dont on va se servir pour générer 2 oiseaux :

#include <iostream> #include <string> using namespace std; class Oiseau { //n'importe qui peut accéder à ces methodes et attributs public: //Cette fonction est appelée "constructeur". En initialisant l'objet, que se passe-t-il ? Oiseau(){ //il a une taille par défaut taille=15; } //Sauf si on a saisi une taille Oiseau(int tailleSaisie){ taille=tailleSaisie; } //Methode pour faire chanter l'oiseau string chante() { return "Piou ! Piou !"; } //Methode pour connaitre la taille de l'oiseau int mesure() { return taille; } //seul la classe peut modifier ces méthodes et attributs private: int taille; }; int main() { //un oiseau par défaut et un oiseau avec une taille de 20 Oiseau oiseauGenerique, hirondelle(20); //faire chanter l'oiseau cout << oiseauGenerique.chante() << endl; cout << hirondelle.chante() << endl; //trouver la taille de l'oiseau cout << "L'oiseau generique mesure " << oiseauGenerique.mesure() << endl; cout << "L'hirondelle mesure " << hirondelle.mesure() << endl; return 0; }


Constructeurs


Pour la fonction d'initialisation (le constructeur), il existe également cette écriture alternative, qu'il est très fortement conseillé d'utiliser :

Oiseau() : taille(15), autrenomvar(valeur) { //Rien besoin de mettre ici }


A noter qu'on pourrait donner à "oiseauGenerique" de la façon suivante tous les paramètres d'un autre oiseau qui aurait été créé précédemment (on utilise ici un constructeur créé par défaut, le "constructeur de copie") :
Oiseau oiseauGenerique(autreoiseau);


Constantes


La methode "mesure", pour connaitre la taille de l'oiseau ne modifie pas l'objet. Dans le but de rendre le code plus clair et d'utiliser moins de mémoire, on peut préfixer cette méthode avec le mot-clef "const".
int Oiseau::mesure() const

Destruction d'un objet


La méthode pour détruire un objet n'est pas obligatoire. C'est le nom de l'objet précédé d'un tilde (~) :

Oiseau() { //chose qu'on veut faire à la suppression de l'objet }


Objet dans plusieurs fichiers



Le fichier Oiseau.h va définir la classe et ses propriétés et ses méthodes ;

#include "Oiseau.h" using namespace std; //En initialisant l'objet, que se passe-t-il ? Taille de 15 par défaut Oiseau::Oiseau() : taille(15) { } //Sauf si on a saisi une taille, c'est elle qui sera prise en compte Oiseau::Oiseau(int tailleSaisie):taille(tailleSaisie) { } //Methode pour faire chanter l'oiseau string Oiseau::chante() { return "Piou ! Piou !"; } //Methode pour connaitre la taille de l'oiseau int Oiseau::mesure() const { return taille; }


Le fichier Oiseau.cpp va donner le code de ces méthodes :

#include "Oiseau.h" using namespace std; //En initialisant l'objet, que se passe-t-il ? Oiseau::Oiseau(){ //il a une taille par défaut taille=15; } //Sauf si on a saisi une taille Oiseau::Oiseau(int tailleSaisie){ taille=tailleSaisie; } //Methode pour faire chanter l'oiseau string Oiseau::chante() { return "Piou ! Piou !"; } //Methode pour connaitre la taille de l'oiseau int Oiseau::mesure() { return taille; }


Enfin, le fichier main va lancer tout ça :

#include <iostream> #include "Oiseau.h" using namespace std; int main() { //un oiseau par défaut et un oiseau avec une taille de 20 Oiseau oiseauGenerique, hirondelle(20); //faire chanter l'oiseau cout << oiseauGenerique.chante() << endl; cout << hirondelle.chante() << endl; //trouver la taille de l'oiseau cout << "L'oiseau generique mesure " << oiseauGenerique.mesure() << endl; cout << "L'hirondelle mesure " << hirondelle.mesure() << endl; return 0; }