2/ Les types de données primitif

16/12/2003

AUTONUMLGL Les Variables.

AUTONUMLGL Les éléments lexicaux.

Les éléments de base utilisés pour écrire des programmes dans un langage donné sont appelés les éléments lexicaux du langage et comprennent le jeu de caractères, les règles pour la formation des identificateurs et des opérateurs, l’usage des mots-clés ou des mots réservés, la façon dont on indique les commentaires et celle dont on dispose le texte du programme.

AUTONUMLGL Le jeu de caractère.

Le jeu de caractère est l’ensemble des signes typographiques utilisés par le langage de programmation : les lettres, les chiffres ainsi que les caractères spéciaux tels que les opérateurs arithmétiques et les signes de ponctuation.

La plupart des langages modernes utilisent les caractères du code ASCII (et éventuellement ceux du code ASCII étendu).

Java accepte tous les caractères du standard Unicode.

Java est sensible à la casse.

AUTONUMLGL Les identificateurs et les mots réservés.

Le jeu de caractères est l’ensemble à partir duquel sont formés les symboles appartenant au vocabulaire du langage de programmation. Or un langage a besoin de conventions pour définir la formation de mots par regroupements de caractères.

Certains des mots appartenant à un langage de programmation reçoivent un sens particulier comme DO et GOTO en Fortran ou begin et end en Pascal. La plupart des langages modernes restreignent l’utilisation de ce genre de mots. Ces mots sont alors appelés mots réservés.

Les mots réservés de Java sont les suivants :

AUTONUMLGL Les littéraux.

Un littéral est la représentation réelle d’un nombre, d’un caractère, d’un état ou d’une chaîne. Un littéral représente la valeur d’un identificateur. Les littéraux alphanumériques comprennent les chaînes entre guillemets, des caractères char uniques entre apostrophes et les valeurs boolean true/ false.

Les littéraux entiers peuvent être stockés en décimal, octal ou hexadécimal, mais soyez attentif à votre syntaxe : tout entier commençant par 0 (une date, par exemple) sera interprété comme un octal. Les littéraux en virgule flottante peuvent s’exprimer seulement en décimal. Ils seront traités comme double sauf si vous spécifiez le type.

AUTONUMLGL Les commentaires.

Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code. La syntaxe pour les commantaires varie fortement suivant les langages : (* et *) en Pascal, REM en Basic, /* et */ en C, une étoile en colonne 7 pour Cobol, le « ; » pour l’assembleur etc…

AUTONUMLGL Disposition du texte.

Certains langages exigent une disposition spéciale du texte. Cobol, par exemple divise les programmes en colonnes.

· Les colonnes 1 à 6 sont utilisées pour les numéros de séquence.

· La colonne 7 est utilisée pour marquer les commentaires ou pour indiquer qu’un ordre se poursuit sur plusieurs lignes.

· Les colonnes 8 à 72 sont utilisées pour les ordres Cobol.

Cette disposition était rendue nécessaire par l’utilisation de feuilles de COBOL pré-imprimées.

AUTONUMLGL Les variables.

Comme vu dans le cours précédent, les langages impératifs partent du principe qu’un ordinateur est construit autour d’une mémoire divisée en cases dans lesquelles on peut ranger des informations. On peut consulter le contenu d’une case ou le modifier.

Dans les langages impératifs les « cases » se nomment des « variables ». Elles sont désignées par un nom et on y stocker des données. Ces données peuvent être issues du disque dur, fournies par l’utilisateur (frappées au clavier), ou que sais-je encore. Il peut aussi s’agir de résultats obtenus par le programme, intermédiaires ou définitifs. Elles peuvent être de plusieurs types (des nombres, du texte, etc.)

Pour employer une image, une variable est une boîte, repérée par une étiquette. Pour avoir accès au contenu de la boîte, il suffit de la désigner par son étiquette.

En réalité, dans la mémoire vive de l’ordinateur, il n’y a ni boîte ni étiquette collée dessus. Il y a un emplacement de mémoire, désigné par une adresse binaire. Le langage informatique se charge, entre autres rôles, de vous épargner la gestion fastidieuse de ces emplacements mémoire et de leurs adresses. Il est beaucoup plus facile d’employer les étiquettes de son choix, que de devoir manier des adresses binaires.

Il est nécessaire de faire une nette distinction entre :

· le nom de la variable (son « identificateur » ou son « étiquette »),

· la zone de mémoire (sa « référence » ou son « adresse »),

· la valeur stockée.

nom référence valeur

Figure 1 les liens entre nom, référence et valeur

Dans la majorité des langages de programmation, les noms des variables sont appelés des identificateurs. Le plus souvent, un identificateur est une suite de lettres et de chiffres dont le premier caractère est une lettre. Les espaces ne sont normalement pas autorisés dans les identificateurs sauf dans des langages comme ALGOL 60 qui ignorent les espaces quel que soit l’endroit où ils apparaissent.

