programmation impérative et langage csylvain.tisserant.perso.luminy.univ-amu.fr/prog... · partie...

Programmation

impérative et langage C

Introduction

Programmation impérative et langage C - Sylvain Tisserant - Polytech Marseille / INFO3 - 2020

Une introduction

� Objectifs� Comprendre les rudiments de la programmation � Concevoir et écrire des programmes lisibles, faciles à

comprendre, à modifier et à maintenir.

� Maîtriser les bases de la programmation avant d’aborder Algorithmique, Interface Matériel Logiciel, Algorithmique Numérique, etc.

� Algorithmique simpliste pour commencer

� Support� Sur AMeTICE :

� https://ametice.univ-amu.fr/course/view.php?id=59827

� Sur ma page personnelle :� http://sylvain.tisserant.perso.luminy.univ-amu.fr/

� Introduction de notions générales� Illustration avec un sous-ensemble du C

� C : langage (séquentiel/impératif) pérenne et très répandu


Motivation du cours (2)

� Démarche � Il ne s’agit pas d’un cours de C� La programmation objet sera étudiée au second semestre� Les bases pour pouvoir commencer à travailler, à vous de

compléter vos connaissances au fur et à mesure (par exemple en fonction de vos besoins en TD/TP, puis en projet)

� Littérature� Web

� L’étude des mécanismes concrets se fera dans les cours Interface Matériel Logiciel, puis Architecture des ordinateurs (?)

� Dans ce cours : se faire une représentation des concepts, du genre tout se passe comme si …

Avertissements

� Présence en cours, TD et TP obligatoire :

� Pour ceux qui croient savoir programmer ou connaître le C :

� Formation destinée à de futurs ingénieurs en informatique

� Il ne suffit pas d’être capable d’écrire du code (même s’il fait ce qui est demandé)

� Il faut être capable de concevoir ⇒ réflexion, analyse du problème, trouver des solutions, puis faire le meilleur choix, savoir le justifier

� A la question que je pose souvent : Pourquoi faites-vous comme cela ?

� La réponse n’est pas : Parce qu’on m’a dit de/appris à faire comme cela

� Vous devez être capable de justifier ce que vous faites

� Oublier vos (mauvaises) habitudes : changement d’état d’esprit

� L’expérience montre que ceux qui croient savoir (et vivent sur leurs acquis) n’ont pas les meilleurs résultats


Cours, TD et TP

� Présence en cours, TD et TP obligatoire

� Uniquement 3 cours :� Cela va aller très vite

� N’accumulez pas de retard dès le début

� 3 séances de TD� Cours

� Préparation de quelques exercices

� 6 séances de TP devant machine� Tous les exercices sont à faire

� Un compte-rendu par fiche : liste des exercices à rendre donnée par l’intervenant en TP

� Noté

� A rendre avant la séance n+1 par mail : fichier pdf

� Aucun retard toléré (correction sur le web le jour du rendu)

� CR non rendu ou en retard → 0

� Copies notées rendues pour séance n+2


Programmation impérative

� Partie 1 : Introduction

� Introduction

� Variables

� Instructions

� Fonctions

� Partie 2 : Structures de contrôle

� Partie 3 : Tableaux et pointeurs

� Tableaux

� Pointeurs

� Chaînes de caractères

� Structures

� Gestion dynamique de la mémoire en C

� Partie 4 : Fonctions

� Passage par valeur

� Utilisation des pointeurs

� Récursivité



Langage de programmation

� Intermédiaire entre le programmeur et la machine

� Très mauvaise illustration :� Surtout ne pas commencer un programme en s’installant devant le terminal

et le clavier� Bonne méthode de travail à prendre dès le début� Phase d’analyse indispensable avant de passer au code :

� Comprendre le problème� Traduire ses idées� Sur papier : brouillon indispensable� Pseudo-code� TD pour mettre en œuvre cette phase essentielle avant TP


Langage de programmation (2)

� Langage machine (Interface Matériel Logiciel, Architecture des ordinateurs)� Instructions codées en binaire

� Constituées de champs� Formats très variables, liés à l’architecture CPU, mémoire, etc.

� Stockées en mémoire� Exploitées par l’unité centrale

� Langage d’assemblage� Souvent représentation symbolique des instructions binaires à l’aide de

mnémoniques plus faciles à manipuler du genre ADD R1,R2� Instructions ≡ opérations simples

� y = a*x2 + b*x + c ⇒ à traduire en une série d’instructions

