# Cour 3 -- Language Orienté Objet avancé (C++)

###### tags `cour` `M1 S1` `cpp`
[Somaire](/V1WXmN9oTdauw8pTXPhqrQ)\
[Precedent](fKuIq0FAQaCvXKklO6Xgew)
> [time= 21 sept 2020]

[TOC]

## les Class
décalaration

class MaClass
{
//...
};

La class défini est un nouveau type.

Dans une class on a:
- des attribut (des champs)
- des methodes

En C++ on a des:
- **déclaration** \
on déclarre juste la forme de notre objet (le .hpp)
- **définition** (dans le .cpp)\
on défini le code des méthodes (.cpp)

//définition de la méthode deposer de l'objet CompteEnBanque
void CompteEnBanque::deposer(int s) 
{ 
    solde += s;
}
// définition d'une fonction déposer
void deposer(int s) 
{ 
    solde += s;
}

## initialisation et construction
Pour initialiser une utilise les constructeurs. (ctors)
Définition du constructeur:
- porte le nom est une méthode qui va porter le nom de la class
- n'a pas de type de retour
- plusieur constructeur peuvent etre défini

class CompteEnBanque
{
private:
    int solde;
    
public:
    CompteEnBanque(); //contructeur
}
CompteEnBanque::CompteEnBanque()
{
    solde = 0;
}
int main()
{
    CompteEnBanque mon_premier_compte;
}

Si on crée une class avec un constructeur avec un parametre on a le droit d'utiliser l'initialisation comme un type primitif.

MyClass o(3); //initialisation habituel
MyClass o = 3; //initialisation comme type primitif
MyClass o{3}; //initialisation c++11
MyClass o = {3}; // l’initialisation C++11 (verbose style)

Attention le compilateur fait des optimisation a l'initialisation.
Si on fveut éviter ccela on utilise: `gcc -fno-elide-constructors`.

## Destructeur
Le destructeur supprime l'objet (d-tor).
On défini le destructeur *~*.\
ajouter virtual devant le destructeur.

## constructeur de copy
Un destucteur (dtor) est défini par:
- une méthode préfixé par **~**
- sans type de renvoie
- la califier de `virtual`

class MayClass
{
    //constructeur
    MyClass();
    
    /*
     * constructeur de copy
     * (notemement utiliser par les passage par valeur)
     */
    MyClass(const MyClass &);
    
    // destructeur
    virtual ~MyClass();
}

## Objet constant
utile pour:
- prog concurente
- meilleur optimisations

Pour cela on ajoute **const** a la fin de la méthode.\
On peut donc utiliser sur l'objet const que les fonction nomé const.\
On ne peut pas changer les attribut de la class dans cette méthode.

class Nombre
{
public:
    Nombre(...);
    long to_long() const;
    int to_int() const;
    void set(long v);
    void set(int v);
}

int main()
{
    Nombre n(...);
    n.set(45L);
    long l = n.toLong();
    const Nombre zero(...);
    l = zero.toLong();
    //zero.set(23); //interdit
}

### mutable
Pour changer un attribut dans une méthod const on la note **mutable**

class Compte {
private:
  int position;
  mutable int nbTransactions; //objet mutable dans les méthode const
public:
  int getPosition() const {
    nbTransactions++; // on change la valteur de notre objet mutable
    return position;
  }
   };

### attribut constant
On a un attribut qui peut que etre initialisé.
Et ne peut etre changer par la suite.

class Individu{
private:
    int numeroSecu;
    
public:
    Individu(...);
};

Individu::Individu(...)
: numeroSecu{...}
{}

## Objets volatiles
Permet d’empêcher toute optimisation de compilation (en particulier tout mécanisme de cache de valeur) sur une variable donnée.
- Une telle variable peut être modifiée à l’insu du programme lui-même
- modifiée par un autre thread

Peut etre en **const** pour ne pas pouvoir modifié la valeur.

int main() 
{
    volatile const int * const mouseButtonState = 
    reinterpret_cast<int *>(0xDEADBABE); 
    // peut etre modifié mais pas par ce pointeur
}

## moi je..
L'objet pour parler de lui meme utilise **this**.
Ce qui permet:
- lever une certaine ambiguité
- absoluement néssaire lorsqu'un objet veuut agir de son propre chef et s’inscrire dans un scénario

[suivant](/xWa96-AGQI6G__rHTzd0Tg)