#include <iostream>

int main()
{
        std::cout << "Hello world!" << std::endl;
        return 0;
}

#include <iostream>

int main()
{
    // ...
    return 0;
}

std::cout << "Hello world!" << std::endl;

std::cout << "Hello world!" << std::endl;

using namespace std;

#include <iostream>

using namespace std;

int main()
{
        cout << "Hello world!" << endl;
        return 0;
}

cout << "Hello world!" << endl;

cout << "Hello world!\n";

int main()
{
    int age = 21;
    cout << "Salut, j'ai " << age << " ans" << endl;
    return 0;
}

int main()
{
    int age = 21;
    char pseudo[] = "M@teo21";
    cout << "Salut, j'ai " << age << " ans et je m'appelle " << pseudo << endl;
    return 0;
}

cout << "Salut, j'ai " << age << " ans" << endl;
cout << "Je m'appelle " << pseudo << endl;

cin >> age;

#include <iostream>

using namespace std;

int main()
{
    int age = 0;
    cout << "Quel age avez-vous ?" << endl;
    cin >> age;
    cout << "Ah ! Vous avez donc " << age << " ans !" << endl;
    return 0;
}

#include <iostream>

using namespace std;

int main()
{
    char pseudo[50];
    cout << "Quel est votre pseudo ?" << endl;
    cin >> pseudo;
    cout << "Salut " << pseudo << endl;
    return 0;
}

bool majeur = true;
int age = 21;

if (majeur == true) // S'il est majeur (forme longue)
{
    // ...
}

if (majeur) // S'il est majeur (forme courte)
{
    // ...
}

if (!majeur) // S'il n'est PAS majeur
{
    // ...
}

void maFonction()
{
    FILE* fichier = NULL;
    fichier = fopen("exemple.txt", "r");

    if (fichier != NULL)
    {
        fonction();

        double prixOrigine = 0.0; // Déclaration au milieu
        fscanf(fichier, "%lf", &prixOrigine);
        
        double prixAchat = 0.0; // Autre déclaration au milieu
        fscanf(fichier, "%lf", &prixAchat);
        
        double difference = prixAchat - prixOrigine; // Encore autre déclaration au milieu
        // etc.
    }
}

void maFonction()
{
    FILE* fichier = NULL;
    fichier = fopen("exemple.txt", "r");

    if (fichier != NULL)
    {
        fonction();

        double prixOrigine = 0.0; // Création de prixOrigine
        fscanf(fichier, "%lf", &prixOrigine);
        
        double prixAchat = 0.0; // Création de prixAchat
        fscanf(fichier, "%lf", &prixAchat);
        
        double difference = prixAchat - prixOrigine; // Création de difference
    } // Destruction automatique de prixOrigine, prixAchat et difference
} // Destruction automatique de fichier

void maFonction()
{
    /* Plein de code
    ....
    ....
    */

    for (int i = 0 ; i < 10 ; i++) // Déclaration de i
    {

    } // Destruction automatique de i
}

int *variable = NULL;

variable = new int; // Allocation dynamique

delete variable; // Libération de mémoire

int main()
{
    int *variable = NULL;

    variable = new int; // Allocation de mémoire

    delete variable; // Libération de mémoire

    return 0;
}

int *tableau = NULL;

tableau = new int[20]; // Allocation de mémoire (20 cases)

tableau = new int[taille]; // Allocation de mémoire ("taille" cases)

delete[] tableau; // Libération de mémoire

int main()
{
    int *tableau = NULL;

    tableau = new int[20]; // Allocation de mémoire (tableau)

    delete[] tableau; // Libération de mémoire (tableau)

    return 0;
}

// Le typedef est réalisé automatiquement par le compilateur, pas besoin de l'écrire

struct Coordonnees
{
    int x;
    int y;
};

Coordonnees point; // Le mot-clé struct est inutile grâce au typedef automatique

int &referenceSurAge;

int age = 21; // Déclaration de la variable age (rien de nouveau)
int &referenceSurAge = age; // Déclaration et initialisation d'une référence sur la variable age

