Programmation C++

Créer un programme

Un ou plusieurs fichiers sources

Compilateur

Executable

- preprocessor

- compiler

- linker

Premier programme

/* 
     premier programme C++
     on peut le tester sur le compilateur en ligne
     http://cpp.sh/
*/

#include <iostream>

int main()
{
    std::cout << "Ia ora na fenua!"<< std::endl;


    return 0;
}

commentaires



librairie

type de donnée, fonction

namespace, flux, chaine de caractères

retour de fonction

Deuxième programme

#include <iostream>
#include <string>

using namespace std;

void afficheArguments( int n, char **tableau )
{
    for( int i=0; i<n; i++ ) {
        cout << "argument "<< i <<" : "<< tableau[i] << endl;
    }
}

int main( int argc, char **argv )
{
    afficheArguments( argc, argv );
    string message;
    cout << "ton message : ";
    cin >> message;
    return message.length();
}

namespace

type de donnée, fonction, pointeur

boucle for
formatage des données



paramètres d'entrée

appel de fonction
classe

flux entrant
fonction membre de classe

Programme Ultime !! (...1er semestre)

La version compilateur en ligne, avec l'exception commentée:
    http://cpp.sh/2ax3

La version offline est sur le serveur : 
    Armada\AGORA\ProgrammationC++\programmeFinal.cpp

montre l'utilisation des classes, tableaux, pointeurs, exception, vector.

C++ sous Windows

Microsoft Visual Studio

 

projet Visual C++

 

Win32 Console app

C++ sous Windows

#include "stdAfx.h"

 

int _tmain( int argc, _TCHAR* argv[] )

{

    // ...

}

Cheat sheet 1

   - programme exemple
// mon premier programme
#include <iostream>
int main()
{
    std::cout << “Ia ora na fenua !”;
    return 0;
}

 

   - commentaires
// commentaire : le reste de cette ligne est ignore
/* un commentaire qui
  s’etale sur plusieurs
  lignes
*/

 

   - inclure des librairies
#include <librairie_standard>     // iostream, string, math, ...

#include "fichier.h"

donne acces a toutes les fonctions disponibles dans ces librairies

 

 

   - types de donnees

bool, char, int, float, double, void, ...

int8_t, uint8_t, uint64_t, ...

string, ...

auto x = var1;    // defini une variable x dont le type est le meme que celui de la variable var1

 

   - fonction

/* pour definir une fonction qui s'appelle maFunction et qui prend un premier parametre de type char et un deuxieme parametre de type float en entree */

int maFunction( char parametre1, float parametre2 ) {

    int monInt = 14;

    return monInt;    // Quand elle a fini, la fonction renvoie un int

}

int main(){

    int x = maFunction( 'C', 10.45 );

}

 

 

Cheat sheet 2

   - operations arithmetiques

+, -, * (multiplication), / (division), % (modulo = reste de la division)

var1 = 23 % 7;    // = 2

+=, -=, *=, /=, %=

var1 += var2;   // equivalent a : var1 = var1 + var2;

var1++;             // equivalent a : var1 = var1 + 1;

var1--;               // equivalent a : var1 = var1 - 1;

var2 = ++var1 + 2;   // equivalent a var1 = var1 + 1; var2 = var1 + 2;

var2 = var1++ + 2;   // equivalent a var2 = var1 + 2; var1 = var1 + 1;

  
   - tests de relations

 == egal

 != different

 >  superieur

 >= superieur ou egal

 <  inferieur

 <= inferieur ou egal

 

   - operateurs logiques

 &&  et

 ||   ou

  !     non

 

   - si <condition> alors

if( booleen_vrai ) {

        // les instructions a faire si la condition est vraie

}

 

if( var1 == var2 ){

       // si var1 est egale a var2, on fait ces instructions ici

       // ...

} else if( var1 == var3 ){

       // sinon, et si var1 = var3, on fait ces instructions ici

} else {

       // sinon, on fait ces instructions

}

 

switch( var1 ){      // test la valeur de var1

    case "OK":        // si var1 est egal a "OK", on fait les instructions

                              // jusqu'au break;

            break;

    case "PAS BON":    // si var1 == "PAS BON" alors ...

            break;

    case "CORRECT":    // si var1 == "CORRECT" alors ...

            break;

    default:              // si var1 est egal a autre chose alors ...

}

 

Cheat sheet 3

   - boucles

/* Au debut, on cree une variable i qui prend la valeur 0.

Ensuite, si la condition i<var1 est vraie, on effectue le contenu de la boucle.

A la fin de la boucle, on fait i++ et on recommence le test ...*/

for( int i=0; i<var1; i++ ){    

        // ...

}

 

int tab1[6];

for( auto& tt : tab1 ) tt = 0;    

modifie toutes les valeurs du tableau tab1. Si on n'a pas besoin de modifier les valeurs du tableau, on utilise "auto tt"

 

while( var1 != var2 ){       // tant que la condition est vraie,

                                           // on effectue le contenu de la boucle

}

 

do{          // effectue le contenu de la boucle puis teste si la

                // condition est vraie. Si oui, on passe dans la boucle

    // ...

} while( var1 > var2 );

 

   - utiliser le namespace std

using namespace std;    // evite d’ecrire std::cout, std::string, ...

Certaines fonctions ou elements sont inclus dans un namespace, pour les utiliser, il faut alors les appeler ainsi: nom_du_namespace::nom_fonction( … )

using permet d’ignorer l’appel au nom du namespace