Certains langages limitent la taille des identificateurs (par exemple FORTRAN limite cette longueur à 6 caractères, FORTRAN 90 à 31).

De plus certains langages (comme Java) font une différence entre les majuscules et les minuscules alors que d’autres ne le font pas (Pascal, Ada).

AUTONUMLGL Les types de variables.

L’attribut le plus important d’un objet est son type. Un type spécifie les valeurs autorisées pour les objets de ce type ainsi que les opérations qu’il est possible d’utiliser pour manipuler ces valeurs. Au niveau le plus bas, les données ne sont qu’une suite de 0 et de 1 mais une telle suite peut aussi bien représenter un nombre entier qu’un nombre réel, un tableau de nombres, des caractères, des images etc. Un type permet donc d’associer un sens à une suite arbitraire de 0 et de 1.

La plupart des langages de programmation offrent les types simples qui suivents :

· Les types numériques : entier, virgule flottante et parfois virgule fixe et complexe.

· Un type logique

· Un ou plusieurs types caractère

AUTONUMLGL Les types numériques.

Tous les langages offrent des types numériques, dont le détail est susceptible de varier légèrement d’un langage à l’autre. En général, on retrouve cependant les types suivants :

Type Numérique

Plage

PASCAL

C

Entier simple

-32 768 à 32 767

integer

int

Entier long

-2 147 483 648 à 2 147 483 647

longint

long

Réel simple

-3,40E38 à -1,40E-45 pour les valeurs négatives

1,40E-45 à 3,40E38 pour les valeurs positives

real

float

Réel double

1,79E308 à -4,94E-324 pour les valeurs négatives

4,94E-324 à 1,79E308 pour les valeurs positives

double

Le type de codage (autrement dit, le type de variable) choisi pour un nombre va déterminer :

· les valeurs maximales et minimales des nombres pouvant être stockés dans la variable

· la précision de ces nombres (dans le cas de nombres décimaux).

· la représentation interne de de nombre.

Les types numériques prennent habituellement modèle sur la représentation en machine des nombres entiers et réels. Bien que cela ait l’avantage de la vitesse, cela signifie tout de même que la plage de variation et la précision des nombres seront différentes d’une machine à l’autre.

AUTONUMLGL Les entiers.

Le type integer est le plus simple des types prédéfinis. La plage de variation pour les entiers dépend du matériel et de la représentation choisie. Avec des mots de 32 bits, il est possible de représenter des entiers entre -231 et 231-1, au moyen de la représentation dite du complément à 2.

Des langages comme C proposent des types d’entiers différents. On a ainsi des entiers short et long qui correspondent à des entiers de longueurs différentes.

En Pascal, il est possible de déclarer des intervalles. Par exemple

var compteur : 1 .. 10 ;

Ces déclarations permettent, certes, de réduire l’encombrement mémoire mais elles sont surtout utiles pour détecter des erreurs de logique dans un programme.

Il existe deux techniques pour représenter les nombres entiers négatifs. La première est extrêmement simple : le premier bit représente le signe, et les autres bits la valeur absolue du nombre. Le bit de signe vaut 1 si le nombre est strictement négatif, 0 sinon.

Par exemple, le nombre (–14) codé sur 8 bits s’écrit ainsi : 10001110

Cette convention n’est quasiment jamais utilisée en informatique. On lui préfère la représentation en complément à 2 dont le principe est le suivant :

-les nombres positifs sont codés de la même façon qu’en convention « signe et valeur absolue».

-les nombres négatifs sont obtenus en inversant tous les bits, puis en ajoutant 1.

Exemple : le nombre 14 codé sur 8 bits est représenté ainsi : 00001110

et (–14) ainsi :

· inversion des bits : 11110001

· ajout d’une unité : 11110010

· résultat : 11110010

Si on fait la somme de 14 et de (–14), de la même façon que s’il s’agissait d’entiers positifs on a :

00001110 + 11110010 = 100000000

Le résultat étant codé sur 8 bits, le 1 situé à gauche n’est pas pris en compte. On obtient donc 14 + (-14) = 0.

L’intérêt évident est que la différence de deux nombres peut se calculer avec le même algorithme que leur somme. Il suffit de transformer au préalable le nombre retranché en son opposé. Cette conversion est très simple et très rapide.

Au contraire, en représentation « signe et valeur absolue », on aurait eu besoin de nombreux algorithmes, car plusieurs cas se présentent.

Exercice 1.

Codez les nombres entiers suivants sur 16 bits en utilisant la technique du complément à deux pour les nombres négatifs. Notez le résultat en binaire, en octal et en hexadécimal.

Nombre

Notation en binaire

Notation octale

Notation hexadécimale

0

13

-13

632

-632

AUTONUMLGL Les nombres en virgule flottante.

Les nombres en virgule flottante constituent le type le plus souvent utilisé dans les calculs mathématiques. Jusqu’à peu, le nom real était choisi pour dénoter ce type dans la plupart des langages mais aujourd’hui, on utilise plutôt float.

