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; 
}

/cout

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 : makefile ou GNUmakefile (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!