---
# System prepended metadata

title: Cour 3 -- Language Orienté Objet avancé (C++)
tags: [M1 S1, cpp, cour]

---

# 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
```cpp
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)

```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
```cpp=
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.
```cpp
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`

```cpp
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.

```cpp
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**
```cpp=
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.

```cpp=
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.

```cpp
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)