formation langague C:La définition des variables

Les variables simples peuvent être définies avec la syntaxe suivante :
type identificateur;
où type est le type de la variable et identificateur est son nom. Il est possible de créer et
d’initialiser une série de variables dès leur création avec la syntaxe suivante :
type identificateur[=valeur][, identificateur[=valeur][...]];
Exemple 1-8. Définition de variables
int i=0, j=0; /* Définit et initialise deux entiers à 0 */
double somme; /* Déclare une variable réelle */
Les variables peuvent être définies quasiment n’importe où dans le programme. Cela permet de ne
définir une variable temporaire que là où l’on en a besoin.
Note : Cela n’est vrai qu’en C++. En C pur, on est obligé de définir les variables au début des
fonctions ou des instructions composées (voir plus loin). Il faut donc connaître les variables temporaires
nécessaires à l’écriture du morceau de code qui suit leur définition.
La définition d’une variable ne suffit pas, en général, à l’initialiser. Les variables non initialisées
contenant des valeurs aléatoires, il faut éviter de les utiliser avant une initialisation correcte. Initialiser
les variables que l’on déclare à leur valeur par défaut est donc une bonne habitude à prendre. Cela est
d’ailleurs obligatoire pour les variables « constantes » que l’on peut déclarer avec le mot clé const,
car ces variables ne peuvent pas être modifiées après leur définition. Ce mot clé sera présenté en détail
dans la Section 3.2.
Note : Si les variables utilisant les types simples ne sont pas initialisées lors de leur définition
de manière générale, ce n’est pas le cas pour les objets dont le type est une classe définie
par l’utilisateur. En effet, pour ces objets, le compilateur appelle automatiquement une fonction
d’initialisation appelée le « constructeur » lors de leur définition. La manière de définir des classes
d’objets ainsi que toutes les notions traitant de la programmation objet seront décrites dans le
Chapitre 8.
La définition d’un tableau se fait en faisant suivre le nom de l’identificateur d’une paire de crochets,
contenant le nombre d’élément du tableau :
type identificateur[taille]([taille](...));
Note : Attention ! Les caractères ’[’ et ’]’ étant utilisés par la syntaxe des tableaux, ils ne signifient
plus les éléments facultatifs ici. Ici, et ici seulement, les éléments facultatifs sont donnés entre
parenthèses.
Dans la syntaxe précédente, type représente le type des éléments du tableau.
Exemple 1-9. Définition d’un tableau
int MonTableau[100];
MonTableau est un tableau de 100 entiers. On référence les éléments des tableaux en donnant l’indice
de l’élément entre crochet :
MonTableau[3]=0;
i=j=k=m=0; /* Annule les variables i, j, k et m. */
• les opérations de base du langage :
valeur op valeur
où op est l’un des opérateurs suivants : +, -, *, /, %, &, |, ^, ~, <<, >>.
Note : ’/’ représente la division euclidienne pour les entiers et la division classique pour les
flottants.
’%’ représente la congruence (c’est-à-dire le reste de la division euclidienne). ’|’ et ’&’ représentent
respectivement le ou et le et binaire (c’est-à-dire bit à bit : 1 et 1 = 1, 0 et x = 0, 1 ou x = 1 et 0 ou 0
= 0). ’^’ représente le ou exclusif (1 xor 1 = 0, 0 xor 0 = 0 et 1 xor 0 = 1). ’~’ représente la négation
binaire (1 devient 0 et vice versa). ’<<’ et ’>>’ effectuent un décalage binaire vers la gauche et la
droite respectivement, d’un nombre de bits égal à la valeur du second opérande.
• les opérations des autres opérateurs du langage. Le C et le C++ disposent d’opérateurs un peu
plus évolués que les opérateurs permettant de réaliser les opérations de base du langage. Ces opérateurs
sont les opérateurs d’incrémentation et de décrémentation ++ et --, l’opérateur ternaire
d’évaluation conditionnelle d’une expression (opérateur ?:) et l’opérateur virgule (opérateur ,).
La syntaxe de ces opérateurs est décrite ci-dessous.
• les appels de fonctions. Nous verrons comment écrire et appeler des fonctions dans les sections
suivantes.
Bien entendu, la plupart des instructions contiendront des affectations. Ce sont donc sans doute les
affectations qui sont les plus utilisées parmi les diverses opérations réalisables, aussi le C et le C++
permettent-ils l’utilisation d’affectations composées. Une affectation composée est une opération permettant
de réaliser en une seule étape une opération normale et l’affectation de son résultat dans la
variable servant de premier opérande. Les affectations composées utilisent la syntaxe suivante :
variable op_aff valeur
où op_aff est l’un des opérateurs suivants : ’+=’, ’-=’, ’*=’, etc. Cette syntaxe est strictement équivalente
à :
variable = variable op valeur
et permet donc de modifier la valeur de variable en lui appliquant l’opérateur op.
Exemple 1-11. Affectation composée
i*=2; /* Multiplie i par 2 : i = i * 2. */
Les opérateurs d’incrémentation et de décrémentation ++ et -- s’appliquent comme des préfixes ou
des suffixes sur les variables. Lorsqu’ils sont en préfixe, la variable est incrémentée ou décrémentée,
Il est possible de créer des instructions composées, constituées d’instructions plus simples. Les instructions
composées se présentent sous la forme de bloc d’instructions où les instructions contenues
sont encadrées d’accolades ouvrantes et fermantes (caractères ’{ et ’}’).
Exemple 1-12. Instruction composée
{
i=1;
j=i+3*g;
}
Note : Un bloc d’instructions est considéré comme une instruction unique. Il est donc inutile de
mettre un point virgule pour marquer l’instruction, puisque le bloc lui-même est une instruction.
Enfin, il existe tout un jeu d’instructions qui permettent de modifier le cours de l’exécution du programme,
comme les tests, les boucles et les sauts. Ces instructions seront décrites en détail dans le
chapitre traitant des structures de contrôle.

