int a; // un commentaire
a = 2*b; int c = b+2; // déclaré là où il sert, initialisé en même temps for( int i=0; i<3; ++i ){ // dans la dernière norme, la portée de i ... // est limitée à la boucle }
const double PI = 3.14; // permet d'éviter #define
inline int max_int( int a, int b ) // permet d'éviter #define { return a>b ? a : b; }
template <class T> inline // fonctionne pour tout type T max_generique( T a, T b ){ return a>b ? a : b; } // muni de l'operateur >Déclaration et définition de méthode générique doivent figurer dans le même fichier.
void permute( int& a, int& b ){ // notez les & int tmp=a; a=b; b=tmp; // simplifie l'écriture } double volume( const Cube& c ); // méthode ne modifiant pas le paramètre
int a; double b; cin >> a >> b; // remplace scanf cout<<"valeurs: "<< a <<", "<< b << endl; // remplace printf
double *b = new double; // remplace malloc delete b; // remplace free double *v = new double[3]; delete[] v;
class A { public: A(int a, double b); // un constructeur ~A(); // le destructeur void set_a(int a); // une méthode membre int get_a() const; // méthode ne modifiant pas l'objet virtual void affiche(); // typage dynamique static char* className(); // méthode indépendante de l'instance protected: // données et méthodes réservées aux classes dérivées private: // données et méthodes cachées int le_a; double le_b; // méthodes externes ayant accès à la partie privée friend ostream& operator << (ostream&, const A&); friend istream& operator >> (istream&, A&); }; A::A(int a, double b) // constructeur : le_a(a), le_b(b) // assigner des valeurs lors de la construction { cout<<"creation d'un A"<<endl; } // autres opérations void A::set_a(int a){ le_a = a; // assigner des valeurs après construction } ostream& operator << (ostream& out, const A& a){ out << a.le_a <<", "<< a.le_b; return out; } istream& operator >> (istream& in, A& a){ in >> a.le_a >> a.le_b; return in; } A a(3,2.2); a.affiche(); A* b = new A(1,5.3); b->affiche(); cin >> a >> b; cout << a <<" "<< b <<endl; delete b; // toujours pas de ramasse-miettes
class B: public A { ... }; // un héritage simple class D: public B public C { ... }; // un héritage multiple
namespace mon_app { typedef int* vector; // vector=tableau d'entiers vector un_vec(); } namespace son_app { typedef double vector[3]; // vector=tableau de 3 double vector un_vec(); } mon_app::vector v = mon_app::un_vec(); // pas de confusion son_app::vector vec = son_app::un_vec();
std::vector<double> mon_vec(4); // tableau redimensionnable de 4 double std::list<int> ma_liste; // liste doublement chaînée d'entiers (vide) template<class Container> void met_a_zero( Container& c ) // méthode générique { Container::iterator i; // sert à désigner un élément for( i=c.begin(); i!=c.end(); ++i ){ // contrôle d'itération *i = 0; // déréferencer avec * } // applicable à tout conteneur STL } met_a_zero( mon_vec ); met_a_zero( ma_liste );