Un programme

 

- instructions

 

 

 

 

- données

 Un programme

 

- fichier binaire

 

- lié à un système d'exploitation

Langage de programmation

 

- pour créer un programme!

- fichier texte lisible

- possède un vocabulaire et une grammaire spécifique

- compilé/interprété

- autorise/force différents concepts de programmation : object-oriented, constraint programming, functional programming, ...

Langage de programmation

 

Assembleur

org 100h
mov dx,msg
mov ah,9
int 21h
mov ah,4Ch
int 21h
msg db 'Hello World!$'

Basic

10 PRINT "Hello World!"
20 END

Pascal

PROGRAM Bonjour;
BEGIN
   WriteLn('Hello World!')
END.

Langage de programmation

 

C++

#include <iostream>
int main() {
    std::cout << "Hello World!" << endl;
    return 0;
}

Java

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Python

print('Hello World!')

Visual Studio

• IDE
• Editeur de texte + assistant programmation
  • coloration syntaxique
  • dictionnaire des fonctions
  • outils d'optimisation
  • ...
• Compilateur, linker
• Debugger
• Editeur C++ officiel pour Unreal Engine

Visual Studio

• Fichier -> Nouveau -> Projet
• Visual C++
  • Application console Windows
  • nom, emplacement
• Générer -> Générer la solution
• ouvrir une Invite de commandes (touche Win, 'cmd', Entrée)
• aller dans le répertoire de la solution \Debug
• lancer l'exécutable

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