int main()
{
    int age = 21;
    int &referenceSurAge = age;

    cout << referenceSurAge << endl;
    cout << age << endl;

    referenceSurAge = 40;

    cout << referenceSurAge << endl;
    cout << age << endl;


    return 0;
}

struct Coordonnees
{
    int x;
    int y;
};

int main()
{
    Coordonnees point;
    Coordonnees &referenceSurPoint = point;

    referenceSurPoint.x = 10;
    referenceSurPoint.y = 5;

    cout << "x : " << referenceSurPoint.x << endl;
    cout << "y : " << referenceSurPoint.y << endl;


    return 0;
}

struct Coordonnees
{
    int x;
    int y;
};

void remiseAZero(Coordonnees &pointAModifier);

int main()
{
    Coordonnees point;

    remiseAZero(point); // Pas besoin d'indiquer l'adresse de point avec un & lors de l'appel

    return 0;
}

void remiseAZero(Coordonnees &pointAModifier) // La fonction indique qu'elle récupère une référence
{
    // La référence s'utilise exactement comme une variable
    // On utilise donc des points "." et non des flèches "->"
    pointAModifier.x = 0;
    pointAModifier.y = 0;
}

remiseAZero(point);

void remiseAZero(Coordonnees &pointAModifier)

pointAModifier.x = 0;
pointAModifier.y = 0;

int nombreDeSecondes(int heures, int minutes, int secondes)
{
    int total = 0;

    total = heures * 60 * 60;
    total += minutes * 60;
    total += secondes;

    return total;
}

#include <iostream>

using namespace std;

// Prototype de la fonction
int nombreDeSecondes(int heures, int minutes, int secondes);

// Main
int main()
{
    cout << nombreDeSecondes(1, 10, 25) << endl;

    return 0;
}

// Définition de la fonction
int nombreDeSecondes(int heures, int minutes, int secondes)
{
    int total = 0;

    total = heures * 60 * 60;
    total += minutes * 60;
    total += secondes;

    return total;
}

int nombreDeSecondes(int heures, int minutes = 0, int secondes = 0);

#include <iostream>

using namespace std;

// Prototype avec les valeurs par défaut
int nombreDeSecondes(int heures, int minutes = 0, int secondes = 0);

// Main
int main()
{
    cout << nombreDeSecondes(1, 10, 25) << endl;

    return 0;
}

// Définition de la fonction, SANS les valeurs par défaut
int nombreDeSecondes(int heures, int minutes, int secondes)
{
    int total = 0;

    total = heures * 60 * 60;
    total += minutes * 60;
    total += secondes;

    return total;
}

cout << nombreDeSecondes(1) << endl;

cout << nombreDeSecondes(1, 10) << endl;

cout << nombreDeSecondes(1,,25) << endl;

cout << nombreDeSecondes(1, 0, 25) << endl;

int nombreDeSecondes(int heures = 0, int minutes, int secondes);
                                  // Erreur, les paramètres par défaut doivent être à droite

int nombreDeSecondes(int secondes, int minutes, int heures = 0);
                                                // OK

int nombreDeSecondes(int heures = 0, int minutes = 0, int secondes = 0);

cout << nombreDeSecondes() << endl;

int somme(int nb1, int nb2)
{
    return nb1 + nb2;
}

double somme(double nb1, double nb2)
{
    return nb1 + nb2;
}

int somme(int nb1, int nb2);
double somme(double nb1, double nb2);

somme(int, int)
somme(double, double)

#include <iostream>

using namespace std;


int somme(int nb1, int nb2);
double somme(double nb1, double nb2);

int main()
{
    cout << somme(10, 15) << endl << somme(2.5, 0.3) << endl;

    return 0;
}

int somme(int nb1, int nb2)
{
    return nb1 + nb2;
}

double somme(double nb1, double nb2)
{
    return nb1 + nb2;
}

double somme(int nb1, double nb2)
{
    return nb1 + nb2;
}

int somme(int nb1, int nb2, int nb3)
{
    return nb1 + nb2 + nb3;
}

inline int carre(int nombre);