� Peu ou pas d’abstraction : � On ne manipule que des registres, des adresses, …� Nom de variables uniquement pour cases mémoires� Le code ne peut être compris que si on connaît ce qui est stocké dans

les registres ou en mémoire.

� Langages de haut niveau (C, C++, Java, Python, etc.)


Traduction

� Assembleur

� Langage d’assemblage → Code machine

� Programme source → Module objet

� Compilateur

� Langage de haut niveau → code machine

� En passant ou pas par l’intermédiaire d’un assembleur

� Souvent, c’est le cas pour le langage C, il y a une phase préparatoire qui modifie le programme source :

� Suppression des commentaires

� Insertion de fichiers

� Expansion des macros

� Etc.

� Editeur de liens� Code source en plusieurs fichiers, bibliothèques, etc.


Traduction (2)


Apprendre un langage

� Par référence à un langage déjà connu� Sauf pour ce cours� Le C sera votre premier langage de référence� Dans ce cours : présentation des notions (générales)

et illustration par des exemples simples

� Tests simples pour assimiler les nouveautés� Guidés par un besoin� Ce que nous ferons en TD/TP� Organiser et conserver son travail : répertoires dédiés,

documentation, etc. ⇒ à faire dès ce cours

� Pour commencer :� Premier exemple ⇒ code source et compilation� Pour tout langage : données et instructions


Premier programme C

� Commentaire :� Encadré par /* et */

� Directive :� Pré-traitement� Commence par #� Ici, insère le fichier

stdio.h dans le fichier source

� Fonction main :� Toujours présente� Exécutée au lancement

du programme� Type, nom et arguments� Ici : impression à l’écran

Fichier source (extension .c)

� printf :� fonction prédéfinie� "décrite" dans stdio.h

� return 0 :� Renvoie le résultat de

la fonction


Premier programme C (2)

� Passage du code source à un programme exécutable :…>gcc nom_fichier.c –o nom_exec

� gcc : un compilateur C (et éditeur de liens)� L’option –o permet de donner un nom à l’exécutable (sinon par

défaut le fichier est nommé a.out)� Pour commencer pas de compilation séparée (sans liens)

� Exécution du programme :…>./nom_execPremier exemple…>

� Si oubli du retour à la ligne (\n) :

…>gcc nom_fichier.c…>./a.outPremier exemple…>

UNIX/Linux

� Un mot sur l’arborescence UNIX/Linux

� Fichiers dans des répertoires (dossiers)

� nom_de_fichier.typ

� Eviter certains caractères : *,?,$, ,-, …

� Deux fichiers peuvent avoir le même nom dans deux répertoires différents

� Identification complète d’un fichier

� Chemin : description de l’arborescence complète jusqu’au répertoire contenant le fichier :

disk/group/name/Info/TD1/

� Nom de fichier

� Repérage relatif au répertoire de travail

� . Répertoire de travail

� .. Répertoire parent


Linux à minimal

� pwd

� mkdir

� cd

� ls –al

� gcc


Linux à minimal (2)


Linux à minimal (3)

� rm (remove)

rm fichier Efface le fichier

rm t* Efface tous les fichiers commençant par t

rm *.* Attention !

� cp (copy)

cp [chemin1]fichier1 [chemin2]fichier2

� mv (move)

mv [chemin1]fichier1 [chemin2]fichier2

mv fichier1 fichier2 ≡ Renommer

� Les permissions :

� Read, write, exec

� Utilisateur, groupe, autres



Variables

� Un programme traite des données ≡ variables

� Rangées en mémoire :� Divisée en cases (en général : octets de 8 bits)� Cases regroupées en mots� Taille des mots : dépend de la nature de l’information

représentée (entier, réel, lettre, …) ≡ type� Localisation d’une variable : position en mémoire ≡

adresse

� Si dans le processeur les instructions accèdent aux données grâce à leurs adresses, le programmeur peut les manipuler en leur associant des noms :� Simplifie l’utilisation des données� Les noms peuvent expliciter le contenu de la variable


Variables (2)

� Déclaration (définition) d’une variable

� Réservation de la place nécessaire en mémoire selon le type

� Association d’un nom : identification du mot en mémoire contenant la variable

� Eventuellement initialisation

� Choix du nom (identificateur) d’une variable

� Lettres minuscules, majuscules, chiffres et souligné _

� Commence par une lettre ou souligné _

� Certains noms sont réservés au langage

