PortailAccueilFAQRechercherCalendrierS'enregistrerMembresGroupesConnexion

Partagez | 
 

 Chapitre1.Première approche du C/C++ (2)

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
didouqen
Admin


Masculin
Nombre de messages : 40
Age : 31
Localisation : Marrakech
Date d'inscription : 07/09/2006

MessageSujet: Chapitre1.Première approche du C/C++ (2)   Mar 25 Sep - 6:43

1.3. 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 "
'\'' 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
1.4. 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;
Note : La syntaxe permettant d'initialiser les tableaux dès leur création est un peu plus complexe que celle permettant d'initialiser les variables de type simple. Cette syntaxe est semblable à celle permettant d'initialiser les structures de données et sera donc décrite dans la section qui leur est dédiée.
En C/C++, les tableaux à plus d'une dimension sont des tableaux de tableaux. On prendra garde au fait que dans la définition d'un tableau à plusieurs dimensions, la dernière taille indiquée spécifie la taille du tableau dont on fait un tableau. Ainsi, dans l'exemple suivant :
int Matrice[5][4];
Matrice est un tableau de taille 5 dont les éléments sont eux-mêmes des tableaux de taille 4. L'ordre de déclaration des dimensions est donc inversé : 5 est la taille de la dernière dimension et 4 est la taille de la première dimension. L'élément suivant :
Matrice[2];
est donc le troisième élément de ce tableau de taille cinq, et est lui-même un tableau de quatre éléments.
En C/C++, les indices des tableaux varient de 0 à taille-1. Il y a donc bien taille éléments dans le tableau. Dans l'exemple donné ci-dessus, l'élément MonTableau[100] n'existe pas : y accéder plantera le programme. C'est au programmeur de vérifier que ses programmes n'utilisent jamais les tableaux avec des indices plus grands que leur taille ou négatifs.
Un autre point auquel il faudra faire attention est la taille des tableaux à utiliser pour les chaînes de caractères. Une chaîne de caractères se termine obligatoirement par le caractère nul ('\0'), il faut donc réserver de la place pour lui. Par exemple, pour créer une chaîne de caractères de 100 caractères au plus, il faut un tableau pour 101 caractères (déclaré avec « char chaine[101]; »).
1.5. Instructions et opérations
Les instructions sont généralement identifiées par le point virgule. C'est ce caractère qui marque la fin d'une instruction.
Exemple 1-10. Instruction vide
; /* Instruction vide : ne fait rien ! */
Il existe plusieurs types d'instructions, qui permettent de réaliser des opérations variées. Les instructions les plus courantes sont sans doute les instructions qui effectuent des opérations, c'est-à-dire les instructions qui contiennent des expressions utilisant des opérateurs.
Les principales opérations utilisables en C/C++ sont les suivantes :
• les affectations :
variable = valeur
Note : Les affectations ne sont pas des instructions. Ce sont bien des opérations qui renvoient la valeur affectée. On peut donc effectuer des affectations multiples :
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 expres​sion(opérateur ?Smile 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, puis sa valeur est renvoyée. S'ils sont en suffixe, la valeur de la variable est renvoyée, puis la variable est incrémentée ou décrémentée. Par exemple :
int i=2,j,k;

j=++i; /* ہ la fin de cette instruction, i et j valent 3. */
k=j++; /* ہ la fin de cette ligne, k vaut 3 et j vaut 4. */
Note : On prendra garde à n'utiliser les opérateurs d'incrémentation et de décrémentation postfixés que lorsque cela est réellement nécessaire. En effet, ces opérateurs doivent contruire un objet temporaire pour renvoyer la valeur de la variable avant incrémentation ou décrémentation. Si cet objet temporaire n'est pas utilisé, il est préférable d'utiliser les versions préfixées de ces opérateurs.
L'opérateur ternaire d'évaluation conditionnelle ?: est le seul opérateur qui demande 3 paramètres (à part l'opérateur fonctionnel () des fonctions, qui admet n paramètres, et que l'on décrira plus tard). Cet opérateur permet de réaliser un test sur une condition et de calculer une expression ou une autre selon le résultat de ce test. La syntaxe de cet opérateur est la suivante :
test ? expression1 : expression2
Dans cette syntaxe, test est évalué en premier. Son résultat doit être booléen ou entier. Si test est vrai (ou si sa valeur est non nulle), expression1 est calculée et sa valeur est renvoyée. Sinon, c'est la valeur de expression2 qui est renvoyée. Par exemple, l'expression :
Min=(i<j)?i:j;
calcule le minimum de i et de j.
L'opérateur virgule, quant à lui, permet d'évaluer plusieurs expressions successivement et de renvoyer la valeur de la dernière expression. La syntaxe de cet opérateur est la suivante :
expression1,expression2[,expression3[...]]
où expression1, expression2, etc. sont les expressions à évaluer. Les expressions sont évaluées de gauche à droite, puis le type et la valeur de la dernière expression sont utilisés pour renvoyer le résultat. Par exemple, à l'issue des deux lignes suivantes :
double r = 5;
int i = r*3,1;
r vaut 5 et i vaut 1. r*3 est calculé pour rien.
Note : Ces deux derniers opérateurs peuvent nuire gravement à la lisibilité des programmes. Il est toujours possible de réécrire les lignes utilisant l'opérateur ternaire avec un test (voir la Section 2.1 pour la syntaxe des tests en C/C++). De même, on peut toujours décomposer une expression utilisant l'opérateur virgule en deux instructions distinctes. Ce dernier opérateur ne devra donc jamais être utilisé.
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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://didouqen.ousama.free.fr
 
Chapitre1.Première approche du C/C++ (2)
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» Première approche étrange ...
» Première construction diapo
» Photos de l'avant-première des bagnoles 2
» Avant première historique !
» Première facture oui mais ... pas sûr de l'adresse pour payer

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
DESIGN STUDIO FORUM :: programmation :: C,C++-
Sauter vers: