Programmation Initiation Aux Langages C et C++ (2) Bruno Permanne 2006

Programmation

Un avenir une formation,

Initiation Aux Langages C et C++ (2)

Bruno Permanne 2006

ProgrammationSommaire

Bruno Permanne 2006

ProgrammationInstructions de bas niveauManipulation de la mémoirePréprocesseurLes fonctions en C++La portée des variablesProgrammation avancée C++

Instructions de bas niveauOpérateurs de manipulation de bits << >> & | ~ ^

Retour sommaireBruno Permanne 2006

Instructions Adresse

Mémoire

Contenu

(décimal)

Contenu

(hexa)

Contenu

(binaire)

unsigned char a; 0x34FE (a) ? ? ?

a=0x54; 0x34FE 84 0x54 0101 0100

a>>=2; 0x34FE (a) 21 0x15 0001 0101

unsigned char b=240,c;

c=a&b;

0x34FE (a)

0x34FF (b)

0x3500 (c)

21

240

16

0x15

0xF0

0x10

0001 0101

1111 0000

0001 0000

c^=0xFF;

ou c~=c;

0x34FE (a)

0x34FF (b)

0x3500 (c)

21

240

239

0x15

0xF0

0xEF

0001 0101

1111 0000

1110 1111

c=a&1|0x30; 0x34FE (a)

0x34FF (b)

0x3500 (c)

21

240

49

0x15

0xF0

0x31

0001 0101

1111 0000

0011 0001

a=(char) (b==240); 0x34FE (a)

0x34FF (b)

0x3500 (c)

1 (true)

240

49

0x01

0xF0

0x31

0000 0001

1111 0000

0011 0001

Manipulation de la mémoireRappel: Le code ASCII


Manipulation de la mémoireOpérateurs d'accès & *



Mémoire

Contenu

char a; 0x34FE (a) ?

a=0x54; 0x34FE 0x54

char *p; 0x34FE (a)

0x34FF (p)

0x3500

0x54

?

?

p=&a; 0x34FE (a)

0x34FF (p)

0x3500

0x54

0x34

0xFE

*p=0x33; 0x34FE (a)

0x34FF (p)

0x3500

0x33

0x34

0xFE

• Déclaration d'un octet• Affectation d'une valeur• Déclaration d'un pointeur sur un octet

• Recopie de l'adresse de a dans le pointeur p

• Modification du contenu de la mémoire à l'adresse pointée par p

Manipulation de la mémoire



Mémoire

Contenu

char a; 0x34FE (a) ?

a=0x54; 0x34FE 0x54

char *p; 0x34FE (a)

0x34FF (p)

0x3500

0x54

?

?

char b;

p=0x3501;

*p=234;

0x34FE (a)

0x34FF (p)

0x3500

0x3501 (b)

0x54

0x35

0x01

0xEA

p--;

*p=0;

0x34FE (a)

0x34FF (p)

0x3500

0x3501 (b)

0x33

0x34

0x00

0xEA

• Déclaration d'un octet• Affectation d'une valeur• Déclaration d'un pointeur sur un octet

• Affectation directe d'une l'adresse dans le pointeur p• modification de la case mémoire pointée• Modification du contenu de la mémoire à l'adresse pointée par p-1

Opérateurs d'accès & *




Mémoire

Contenu

int a=0x54FE; 0x34FE (a)

0x34FF

0x54

0xFE

int *pa;

pa=&a;

0x34FE (a)

0x34FF

0x3500 (pa)

0x3501

0x54

0xFE

0x34

0xFE

*pa=0; 0x34FE (a)

0x34FF

0x3500 (pa)

0x3501

0x00

0x00

0x34

0xFE

int **pb;

*pb=&pa;

0x3500 (pa)

0x3501

0x3502 (pb)

0x3503

0x34

0xFE

0x35

0x00

• Déclaration d'un entier initialisé •Déclaration d'un pointeur sur un entier et affectation à l'adresse de a

• Remise à zéro de l'entier pointé par pa

•Déclaration d'un pointeur sur un pointeur.





Mémoire

Contenu

char b=4; 0x34FE (a)

0x34FF (p)

0x3500

0x3501 (b)

0x33

0x34

0xFE

0x04

b=*(p+2); 0x34FE (a)

0x34FF (p)

0x3500

0x3501 (b)

0x33

0x34

0xFE

0xFE

a=*p-3; 0x34FE (a)

0x34FF (p)

0x3500

0x3501 (b)

0xFE

0x34

0xFE

0xFB

• Déclararation et initialisation d'un octet b

• la variable b reçoit la contenu de la case mémoire pointée par l'adresse stockée par la pointeur p augmentée de 2• Modification du contenu de la mémoire à l'adresse pointée par p


Tableaux, chaînes de caractères et pointeurs



Mémoire

Contenu

char a[3]=

{10,0x34,'0');

0x34FE (a)

0x34FF

0x3500

0x0A

0x34

0x30

char b,*p; p=&a; b=a[2];

ou b=*(p+2);

ou p+=2; b=*p;

0x34FE (a)

0x34FF

0x3500

0x3501 (b)

0x30

0x34

0x30

0x30

string s="OK";

ou

char s[]="OK";

ou

char s[]=

{'O','K','\0');

ou char s[3];

s[0]='O';

s[1]='K';

s[2]='\0';

0x3502 (s)

0x3503

0x3504

0x3505

0x4F ('O')

0x4B ('K')

0x00 ('\0')

?

• Déclaration d'un tableau d'octets initialisé

•Déclaration d'un octet, d'un pointeur sur a et accès aux cases du tableau

• Déclaration dune chaine de caractère string pour le C++

•Différents styles de déclaration

•Ne pas oublier le caractère nul '\0' à la fin de la chaine


Directives de compilation #include et #define


Préprocesseur

Directive Action

#include <iostream> Inclure à cet endroit le fichier source iostream du C++ standard

#include "MonEntete.h" Inclure à cet endroit un fichier que j'ai écrit et qui se trouve dans le répertoire courant du projet

#define PI 3.14159

#define S(r) PI*r*r

Définition du symbole PI et S(r) (comportant un paramètre) qui sera remplacé avant la compilation dans le programme source

s1=PI*r*r;

s2=S(r);

s1=3.14159*r*r;

s2=3.14159*r*r;

Au moment de l'écriture,

Après le passage du préprocesseur et avant la compilation

Définition des fonctions (1)


Directive Action

// fichier simple.hpp

#include <csdtlib>

#include <iostream>

using spacename std;

void simple(void);

void simple(void)

{

cout << "Bonjour" << endl;

}

Fichier des bibliothèques utilisées

Prototype d'une fonction sans arguments et sans valeur de retourdéfinition de la fonction, c'est un simple sous programme

// fichier simple.cpp

#include "simple.hpp"

main()

{

simple();

}

Programme principal complet avec appel de la fonction simple()

Les fonctions en C++



Directive Action

// fichier simple2.hpp

#include <csdtlib>

#include <iostream>


void simple2(string);

void simple2(string s)

{

cout << s << endl;

}


Prototype d'une fonction avec un argument et sans valeur de retourdéfinition de la fonction

// fichier simple2.cpp

#include "simple2.hpp"

main()

{

simple2("Bonjour");

}

Programme principal complet avec appel de la fonction simple2()




Directive Action

// fichier mult.hpp

#include <csdtlib>


int mult(int, int);

int mult(int a, int b)

{

return a*b;

}


Prototype d'une fonction avec un argument et une valeur de retourdéfinition de la fonction

// fichier mult.cpp

#include <iostream>

#include "mult.hpp"

main()

{ int r=10;

cout << mult(r, 3);

}

Programme principal complet avec appel de la fonction mult()




Directive Action

// fichier mult.hpp

#include <csdtlib>


void mult(int, int, int*);

void mult(int a, int b, int *s)

{

*s=a*b;

}


Prototype d'une fonction avec un argument et pas de valeur de retourdéfinition de la fonction avec passage d'un pointeur sur la variable résultat

// fichier mult.cpp

#include <iostream>

#include "mult.hpp"

main()

{ int s, r=10; mult(r,3,&s);

cout << s;

}

Programme principal complet avec appel de la fonction mult()Notez le passage de l'adresse de la variable résultat par &s




Directive Action

// fichier mult.hpp

#include <csdtlib>


void mult(int, int, int&);

void mult(int a, int b, int &s)

{

s=a*b;

}


Prototype d'une fonction avec un argument et pas de valeur de retourdéfinition de la fonction avec passage d'une référence sur la variable résultat

// fichier mult.cpp

#include <iostream>

#include "mult.hpp"

main()

{ int s, r=10; mult(r,3,s);

cout << s;

}

Programme principal complet avec appel de la fonction mult()Notez le passage de l'adresse de la variable résultat sans le &


La portée des variables (1)


Directive Action

// fichier portee.hpp

#include <csdtlib>

#include <iostream>


int x=5:

void fonc(void);

void fonc(void)

{

cout << x;

}

Définition de x globale au fichier portee.hpp

Affiche la valeur 5

// fichier portee.cpp

#include "portee.hpp"

main()

{

cout << x;

}

Affiche une erreur car la variable x est inconnue du fichier principal portee.cpp




Directive Action


#include <csdtlib>

#include <iostream>


extern int x=5:

void fonc(void);

void fonc(void)

{

cout << x;

}

Définition de x globale à tous les fichiers du projets

Affiche la valeur 5



extern int x;

main()

{

cout << x;

}

la variable extern doit être reprécisée ici (sans valeur !)Affiche la valeur 5




Directive Action


#include <csdtlib>

#include <iostream>


int x=5:

void fonc(void);

void fonc(void)

{ int x=10;

cout << x;

}

Définition de x globale au fichier portee.hpp

Affiche la valeur 10



main()

{

int x=1;

cout << x;

}

Affiche la valeur 1


Enumérations enum


Directive Action

#define PRINTEMPS 0

#define ETE 1

#define AUTOMNE 2

#define HIVER 3

Utilisation du #define classique

#enum {PRINTEMPS,ETE,AUTOMNE,HIVER};

L'énumération est plus élégante

enum SAISON {PRINTEMPS,ETE,AUTOMNE,HIVER};

Elle peut être nommée

SAISON saison_2=HIVER; Nouveau type légal en C++ en fait SAISON est un int

Programmation avancée C++

types et structures struct


Programmation avancée C++

Directive Action

struct complexe

{

double re; double im;

};

en C++ une structure est un nouveau type, pas en C !

complexe addcomp(complexe, complexe);

complexe addcomp(complexe x, complexe y)

{

complexe res;

res.re=x.re+y.re; res.im=x.im+y.im;

return res;

}

fonction addition de nombres complexes

prototype obligatoireLe '.' permet l'accès aux membres de la structure

complexe m,n,somme;

somme=addcomp(m,n);

Appel de la fonction

Programmation

Un avenir une formation,

Fin de la deuxième partie

Bruno Permanne 2006

Documents

Programmation Initiation Aux Langages C et C++ (2) Bruno Permanne 2006