Éléments de syntaxe en C++ par l'exemple (POO)

#include<iostream>

using namespace std;

int main()
{
  cout << "Age: "
       << (20+3)
       <<  " ans, "
       << "Taille: "
       << 1.82
       << 'm'
       << '\n';
  return 0;
}

#include<iostream>

using namespace std;

int main()
{
  int entier1;
  int entier2;
  cout << "Donnez le premier entier: \n";
  cin >> entier1;
  cout << "\nDonnez le deuxième entier: \n";
  cin >> entier2;
  cout << "\nLa somme de " 
       << entier1 
       << " et de " << entier2 
       << " est " << (entier1+entier2) << '\n';
  return 0;
}

#include<iostream>

using namespace std;

int main()
{
   cout << "Table de multiplication de 9:\n";
   for(int i = 0; i <= 10; i++)
   {
      cout << i << '*' << 9 <<  " = " << (i*9) << '\n';
   }
  return 0;
}

#include<iostream>

using namespace std;

int main()
{
   cout << "Table de multiplication de 9:\n";
   int i =0;
   while(i <= 10)
   {
      cout << i << '*' << 9 <<  " = " << (i*9) << '\n';
      ++i;
   }
   return 0;
}

#include<iostream>

using namespace std;

int main()
{
   cout << "Table de multiplication de 9:\n";
   int i =0;
   do
   {
      cout << i << '*' << 9 <<  " = " << (i*9) << '\n';
      ++i;
   }
   while(i<11);
   return 0;
}

#include<iostream>

using namespace std;

int main()
{
   int i;
   cin >> i;
   if( i % 2 == 0) // % c'est le modulo
   {
      cout << "L'entier " << i << " est pair.\n";
   }
   else
   {
      cout << "L'entier " << i << " est impair.\n";
   }
  return 0;
}

#include<iostream>

using namespace std;

int main()
{
   char caractereLu;
   cin >> caractereLu;
   switch(caractereLu)
   {
   case 'a' : { cout << "voyelle\n"; break; }
   case 'e' : { cout << "voyelle\n"; break; }
   case 'i' : { cout << "voyelle\n"; break; }
   case 'o' : { cout << "voyelle\n"; break; }
   case 'u' : { cout << "voyelle\n"; break; }
   case 'y' : { cout << "voyelle\n"; break; }
   case 'A' : { cout << "voyelle\n"; break; }
   case 'E' : { cout << "voyelle\n"; break; }
   case 'I' : { cout << "voyelle\n"; break; }
   case 'O' : { cout << "voyelle\n"; break; }
   case 'U' : { cout << "voyelle\n"; break; }
   case 'Y' : { cout << "voyelle\n"; break; }
   default: { cout << "si c'est une lettre, c'est une consonne, sinon ce n'est même pas une lettre\n"; }
   }

   return 0;
}

#include<vector>
#include<iostream>
using namespace std;

int main()
{
  vector<int> vecteur;
  vecteur.push_back(10);
  vecteur.push_back(20);
  vecteur.push_back(30);
  for(size_t i = 0;  i < vecteur.size(); ++i)
  {
     cout << "L'entier à l'indice " 
          << i << " dans le vecteur est: " 
          << vecteur.at(i) 
          << '\n';
  }
  // changer la valeur de l'indice 1: 20 -> 40
  vecteur.at(1) = 40;
  // copier un tableau
  vector <int> copie(vecteur);
  // effacer le contenu d'un tableau
  copie.clear();
  // reaffecter le contenu du tableau vecteur
  copie = vecteur;
}

#include<vector>
#include<string>
#include<iostream>
using namespace std;

int main()
{
  vector<string> vecteur;
  vecteur.push_back("vache");
  vecteur.push_back("cochon");
  vecteur.push_back("mouton");
  cout << "Voici les animaux de la ferme: \n";
  for(size_t i = 0;  i < vecteur.size(); ++i)
  {
     cout << vecteur.at(i) << " "  
          << '\n';
  }
  cout << "Le premier animal est " <<  vecteur.front() << '\n';
  cout << "Le dernier animal est " <<  vecteur.back() << '\n';
}