int main()
{
    cout << carre(10) << endl;

    return 0;
}

inline int carre(int nombre)
{
    return nombre * nombre;
}

int main()
{
    cout << 10 * 10 << endl;

    return 0;
}

#include <iostream>
#include <string> // Obligatoire pour pouvoir utiliser les objets string
 
using namespace std;
 
 
int main()
{
    string maChaine; // Création d'un objet "maChaine" de type string
 
    return 0;
}

int main()
{
    string maChaine("Bonjour !"); // Création d'un objet "maChaine" de type string et affectation
 
    return 0;
}

int main()
{
    string maChaine = "Bonjour !"; // Création d'un objet "maChaine" de type string et affectation
 
    return 0;
}

int main()
{
    string maChaine = "Bonjour !";
    cout << maChaine << endl; // Affichage du string comme si c'était une chaîne de caractères
 
    return 0;
}

int main()
{
    string maChaine = "Bonjour !";
    cout << maChaine << endl;
    
    maChaine = "Bien le bonjour !";
    cout << maChaine << endl;
 
    return 0;
}

int main()
{
    string chaine1 = "Bonjour !";
    string chaine2 = "Comment allez-vous ?";
    string chaine3;
 
    chaine3 = chaine1 + chaine2; // 3... 2... 1... Concaténatioooooon
    cout << chaine3 << endl;
 
    return 0;
}

chaine3 = chaine1 + " " + chaine2;

int main()
{
    string chaine1 = "Bonjour !";
    string chaine2 = "Comment allez-vous ?";
 
    if (chaine1 == chaine2) // Faux
    {
        cout << "Les chaines sont identiques" << endl;
    }
    else
    {
        cout << "Les chaines sont differentes" << endl;
    }
 
    return 0;
}

int main()
{
    string chaine1 = "Bonjour !";
    string chaine2 = "Bonjour !";
 
    if (chaine1 == chaine2) // Vrai
    {
        cout << "Les chaines sont identiques" << endl;
    }
    else
    {
        cout << "Les chaines sont differentes" << endl;
    }
 
    return 0;
}

maChaine.size()

int main()
{
    string maChaine = "Bonjour !";
    cout << "Longueur de la chaine : " << maChaine.size();
 
    return 0;
}

maChaine.size()

int main()
{
    string chaine = "Bonjour !";
    chaine.erase();
    cout << "La chaine contient : " << chaine << endl;
 
    return 0;
}

string substr( size_type index, size_type num = npos );

int main()
{
    string chaine = "Bonjour !";
    cout << chaine.substr(3) << endl;
 
    return 0;
}

int main()
{
    string chaine = "Bonjour !";
    cout << chaine.substr(3, 4) << endl;
 
    return 0;
}

int main()
{
    string chaine = "Bonjour !";
    const char* chaineC = NULL;
 
    chaineC = chaine.c_str(); // On récupère le tableau de char dans chaineC
    cout << "La chaine contient : " << chaineC << endl; // On l'affiche pour vérifier que ça fonctionne
 
    return 0;
}

class Personnage
{
    
}; // N'oubliez pas le point-virgule à la fin !

class Personnage
{
    int m_vie;
    int m_mana;
    string m_nomArme;
    int m_degatsArme;
};

class Personnage
{
    // Méthodes
    void recevoirDegats(int nbDegats)
    {

    }

    void attaquer(Personnage &cible)
    {

    }

    void boirePotionDeVie(int quantitePotion)
    {

    }

    void changerArme(string nomNouvelleArme, int degatsNouvelleArme)
    {

    }

    bool estVivant()
    {

    }

    // Attributs
    int m_vie;
    int m_mana;
    string m_nomArme;
    int m_degatsArme;    
};

#include <iostream>
#include <string>
 
using namespace std;
 
class Personnage
{
    // Méthodes
    void recevoirDegats(int nbDegats)
    {
 
    }
 
    void attaquer(Personnage &cible)
    {
 
    }
 
    void boirePotionDeVie(int quantitePotion)
    {
 
    }
 