formation langague C:Notation des valeurs

Les entiers se notent de la manière suivante :
• base 10 (décimale) : avec les chiffres de ’0’ à ’9’, et les signes ’+’ (facultatif) et ’-’.
Exemple 1-4. Notation des entiers en base 10
12354, -2564
• base 16 (hexadécimale) : avec les chiffres ’0’ à ’9’ et ’A’ à ’F’ ou a à f (A=a=10, B=b=11, ...
F=f=15). Les entiers notés en hexadécimal devront toujours être précédés de « 0x » (qui indique la
base). On ne peut pas utiliser le signe ’-’ avec les nombres hexadécimaux.
Exemple 1-5. Notation des entiers en base 16
0x1AE
base 8 (octale) : avec les chiffres de ’0’ à ’7’. Les nombres octaux doivent être précédés d’un 0 (qui
indique la base). Le signe ’-’ ne peut pas être utilisé.
Exemple 1-6. Notation des entiers en base 8
01, 0154
Les flottants (pseudo réels) se notent de la manière suivante :
[signe] chiffres [.[chiffres]][e|E [signe] exposant][f]
où signe indique le signe. On emploie les signes ’+’ (facultatif) et ’-’ aussi bien pour la mantisse que
pour l’exposant. ’e’ ou ’E’ permet de donner l’exposant du nombre flottant. L’exposant est facultatif.
Si on ne donne pas d’exposant, on doit donner des chiffres derrière la virgule avec un point et ces
chiffres. Le suffixe ’f’ permet de préciser si le nombre est de type float ou non (auquel cas il s’agit
d’un double).
Les chiffres après la virgule sont facultatifs, mais pas le point. Si on ne met ni le point, ni la mantisse,
le nombre est un entier décimal.
Exemple 1-7. Notation des réels
-123.56f, 12e-12, 2
« 2 » est entier, « 2.f » est réel.
Les caractères se notent entre guillemets simples :
’A’, ’c’, ’(’
On peut donner un caractère non accessible au clavier en donnant son code en octal, précédé du
caractère ’\’. Par exemple, le caractère ’A’ peut aussi être noté ’\101’. Remarquez que cette notation
est semblable à la notation des nombres entiers en octal, et que le ’0’ initial est simplement remplacé
par un ’\’. Il est aussi possible de noter les caractères avec leur code en hexadécimal, à l’aide de
la notation « \xNN », où NN est le code hexadécimal du caractère. Enfin, il existe des séquences
d’échappement particulières qui permettent de coder certains caractères spéciaux plus facilement.
Les principales séquences d’échappement sont les suivantes :
’\a’ Bip sonore
’\b’ Backspace
’\f’ Début de page suivante
’\r’ Retour à la ligne (sans saut de ligne)
’\n’ Passage à la ligne
’\t’ Tabulation
’\v’ Tabulation verticale
D’autres séquences d’échappement sont disponibles, afin de pouvoir représenter les caractères ayant
une signification particulière en C :
’\\’ Le caractère \
’\"’ Le caractère "
Bien qu’il n’existe pas à proprement parler de chaînes de caractères en C/C++, il est possible de
définir des tableaux de caractères constants utilisables en tant que chaînes de caractères en donnant
leur contenu entre doubles guillemets :
"Exemple de chaîne de caractères..."
Les caractères spéciaux peuvent être utilisés directement dans les chaînes de caractères constantes :
"Ceci est un saut de ligne :\nCeci est à la ligne suivante."
Si une chaîne de caractères constante est trop longue pour tenir sur une seule ligne, on peut concaténer
plusieurs chaînes en les juxtaposant :
"Ceci est la première chaîne " "ceci est la deuxième."
produit la chaîne de caractères complète suivante :
"Ceci est la première chaîne ceci est la deuxième."
Note : Attention : il ne faut pas mettre de caractère nul dans une chaîne de caractères. Ce
caractère est en effet le caractère de terminaison de toute chaîne de caractères.
Enfin, les versions longues des différents types cités précédemment (wchar_t, long int et long double)
peuvent être notées en faisant précéder ou suivre la valeur de la lettre ’L’. Cette lettre doit précéder la
valeur dans le cas des caractères et des chaînes de caractères et la suivre quand il s’agit des entiers et
des flottants. Par exemple :
L"Ceci est une chaîne de wchar_t."
2.3e5L

formation langague C:Les types prédéfinis du C/C++

Le C, et encore plus le C++, est un langage typé. Cela signifie que chaque entité manipulée dans les
programmes doit disposer d’un type de donnée grâce auquel le compilateur pourra vérifier la validité
des opérations qu’on lui appliquera. La prise en compte du type des données peut apparaître comme
une contrainte pour le programmeur, mais en réalité il s’agit surtout d’une aide à la détection des
erreurs.
Il existe plusieurs types prédéfinis. Ce sont :
• le type vide : void. Ce type est utilisé pour spécifier le fait qu’il n’y a pas de type. Cela a une utilité
pour faire des procédures (fonctions ne renvoyant rien) et les pointeurs sur des données non typées
(voir plus loin) ;
• les booléens : bool, qui peuvent prendre les valeurs true et false (en C++ uniquement, ils
n’existent pas en C) ;
2
Chapitre 1. Première approche du C/C++
• les caractères : char ;
• les caractères longs : wchar_t (ce n’est un type de base que pour le langage C++, mais il est également
défini dans la bibliothèque standard C et est donc utilisable malgré tout en C) ;
• les entiers : int ;
• les réels : float ;
• les réels en double précision : double ;
• les tableaux à une dimension, dont les indices sont spécifiés par des crochets (’[’ et ’]’). Pour les
tableaux de dimension supérieure ou égale à 2, on utilisera des tableaux de tableaux ;
• les structures, unions et énumérations (voir plus loin).
Les types entiers (int) peuvent être caractérisés d’un des mots clés long ou short. Ces mots clés
permettent de modifier la taille du type, c’est-à-dire la plage de valeurs qu’ils peuvent couvrir. De
même, les réels en double précision peuvent être qualifiés du mot clé long, ce qui augmente leur
plage de valeurs. On ne peut pas utiliser le mot clé short avec les double. On dispose donc de types
additionnels :
• les entiers longs : long int, ou long (int est facultatif) ;
• les entiers courts : short int, ou short ;
• les réels en quadruple précision : long double.
Note : Attention ! Il n’y a pas de type de base permettant de manipuler les chaînes de caractères.
En C/C++, les chaînes de caractères sont en réalité des tableaux de caractères. Vous trouverez
plus loin pour de plus amples informations sur les chaînes de caractères et les tableaux.
La taille des types n’est spécifiée dans aucune norme. La seule chose qui est indiquée dans la norme
C++, c’est que le plus petit type est le type char. Les tailles des autres types sont donc des multiples
de celle du type char. De plus, les inégalités suivantes sont toujours vérifiées :
char short int int long int
float double long double
où l’opérateur « » signifie ici « a une plage de valeur plus petite ou égale que ». Cela dit, les
tailles des types sont généralement les mêmes pour tous les environnements de développement. Le
type char est généralement codé sur un octet (8 bits), le type short int sur deux octets et le type
long int sur quatre octets. Le type int est celui qui permet de stocker les entiers au format natif du
processeur utilisé. Il est donc codé sur deux octets sur les machines 16 bits et sur quatre octets sur
les machines 32 bits. Enfin, la taille des caractères de type wchar_t n’est pas spécifiée et dépend de
l’environnement de développement utilisé. Ils sont généralement codés sur deux ou sur quatre octets
suivant la représentation utilisée pour les caractères larges.
Note : Remarquez que, d’après ce qui précède, le type int devrait être codé sur 64 bits sur les
machines 64 bits. Le type long int devant lui être supérieur, il doit également être codé sur 64 bits
ou plus. Le type short int peut alors être sur 16 ou sur 32 bits. Il n’existe donc pas, selon la norme,
de type permettant de manipuler les valeurs 16 bits sur les machines 64 bits si le type short int
est codé sur 32 bits, ou, inversement, de type permettant de manipuler les valeurs 32 bits si le
type short int est codé sur 16 bits.

Afin de résoudre ces problèmes, la plupart des compilateurs brisent la règle selon laquelle le
type int est le type des entiers natifs du processeur, et fixent sa taille à 32 bits quelle que soit
l’architecture utilisée. Ainsi, le type short est toujours codé sur 16 bits, le type int sur 32 bits et le
type long sur 32 ou 64 bits selon que l’architecture de la machine est 32 ou 64 bits. Autrement
dit, le type qui représente les entiers nativement n’est plus le type int, mais le type long. Cela ne
change pas les programmes 32 bits, puisque ces deux types sont identiques dans ce cas. Les
programmes destinés aux machines 64 bits pourront quant à eux être optimisés en utilisant le
type long à chaque fois que l’on voudra utiliser le type de données natif de la machine cible. Les
programmes 16 bits en revanchent ne sont en revanche plus compatibles avec ces règles, mais
la plupart des compilateurs actuels ne permettent plus de compiler des programmes 16 bits de
toutes manières.
Les types char, wchar_t et int peuvent être signés ou non. Un nombre signé peut être négatif, pas un
nombre non signé. Lorsqu’un nombre est signé, la valeur absolue du plus grand nombre représentable
est plus petite. Par défaut, les nombres entiers sont signés. Le signe des types char et wchar_t dépend
du compilateur utilisé, il est donc préférable de spécifier systématiquement si ces types sont signés ou
non lorsqu’on les utilise en tant que type entier. Pour préciser qu’un nombre n’est pas signé, il faut
utiliser le mot clé unsigned. Pour préciser qu’un nombre est signé, on peut utiliser le mot clé signed.
Ces mots clés peuvent être intervertis librement avec les mots clés long et short pour les types entiers.
Exemple 1-3. Types signés et non signés
unsigned char
signed char
unsigned wchar_t
signed wchar_t
unsigned int
signed int
unsigned long int
long unsigned int
Note : Le C++ (et le C++ uniquement) considère les types char et wchar_t comme les types de
base des caractères. Le langage C++ distingue donc les versions signées et non signées de ces
types de la version dont le signe n’est pas spécifié, puisque les caractères n’ont pas de notion
de signe associée. Cela signifie que les compilateurs C++ traitent les types char, unsigned char
et signed char comme des types différents, et il en est de même pour les types wchar_t, signed
wchar_t et unsigned wchar_t. Cette distinction n’a pas lieu d’être au niveau des plages de valeurs
si l’on connaît le signe du type utilisé en interne pour représenter les types char et wchar_t, mais
elle est très importante dans la détermination de la signature des fonctions, en particulier au
niveau du mécanisme de surcharge des fonctions. Les notions de signature et de surcharge des
fonctions seront détaillées plus loin dans ce cours.
Les valeurs accessibles avec les nombres signés ne sont pas les mêmes que celles accessibles avec les
nombres non signés. En effet, un bit est utilisé pour le signe dans les nombres signés. Par exemple, si
le type char est codé sur 8 bits, on peut coder les nombres allant de 0 à 255 avec ce type en non signé
(il y a 8 chiffres binaires, chacun peut valoir 0 ou 1, on a donc 2 puissance 8 combinaisons possibles,
ce qui fait 256). En signé, les valeurs s’étendent de -128 à 127 (un des chiffres binaires est utilisé pour
le signe, il en reste 7 pour coder le nombre, donc il reste 128 possibilités dans les positifs comme dans
les négatifs. 0 est considéré comme positif. En tout, il y a autant de possibilités.).
De même, si le type int est codé sur 16 bits (cas des machines 16 bits), les valeurs accessibles vont
de -32768 à 32767 ou de 0 à 65535 si l’entier n’est pas signé. C’est le cas sur les PC en mode réel

(c’est-à-dire sous DOS) et sousWindows 3.x. Sur les machines fonctionnant en 32 bits, le type int est
stocké sur 32 bits : l’espace des valeurs disponibles est donc 65536 fois plus large. C’est le cas sur
les PC en mode protégé 32 bits (Windows 9x ou NT, DOS Extender, Linux) et sur les Macintosh. Sur
les machines 64 bits, le type int devrait être 64 bits (DEC Alpha et la plupart des machines UNIX par
exemple).
Enfin, le type float est généralement codé sur 4 octets, et les types double et long double sont souvent
identiques et codés sur 8 octets.
Note : On constate donc que la portabilité des types de base est très aléatoire. Cela signifie qu’il
faut faire extrêmement attention dans le choix des types si l’on veut faire du code portable (c’està-
dire qui compilera et fonctionnera sans modification du programme sur tous les ordinateurs). Il
est dans ce cas nécessaire d’utiliser des types de données qui donnent les mêmes intervalles de
valeurs sur tous les ordinateurs. La norme ISO C99 impose de définir des types portables afin de
régler ces problèmes sur toutes les architectures existantes. Ces types sont définis dans le fichier
d’en-tête stdint.h. Il s’agit des types int8_t, int16_t, int32_t et int64_t, et de leurs versions non
signées uint8_t, uint16_t, uint32_t et uint64_t. La taille de ces types en bits est indiquée dans leur
nom et leur utilisation ne devrait pas poser de problème.
De la même manière, deux représentations d’un même type peuvent être différentes en mémoire
sur deux machines d’architectures différentes, même à taille égale en nombre de bits. Le problème
le plus courant est l’ordre de stockage des octets en mémoire pour les types qui sont stockés
sur plus d’un octet (c’est-à-dire quasiment tous). Cela a une importance capitale lorsque des données
doivent être échangées entre des machines d’architectures a priori différentes, par exemple
dans le cadre d’une communication réseau, ou lors de la définition des formats de fichiers. Une
solution simple est de toujours d’échanger les données au format texte, ou de choisir un mode
de représentation de référence. Les bibliothèques réseau disposent généralement des méthodes
permettant de convertir les données vers un format commun d’échange de données par un
réseau et pourront par exemple être utilisées.

formation langague C:Les commentaires en C++

Les commentaires sont nécessaires et très simples à faire. Tout programme doit être commenté. Attention
cependant, trop de commentaires tue le commentaire, parce que les choses importantes sont
noyées dans les banalités.
Il existe deux types de commentaires en C++ : les commentaires de type C et les commentaires de fin
de ligne (qui ne sont disponibles qu’en C++).
Les commentaires C commencent avec la séquence barre oblique - étoile. Les commentaires se terminent
avec la séquence inverse : une étoile suivie d’une barre oblique.
Exemple 1-1. Commentaire C
/* Ceci est un commentaire C */
Ces commentaires peuvent s’étendre sur plusieurs lignes.
En revanche, les commentaires de fin de lignes s’arrêtent à la fin de la ligne courante, et pas avant.
Ils permettent de commenter plus facilement les actions effectuées sur la ligne courante, avant le
commentaire. Les commentaires de fin de ligne commencent par la séquence constituée de deux
barres obliques (ils n’ont pas de séquence de terminaison, puisqu’ils ne se terminent qu’à la fin de la
ligne courante). Par exemple :
Exemple 1-2. Commentaire C++
action quelconque // Ceci est un commentaire C++
action suivante

formation langague C

Le C/C++ est un langage procédural, du même type que le Pascal par exemple. Cela signifie que les
instructions sont exécutées linéairement et regroupées en blocs : les fonctions et les procédures (les
procédures n’existent pas en C/C++, ce sont des fonctions qui ne retournent pas de valeur).
Tout programme a pour but d’effectuer des opérations sur des données. La structure fondamentale est
donc la suivante :
ENTRÉE DES DONNÉES
(clavier, souris, fichier, autres périphériques)
|
TRAITEMENT DES DONNÉES
|
SORTIE DES DONNÉES
(écran, imprimante, fichier, autres périphériques)
Ces diverses étapes peuvent être dispersées dans le programme. Par exemple, les entrées peuvent se
trouver dans le programme même (l’utilisateur n’a dans ce cas pas besoin de les saisir). Pour la plupart
des programmes, les données en entrée proviennent du flux d’entrée standard, et les données émises
en sortie sont dirigées vers le flux de sortie standard. Toutefois, le processus d’entrée des données peut
être répété autant de fois que nécessaire pendant l’exécution d’un programme, et les données traitées
au fur et à mesure qu’elles apparaissent. Par exemple, pour les programmes graphiques, les données
sont reçues de la part du système sous forme de messages caractérisant les événements générés par
l’utilisateur ou par le système lui-même (déplacement de souris, fermeture d’une fenêtre, appui sur
une touche, etc.). Le traitement des programmes graphiques est donc une boucle infinie (que l’on
appelle la boucle des messages), qui permet de récupérer les messages et de prendre les actions en
conséquence. Dans ce cas, la sortie des données correspond au comportement que le programme
adopte en réponse à ces messages. Cela peut être tout simplement d’afficher les données saisies, ou,
plus généralement, d’appliquer une commande aux données en cours de manipulation.
Les données manipulées sont stockées dans des variables, c’est-à-dire des zones de la mémoire.
Comme leur nom l’indique, les variables peuvent être modifiées (par le traitement des données). Des
opérations peuvent donc être effectuées sur les variables, mais pas n’importe lesquelles. Par exemple,
on ne peut pas ajouter des pommes à des bananes, sauf à définir cette opération bien précisément. Les
opérations dépendent donc de la nature des variables. Afin de réduire les risques d’erreurs de programmation,
les langages comme le C/C++ donnent un type à chaque variable (par exemple : pomme
et banane). Lors de la compilation (phase de traduction du texte source du programme en exécutable),
ces types sont utilisés pour vérifier si les opérations effectuées sont autorisées. Le programmeur peut
évidemment définir ses propres types.
Le langage fournit des types de base et des opérations prédéfinies sur ces types. Les opérations qui
peuvent être faites sont soit l’application d’un opérateur, soit l’application d’une fonction sur les
variables. Logiquement parlant, il n’y a pas de différence. Seule la syntaxe change :
a=2+3
est donc strictement équivalent à :
a=ajoute(2,3)

formation de zero en HTML cour 1

Notre objectif dans l'élaboration de cette formation consacrée à la création de pages Web et donc au langage
Html a été la simplicité de l'exposé et le souci de fournir des bases saines pour une étude et une utilisation plus
poussée.
Nous n'avons nullement la prétention d'être exhaustif et d'être "LA" référence. Nous savons pertinemment que
notre synthèse est très subjective et que nous ferons hurler les puristes. Nous espérons cependant vous faire
comprendre et apprécier le langage Html et vous donner l'envie d'en apprendre plus au sujet de la publication sur
Internet.

Le Web parle Html

HTML est le langage universel utilisé pour communiquer sur le Web. Votre information sera ainsi transportée sur
cette gigantesque toile de réseaux interconnectés qu'est Internet, pour aboutir sur l'ordinateur de votre lecteur
grâce à un programme appelé navigateur ou browser.
- Vous avez donc deux interlocuteurs : 1. le browser de votre lecteur. et votre lecteur lui-même.
Ce logiciel, que l'on appelle un browser, vous permet de surfer sur le Net et d'afficher sur votre écran les "pages"
qu'il a interceptées. Il y a, hélas, beaucoup de marques et de types de browsers différents. Des simples, des
archaïques ou des sophistiqués... Les plus connus sont Netscape dans sa version 2, 3 et 4 ainsi Internet Explorer
de Microsoft mais il en existe beaucoup d'autres.
- Chaque browser a sa propre façon de travailler.
A la différence de votre traitement de texte préféré qui restitue exactement votre document sur une feuille de
papier avec votre police de caractères et votre mise en page, vous ne saurez jamais exactement ce que le browser
de votre lecteur du bout du monde affichera sur l'écran de celui-ci.
- En HTML, vous n'avez pas la maîtrise totale de votre document.
Pour transiter le plus rapidement possible sur les lignes téléphoniques, on a adopté un format de texte très
compact mais aussi (par conséquence) peu sophistiqué. C'est le bon vieux format de texte pur et dur, sans
fioritures du Bloc-notes ou Notepad de Windows par exemple. Et de plus ce format ASCII a été amputé d'un bit
(7 bits au lieu de 8) ! Vous serez donc privé de certains caractères spéciaux comme le é pour lesquels il faudra
passer par des codes particuliers.
- Mais récompense suprême... Html est un langage universel qui s'adapte à toutes les plate-formes que ce soit
Windows, Macintoch, Unix, OS/2...
En plus du texte adressé à votre lecteur, il vous faudra inclure des instructions pour le browser de celui-ci. Ces
instructions seront différenciées de votre texte par les signes < et > par exemple <html>. Ces "instructions"
s'appellent des tags ou des balises.
Quand vous écrirez les balises de votre page HTML, il faudra garder à l'esprit :
- qu'une balise marque une action pour le browser (ce qu'il doit faire...).
- que les attributs précisent les modalités de cette action (comment il doit le faire...).
Vos premiers outils