Ex:

#include <iostream>

// …

std::cout << “message”;

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

#include <iostream>

using namespace std;

// …

cout << “message”;

 

   - afficher et recuperer des valeurs sur la console

cin >> var1;       /* lit ce que l'utilisateur a rentre dans la console et le range dans la variable var1. L'utilisateur doit avoir tape la touche entree pour que cin s'execute */

cout << "mon message!";    // affiche un message sur la console

cout << "variable1 : "<< var1 << ", variable2 : "<< var2 << endl;  

/* affiche un message et le contenu des variables puis effectue un retour a la ligne (...grace a endl) dans la console */

Cheat sheet 4

   - pointeurs

int *ptr;        // defini un pointeur vers un int. ptr contiendra l'adresse d'une variable de type entier

ptr = &var1;    // ptr est initialise avec l'adresse de var1

int var2 = *ptr;    // var2 est initialise avec la valeur int qui se

                              // trouve a l'adresse contenue dans ptr

ptr = &var2;    // maintenant ptr pointe vers la valeur de var2

var2 = 12;

int var3 = *ptr;  // var3 = 12

cout << ptr;       // affiche l’adresse de var2    

cout << *ptr;     // affiche 12

 

   - modification du type

const int var = 12;  // variable dont la valeur n’est plus modifiable

const int * var1 = &var;    // var1 est un pointeur vers un int

                                             // non modifiable (var)    

int const * var1 = &var;    // var1 est un pointeur vers un int

                                             // non modifiable (var)

int * const var1 = &var2;    // var1 est un pointeur non modifiable

                                               // vers un int modifiable (var2)

 

float& vf2 = vf1;    // & indique une reference : vf2 correspond a

                                // la meme valeur que vf1

Attention: & devant le nom d’une variable deja initialisee indique son adresse

   - tableaux

int tab0[15];    // cree un tableau contenant 15 int.

                          // Les valeurs ne sont pas encore initialisees

float tab1[] = {4.2, 5, 9.78};   // tableau contenant 3 float, initialise

                                                  // avec les valeurs donnees

tab1[0] = 1.1;  // met la valeur 1.1 dans la premiere case de tab1

float x = tab1[2];    // x est initialisee avec la valeur de la

                                 // troisieme case de tab1

 

char *tab3 = new char[nombreVariable]; /* tableau dont la taille (nombreVariable) n'est connue qu'a l'execution du programme*/

    // ...

delete [] tab3;    /* tableau initialise avec new doit etre detruit avec delete [ ] lorsqu'on a fini avec */

   - exception

try{

        /* bloc de code qui va peut etre lancer une exception en cas de probleme */

} catch( int monInt ) {

 // une exception de type int a ete lancee! traite le probleme ici

} catch( … ){

 // recupere toutes les autres exceptions

}

throw 20;    // lance une exception de type int, egal a 20

Cheat sheet 5

   - classe et structure

class maClasse {    // defini une classe appelee maClasse

public:

  maClasse();    // constructeur : appelee a l’initialisation

  ~maClasse(){ delete [] c; };  // destructeur : appele a la destruction

  char* uneFonction( float a );

  float b;

 

private:

   char uneAutreFonction(){ if( b > 0 ) return 'N'; return 'O'; };

   int var1;

 

protected:

   char *c;

};

 

maClasse::maClasse()

{

    var1 = 45;

    c = new char[10];

    c = "rien";

}

char* uneFonction( float a )

{

    b = a;

    return c;

}

 

int main()

{

    maClasse mac;

    cout << mac.uneFonction( 12 ) <<” - ”<< mac.b;

}

 

Une Structure est equivalente a une classe mais elle se definie comme suit:

    struct maStructure { … };

La principale difference est que les elements d’une structure sont public par defaut alors que les elements d’une classe sont private

 

Cheat sheet 6

   - template

template<class T>
T Add(T n1, T n2)
{
        T result;
        result = n1 + n2;
        return result;
}

 

 // …

 

int a = Add( 5, 12 );

double a = Add( 5.4, 12.8 );

Les templates permettent de definir des fonctions ou classes qui manipulent differents types de parametres. Le compilateur generera des fonctions ou classes differentes a chaque fois qu’elles sont appelees avec des types de donnees differents

template<class T>
class Item {
    T Data;
public:
    Item() : Data( T() )    {}
    void SetData(T nValue)    {        Data = nValue;    }
    T GetData() const    {        return Data;    }
    void PrintData()    {        cout << Data;    }
};

    // …

 

Item<int> entite;

entite.setData( 23 );

entite.PrintData();

Cheat sheet 7

   - vector/iterator

#include <vector>

#include <iostream>

//...

std::vector<char> array;    // tableau de char, de taille variable

char c = 0;

while( c != 'x' ){

    std::cin>>c;

    array.push_back( c );    // cree une nouvelle case contenant c a

                                            // la fin du tableau array

}

char deuxiemeElement = array[ 1 ];

char quatriemeElement = array.at( 3 );

vector permet de creer des tableaux dont la taille peut varier automatiquement quand on rajoute ou retire des elements

std::vector<double> a;

a.push_back(1);

a.push_back(2);

a.push_back(3);

a.push_back(4);

a.push_back(5);

std::vector<double>::const_iterator i;

// parcourt tous les elements du tableau a :

for( i = a.begin(); i != a.end(); ++i ){    

    std::cout<<(*i)<<std::endl;    // *i est un element du tableau a

}

Voir aussi list et deque