    void changerArme(string nomNouvelleArme, int degatsNouvelleArme)
    {
 
    }
 
    bool estVivant()
    {
 
    }
 
    // Attributs
    int m_vie;
    int m_mana;
    string m_nomArme;
    int m_degatsArme;
};
 
int main()
{
    Personnage david, goliath; // Création de 2 objets de type Personnage : david et goliath
 
    goliath.attaquer(david); // goliath attaque david
    david.boirePotionDeVie(20); // david boit une potion de vie qui lui rapporte 20 de vie
    goliath.attaquer(david); // goliath réattaque david
    david.attaquer(goliath); // david contre-attaque... c'est assez clair non ? ^^
    goliath.changerArme("Double hache tranchante vénéneuse de la mort", 40);
    goliath.attaquer(david);
 
 
    return 0;
}

class Personnage
{
    // Tout ce qui suit est public (accessible depuis l'extérieur)
    public:
    
    void recevoirDegats(int nbDegats)
    {
 
    }
 
    void attaquer(Personnage &cible)
    {
 
    }
 
    void boirePotionDeVie(int quantitePotion)
    {
 
    }
 
    void changerArme(string nomNouvelleArme, int degatsNouvelleArme)
    {
 
    }
 
    bool estVivant()
    {
 
    }
 
    // Tout ce qui suit est privé (inaccessible depuis l'extérieur)
    private:
    
    int m_vie;
    int m_mana;
    string m_nomArme;
    int m_degatsArme;
};

goliath.m_vie = 90;

#ifndef DEF_PERSONNAGE
#define DEF_PERSONNAGE

class Personnage
{
    public:

    void recevoirDegats(int nbDegats);
    void attaquer(Personnage &cible);
    void boirePotionDeVie(int quantitePotion);
    void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
    bool estVivant();


    private:

    int m_vie;
    int m_mana;
    std::string m_nomArme; // Pas de using namespace std, donc il faut mettre std:: devant string.
    int m_degatsArme;
};

#endif

#include <string>
#include "Personnage.h"

using namespace std;

void Personnage::recevoirDegats(int nbDegats)
{

}

void Personnage::recevoirDegats(int nbDegats)
{
    m_vie -= nbDegats; // On enlève le nombre de dégâts reçus à la vie du personnage
    
    if (m_vie < 0) // Pour éviter d'avoir une vie négative
    {
        m_vie = 0; // On met la vie à 0 (ça veut dire mort)
    }
}

void Personnage::attaquer(Personnage &cible)
{
    cible.recevoirDegats(m_degatsArme); // On inflige à la cible les dégâts que causent notre arme
}

void Personnage::boirePotionDeVie(int quantitePotion)
{
    m_vie += quantitePotion;

    if (m_vie > 100) // Interdiction de dépasser 100 de vie
    {
        m_vie = 100;
    }
}

void Personnage::changerArme(string nomNouvelleArme, int degatsNouvelleArme)
{
    m_nomArme = nomNouvelleArme;
    m_degatsArme = degatsNouvelleArme;
}

bool Personnage::estVivant()
{
    if (m_vie > 0) // Plus de 0 de vie ?
    {
        return true; // VRAI, il est vivant !
    }
    else
    {
        return false; // FAUX, il n'est plus vivant !
    }
}

#include <string>
#include "Personnage.h"

using namespace std;

void Personnage::recevoirDegats(int nbDegats)
{
    m_vie -= nbDegats; // On enlève le nombre de dégâts reçus à la vie du personnage

    if (m_vie < 0) // Pour éviter d'avoir une vie négative
    {
        m_vie = 0; // On met la vie à 0 (ça veut dire mort)
    }
}

void Personnage::attaquer(Personnage &cible)
{
    cible.recevoirDegats(m_degatsArme); // On inflige à la cible les dégâts que causent notre arme
}

void Personnage::boirePotionDeVie(int quantitePotion)
{
    m_vie += quantitePotion;

    if (m_vie > 100) // Interdiction de dépasser 100 de vie
    {
        m_vie = 100;
    }
}