Vous avez besoin:

· d'un éditeur de texte tout simple comme par exemple le Bloc-notes ou Notepad de Windows ou tout
autre équivalent dans votre système d'exploitation.

· d'un browser soit Netscape Navigator (payant) que vous pouvez cependant télécharger gratuitement
au site de Netscape (http://home.netscape.com) ou sur les CD de certains mensuels informatiques
soit Microsoft Explorer (gratuit également) à télécharger (http://www.microsoft.com) ou dans les
revues.
Vous n'avez pas besoin:
· d'être connecté pour écrire, voir et peaufiner vos pages Html.
· d'avoir le dernier éditeur Html sans doute performant mais coûteux qu'il sera toujours temps
d'adopter lorsque vous aurez usé vos petits doigts sur vos premières pages. Nous pensons à Claris
Home Page, Frontpage de Microsoft, Hotdog, Hotmetal, WebExpert ou Netscape Editor ainsi qu'aux
dizaines d'autres éditeurs que vous rencontrerez sur le Web.
 Conseils
Le langage Html étant un ensemble de balises et d'attributs, il nous paraît utile sinon indispensable de les
passer en revue et surtout de les visionner au moins une fois car :
· si les éditeurs Html vous faciliteront grandement la tâche, ils ne sont pas toujours parfaits surtout lors
des modifications, annulations ou suppressions en cours de travail. Il vous faudra bien alors vous
plonger dans le code source pour corriger les dysfonctionnements.
· les codes source de vous pages préférées sont disponibles (et sans copyright). Il est alors possible de
s'en inspirer pour reprendre le procédé sans avoir à réinventer le monde.
· ces mêmes éditeurs Html vous proposeront des termes comme" En-tête, Heading, Cell spacing,
Numered List..." qui sont propres au langage Html.
· vous aurez besoin d'une connaissance pointue du Html pour inclure les codes du Javascript ou du
VBscript dans vos pages.

Le document Html minimum
Voici vos premières balises ou tags :
<HTML> Ceci est le début d'un document de type HTML.
</HTML> Ceci est la fin d'un document de type HTML.
<HEAD> Ceci est le début de la zone d'en-tête
(prologue au document proprement dit contenant
des informations destinées au browser).
</HEAD> Ceci est la fin de la zone d'en-tête.
<TITLE> Ceci est le début du titre de la page.
</TITLE> Ceci est la fin du titre de la page.
<BODY> Ceci est le début du document proprement dit.
</ BODY> Ceci est la fin du document proprement dit.
· Vous aurez remarqué qu'à chaque balise de début d'une action, soit <...>, correspond (en toute
logique) une balise de fin d'une action </...>.
· Vous noterez aussi que les balises ne sont pas "case sensitive". Il est donc équivalent d'écrire
<HTML>, <html>, <Html>, etc.Faisons ensemble notre premier document Html:
- Ouvrir l'éditeur de texte.
- Ecrire les codes Html suivants:
<HTML>
<HEAD>
<TITLE>Document Html minimum</TITLE>
</HEAD>
<BODY>
</BODY>
</HTML>

- Enregistrer le document avec l'extension .html ou .htm.
- Ouvrir le navigateur.
- Afficher le document via le menu File/Open file...
- Admirer votre premier document Html.
Celui-ci est vide (et c'est normal) mais tout à fait opérationnel! Il faudra maintenant lui fournir votre information
à l'intérieur des balises <BODY></BODY>. Remarquez que votre "TITLE" est présent dans la fenêtre de
Netscape.
Pour vos éventuelles modifications, il n'est pas nécessaire de rouvrir à chaque fois le navigateur.
· Retourner dans l'éditeur de texte (sans fermer le navigateur).
· Modifier les codes Html.
· Enregistrer le fichier.
· Utiliser la commande Reload du browser ou si celui-ci est paresseux cliquer dans la barre "Location"
et faire "Enter".