#ifndef A_H
#define A_H

class A
{
// ici on déclare les méthodes, les attributs, les constructeurs, le destructeur.


};


#endif

#include"A.h" // on include d'abord la déclaration de la classe A

// definition des méthodes, des constructeurs et de destructeur de la classe A.

#ifndef A_H
#define A_H

#include<string>
#include<vector>
#include"B.h"

using namespace std;

class A
{
private: // accès privé
  int _attribut1;  // un simple entier
  char _attribut2; // un simple caractère 
  string _attribut3; // une chaîne de caractère
  vector<int> _attribut4; // un vecteur d'entier
  A * _attribut5; // un pointeur sur un objet de type A
  B _attribut6; // un objet de type B
  vector<B *> _attribut7; // un vecteur de pointeurs sur des objets de type B 
  vector<A *> _attribut8; // un vecteur de pointeurs sur des objets de type A
  // ....


};


#endif

#ifndef A_H
#define A_H

class A
{
private:
   int _attribut1;
   B * _attribut2;
   string _attribut3;

public:

   ~A();  // destructeur unique

};
#endif

A::~A()
{}

A::~A()
{
   delete _attribut2; // on détruit l'objet pointé par _attribut2
}

#include "A.h"

void uneFonction(string etiquette, int nombre)
{
   A objet1; // creation par défaut
   A objet2(etiquette,nombre); // creation paramétrée
   A objet3(objet2);   // creation par copie

   cout << "Etiquette de l'objet2 " << objet2.etiquette() << '\n';
   cout << "Entier de l'objet1 " << objet1.entier() << '\n';
   objet3.modifieEntier(40);
   objet3.modifieEtiquette("titi");
   cout << "Les étiquettes de objet2 et objet3 sont-elles les mêmes ?" 
        << (objet3.etiquette() == objet2.etiquette());
} // destruction automatique des objets 1 2 et 3 en fin de focntion

#include "A.h"

void uneFonction(string etiquette, int nombre)
{
   A * objet1 = new A(); // creation par défaut
   A * objet2 = new A(etiquette,nombre); // creation paramétrée
   A * objet3 = new A(objet2);   // creation par copie

   // ici objet1-2-3 sont des pointeurs sur des objets

   cout << "Etiquette de l'objet2 " << objet2->etiquette() << '\n';
   cout << "Entier de l'objet1 " << objet1->entier() << '\n';
   objet3->modifieEntier(40);
   objet3->modifieEtiquette("titi");
   cout << "Les étiquettes de objet2 et objet3 sont-elles les mêmes ?" 
        << (objet3->etiquette() == objet2->etiquette());

   // destruction explicite des objets 1 2 et 3 en fin de fonction s'ils deviennent inutiles
   delete objet1;
   delete objet2;
   delete objet3;
}

class A 
{
 ...


};

#include "A.h"

class B : public A
{


};

class A 
{
  private:
    int _attribA; // attribut de A

  public:  
    A();
    A(int i);
};

class B : public A
{
  private:
    int _attribB; // attribut de B

  public:  
    B();
    B(int i,int j);
};

#include "B.h"

// appel du constructeur par défaut de A et initialisation de 
// _attribB à 0
B::B():A(),_attribB(0) {}

// appel du constructeur paramétré de A et initialisation de 
// _attribB à j
B::B(int i,int j): A(i),_attribB(j){}

};

class A 
{
 ...
     virtual int meth(int i);
 ...
     virtual ~A();
};

class B: public A
{
 ...
     virtual int meth(int i);
 ...
     virtual ~B();
};

int B::meth(int i)
{
   // A::meth est la méthode meth de la classe A
   // B::meth est la méthode meth spécialisée de la classe fille B
   return A::meth(i)+3;
}

class A 
{
  protected:
    int _attribA; // attribut de A protégé, la classe B y a accès


};