� A faire dès le brouillon et le pseudo-code

� Nom explicite (facilite la relecture du code et sa compréhension), sans être trop long (sinon « détruit la mise en page du code »)

� Eviter de changer les noms pendant la transposition du pseudo-code en code (pour réduire le risque d’erreurs)


Variables (3)

� Mots réservés par C :

� Mots réservés par C++ :


Définition d’une variable en C

� Syntaxetype nom [= valeur] ; // [] ≡ optionnel

� Types simples prédéfinis :� caractères : char� entiers : int, short, long, unsigned, …� réels : float, double� constantes : préfixe const (devant le type, vérification à la

compilation qu’elle n’est pas modifiée)

� Types définis par le programmeur :� tableaux : vecteurs, matrices, etc.� structures� unions� énumérations


Entiers

� Type : int

� en mémoire : 4 octets

� Notation des valeurs (ou constantes)

� en décimal (base 10) : suite de chiffres précédée du signe (+ facultatif) : 56327, -351

� en octal (base 8) : suite de chiffres (0,1,2,3,4,5,6,7) précédée de 0 : 0754

� Chaque chiffre représente un ensemble de 3 bits

� en hexadécimal (base 16) : suite de caractères (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F) précédée de 0x : 0xAB54

� Chaque caractère représente un ensemble de 4 bits

� pas de signe en représentation octale ou hexadécimale

� Exemple de déclaration :int n = -256, m = 32, i, j, flag = 0xFFF ;


Entiers (2)

� Gamme dynamique d’une représentation :� Les valeurs extrêmes dépendent du nombre de bits

utilisés pour la représentation des entiers en mémoire :� Une représentation non signée sur n bits permet de

représenter des entiers compris entre 0 et 2n-1� Une représentation signée sur n bits permet de

représenter des entiers compris entre -2n-1 et 2n-1-1

� Autres types disponibles :� Ils permettent d’utiliser plus ou moins d’octets :

� char : 1 octet, short : 2 octets : long : 4 octets ou plus

� Ils permettent de choisir une représentation signée ou non en faisant précéder le type de :

� unsigned ou signed


Entiers (3)

Constantes prédéfinies dans le fichier limits.h :


Réels

� Contrairement aux entiers il est impossible de représenter dans un format binaire tous les réels d’un intervalle donné (indénombrable)

� Deux types :� float : 4 octets

� Plus grande valeur absolue ≈ 1038

� Plus petite valeur absolue ≈ 10-38

� environ 7 chiffres significatifs

� double : 8 octets

� Plus grande valeur absolue ≈ 10308

� Plus petite valeur absolue ≈ 10-308

� environ 15 chiffres significatifs


Réels (2)

� Notation des valeurs :

� Première forme : partieEntière.partieFractionnaire, c'est-à-dire 2 entiers séparés par un point : -53.667, 54., .235

� Une des deux parties peut être omise, mais pas les deux.

� Autre forme mantisse E exposant ou mantisse e exposant

qui représente le nombre mantisse x 10exposant. L’exposant est un entier relatif. La mantisse est un réel sous la 1ère

forme : 1.5389e-3 (soit : 1,5389 10-3)

� Exemple de déclarations :float x, y, pi = 3.14159, epsilon = 1.e-10 ;

const float taux_TVA = 19.6 ;


Réels (3)

Constantes prédéfinies dans le fichier float.h :


Caractères

� Permettent de coder :

� caractères alphanumériques

� signes de ponctuation et autres :

! : / ; . , * % < > ^ & ~ " # ‘ { } ( ) [ ] - + | = ? \ _

� espace, tabulation horizontale et verticale, nouvelle ligne, nouvelle page

� Représentés par un code (en général ASCII) de 8 bits

� extraits du code ASCII (en octal) :

� 0 → 9 : 060 → 071, A → Z : 0101 → 0132, a → z : 0141 → 0172

� ‘0’ < ‘1’ < … < ‘9’ < ‘A’ < … < ‘Z’ < ‘a’ < … < ‘z’

� Type : char

� en mémoire : un octet

� utilisé également pour coder des entiers


Caractères (2)

� Notation des caractères :� entre apostrophes : ‘a’, ‘1’, ‘H’ ou ‘ ’

� séquence échappement précédée de \

� si ambiguïté

� pour caractère non imprimable

� Exemple de déclaration :char lettre = ‘a’ ;


Tableaux

