2. Variables et types simples
•
Déclarations de variables
•
Types scalaires
•
Conversions de types
•
Tableau
•
Espaces de visibilité et classes d’allocation
Types et variables
•
Tout objet doit être déclaré avant d’être utilisé
•
Déclaration associe un type à un identificateur
•
En C, on dispose des types :
•
fondamentaux : int , float , char , void
•
composés : tableau, structure, énumération
•
pointeurs
Variables scalaires
•
Entiers
• déclaration :
int i;
int resultat ; ou int i, resultat;
• taille varie selon les machines (2, ou 4 octets (linux)), entier signé par défaut
• Variable non initialisée: contient une valeur aléatoire.
• déclaration avec initialisation : (facultative)
int i=3; int j=3, resultat=2;
• Initialisation a posteriori :
i=3; resultat=4;
Variables scalaires
• qualificatifs
: short, long, unsigned, signed
exemples :
short j;
idemshort int j ;
(int facultatif)unsigned u = 2;
Type Octets
(linux)
Format (printf) Valeurs admisses
short,signed short 2 %hi -32 768 … 32 767 unsigned short 2 %hu 0 … 65535
unsigned 4 %u 0 … 4 294 967 295
signed 4 %i, %d -2 147 483 648 … 2 147 483 647 unsigned long 4 %lu 0 … 4 294 967 295
long 4 %li, %ld -2 147 483 648 … 2 147 483 647 long long 8 %lli, %lld -9.22E+8 … 9.22E+18
Variables scalaires
•
Réels (à virgule)
• déclaration :
float i; float resultat ; float i, resultat;
• précision :
• initialisation : (facultative)
float i=3.2;
double resultat= 3.4e-2 ; ou float i; i=0.4e-1;
Type Octets (linux) Format (printf)
float 4 (mantisse+exposant) %f, %e double 8 (mantisse+exposant) %lf, %le
Variables scalaires
•
Caractères
• codé sur 1 octet d’après le code ASCII standard ( 0 – 127)
• déclaration :
char c , d , e ;
• qualificateur :
•
unsigned char f ;
Ø Si 1 char est utilisé pour un usage autre que stocker un caractère imprimable:
préciser signed ou unsigned.
Type Octets
(Linux)
Format (printf)
Valeurs admissibles dans le calcul avec 1 entier
unsigned char 1 %c , %hhu, %u 0 … 255 signed char 1 %c, %hhi, %i -128 …127
char 1 %c ? signé ou non, dépend machine Mais caractère du code ascii standard
positif (0-127)
Variables scalaires
•
Initialisation : c = ’A’ ; idem que char c = 65;
char line = ’\n’;
c = ’A’;
d = 66 ; e = c + 5 ;
•
Caractères particuliers
•
\n (retour à la ligne, code ascii =9 )
•
\t ( tabulation, code ascii = 10
(10))
c d e
65
66
70
Conversion de types
Conversions implicites
(en l’absence d’unsigned):
•
Lors d’une opération à 2 opérandes (+, -, *, / ) :
« le type le + petit est promu dans le type du plus grand »
•
Exemple:
float a, b=3.2;
int c=2;
a=b+c;
(a=3.2+ 2.0) -> a=5.2
double float long int
int char short
Pr o m o ti o n
Conversion implicite en float
Conversion de types
Conversions implicites
:
•
Lors d’une affectation (a = b) :
« le type de b est converti dans le type du résultat a »
•
Exemple 1:
float b=3.2;
int a=3, c=2;
b=c+a; c=b+a;
(b=5.0) (c=6)
Conversion implicite en float
=5, int =6.2, float (1.implicite conversion de a)
2.conversion implicite en int
(troncature de la partie fractionnaire )
Conversion de types
Conversions implicites
:
•
Lors d’une affectation (a = b) :
« le type de b est converti dans le type du résultat a »
•
Exemple 2 :
short b=0x010B; (
utilise 2 octets)char c=0x02;
b=c; c=b;
(b=0x0002) (c=0x0B)
Conversion implicite en short
Conversion implicite en char(troncature des
bits de poids fort)
Conversions explicite
: operateur de cast (type)
•
L’utilisateur peut forcer la conversion d’une variable dans un autre
•
Exemple 1: float f;
int k=3, j=2;
f=k/j; f=(float)k/j;
(f=1.0)
(f=1.5)
Idem f=(float)(k/j); Idem (float)k/(float)j
Conversion
implicite en float =1.5, float
=1, division entière k float
(-> implicite conversion de j en float)
Conversion de types
Void
•
Type introduit tardivement, utilisé pour :
•
Indiquer qu’une fonction ne renvoie pas de valeur
void function (int x, int y)
• Un pointeur générique, ne pointe sur aucun type en particulier: void* (à voir plus tard)
Un tableau est une collection d'éléments de même type, stockés de façon contiguë en mémoire.
•
Déclaration : < type nom [taille] >
Exemples
:int tab[5] ;
char ligne[80] ;
•
Chaque élément est repéré par un indice
tab[0] tab[1] tab[2] tab[3] tab[4]
•
int t[5] ;
•
t[0] = 23 ;
•
t[3] = t[0] + 4 ;
•
t[2] = t[3] + t[0] ;
t[0] t[1] t[2] t[3] t[4]
t[0] t[1] t[2] t[3] t[4]
t[0] t[1] t[2] t[3] t[4]
t[0] t[1] t[2] t[3] t[4]
23
23 27
23 50 27
•
int t[4] = {12,34,56,78};
•
int t[4] = {1,2};
•
int t[3] = {21,43,65,87};
•
int t[] = {3,2,1} ;
t[0] t[1] t[2] t[3]
12 34 56 78
t[0] t[1] t[2] t[3]
1 2
t[0] t[1] t[2]
21 43 65
t[0] t[1] t[2]
3 2 1
Chaînes de caractères
•
tableau de caractères se termine par ' \0 ’
(backlash 0)•
avec initialisation : char tab[80] = "hello!";
idem char tab[80] ={’h’,’e’,’l’,’l’,’o’,’!’,’\0’};
•
tableau assez grand pour contenir les caractères de la chaîne + le delimiteur de fin \0
•
accès identiques aux tableaux : tab[4]=’o’;
•
constantes chaînes entre guillemets : "bonjour"
Chaînes de caractères
char str1[6] = "hello" ;
printf("1: %s ? \n" , str1);
scanf( "%s",str1);
ou pour lire au plus 5 caractères:
scanf ("%5s",str1);
printf("Hello %s !\n" , str1);
h e l l
o \0
str1
A l’écran:
hello ? loic c ↵
Hello loic !
Note: scanf("%s", )
stoppe la lecture au premier espace blanc
Chaînes de caractères
•
fonctions de manipulation dans les bibliothèques standards :
•
strlen : calcul la longueur d’une chaîne
•
strcomp : compare 2 chaînes
•
strstr : recherche une chaîne de caractère à l’intérieur d’une
autre chaîne
Espace de validité et classe d ’ allocation
Variable locale
• définie à l’intérieur d’un bloc (fonction ou sous-bloc)
• connue et accessible, valide à l’intérieur de ce bloc uniquement
•
Classe automatique (par défaut)
• allouer dynamiquement à l’exécution du bloc et libérée à la fin du bloc
• contenu est perdu entre deux exécutions
• allocation se fait sur une pile de travail
• il faut les initialiser avant de les utiliser
• classe par défaut , donc
auto int j ;
équivalent àint j ;
Espace de validité et classe d ’ allocation
Variable locale
#include <stdio.h>
void main() {
int i=1;
{
int k=2;
printf(”> %d %d\n",i,k);
} }
Compilation: OK Sortie écran :
> 1 2
Espace de validité et classe d ’ allocation
Variable locale
#include <stdio.h>
void main() {
int i=1;
{
int k=2;
}
printf(”> %d %d\n",i,k);
}
Compilation: Erreur ! In function ‘main’:
10: error: ‘k’ undeclared
Espace de validité et classe d ’ allocation
Variable locale
#include <stdio.h>
void main() {
int i=1;
{
int i=2;
printf(”> %d\n",i);
} }
Compilation: OK Sortie écran:
> 2
Note:
le i le plus local est utilisé.
Mais mauvaise idée !
èUtiliser des noms différents
Espace de validité et classe d ’ allocation
Variable locale
•
Classe statique
• allocation permanente pas détruite lors de la sortie de la fonction (bloc)
valeur conservée entre 2 appels
• mais visibilité toujours limité au bloc, inaccessible hors du bloc
•
static int i ; static float f ;
Espace de validité et classe d ’ allocation
#include <stdio.h>
void plus()
{ int i , j = 1 ; static int k = 1;
j = j + 1;
k = k + 1;
printf(’’i=%d j=%d k=%d\n’’, i,j,k);
} int main() { plus();
plus();
plus();
return(0);
}
Sortie écran:
i=0 j=2 k=2 i=0 j=2 k=3 i=0 j=2 k=4
Note : i pas initialisé Hasard, si i=0.
Espace de validité et classe d ’ allocation
Variables globales
– définies hors du corps d’une fonction
– connues et accessibles tout au long du programme (globalement visibles par n’importe quelle fonction)
– permettent de partager l’information entre toutes les fonctions
int i;
{ int j ;
…
}
{ int k ; …
}
Global variable
Fichier source
Ne pas abuser des variables globales:
-garder local ce qui est local,
pour avoir des fonctions réutilisables (bibliothèque))
Espace de validité et classe d ’ allocation
int j; /* GLOBAL VARIABLE*/
void plus()
{ int i = 1 ; static int k = 1;
j = j + 1;
k = k + 1;
printf("i=%d j=%d k=%d \n", i,j,k);
i= i+1;
}
void main() { j=6;
plus();
plus();
plus();
}
Sortie écran:
i = 1 j = 7 k = 2
i = 1 j = 8 k = 3
i = 1 j = 9 k = 4
Espace de validité et classe d ’ allocation
Variables globales pour un programme sur plusieurs fichiers
– Définition : réserve de la place mémoire
– Allusion : représente les propriétés (déclaration)
extern
– Classe statique pour une variable globale:
portée, visibilité, de la variable globale limitée au fichier
Fichier b
int i;
fonction 1
fonction 2
extern int i;
static int j;
fonction 3
Fichier a
définition allusion