Exemple de programmation en C++

Je vais vous montrer les étapes pour la réalisation d'un petit projet en C++
Sans que cet exemple soit très compliqué, je vais vous montrer l'utilisation des classes pour une implémentation de l'utilisation des nombres complexes.
Egalement, l'implémentation des opérateurs de surcharge pour vous faire voir toute la puissance du C++

Premier fichier à créer qui va contenir les définitions de la classe complexe.
Le fichier se nomme complexe.h et est défini ainsi

	  #ifndef COMPLEXE_H
	  #define COMPLEXE_H
	  #include 

	    class complexe
	    {
	    public:
	    complexe();
	    complexe(double a, double b);
	    ~complexe();
	    complexe& operator=(const complexe &z2);
	    complexe conjugue(void);
	    complexe ajout(const complexe z2 );
	    complexe& operator+=(const complexe z2);
	    friend complexe operator+(const complexe z1, const complexe z2);
	    complexe& operator-=(const complexe z2);
	    friend complexe operator-(const complexe z1, const complexe z2);
	    complexe& operator*=(const complexe z2);
	    friend complexe operator*(const complexe z1, const complexe z2);
	    friend std::ostream& operator<<(std::ostream& os,const complexe& z2);
	    complexe soustraction(complexe z2);
	    complexe multiplication(complexe z2);
	    void affichage();
	    private:
	    double a,b;
	    };
	    #endif
	

Deuxième fichier à créer est le fichier d'implémentation des fonctions de la classe complexe
Le fichier se nomme complexe.cpp. Voici son code source

	    #include "complexe.h"
	    #include <iostream>
	    #include <ostream>

	    complexe::complexe()
	    {
	    a=0;
	    b=0;
	    }

	    complexe::complexe(double reel, double ima)
	    {
	    a=reel;
	    b=ima;
	    }

	    complexe::~complexe()
	    {
	    
	    }

	    complexe complexe::conjugue(void)
	    {
	    complexe ret;
	    ret.a=a;
	    ret.b=-b;
	    return ret;
	    }

	    complexe complexe::ajout(complexe z2)
	    {
	    complexe ret;
	    ret.a=a+z2.a;
	    ret.b=b+z2.b;
	    return ret;
	    }

	    complexe complexe::soustraction(complexe z2)
	    {
	    complexe ret;
	    ret.a=a-z2.a;
	    ret.b=b-z2.b;
	    return ret;
	    }

	    complexe complexe::multiplication(complexe z2)
	    {
	    complexe ret;
	    ret.a=a*z2.a - b*z2.b;
	    ret.b=a*z2.b + b*z2.a;
	    return ret;
	    }

	    void complexe::affichage()
	    {
	    std::cout<<"z="<<a;
	    if (b>0)
	    {
	    std::cout <<"+"<<b<<"i";	  
	    }
	    else if (b<0)
	    {
	    std::cout<<b<<"i";	  
	    }
	    std::cout<<std::endl;
	    }

	    complexe& complexe::operator=(const complexe &z2)
	    {
	    a=z2.a;
	    b=z2.b;
	    return *this;
	    }

	    complexe& complexe::operator+=(const complexe z2)
	    {
	    a+=z2.a;
	    b+=z2.b;
	    return  *this;
	    }

	    complexe& complexe::operator-=(const complexe z2)
	    {
	    a-=z2.a;
	    b-=z2.b;
	    return *this;
	    }

	    complexe& complexe::operator*=(const complexe z2)
	    {
	    a=a*z2.a - b*z2.b;
	    b=a*z2.b + b*z2.a;
	    return *this;
	    }

	    std::ostream& operator<<(std::ostream& os, const complexe& z2)
	    {
	    os<<"z="<<z2.a;
	    if (z2.b>0)
	    {
	    os<<"+"<<z2.b<<"i";
	    }
	    else if (z2.b<0)
	    {
	    os<<z2.b<<"i";
	    }
	    os<<std::endl;
	    return os;
	    }

	    complexe operator+(const complexe z1, const complexe z2)
	    {
	    complexe ret;
	    ret=z1;
	    return ret+=z2;
	    }

	    complexe  operator-(const complexe z1, const complexe z2)
	    {
	    complexe ret;
	    ret=z1;
	    return ret-=z2;
	    }

	    complexe operator*(const complexe z1, const complexe z2)
	    {
	    complexe ret;
	    ret=z1;
	    return ret*=z2;
	    }
	

Le dernier fichier comporte quelques exemples d'utilisation de la classe complexe
Il se nomme main.cpp

	    #include "complexe.h"
	    #include <iostream>

	    int main(void)
	    {
	    complexe z, z1(2,-1), z2(3,-4);
	    z1.affichage(); //Méthode fonction
	    z=z1.conjugue();
	    std::cout << z; //Méthode operator
	    z=z1.ajout( z2); //Méthode fonction
	    z.affichage(); //Méthode fonction
	    z=z1+z2; //Méthode operator
	    std::cout<<z; //Méthode operator
	    z=z1.soustraction( z2); //Méthode fonction
	    z.affichage(); //Méthode fonction
	    z=z1-z2; //Méthode operator
	    std::cout<<z; //Méthode operator
	    z=z1.multiplication(z2); //Méthode fonction
	    z.affichage(); //Méthode fonction
	    z=z1*z2; //Méthode operator
	    std::cout<<z; //Méthode operator
	    return 0;
	    }
	

Maintenant que nous avons créé ces trois fichiers, pour lancer le programme complexe et voir ce qu'il affiche, nous devons compiler le code source
La commande pour le faire est très simple

	    g++ *.cpp -o complexe
	

Que veut dire cette commande :

g++ : on invoque le compilateur C++

*.cpp : tous les fichiers sources se terminant par l'extension cpp sont à traiter

-o complexe : le résultat de la compilation fournira l'exécutable complexe

Pour vérifier ce que produit cet exécutable, il suffit de le lancer : ./complexe

Pour automatiser la compilation, nous pouvons créer un makefile :

	    CC=g++
	    CFLAGS=-W -Wall -ansi -pedantic
	    LDFLAGS=
	    EXEC=complexe

	    all: $(EXEC)

	    complexe: complexe.o main.o
	    $(CC) -o complexe complexe.o main.o $(LDFLAGS)

	    complexe.o: complexe.cpp
	    $(CC) -o complexe.o -c complexe.cpp $(CFLAGS)

	    main.o: main.cpp complexe.h
	    $(CC) -o main.o -c main.cpp $(CFLAGS)

	    clean:
	    rm -rf *.o

	    mrproper: clean
	    rm -rf $(EXEC)
	

Voilà c'est un début de projet en C++. Vous pouvez enrichir le makefile pour pouvoir installer l'exécutable dans un dossier spécifique.
Vous avez acquis quelques notions pour débuter la programmation en C++