� Un tableau est un ensemble fini de mots consécutifs en mémoire� Longueur des mots identique, dépend du type� Pour réserver la place en mémoire il faut préciser les

dimensions d’un tableau� Déclaration des tableaux en C :

type nom[taille] ;� taille : constante entière (connue à la compilation)

� Accès aux éléments d’un tableau :� Nom du tableau� Indice ou rang dans le tableau : en C commence à 0

� tab[0] : premier élément du tableau� tab[taille-1] : dernier élément du tableau

� vect[i] (avec i de type int)

� Le programmeur doit vérifier la validité des indices !


Chaînes de caractères

� Constante chaîne de caractères

� Elle est constituée d’une suite de caractères entre guillemets doubles ", tenant sur une seule ligne physique comme :

"Ceci est une chaine de caracteres"

� Elle peut contenir des séquences d’échappement :

"bonjour\nMonsieur" "je parle l\’anglais" .

� Si nous imprimons ces deux constantes à la suite l’une de l’autre nous obtenons :

bonjourMonsieurje parle l’anglais

� Nous étudierons le traitement des chaînes de caractères en C plus loin


Opérations et instructions

� Exprimer les calculs et les transformations à effectuer sur les données � Obtenir les résultats intermédiaires et les résultats finaux� Elément de base : les expressions� Une expression est constituée :

� d’opérandes qui sont eux-mêmes des expressions ;� d’opérateurs avec certaines conventions (priorités, respect des

types, associativité, etc.) ;� de parenthèses ( et ) pour s’affranchir de certaines conventions

implicites.

� L’expression 2*4+1 est de type entier et a pour valeur 9

� 2, 4 et 1 sont des opérandes, de même que 2*4� Les symboles + et * sont des opérateurs

� Pour évaluer cette expression, on commence par calculer la sous-expression 2*4 puis on ajoute 1 au résultat D’une façon générale, on évalue tout d’abord les sous expressions les plus prioritaires puis on combine entre eux, niveau par niveau, les résultats intermédiaires.


Opérations et instructions (2)

� Programme C : suite d’instructions exécutées en séquence � Langage impératif : suite d’ ″ordres″� Les instructions en C sont terminées par un point-virgule� Opération de base : affectation

variable = expression ;� L’expression est évaluée et sa valeur est ensuite stockée

dans la variable

� L’affectation i = 2*4+1 est aussi une expression

� Le signe = est un opérateur dont la priorité est inférieure à celles du * et du +

� Après l’exécution, la variable i vaut 9� Contrôle du déroulement

� Exécution conditionnelle, boucle, déroutement, etc.

� Appel de fonctions


Sous-programmes

� Elément essentiel de tous les langages� Même traitement à effectuer à diverses étapes du déroulement

d’un logiciel ⇒ même portion de code à plusieurs endroits d’un programme, traitant des données différentes

� Sous-programme ⇒ code à un seul endroit :� Dérouter l’exécution vers ce code (appel)� Revenir ensuite à l’exécution en cours (retour)

� Réduction de la taille du code mais perte de temps (compromis)

� Besoin de transmettre des données et de recevoir un résultat� Mécanismes variés selon les langages

� Autres intérêts : modularité� Facilite la maintenance et la portabilité : modification du code� Permet le travail en équipe� Réutilisation de code déjà développé et testé� Simplifie la lecture du code (mais ne pas abuser)


Fonctions en C

� Définition :type identificateur (paramètres){

déclarationsinstructions

}� type : définit le type du résultat : (int, float, etc.)� identificateur : nom de la fonction� paramètres : suite de déclarations de variables

� Une déclaration par variable� Déclarations séparées par des virgules� Par ex : (type1 variable1, type2 variable2)� Argument ≡ paramètre formel

� Attention : pas de point virgule après la parenthèse� Le corps de la fonction (entre les accolades) est constitué de

déclarations et d’instructions� Utilisation des variables déclarées en paramètres


Fonctions (2)

� Retour : return [expression] ;� L’expression est évaluée et donne la valeur du résultat

� Si pas de résultat (procédure) :type de la fonction → voidreturn ; (sans expression, peut être omis)

� Reprise de l’exécution à l’instruction suivant l’appel de la fonction� Appel :

[variable =] identificateur (valeurs) ;� variable (optionnelle) reçoit la valeur du résultat� identificateur : nom de la fonction� valeurs : liste d’expressions correspondant aux paramètres, un par

un, dans l’ordre de la définition� Valeur ≡ paramètre effectif

