Stringh

------------------------------------------------------------------------------------
String est un objet.
Pour manipuler cet objet on inclut <string.h>
Pour créer un string, constructeur:
string maChaine("Bonjour")<<endl;
cout << maChaine;
maChaine = "ReBojour !";
accès à l'élément 3: maChaine[3]
+ pour contacéner deux string.
== pour comparer deux chaines (string)
des fonctions maChaine.size(), maChaine.erase(), etc.


------------------------------------------------------------------------------------

Objet

------------------------------------------------------------------------------------
class nom_du_class{
//attributs
    type nom ; // par exemple int toto; float tata;
    ...
    // méthodes, les fonctions
public: //la fonction ou l'attribut peut être appelée depuis l'extérieur de l'objet
    void function1(int x, int y, float z){
    }
private: //l'attribut ou la méthode ne peut pas être appelé depuis l'extérieur de l'objet (c'est par défault aussi)
    int function2(int x, ...){
    }
}

les définitions des class et les prototypes des focntions dans .h; les définitions des fonctions dans .cpp.
    void nom_du_class::function1(int x, int y, float z){ le programme }

Constructeur:
prototype dans la déclaration de la class: nom_du_class();
définition dans le .cpp:
nom_du_class::nom_du_class(){
    nom1 = valeur1;
    nom2 = valeur2;
    etc
}
pas de retour pour un constructeur (pas de void non plus)
Autre façon d'initialiser qui est équivalene:
nom_du_class::nom_du_class() : nom1(valeur1) , nom2(valeur2) { //rien ici
}

namespace:
exemple pour un constructeur avec string
class nom_du_class {
string nomArme, etc ...
Et qu'on veut créer et initialiser le constructeur, quand on ajoute le prototype dans .h, nous somme obligé d'ajouter
nom_du_class(std::string nomArme, ...)
Parceque on n'utilise pas la directive "using namespace std;" dans .h
mais dans .cpp, on peut ajouter cette directive dès le départ et donc
nom_du_class ::nom_du_class (string nomArmeVal, int xVal) :nom_Arme(nomArmeVal), x(xVal){}; 


destructeur
Dans le .h : ~nom_du_class();
dans .cpp: nom_du_class ::~nom_du_class (){ ...}

Heritage
"Objet1" est un "objet2" (donc objet 2 est la mère et objet1 est la fille qui hérite de la mère)
exemple: Nissan est une voiture (en gors elle est une voiture mais elle a d'autres caractéristiques)
class mere{ methodes et attribus}
class fille : public nom_de_mere{ méthodes et attributs}

Les portées: public, private, et maintenant entre les deux: protected. Pour cette portée, les attributs et les méthodes sont aussi accessibles depuis les classes filles.
(il est même utile de ne déclarer que des "protected" au lieu de private)

méthode static: les méthodes statiques appartiennet à la classe mais pas à l'objet instancié. Par exemple
public:
static void maFonction() est appelée comme nom_de_class::maFonction() depuis l'exterieur d'objets. Le mot clé static est dans le prototype (.h) mais pas dans la définition de la fonction dans .cpp
intérêt : rangé des fonctions liés dans une classe, et éviter des conflits de noms.

Attribut static:
C'est une variable unique accessible par tous les objets instanciés. L'initialisation se fait dans l'espace global, en dehors de toutes fonctions (en dehors de main aussi).
dans la class nom_de_class: (dans la partie public ou privée, de toute façon il sera accessible de l'exterieur.
static int maVariable;
et puis dans l'espace global: int nom_de_class::maVariable = 5;
exemple d'utilisation: compteur de nombre d'objet d'une clsse. Initialisé à zéro, dans le constructeur on l'incrémente, dans le destructeur on le décrémente.