Utilisateur:Darkoneko/C plus plus
Un article de Wikipédia, l'encyclopédie libre.
http://www.sgi.com/tech/stl/table_of_contents.html
Pour les parametres à main, utiliser :
int main(int argc, char const * argv[])
et SURTOUT pas char ** argv ni même char * argv[]
C++
1e 1er standart ISO de C++ date seulement de 1999 !
cependant, les premiers balbutiements datent de 1983
/* un super programme en c++ */ #include <iostream> #include <string> //std est un namespace ou sont situé une serie d'outils //raccourcis de syntaxe using std::cout; //permet d'utiliser cout sans devoir mettre std:: devant using std::endl; //pareil using std::cin; //pareil using std::string; //pareil int main() { string nom; int age; cout << "What's your name and age ? " << endl; //si utilisé dans une condition, cin retourne true ou false //false si il n'a rien pu lire ou si l'une des car a eu des données incorrectes //(par exemple, des lettres dans un int) if ( (cin >> nom >> age) ) {//pour arreter le flux sans rien entrer, appuyer sur ctrl+d cout << "Hello " << nom << '!' << "\nTu as "<< age << "ans " << endl; return 0; } cout << "Ton nom est personne ! nom=\"" << nom << "\" ;age=\"" << age << '\"' << endl; return 1; }
Sommaire |
[modifier] gestion de l'etat d'erreur
[modifier] etats d'erreur de cin
- eof : fin de fichier
- fail : erreur (par exemple, type entre incompatible avec la variable) - note, les caracteres ayant cause le probleme sont remis dans le flux.
comment faire sortir cin de l'etat d'erreur ? (il bloque systematiquement apres une 1ere erreur)
-> cin.clear()
attention aux boucles infinies.
[modifier] compilation
[modifier] Makefile
Make peut avoir plusieurs noms
- nom officiel : Makefile (avec la majuscule)
- autres :
makefileouGNUmakefile(attention, certains trucs peuvent clocher avec makefile)
[modifier] Creation d'un fichier Makefile
quoi mettre dedans ?
voir compte (quand on créé Makefile sous vin ça créé automatiquement u ntruc par defaut bien remplie, merci ~manu)
un Makefile se divise en deux parties :
- les variables
- les règles
[modifier] coté variables
- NAME = nom de l'executable principal
- OBJS = tous les .o a integrer
note : pour pouvoir simuler une ligne sur plusieurs, il suffit de terminer les lignes intermediaires par \
OBJS = blabla.o tsss.o gnagna.o \ sprites.o gfx.o mano.o sounds.o
[modifier] Noms reservés
- $(RM) a pour valeur par défaut rm -f (sans confirmation)
- $(CC) compilateur par défaut de c
- $(CXX) compilateur par defaut de c++
[modifier] coté règles
Toutes les règles ont la même structure
certaines règles ont un nom réservé (.PHONY ...)
Toutes les lignes de commande doivent commencer par une tabulation
le prérequis peuvent etre une ou plusieurs variable/règles
les variables sont écrites $(nom)
une variable peu etre un fichier - permet par exemple de recompiler automatiquement tous les fichiers qui ne sont plus à jour
''nomCible'': ''prérequis éventuel'' commande1 commande2 ....
- pour permettre l'execution de règles meme si l'une des commande echoue : préfixer avec"-"
- pour que la commande ne s'affiche page lors de la compilation : préfixer avec "@"
.PHONY: permet de proteger certaines règles, de maniere à ce que la variable ne soit pas d'abord recherchée comme fichier avant d'etre recherchée comme regle (ex: si un fichier et une règle s'appellent "re", c'est le fichier qui est pris par defaut)
[modifier] 2006/01/26
[modifier] swap( , )
inverse 2 elements
[modifier] ite_swap( , )
inverse les elements contenus dans 2 iterateurs
[modifier] swap_ranges
permet d'inverser des zones de donnees - il ne faut pas que les intervalles se chevauchent
ex : swap_ranges(v.begin(), v.begin()+3, v.begin()+5);
- 1 2 3 4 5 6 7 8
->6 7 8 4 1 2 3 8
[modifier] copy
utilisation de copy pour l'affichage : iterateurs sur flux (ostream_iterator, istream_iterator)
ostream_iterator<string>(cout, "\n")
- chaque objet affiche sera fini par un passage a la ligne
- cette fonction est contenue dans la bibliotheque <iterator>
copy( vector<string> x, ostream_iterator<string>(cout, "\n") );
[modifier] rotate
rotate fait un decalage a gauche circulaire (le derniere se retrouve en premier si decalage a droite) des elements d'un conteneur.
[modifier] replace
replace : prend une sequence et lorrsqu'elle rencontre une valeur donnee, la remplace partout dans le conteneur
replace_if : pareil mais on precise la condition normale par une fonction predicat
replace_copy : au lieu de remplacer dans le conteneur, il cree un nouveau conteneur avec les nouvelles valeurs exemple d'affichage a la volee en conservant les valeurs d'origine
//toutes les chaines de <15 char seront remplacees par *** std::replace_copy_if(li.begin(), li.end(), std::ostream_iterator<string>(cout, "\n"), isTooShort, "***" );
[modifier] remove
remove "supprime" des elements. (fonction de type stable)
En fait, comme pour unique, il fait des deplacements internes et renvoie la nouvelle fin "normale" du conteneur
remove : par egalite
remove_if : par predicat
remove_copy, remove_copy_if : voir plus haut
[modifier] back_inserter
il ne s'agit non pas d'une fonction comme celles plus haut, mais d'un syteme gerant l'iterateur et permettant d'eviter d'avoir a preallouer un vecteur lorsque l'on fait un xxx_copy : il fait un push_back(x) automatiquement.
//mise du resultat dans un nouveau vecteur vector<string> newLi; cout << "--------------------------------------------------------------------------" << std::endl; //seules les chaunes d'au moins 15 char seront affichees std::remove_copy_if(li.begin(), li.end(), std::back_inserter(newLi), isTooShort);
[modifier] fill
fill : remplie un conteneur avec des trucs
fill_n
[modifier] iota
Note : n'est pas en C++ standart /!\ mais une extension
- appel de l bibliotheque : #include <ext/numeric>
- namespace (sous g++) : using __gnu_cxx:iota;
permet de remplir avec un truc incremente.
[modifier] transform
voir http://www.sgi.com/tech/stl/transform.html
[modifier] stream_iterator
istream_iterator : pour reperer la fin du flux, il faut comparer un iterator sans flux avec l'iterator local.
[modifier] Bindeur de fonctions
http://www.sgi.com/tech/stl/binder1st.html
http://www.sgi.com/tech/stl/binder2nd.html
fonctionnemment : un 'objet fonction', c'est un objet auquel on peut passer un operator () (tout comme ca pourrait etre ++, += ....)
transformer une fonction en objet-fnonction, utiliser ptr_fun(fonction)
on enrobe une fonction et un parametre dans l'objet, et du coup on n'a plus besoin que de lui passer le second en parametre
std::transform(std::istream_iterator<double>(cin), std::istream_iterator<double>(), std::ostream_iterator<double>(cout, " "), std::bind2nd(std::ptr_fun(times), multipliant);
[modifier] Fonctions prexistantes
voir STL : 6. Function Objects
[modifier] composer les fonctions entre elles
[modifier] conteneurs
[modifier] vector
- type : back_inserter (push_back(), pop_bask()...)
- acces aleatoire
- non trié
[modifier] map
- acces aleatoire
- trié : très rapide (acces dichotomique)
- insertion : lent
[modifier] list
systeme de liste doublement chainée
- PAS d'acces aléatoire
[modifier] deque
comme un vecteur, mais avec un push_front et pop_front performants
prévu spécifiquement pour inserer/virer des choses seulement/principalement à la fin ou au début d'une liste.
[modifier] hash_map
(pas standart, extension gnu) un peu comme map, mais sans tri. Très rapide!