� La définition doit toujours précéder l’appel� Sinon prototype (pour le compilateur)

type identificateur (paramètres) ;ou type identificateur (types) ; (liste limitée aux types)


Fonctions (3)

� Exemple de définition : somme de deux entiersint somme (int i, int j){

int s ;s = i+j ;return s ;

}� La fonction est dénommée somme, elle reçoit deux entiers en

paramètres et le résultat est un entier� Le code contient une déclaration, un calcul faisant référence

aux arguments i et j et le retour avec renvoi du résultat

� Exemple d’appel :int k ;k = somme (2, 3) ;� Les arguments i et j valent respectivement 2 et 3 à l’appel� La variable k vaut donc 5 après exécution de la fonction


Fonctions (4)

� Autre exemple de la définition de la même fonction :int somme (int i, int j){

return i+j ;}

� Autre exemple d’appel :int x = 5, y = 34, s = 1 ;s = somme (x, y+s) ;

� Fonction main :� Point d’entrée de tout programme C� Pour commencer : pas d’argument� Renvoie un code qui indique si l’exécution s’est déroulée avec ou sans

erreur (le code peut servir à identifier l’erreur)� Définition :

int main (void){

…return 0 ;

}

Deuxième programme C

� Remarquer l’indentation :

� décalage à droite à l’ouverture d’une parenthèse

� décalage à gauche à la fermeture d’une parenthèse

� Identification des blocs : facilite la lecture et la compréhension du code source

� A faire dès le début (premier exercice du premier TP) : paramétrer la tabulation dans votre éditeur favori

� Très utile également :

� Commentaires

� Lignes blanches



Deuxième programme C (2)

� #define N 10� Le préprocesseur remplace toutes les occurrences de l’identificateur N par l’entier 10

(N est ce qu’on appelle une macro).� Facilite la lisibilité et la maintenance du code.� Nombreuses possibilités offertes par le prétraitement, pas étudiées dans ce cours.

� int i, s ; � Déclaration de variables :

� Type, nom et réservation espace mémoire

� i=0 ; s=0 ; � Initialisation des variables, indispensable avant toute utilisation

� while (i<N) {...}� Instruction de contrôle� boucle qui répète les instructions entre {} tant que la condition entre () est vérifiée.

� i = i+1 ; s = s+i ;� Instructions d’affectation� Comporte 2 membres, séparés par un signe « = ».� Calcul de la valeur de l’expression à droite, puis stockage du résultat dans la variable

désignée à gauche. � printf :

� Format d’impression suivi des variables à imprimer.


Troisième programme C


Troisième programme C (2)

� Le nombre d’entiers à sommer n’est plus une constante� Variable : n� Lue au clavier

� scanf :� Fonction prédéfinie (stdio.h)� Lire un entier (%d) à stocker dans zone allouée à n (&n représente

l’adresse de la variable n en mémoire)� Retourne 0 si erreur

� Initialisation des variables i et s lors de leur déclaration� i++ ; s += i ;

� Incrémentation et affectation composée, identiques à i=i+1 ; s = s+i ;

� EXIT_SUCCESS et EXIT_FAILURE :� Constantes prédéfinies dans stdlib.h� Dépendent du système d’exploitation

� if :� Instruction conditionnelle� Arrêt de l’exécution en cas d’erreur de lecture

printf

� Sortie à l’écran :

int printf (format [,variable [,variable…]])

� Format :

� Chaîne de caractères

� Champs formatés, identifiés par signe %, pour insérer les valeurs des variables

� Exemples :printf ("Message d\’information uniquement ") ;

printf ("Entier decimal signe i = %d\n", i) ;

printf ("Reel format 1 : x = %f\n", x) ;

printf ("Reel format 2 : x = %e\n", x) ;


scanf

� Lecture au clavier:

int scanf (format [,&variable [,&variable…]])

� Format :

� Chaîne de caractères

� Champs formatés, identifiés par signe %, pour interpréter les valeurs des variables

� La séquence tapée par l’utilisateur doit correspondre exactement à la chaîne attendue

� Exemples :scanf ("%d", &i) ;

scanf ("%f %e %lf", &x, &y, &z) ; // double z

scanf ("%i/%i/%i", &j, &m, &a) ;

� Ne pas oublier le caractère & devant la variable


Types et formats de sortie


Quelques exemples pour entiers


Quelques exemples pour réels



Compilation d’un programme C

� Le texte source C est d’abord traité par le pré-processeur C :1. Chaque ligne terminée par « \ » est concaténée à la ligne