void Personnage::changerArme(string nomNouvelleArme, int degatsNouvelleArme)
{
    m_nomArme = nomNouvelleArme;
    m_degatsArme = degatsNouvelleArme;
}

bool Personnage::estVivant()
{
    if (m_vie > 0) // Plus de 0 de vie ?
    {
        return true; // VRAI, il est vivant !
    }
    else
    {
        return false; // FAUX, il n'est plus vivant !
    }
}

#include "Personnage.h" // Ne pas oublier

#include <iostream>
#include <string>
#include "Personnage.h" // Ne pas oublier

using namespace std;


int main()
{
    Personnage david, goliath; // Création de 2 objets de type Personnage : david et goliath

    goliath.attaquer(david); // goliath attaque david
    david.boirePotionDeVie(20); // david boit une potion de vie qui lui rapporte 20 de vie
    goliath.attaquer(david); // goliath réattaque david
    david.attaquer(goliath); // david contre-attaque... c'est assez clair non ? ^^
    goliath.changerArme("Double hache tranchante vénéneuse de la mort", 40);
    goliath.attaquer(david);


    return 0;
}

Personnage david, goliath;

#include <string>
 
class Personnage
{
    public:
 
    void recevoirDegats(int nbDegats);
    void attaquer(Personnage &cible);
    void boirePotionDeVie(int quantitePotion);
    void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
    bool estVivant();
 
 
    private:
 
    int m_vie;
    int m_mana;
    std::string m_nomArme;
    int m_degatsArme;
};

#include <string>
 
class Personnage
{
    public:
 
    Personnage(); // Constructeur
    void recevoirDegats(int nbDegats);
    void attaquer(Personnage &cible);
    void boirePotionDeVie(int quantitePotion);
    void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
    bool estVivant();
 
 
    private:
 
    int m_vie;
    int m_mana;
    std::string m_nomArme;
    int m_degatsArme;
};

Personnage::Personnage()
{
    m_vie = 100;
    m_mana = 100;
    m_nomArme = "Epée rouillée";
    m_degatsArme = 10;
}

Personnage david, goliath; // Les constructeurs de david et goliath sont appelés.

Personnage::Personnage()
{
    m_vie = 100;
    m_mana = 100;
    m_nomArme = "Epée rouillée";
    m_degatsArme = 10;
}

Personnage::Personnage() : m_vie(100), m_mana(100), m_nomArme("Epée rouillée"), m_degatsArme(10)
{
    // Rien à mettre dans le corps du constructeur, tout a déjà été fait !
}

Personnage();

Personnage(std::string nomArme, int degatsArme);

Personnage::Personnage(string nomArme, int degatsArme) : m_vie(100), m_mana(100), m_nomArme(nomArme), m_degatsArme(degatsArme)
{
 
}

Personnage david, goliath;

Personnage david, goliath("Epée aiguisée", 20);

~Personnage();

Personnage::~Personnage()
{
    /* Rien à mettre ici car on ne fait pas d'allocation dynamique
    dans la classe Personnage. Le destructeur est donc inutile mais
    je le mets pour montrer à quoi ça ressemble ^^
    En temps normal, un destructeur fait souvent des delete et quelques
    autres vérifications si nécessaire avant la destruction de l'objet */
}

#ifndef DEF_ARME
#define DEF_ARME

#include <string>
 
class Arme
{
    public:
 
    Arme();
    Arme(std::string nom, int degats);
    void changer(std::string nom, int degats);
    void afficher();
 
    private:
 
    std::string m_nom;
    int m_degats;
};
 
#endif

#include <iostream>
#include "Arme.h"
 
using namespace std;
 
Arme::Arme() : m_nom("Epée rouillée"), m_degats(10)
{
 
}
 
Arme::Arme(string nom, int degats) : m_nom(nom), m_degats(degats)
{
 
}
 
void Arme::changer(string nom, int degats)
{
    m_nom = nom;
    m_degats = degats;
}
 
void Arme::afficher()
{
    cout << "Arme : " << m_nom << " (Dégâts : " << m_degats << ")" << endl;
}