PortailAccueilFAQRechercherCalendrierS'enregistrerMembresGroupesConnexion

Partagez | 
 

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

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

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

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

Table des matières
1.1. Les commentaires en C++
1.2. Les types prédéfinis du C/C++
1.3. Notation des valeurs
1.4. La définition des variables
1.5. Instructions et opérations
1.6. Les fonctions
1.7. La fonction main
1.8. Les fonctions d'entrée / sortie de base
1.9. Exemple de programme complet

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)
ةvidemment, des fonctions utilisateur peuvent être définies. Les opérateurs ne peuvent être que surchargés : il est impossible d'en définir de nouveaux (de plus, la surcharge des opérateurs n'est faisable qu'en C++). La notion de surcharge de fonction sera décrite en détail ci-dessous, dans la Section 1.6.4.
Cette première partie est donc consacrée à la définition des types, la déclaration des variables, la construction et l'appel de fonctions, et aux entrées / sorties de base (flux d'entrée / sortie standards).
1.1. 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
1.2. 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) ;
• 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 sous Windows 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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://didouqen.ousama.free.fr
 
Chapitre1.Première approche du C/C++ (1)
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
» Première facture oui mais ... pas sûr de l'adresse pour payer
» [résolu]Nouveau PC Première utilisation

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