suivante ce qui peut être utile pour traiter de grandes constantes chaînes dont la longueur est supérieure à celle d’une ligne physique.

2. Chaque commentaire est remplacé par un espace.3. Le texte source est découpé en unités lexicales.4. Les blancs sont éliminés (sauf ceux à l’intérieur des chaînes et

les constantes caractères).5. Les directives sont remplacées par le texte correspondant.6. Les séquences échappement sont remplacées par le code des

caractères correspondants.7. Les constantes chaînes de caractères adjacentes sont

concaténées.8. Le texte transformé est passé au compilateur qui vérifie la

syntaxe et, s’il n’y a pas d’erreur, engendre du langage machine.


Structure d’un programme C

� Un programme est composé de déclarations et d’instructions.� Des variables qui vont héberger les données initiales, les résultats

intermédiaires et le résultat final.� Ces données sont définies par un type : simple (prédéfini) ou complexe (défini

par l’utilisateur) � Les fonctions sont une façon d’encapsuler et de nommer une suite

d’instructions pour réaliser un traitement particulier. Une fonction agit sur des arguments et renvoie un résultat d’un type donné.

� Avant d’être utilisée, une variable ou une fonction doit avoir été déclarée au préalable et cette déclaration doit mentionner le nom et le type de la variable ou de la fonction.

� Certains objets sont définis dans des bibliothèques dont il faut inclure les entêtes (fichiers avec l’extension .h pour header).

� Le programme comporte une fonction nommée main qui sera activée au lancement du programme.

� Plusieurs instructions peuvent être groupées ensemble dans un bloc. Un bloc est en quelque sorte une méta-instruction qui peut contenir ses propres déclarations de variables (à éviter).

� La lisibilité du programme (et sa portabilité) peut être notablement améliorée par l’utilisation de directives (ex : certaines constantes sous forme de paramètres), et par l’utilisation de commentaires.


Eléments de base du langage C

� Eléments syntaxiques� les lettres : a..z, A..Z� les chiffres : 0..9� le souligné : _� des signes de ponctuation : ! : / ; . , * % < > ^ & ~ " # ‘ { } ( )

[ ] - + | = ? \� les blancs : espace, tabulation horizontale et verticale,

nouvelle ligne, nouvelle page� Tous les autres caractères sont interdits.� Ces caractères servent à construire les unités lexicales :

� identificateurs � mots réservés (ex : if, while, etc.)� nombres (réels et entiers)� constantes (numériques, caractères, chaînes)� opérateurs et séparateurs


Opérateurs, délimiteurs et

séparateurs

� Caractères ou combinaisons particulières de caractères ayant un sens précis en C/C++

� Opérateurs arithmétiques : + , - , * , / , %

� Opérateurs binaires : & , | , ^ , << , >> , ~

� Opérateurs logiques : > , >= , < , <= , == , != , && , || , !

� Opérateurs d’affectation : = , += , -= , *= , /= , %= , &= , |= , ^=<<= , >>=

� Opérateurs d’incrémentation et décrémentation : ++ , --

� Utilisés en préfixe ou postfixe

� Opérateurs d’adressage et d’indexation : . , -> , [] , * , &

� Opérateurs divers : () , ?: , ,


Conversion de type en C

� Lorsque les opérandes d’un opérateur sont de types différents ils sont convertis automatiquement dans un type commun :

� en évitant la perte d’information

� Si un opérande est de type long double les autres sont convertis en long double

� Si un opérande est de type double les autres sont convertis en double

� Si un opérande est de type float les autres sont convertis en float

� vers une représentation plus longue

� Un char ou short est converti en int


Conversion de type en C (2)


Conversion de type forcée

� Le transtypage peut être forcé (cast)

� En C :

(type) expression ;


Priorités

� Les expressions sont évaluées en respectant une hiérarchie entre les opérateurs :

Une bonne habitude : utiliser des parenthèses !


Opérateurs


Opérateurs (2)


Opérateurs (3)


Affectation composée


Incrémentation et décrémentation


Expressions conditionnelles

� exp_cond = test ? exp1 : exp2 ;

� exp_cond = exp1 si test ≠ 0 (VRAI)

� exp_cond = exp2 si test = 0 (FAUX)


Opérateurs binaires


Opérateurs binaires (2)

programmation impérative et langage csylvain.tisserant.perso.luminy.univ-amu.fr/prog... · partie...

Documents