Soit un réel x et b une base de numération, la représentation repose sur la propriété suivante :

où

· m est la mantisse

· e est l'exposant.

· b est la base.

La plage de variation et la précision des nombres en virgule flottante est déterminée par l’implémentation. Un nombre réel sera souvent représenté à l’aide de 32 bits : un bit pour le signe, sept bits pour l’exposant et les 24 bits restants pour la mantisse.

1 bit

de

signe

Exposant de 7 bits Mantisse de 24 bits

Figure 2 Un nombre réel = signe * m * 2e

Les littéraux réels peuvent être écrits avec ou sans exposants. Quelques exemples en Java :

3.754.02.5E70.1786E-5

Avec la représentation donnée ci-dessus, pour un mot de 32 bits, un nombre en virgule flottante aura une précision d’environ 7 chiffres après la virgule. Bien que cela soit généralement suffisant, on peut dans certaines occasions avoir besoin d’une précision plus grande. En conséquence, les langages comportent généralement un type qui apporte une plus grande précision. En ALGOLW et en ALGOL68 il s’agit du type Long Real, en FORTRAN il s’appelle DOUBLE PRECISION et en C il se nomme DOUBLE. La méthode normalement adoptée est de prendre deux mots mémoire, au lieu d’un seul, pour un nombre en virgule flottante. Les parties signe et exposant de la représentation ne changent normalement pas et la mantisse est étendue pour englober le deuxième mot.

L’IEEE (Institute of Electrical and Electronics Engineers) a défini un standard pour la représentation des nombres en virgule flottante sur 32 et 64 bits.

Sur 32 bits :

S

E

E

E

E

E

E

E

E

M

M

M

M

M

M

M

M

M

M

M

M

M

M

M

M

M

0

1

8

9

31

Le nombre V représenté est défini de cette manière :

· Si E=255 et M<>0, alors V=NaN (« Not a Number »).

· Si E=255 et M=0 et S=1, alors V = - l’infini.

· Si E=255 et M=0 et S=0, alors V = + l’infini.

· Si 0

· Si E=0 et M<>0 alors V = =(-1)^S * 2 ^ (-126) * (0.M)

· Si E=0 et M=0 et S=1 alors V=-0.

· Si E=0 et M=0 et S=0 alors V=+0.

Par exemple :

0 00000000 00000000000000000000000

+ 0

1 00000000 00000000000000000000000

- 0

0 11111111 00000000000000000000000

+ Infinity

1 11111111 00000000000000000000000

- Infinity

0 11111111 00000100000000000000000

Nan

1 11111111 00100010001001010101010

Nan

0 10000000 00000000000000000000000

+1 * 2^(128-127) * 1.0 = 2

0 10000001 10100000000000000000000

+1 * 2^(129-127) * 1.101 = 6.5

1 10000001 10100000000000000000000

-1 * 2^(129-127) * 1.101 = -6.5

0 00000001 00000000000000000000000

+1 * 2^ (1-127) * 1.0 = 2^(-126)

0 00000000 10000000000000000000000

+1 * 2^(-126) * 0.1 = 2^(-127)

0 00000000 00000000000000000000001

+1 * 2^(-126) * 0.00000000000000000000001 = 2^(-149)

Sur 64 bits :

S

E

E

E

E

E

E

E

E

M

M

M

M

M

M

M

M

M

M

M

M

M

M

0

1

11

12

63

Le nombre V représenté est défini de cette manière :

· Si E=2047 et M<>0, alors V=NaN (« Not a Number »).

· Si E=2047 et M=0 et S=1, alors V = - l’infini.

· Si E=2047 et M=0 et S=0, alors V = + l’infini.

· Si 0

· Si E=0 et M<>0 alors V = =(-1)^S * 2 ^ (-1022) * (0.M)

· Si E=0 et M=0 et S=1 alors V=-0.

· Si E=0 et M=0 et S=0 alors V=+0.

Exercice 2.

Codez les nombres réels suivants sur 32 bits. Notez le résultat en binaire et en hexadécimal.

Nombre

Notation en binaire

Notation hexadécimale

0

00000000000000000000000000000000

0x00000000

13

1 * 2^(130-127)*1.625(10)

0 10000010 10100000000000000000000

0x4150000

-13

1 10000010 10100000000000000000000

0xC150000

0.65625

1 * 2^(125-127) * 1.25

0 01111101 01000000000000000000000

0x3EA000

-1/2

1 * 2^(125-127) * 1.0

1 01111101 00000000000000000000000

0xBE8000

AUTONUMLGL Les nombres en virgule fixe.

Dans les applications de gestion, on utilise souvent des nombres en virgule fixe. Certains langages proposent donc des types de données avec une virgule fixe. Par exemple, en PL/I la déclaration d’une variable X ayant deux chiffres après la virgule et d’une précision de six chiffres se ferait ainsi :

DECLARE X FIXED DECIMAL (6,2)

On retrouve souvent des types en virgule fixe dans les bases de données, la plupart des versions d’SQL supportant ces types. Par exemple :

create table dbo.fiche_travail

(cle_interne_ft int not null,

HN decimal(9,6) not null,

HDJF decimal(9,6) not null,

NBINT smallint not null,

intervacations smallint null,

affranchissements decimal(5,2) null, l) ;

Certains langages autorisent d’autres types numériques, notamment :

· le type monétaire (avec strictement deux chiffres après la virgule)

· les type datetime. Il existe, par exemple, en Transact-SQL (Sybase) un type smalldatetime qui permet de stocker des dates comprises entre le 01/01/1900 et le 06/06/2079 avec une précision d’une minute. Dans ce format, 4 octets sont utilisés. 2 pour stocker le nombre de jours après le 01/01/1900 et 2 pour le nombre de minutes après minuit.

AUTONUMLGL Les types non numériques.

AUTONUMLGL Les types logiques.

Dans un programme, on verra que les instructions conditionnelles sont très importantes. Comme ce genre d’instructions dépend d’expressions logiques qui peuvent être vraies ou fausses, la plupart des langages ont un type type logique. En FORTRAN et en ALGOLW, il se nomme LOGICAL, mais la plupart des langages l’ont baptisé Boolean, en hommage à George Boole, le mathématicien anglais qui a inventé une approche algébrique de la notation logique. En théorie, il est possible de représenter les valeurs booléennes par un bit unique, mais on le fait rarement car d’ordinaire, les bits ne sont pas adressables individuellement.

En général, les valeurs logiques sont écrites false et true.

C n’a pas de littéraux logiques en tant que tels. Pour ce langage, une valeur entière de 0 est équivalente au Faux et une valeur de 1 signifie Vrai. C’est une source fréquente d’erreurs pour les programmeurs qui ont connus d’autres langages et qui passent à C.

AUTONUMLGL Les types caractères.

Aujourd’hui, les langages de programmation proposent presque tous un type caractère ainsi que des opérations sur les caractères. Ces caractères sont souvent codés avec le code ASCII, sur 1 octet ou avec le standart unicode sur 2 octets.

Le code ASCII, acronyme de "American Standard Code for Information Interchange" permet de restituer les lettres de l'alphabet romain, les chiffres et les principaux caractères spéciaux utilisés en informatique. Les caractères ASCII peuvent être sur 7 ou 8 bits.

Le code ASCII a été mis au point pour la langue anglaise, il ne contient donc pas de caractères accentués, ni de caractères spécifiques à une langue. Pour coder ce type de caractère il faut recourir à un autre code. Le code ASCII a donc été étendu à 8 bits (un octet) pour pouvoir coder plus de caractères (on parle d'ailleurs de code ASCII étendu...).

code

0

1

2

3

4

5

6

7

8

9

0

NUL

SOH

STX

ETX

EOT

ENQ

ACK

BEL

BS

HT

10

LF

VT

NP

CR

SO

SI

DLE

DC1

DC2

DC3

20

DC4

NAK

SYN

ETB

CAN

EM

SUB

ESC

FS

GS

30

RS

US

SP

!

"

#

$

%

&

'

40

(

)

*

+

,

-

.

/

0

1

50

2

3

4

5

6

7

8

9

:

;

60

<

=

>

?

@

A

B

C

D

E

70

F

G

H

I

J

K

L

M

N

O

80

P

Q

R

S

T

U

V

W

X

Y

90

Z

[

\

]

^

_

`

a

b

c

100

d

e

f

g

h

i

j

k

l

m

110

n

o

p

q

r

s

t

u

v

w

120

x

y

z

{

|

}

~

DEL

Le code ASCII

Remarques :

· Les codes 0 à 31 ne sont pas des caractères. On les appelle caractères de contrôle car ils permettent de faire des actions telles que:

· retour à la ligne (CR)

· bip sonore (BEL)

· Les codes 48 à 57 représentent les chiffres.

· Les codes 65 à 90 représentent les majuscules.

· Les codes 97 à 122 représentent les minuscules.

Classe

Code

Signification

TC6

ACK

ACKnowledge

Accusé réception

BEL

BEL

Sonnerie

FE0

BS

BackSpace

Retour d’un caractère en arrière

CAN

Cancel

Annulation

FE5

CR

Carriage Return

Retour chariot

DC1 à

DC

Device Control

Commande de périphérique

DC4

DEL

DELete

Effacement

TC7

DLE

Data Link Escape

Echappement transmission

EM

End of Medium

Fin de support

TC5

ENQ

ENQuiry

Demande

TC4

EOT

End Of Transmission

Fin de transmission

ESC

ESCape

Echappement

TC10

ETB

End Transmission Block

Fin de bloc de transmission

TC3

ETX

End of TeXt

Fin de texte

FE4

FF

Form Feed

Présentation d’imprimé

IS4

FS

File Separator

Séparateur de fichier

IS3

GS

Group Separator

Séparateur de groupe

FE1

HT

Horizontal Tabulation

Tabulation horizontale

FE2

LF

Line Feed

Interligne

TC8

NAK

Negative Acknowledge

Accusé réception négatif

NUL

NUL

Nul

IS2

RS

Record Separator

Séparateur de zone

SI

Shift In

En code

SO

Shift Out

Hors Code

TC1

SOH

Start Of Heading

Début d’en tête

SP

Space

Espace

TC2

STX

Start Of Text

Début de texte

SUB

SUBstitution

Remplacement

TC9

SYN

SYNchronous idle

Synchronisation

IS1

US

Unit Separator

Séparateur de champ

FE3

VT

Vertical Tabulation

Tabulation verticale

DC1 à DC4

Commandes destinées à d’autres périphériques (DC = Device Control)

FE0 à FE5

Commandes de mises en page (FE = Format Effector)

IS1 à IS4

Caractères séparateurs (IS = Information Separator)

TC1 à TC10

Commandes pour appareils de transmission (TC = Transmitter Control)

Le système Unicode code les caractères sur 2 octets car il est prévu pour gérer tous les caractères de toutes les langues écrites. Cela offre un jeu de 65536 caractères parmi lesquels environ 35000 sont utilisés actuellement (y compris des caractères de ponctuation, signes diacritiques, symboles mathématique et techniques, flèches, dingbats) Cependant, bien qu'il soit théoriquement possible d'utiliser n'importe quel caractère dans une application Java, l'affichage d'un caractère dépend, en définitive, des possibilités de votre système d'exploitation et éventuellement de votre navigateur. Il n'est, par exemple, pas possible d'afficher du Kanji sur une machine équipée de la version US de Windows 95.

Les alphabets traités sont :

Latin, Greek, Cyrillic, Armenian, Hebrew, Arabic, Devanagari, Bengali, Gurmukhi, Gujarati, Oriya, Tamil, Telugu, Kannada, Malayalam, Thai, Lao, Georgian, Tibetan, Japanese Kana, modern Korean Hangul, Chinese/Japanese/Korean (CJK) ideographs. Et bientôt: Ethiopic, Canadian Syllabics, Cherokee, additional rare ideographs, Sinhala, Syriac, Burmese, Khmer, et Braille.

Latin de base (: [standard ASCII (Latin-1)])

Cyrillique ([Cyrillic])

AUTONUMLGL Les Pointeurs.

Les variables de type pointeur ont pour valeur une adresse, c’est à dire une référence à un autre objet-donnée. Ce type de donnée n’existait pas dans les premiers langages tels que FORTRAN, ALGOL ou COBOL. Mais presque tous ceux qui ont suivi ont intégré cette fonctionnalité.

Les pointeurs possèdent une valeur spéciale nil (nul en ADA et en C) qui indique que la variable ne désigne rien actuellement.

Exemple en Pascal :

Une variable de type pointeur contient l'adresse mémoire d'une variable dynamique d'un type de base défini.

Vous pouvez affecter une valeur à un pointeur de la manière suivante:

· avec les procédures New ou GetMem qui permettent de créer une variable dynamique et d’y associer un pointeur.

· avec l'opérateur @ qui renvoie un pointeur sur une variable.

· avec la fonction Ptr qui convertit une adresse segment:offset en une valeur pointeur.

Le mot réservé nil indique une constante pointeur qui ne pointe sur rien, mais qui ne risque pas de créer de problème.

Le type prédéfini Pointer indique un pointeur non typé (un pointeur qui ne pointe sur aucun type particulier).

Exemple de déclaration du type Pointer :

type

BytePtr = ^Byte;

WordPtr = ^Word;

IdentPtr = ^IdentRec;

IdentRec = record

Ident: string[15];

RefCount: Word;

Next: IdentPtr;

end;

AUTONUMLGL Les tableaux.

Les tableaux (parfois appelés « vecteurs ») sont des suites finies et modifiables de valeurs d'un même type.

Puisque les éléments du tableau sont tous de même nature, on qualifie les tableaux de suites homogènes de valeurs.

AUTONUMLGL Les chaînes de caractères.

L’implémentation des chaînes de caractères varie fortement selon les langages de programmation. On a les cas de figure suivant :

Chaînes de longueur fixée à la déclaration. Complétée par des blancs si la chaine contenue dans la variable est plus courte.

COBOL

Chaînes de longueur variable avec deux nombres indiquant : la taille réservée pour la chaine de caractère et la longueur réelle de la chaine.

Chaîne de longueur fixée à la déclaration avec un octet indiquant la taille réelle de la chaîne.

PASCAL

Chaînes de longueur variables avec un caractère spécial marquant la fin de la chaîne.

C

En Java, les chaînes de caractères sont des objets et ont donc un traitement particulier.

AUTONUMLGL Types complexes.

Nous avons vu les types de données de base. A partir de ceux-ci on peut construire des types plus complexes, associant par exemple trois entier pour former un nouveau type de données. En Pascal, on peut, par exemple écrire :

Type Tma_date = record

jour : integer ;

mois : integer ;

annee : integer ;

end ;

Il existe aussi des types qui associent un ensemble de données du même type. Ce sont, par exemple les types tableaux :

var mon_tableau = array[1..250] of integer ;

En associant à ces types des opérations possibles on obtient ce qu’on appelle des types de données abstraits. Et si on y ajoute du code, on obtient des objets. Ces concepts seront détaillés plus tards.

AUTONUMLGL La déclaration des variables.

La déclaration de type est la technique mise en œuvre dans certains langages tels que Pascal, C ou Ada. Dans ce cas, chaque objet figurant dans le programme est préalablement déclaré avec la mention explicite du type auquel il appartient.

La synthèse de type dispense de toute déclaration préalable du type de l'objet. Le type de l'objet est déduit du contexte par l'application de règles d'inférence de type. La synthése de type est utilisée dans certains langages fonctionnels tels que Caml.

AUTONUMLGL Déclaration.

Dans la plupart des langages de programmation modernes, les variables sont introduites dans un programme par une déclaration. Elles peuvent alors être utilisées dans les instructions du programme. Le lien entre l’utilisation d’un nom dans une instruction et sa déclaration est appelé ici la liaison entre nom et déclaration.

Voici quelques exemples de déclarations dans différents langages :

PASCAL

C

Var a,b : integer ;

f1,f2 : real ;

ok : boolean ;

int a,b ;

float f1,f2 ;

boolean ok ;

TRANSACT-SQL

Java

DECLARE

@a INTEGER,

@b INTEGER,

@f1 DECIMAL(8,2),

@f2 DECIMAL(8,2),

@ok BOOLEAN

int a,b;

float f1,f2 ;

boolean ok ;

ASSEMBLEUR

COBOL

a DW 0

b DW 0

ok DB ?

msg DB “Bonjour, monde !”, ‘$’

000039 DATA DIVISION.

000040 WORKING-STORAGE SECTION.

000041 01 A PIC 9.

000042 01 B PIC 9.

000043 01 F1 PIC 9(6)V99.

000043 01 F2 PIC 9(6)V99.

Certains langages réservent des emplacements précis dans le programme pour la déclaration des variables. Cobol, par exemple, demande que les variables soient déclarées dans des sections spécifiques du programme.

En Pascal, l’endroit où on déclare une variable est également important. De lui dépendra la visibilité de la variable et sa durée de vie.

AUTONUMLGL Initialisation.

Java permet également d’initialiser une variable à sa déclaration :

int ma_variable = 5; // Déclaration et initilisation

AUTONUMLGL La déclaration des constantes.

Les constantes nommées (aussi appelées constantes symboliques) sont déclarées avec le modificateur final :

final double PI = 3.14159265359;

Elles ne peuvent plus être modifiées dans la suite du programme (il est donc important de les initialiser directement lors de leur définition). Par convention, les identificateurs de constantes sont entièrement en majuscules.

AUTONUMLGL Manipulation.

Pour pouvoir utiliser une variable, deux opérations sont indispensables :

· la lecture (consulter le contenu de la variable)

· l’écriture (affecter un contenu à une variable).

AUTONUMLGL Affectation.

En algorithmique, cette instruction se note généralement avec le signe .

Ainsi :

ma_variable 10.25

affecte la valeur 10 à la variable nommée « ma_variable ».

ma_variable ma_variable + 1

affecte la valeur « contenu de ma_variable » + 1 à la variable nommée « ma_variable ».

En Java.

En plus de l'affectation classique (opérateur =), il existe d'autres opérateurs d'affectation. Par exemple :

Opération

Equivalence

a+=b

a = a + b

a -= b

a = a – b

a *= b

a = a * b

a /= b

a = a/b

a %= b

a = a % b

a >>= b

a = a >> b

a <<= b

a = a << b

a &= b

a = a & b

a ^= b

a = a ^ b

a |= b

a = a | b

AUTONUMLGL Lecture.

Certains langages nécessitent l’utilisation d’opérateurs de déréférencement pour lire le contenu d’une variable.

AUTONUMLGL Transtypage et conversion.

Les valeurs des types de données peuvent être convertis dans un autre type. Notez que cette conversion ne change pas le type initial de la valeur, mais uniquement la perception qu’en a le compilateur pour cette seule opération.

Des restrictions logiques évidentes s’appliquent. Une conversion d’agrandissement — d’un type petit vers un plus grand — est facile, mais une conversion de raccourcissement — d’un type grand (par exemple, double ou Mammifère) vers un plus petit (par exemple, float ou Ours) — est dangereuse pour vos données, sauf si vous être certain que les données tiendront dans les paramètres du nouveau type. Une conversion de raccourcissement requiert une opération spéciale qu’on appelle le transtypage.

Tableau des conversions sans pertes

DE \ A

byte

short

int

long

float

double

char

byte

Oui

Oui

Oui

Oui

Oui

Oui

Oui

short

Oui

Oui

Oui

Oui

Oui

int

Oui

Oui

Perte

Oui

long

Oui

Perte

Perte

float

Oui

Oui

double

Oui

char

Oui

Oui

Oui

Oui

Oui

AUTONUMLGL Recommandations.

Il n’est pas recommandé d’utiliser des caractères accentués dans les identifiants de variables, cela peut éventuellement poser des problèmes dans le cas ou le code est édité sur des systèmes d'exploitation qui ne les gèrent pas correctement.

Il ne doit y avoir qu’une seule déclaration d’entité par ligne.

Exemple :

String nom;

String prenom;

Cet exemple est préférable à

Exemple :

String nom, prenom; //ce type de déclaration n’est pas recommandée

Il faut éviter de déclarer des variables de types différents sur la même ligne même si cela est accepté par le compilateur.

Exemple :

int age, notes[]; // ce type de déclaration est à éviter

Il est préférable d’aligner le type, l’identifiant de l’objet et les commentaires si plusieurs déclarations se suivent pour retrouver plus facilement les divers éléments.

Exemple :

String nom //nom de l’eleve

String prenom //prenom de l’eleve

int notes[] //notes de l’eleve

Il est fortement recommandé d’initialiser les variables au moment de leur déclaration. Il est préférable de rassembler toutes les déclarations d’un bloc au début de ce bloc. (un bloc est un morceau de code entouré par des accolades).

AUTONUMLGL Exercices.

AUTONUMLGL Exercice 3.

La figure ci-dessus représente un « dump » en hexadécimal d’un fichier. On considère les octects en début de ligne 172 (60 56 C0 00).

Si on suppose que ces octets représentent 2 entiers codés sur 16 bits, quelles sont leurs valeurs.

Si on suppose que ces octets représentent 1 réel codé sur 32 bit, quelle est sa valeur ?

AUTONUMLGL Corrections

AUTONUMLGL Exercice 1

Codez les nombres entiers suivants sur 16 bits en utilisant la technique du complément à deux pour les nombres négatifs. Notez le résultat en binaire, en octal et en hexadécimal.

Nombre

Notation en binaire

Notation octale

Notation hexadécimale

0

0000000000000000

00000000

0x0000

13

0000000000001101

00000015

0x000D

-13

1111111111110011

00177763

0xFFF3

632

0000001001111000

00001170

0x0278

-632

1111110110001000

00176610

0xFD88

AUTONUMLGL Exercice 2

Codez les nombres réels suivants sur 32 bits. Notez le résultat en binaire et en hexadécimal.

Nombre

Notation en binaire

Notation hexadécimale

0

00000000000000000000000000000000

0x00000000

13

1 * 2^(130-127)*1.625(10)

0 10000010 10100000000000000000000

0x4150000

-13

1 10000010 10100000000000000000000

0xC150000

0.65625

1 * 2^(125-127) * 1.25

0 01111101 01000000000000000000000

0x3EA000

-1/2

1 * 2^(125-127) * 1.0

1 01111101 00000000000000000000000

0xBE8000

AUTONUMLGL Exercice 3

On commence par tout convertir en binaire :

Hexa :

60

56

C0

00

Binaire :

01100000

01010110

11000000

00000000

Si on suppose que ces octets représentent 2 entiers codés sur 16 bits, on a donc :

· L’entier 0110000001010110 qui a pour valeur 24662(10) soit 6056(16).

· L’entier 1100000000000000 qui est un nombre négatif. On calcule donc le complément à deux qui est 0100000000000000 et vaut 16384(10). Le nombre représenté est donc -16384(10).

Si on suppose que ces octets représentent 1 réel codé sur 32 bit, on a :

Signe

Exposant

Mantisse

0

1100000

010101101100000000000000

Nombre positif

96(10)

Le nombre recherché est donc 2^(96-127)*1.0101011011 soit 2-31*1.3388671875 soit 6.2345861806534230709075927734375e-10(10)

En java :

Les identificateurs peuvent être composés de tous les caractères alphanumériques et des caractères _ et $. Le premier caractère doit être une lettre, le caractère de soulignement ou le signe dollars.

En java :

Les entiers peuvent s'écrire en hexadécimal. Dans ce cas, ils seront préfixés par 0x. (par exemple "0x89A4" ou "0xCAFE").

Ils peuvent également s'écrire en octal. Dans ce cas, ils sont précédés de 0. (par exemple "01234" ou "077").

Exemples de constantes réelles : "3.1", "6.", "0.123456", "-4E3", "-4E3D", "-4E3F" ...

Les constantes de type caractère sont représentées entre deux apostrophes : 'a', 'A', '1', '0', 'ç', 'ù', '£', 'µ' etc...

En java :

Il existe trois type de commentaire en Java :

Type de commentaires�

Exemple�

�

commentaire abrégé�

// commentaire sur une seule ligne

int N=1; // déclaration du compteur�

�

commentaire multiligne�

/* commentaires ligne 1

commentaires ligne 2 */�

�

commentaire de documentation automatique�

/** commentaire */�

�

En java :

Les types de données permettent de répertorier le type d’information que peuvent contenir certains éléments de programmation Java. Les types de données se divisent en deux catégories :

• Primitifs ou de base

• Composites ou de référence.

En Java, les types élémentaires ont une taille identique quelque soit la plate-forme d'exécution : c'est un des éléments qui permet à java d'être indépendant de la plate-forme sur lequel le code s'exécute.

En java :

Type�

Désignation�

Longeur�

Valeurs�

�

byte�

Octet �

Signé 8 bits�

-128 à 127�

�

short�

Entier court�

Signé 16 bits�

-32768 à 32767�

�

int�

Entier�

Signé 32 bits�

-2147483648 à 2147483647�

�

long�

Entier long�

Signé 64 bits�

-9223372036854775808 à 9223372036854775807�

�

En java :

Type�

Désignation�

Longeur�

Valeurs�

�

float�

Virgule flottante �

32 bits�

1.401e-045 à 3.40282e+038�

�

double�

Double prec.�

64 bits�

2.22507e-308 à 1.79769e+308�

�

En java :

Type�

Désignation�

Longeur�

Valeurs�

�

bool�

Logique�

1 octet�

true, false�

�

En Java, le type boolean de Java ne peut être assimilée à un 0 ou 1 comme dans le cas des langages C ou C++.

En java :

Les caractères sont codés avec le standard Unicode2. Il est ainsi possible d'utiliser des caractères de n'importe quel alphabet (latin accentué, grec, cyrillique, arabe, hiragana etc...) ainsi que des symboles mathématiques et techniques. Les constantes de type caractère sont représentées entre deux apostrophes :

'a', 'A', '1', '0', 'ç', 'ù', '£', 'µ' etc...

Il existe très peu d'éditeurs de texte Unicode. C'est la raison pour laquelle Java résout cette difficulté en ayant recours aux séquences d'échappement Unicode qui n'utilisent que des caractères ASCII. Pour un caractère Unicode représenté par les quatres chiffres hexadécimaux wxyz, la séquence d'échapement est \uwxyz.

Exemples :

à \u00E0 â \u00E2 ç \u00E7è \u00E8

é \u00E9ê \u00EA ë \u00EBî \u00EE

ï \u00EFô \u00F4

Type�

Désignation�

Longeur�

Valeurs�

�

char�

caractère�

2 octet�

Standart unicode.�

�

En java :

Java, comme tous les langages fondés sur le Pascal, demande que le type de chaque variable soit

déclaré. On déclare une variable en spécifiant d'abord son type puis son nom :

byte un_octet;

int un_entier;

long un_entier_long;

char un_caractère;

Chaque déclaration se termine par un point-virgule. Le point-virgule est nécessaire car une déclaration est une instruction Java complète.

En java :

L’identificateur est le nom que vous choisissez pour appeler un élément (une variable ou une méthode, par exemple). Java accepte tout identificateur correct, mais, pour un bon usage, il vaut mieux utiliser un terme simple du langage modifié pour répondre aux exigences suivantes : • Il doit commencer par une lettre. A vrai dire, il peut commencer par un symbole monétaire Unicode ou par un caractère de soulignement (_), mais certains de ces symboles peuvent être utilisés dans les fichiers importés ou par les traitements internes. Il vaut donc mieux les éviter. Ensuite, il peut contenir tous les caractères alphanumériques (lettres ou chiffres), des caractères de soulignement ou des symboles monétaire Unicode ($ ou £, par exemple), mais pas d’autres caractères spéciaux. • Il doit être constitué d’un seul mot (sans espace ni tiret). L’utilisation des majuscules dans un identificateur dépend de son type. Java distingue les majuscules des minuscules, soyez donc attentif à l’utilisation des majuscules. L’utilisation correcte des majuscules est mentionnée dans le contexte.

Notez qu'en Java, le sens des termes "lettres" ou "chiffres" est beaucoup plus large que dans beaucoup d'autres langages. Une lettre est définie comme n'importe quel caractère Unicode représentant une lettre dans une langue quelconque. L'utilisateur français ou allemand peut donc très bien utiliser les caractères accentués. De même l'utilisateur russe peut utiliser des caractères cyrilliques.

� Remarque : le résultat intermédiaire, 11110001, est appelé « complément à 1 ».

� Le type Datetime permet lui de stocker des dates comprises entre le 01/01/1753 et le 31/12/9999 avec une précision 1/300 de seconde. Ce format utilise 8 octets. 4 pour pour le nombre de jours avant ou après le 01/01/1900 et 4 pour l’heure de la journée.

� Traduisez «Code Américain Standard pour l'Echange d'Informations ».

2/ Les types de données primitif

Page 1 sur 21

_1132137798.vsd

_1132142000.vsd