21:I[12806,["72190","static/chunks/d012089c-332b2cdf12058945.js","85529","static/chunks/85529-ed204f0f47b12f03.js","80988","static/chunks/80988-80efa22e33155f97.js","87915","static/chunks/87915-c5391cf8a52b0f5e.js","49539","static/chunks/49539-75205cda1cc75638.js","16535","static/chunks/16535-0e435d803516ee88.js","46856","static/chunks/46856-929232a975a49956.js","89524","static/chunks/89524-fd8ec3796ab5d46e.js","33411","static/chunks/33411-21be31cc50cc5119.js","89810","static/chunks/89810-189603dca2a16f90.js","1562","static/chunks/1562-939c16808d007de0.js","61935","static/chunks/61935-e79077832a75821d.js","60465","static/chunks/60465-c97ac92a269e0c9a.js","88615","static/chunks/88615-930a9861b8e776cc.js","89157","static/chunks/89157-8f1daa4264e45b88.js","94609","static/chunks/94609-3232e8eb0e1bc120.js","32605","static/chunks/32605-1281cc40678cedbe.js","44439","static/chunks/44439-274a2a1caaf4b008.js","88573","static/chunks/88573-cef2a196c8ea06da.js","53267","static/chunks/53267-027347f9903a6c3a.js","8794","static/chunks/8794-071000403acb1eb6.js","10462","static/chunks/10462-44694588859ead85.js","95074","static/chunks/95074-1e9e1ec172a6d18e.js","63128","static/chunks/63128-713b954ff588a306.js","66743","static/chunks/66743-8e5c10f3a5a883cf.js","86224","static/chunks/86224-b0102aeda0ad2a8e.js","867","static/chunks/app/(app)/cours/%5Bslug%5D/%5BpageSlug%5D/page-16b2bf18eb56d5bb.js"],"CourseLessonPin"] 22:I[88573,["72190","static/chunks/d012089c-332b2cdf12058945.js","85529","static/chunks/85529-ed204f0f47b12f03.js","80988","static/chunks/80988-80efa22e33155f97.js","87915","static/chunks/87915-c5391cf8a52b0f5e.js","49539","static/chunks/49539-75205cda1cc75638.js","16535","static/chunks/16535-0e435d803516ee88.js","46856","static/chunks/46856-929232a975a49956.js","89524","static/chunks/89524-fd8ec3796ab5d46e.js","33411","static/chunks/33411-21be31cc50cc5119.js","89810","static/chunks/89810-189603dca2a16f90.js","1562","static/chunks/1562-939c16808d007de0.js","61935","static/chunks/61935-e79077832a75821d.js","60465","static/chunks/60465-c97ac92a269e0c9a.js","88615","static/chunks/88615-930a9861b8e776cc.js","89157","static/chunks/89157-8f1daa4264e45b88.js","94609","static/chunks/94609-3232e8eb0e1bc120.js","32605","static/chunks/32605-1281cc40678cedbe.js","44439","static/chunks/44439-274a2a1caaf4b008.js","88573","static/chunks/88573-cef2a196c8ea06da.js","53267","static/chunks/53267-027347f9903a6c3a.js","8794","static/chunks/8794-071000403acb1eb6.js","10462","static/chunks/10462-44694588859ead85.js","95074","static/chunks/95074-1e9e1ec172a6d18e.js","63128","static/chunks/63128-713b954ff588a306.js","66743","static/chunks/66743-8e5c10f3a5a883cf.js","86224","static/chunks/86224-b0102aeda0ad2a8e.js","867","static/chunks/app/(app)/cours/%5Bslug%5D/%5BpageSlug%5D/page-16b2bf18eb56d5bb.js"],"InlineTextParts"] 23:I[95297,["72190","static/chunks/d012089c-332b2cdf12058945.js","85529","static/chunks/85529-ed204f0f47b12f03.js","80988","static/chunks/80988-80efa22e33155f97.js","87915","static/chunks/87915-c5391cf8a52b0f5e.js","49539","static/chunks/49539-75205cda1cc75638.js","16535","static/chunks/16535-0e435d803516ee88.js","46856","static/chunks/46856-929232a975a49956.js","89524","static/chunks/89524-fd8ec3796ab5d46e.js","33411","static/chunks/33411-21be31cc50cc5119.js","89810","static/chunks/89810-189603dca2a16f90.js","1562","static/chunks/1562-939c16808d007de0.js","61935","static/chunks/61935-e79077832a75821d.js","60465","static/chunks/60465-c97ac92a269e0c9a.js","88615","static/chunks/88615-930a9861b8e776cc.js","89157","static/chunks/89157-8f1daa4264e45b88.js","94609","static/chunks/94609-3232e8eb0e1bc120.js","32605","static/chunks/32605-1281cc40678cedbe.js","44439","static/chunks/44439-274a2a1caaf4b008.js","88573","static/chunks/88573-cef2a196c8ea06da.js","53267","static/chunks/53267-027347f9903a6c3a.js","8794","static/chunks/8794-071000403acb1eb6.js","10462","static/chunks/10462-44694588859ead85.js","95074","static/chunks/95074-1e9e1ec172a6d18e.js","63128","static/chunks/63128-713b954ff588a306.js","66743","static/chunks/66743-8e5c10f3a5a883cf.js","86224","static/chunks/86224-b0102aeda0ad2a8e.js","867","static/chunks/app/(app)/cours/%5Bslug%5D/%5BpageSlug%5D/page-16b2bf18eb56d5bb.js"],"CoursePageReadChip"] 24:I[76545,["72190","static/chunks/d012089c-332b2cdf12058945.js","85529","static/chunks/85529-ed204f0f47b12f03.js","80988","static/chunks/80988-80efa22e33155f97.js","87915","static/chunks/87915-c5391cf8a52b0f5e.js","49539","static/chunks/49539-75205cda1cc75638.js","16535","static/chunks/16535-0e435d803516ee88.js","46856","static/chunks/46856-929232a975a49956.js","89524","static/chunks/89524-fd8ec3796ab5d46e.js","33411","static/chunks/33411-21be31cc50cc5119.js","89810","static/chunks/89810-189603dca2a16f90.js","1562","static/chunks/1562-939c16808d007de0.js","61935","static/chunks/61935-e79077832a75821d.js","60465","static/chunks/60465-c97ac92a269e0c9a.js","88615","static/chunks/88615-930a9861b8e776cc.js","89157","static/chunks/89157-8f1daa4264e45b88.js","94609","static/chunks/94609-3232e8eb0e1bc120.js","32605","static/chunks/32605-1281cc40678cedbe.js","44439","static/chunks/44439-274a2a1caaf4b008.js","88573","static/chunks/88573-cef2a196c8ea06da.js","53267","static/chunks/53267-027347f9903a6c3a.js","8794","static/chunks/8794-071000403acb1eb6.js","10462","static/chunks/10462-44694588859ead85.js","95074","static/chunks/95074-1e9e1ec172a6d18e.js","63128","static/chunks/63128-713b954ff588a306.js","66743","static/chunks/66743-8e5c10f3a5a883cf.js","86224","static/chunks/86224-b0102aeda0ad2a8e.js","867","static/chunks/app/(app)/cours/%5Bslug%5D/%5BpageSlug%5D/page-16b2bf18eb56d5bb.js"],"CourseLessonLayoutRegistrar"] 25:T437,

L’ordre des fonctions dans un programme est fondamental. En effet, le compilateur lit le code de haut en bas. Lorsqu’une fonction est appelée, il doit déjà connaître son existence, son type de retour et les types de ses paramètres. Si une fonction est appelée avant d’être définie, le compilateur ne dispose pas de ces informations et génère une erreur de compilation. C’est pourquoi, chaque fonction doit être définie avant toute utilisation dans le code. L’organisation des fonctions devient donc essentielle : les fonctions utilitaires doivent être placées avant les fonctions qui les appellent, et la fonction principale (main) est souvent placée à la fin du fichier. Cette contrainte garantit que le compilateur possède toutes les informations nécessaires au moment où il analyse chaque appel de fonction.

Reprenons l'exemple précédent et changeons simplement l'ordre de la fonction main et somme pour voir ce que le compilateur répond :

26:T4cd,

En langage C, les types jouent un rôle essentiel :

ils permettent de définir la nature des données manipulées par un programme (nombres entiers, nombres réels, caractères, etc.)
ainsi que les opérations qui peuvent leur être appliquées.

Le typage correspond au mécanisme par lequel le compilateur vérifie la cohérence de ces types afin de détecter de potentiels erreurs avant l'exécution du programme. Le C est un langage à typage statique : le type des variables doit être déclaré avant leur utilisation et reste connu du compilateur tout au long de la compilation. Cette caractéristique contribue à la fiabilité des programmes et à l'optimisation du code généré. Comprendre les types et le typage constitue donc une étape fondamentale pour écrire des programmes C corrects, efficaces et faciles à maintenir.

27:T15f3,

Type	Taille (en octets)	Plage de valeur possible
`int`	4	-2 147 483 648 à 2 147 483 647
`unsigned int`	4	0 à 4 294 967 295
`short` ou `short int`	2	-37 768 à 37 767
`unsigned short`	2	0 à 65 535
`long` ou `long int`	4 ou 8	dépend du pc
`unsigned long`	4 ou 8	uniquement valeurs positive
`long long`	8	très grands nombres
`unsigned long long`	8	les positifs

28:T48a,

En langage C, le type flottant (floating-point) est utilisé pour représenter les nombres réels avec une partie décimale. Il existe deux types flottants :

float précision simple : généralement sur 32bits et environ 7 chiffres significatifs
double précision double : généralement sur 64bits et environ 15-16 chiffres significatifsLe nombre de chiffres significatif représente la précision avec laquelle est donnée un nombre.

Le nombre de chiffres significatif représente la précision avec laquelle est donnée un nombre.

Les valeurs minimales et maximales sont définies dans le header <float.h> avec les constantes FLT_MIN, FLT_MAX, ...

29:T4d2,

La portée des variables en C (aussi appelée scope), c’est la partie du programme dans laquelle une variable est accessible (où tu peux l’utiliser). Il y a plusieurs types de portée selon où et comment tu déclares ta variable. Une variable doit être déclarée et initialisée avant d’être utilisée… !

Prenons l’instruction suivante : int j = 0, c;

En C, on peut déclarer plusieurs variables en même temps sans pour autant les initialiser. Hors, quand on est en C, si on initialise pas les variables, elles ont ce qu’on appelle une valeur indéfinie, ce qui signifie que tu ne peux pas savoir ce qu’elle contient. Du coup dans l’instruction ci-dessus, tu initialises bien j à 0, donc ta variable j stocke bien la valeur 0. Alors que pour la variable c, tu ne lui donne pas de valeur.
Ainsi, quand tu voudras afficher les valeurs de j et de c, tu obtiendra pour c une valeur différente à chaque exécution du programme.

2a:T25fa,

Voici un tableau récapitulatif des types valides en C, évidemment il peut faire peur au premier abord, mais inutile de l'apprendre par cœur, c'est en programmant que vous retiendrez ce qu'il faut.

Format	Type de l’argument affiché	Format d’affichage	Exemple	Bornes usuelles
`%c`	caractère (`char`)	ASCII	`a` `G` `u`	`signed char` : −128 à 127 `unsigned char` : 0 à 255
`%hd` `%hu` `%hX`	entier `short int` signé entier `short int` non signé hexadécimal (`unsigned short`)	Base 10 Base 10 Base 16	`-12` `463` `90AF`	`short` signé : −32768 à 32767 `unsigned short` : 0 à 65535
`%ld` `%lu` `%lX`	entier `long int` signé entier `long int` non signé hexadécimal (`unsigned long`)	Base 10 Base 10 Base 16	`-1289` `46399` `B4E98A0F`	`long` signé (64 bits) : de −9223372036854775808 à 9223372036854775807 `unsigned long` : 0 à 18446744073709551615
`%d` `%X`	entier `int` signé entier `int` en hexadécimal	Base 10 Base 16	`-546` `9A0F`	`int` signé (32 bits) : −2147483648 à 2147483647 `unsigned int` : 0 à 4294967295
`%le` `%lf`	réel double précision `double`	scientifique ou flottant	`-3.195874` `-45e-7`	environ ±1.7×10−38 à ±1.7×1038 (15-16 chiffres de précision)
`%e` `%f`	réel simple précision `float`	scientifique ou flottant	`-3.195874` `-45e-7`	environ ±1.2×10−38 à ±3.4×1038 (6-7 chiffres de précision)
`%s`	chaîne de caractères	—	`Hello world`	dépend de la mémoire disponible

Il est aussi possible d’ajouter des options entre % et la lettre qui définit le format.

Ajouter un entier qui précise sur combien de caractère est affiché la variable. Par exemple, si on souhaite afficher une variable entière sur 5 caractère on utilisera le format %5d.

2b:Tc30,

Il existe aussi des constantes caractères permettant d’effectuer un sout de ligne par exemple.

constante caractère	signification
`\n`	saut de ligne
`\t`	tabulation
`\r`	retour chariot
`\f`	saut de page
`\'`	apostrophe
`\?`	point d’interrogation

e:["$","article",null,{"className":"course-content w-full min-w-0 max-w-none","children":[["$","$L21",null,{"courseHref":"/cours/prog-c","courseTitle":"Programmation C","iconName":"MemoryStick","numberLabel":"03","title":"Commencer à programmer en C"}],["$","header",null,{"className":"course-page-header course-page-header--lesson course-page-header--accent","style":{"--course-header-accent":"#b25a9e"},"children":[["$","div",null,{"className":"course-page-header__band","children":[["$","svg",null,{"xmlns":"http://www.w3.org/2000/svg","viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeLinecap":"round","strokeLinejoin":"round","aria-hidden":true,"width":24,"height":24,"strokeWidth":1,"className":"course-page-header__glyph","dangerouslySetInnerHTML":{"__html":""}}],["$","div",null,{"className":"course-page-header__band-top","children":[["$","div",null,{"className":"course-page-header__band-copy","children":[["$","nav",null,{"className":"course-page-header__crumb","aria-label":"Fil d'Ariane","children":[["$","svg",null,{"xmlns":"http://www.w3.org/2000/svg","viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeLinecap":"round","strokeLinejoin":"round","aria-hidden":true,"width":24,"height":24,"strokeWidth":1.7,"className":"course-page-header__crumb-icon","dangerouslySetInnerHTML":{"__html":""}}],["$","$L20",null,{"href":"/cours/prog-c","className":"course-page-header__crumb-link","children":["$","$L22",null,{"text":"Programmation C"}]}],[["$","span",null,{"className":"course-page-header__crumb-sep","aria-hidden":true,"children":"/"}],["$","span",null,{"className":"course-page-header__crumb-part","children":"Partie 1"}]]]}],["$","div",null,{"className":"course-page-header__headline","children":[["$","span",null,{"className":"course-page-header__num","aria-hidden":true,"children":"03"}],["$","h1",null,{"className":"course-page-header__title","children":["$","$L22",null,{"text":"Commencer à programmer en C"}]}]]}],["$","div",null,{"className":"course-page-header__meta","children":[["$","span",null,{"className":"course-page-header__meta-pill","children":"L2 INFO"}],["$","span",null,{"className":"course-page-header__meta-pill","children":"Semestre 3"}],[],["$","span",null,{"className":"course-page-header__updated","children":["Mis à jour le ","23 juin 2026"]}]]}]]}],["$","div",null,{"className":"course-page-header__acts","role":"group","aria-label":"Actions de la page","children":[["$","$L23",null,{}],["$","$L20",null,{"href":"/cours/prog-c/sommaire","className":"course-page-header__act","children":[["$","$L1f",null,{"ref":"$undefined","iconNode":[["path",{"d":"M8 5h13","key":"1pao27"}],["path",{"d":"M13 12h8","key":"h98zly"}],["path",{"d":"M13 19h8","key":"c3s6r1"}],["path",{"d":"M3 10a2 2 0 0 0 2 2h3","key":"1npucw"}],["path",{"d":"M3 5v12a2 2 0 0 0 2 2h3","key":"x1gjn2"}]],"className":"lucide-list-tree course-page-header__act-icon","aria-hidden":true}],["$","span",null,{"className":"course-page-header__act-label","children":"Sommaire"}],["$","span",null,{"className":"course-page-header__act-label-short","children":"Plan"}]]}]]}]]}],null]}],["$","div",null,{"className":"course-page-header__rule","aria-hidden":true}]]}],null,["$","$L24",null,{"layout":[{"id":"6a2c7217cd8b16860fb45108","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"Première partie","level":"h2","text":"L'incontournable : Hello World "},{"id":"6a2c7243cd8b16860fb45109","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Et oui, ici aussi vous n’y échapperez pas, notre premier programme C vas nous permettre d’afficher ce fameux Hello world dans la console.

Avant de commencer à coder, réfléchissons un peu. Pour rappel le C est une suite de fonction dont une obligatoire la fonction main( ), c’est elle qui sera exécutée en premier d’où son appellation point d’entrée. Nous allons devoir trouver le moyen d’afficher du texte dans la console. En programmation C, il est aussi impératif de réfléchir à quel genre de “chose” doit renvoyer la fonction, ce que j'entends par là c'est de déterminer si la fonction va renvoyer un nombre, une lettre, un ou plusieurs mots, et d'autres.

"},{"id":"6a2c72b2cd8b16860fb4510a","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Structure d'une fonction"},{"id":"6a2c72d6cd8b16860fb4510d","blockType":"contentColumns","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"plain","sizingMode":"percent","layout":"2-equal","gap":"1rem","alignItems":"center","columns":[{"widthPercent":65,"blocks":[{"id":"6a2c7373cd8b16860fb45113","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"definition","title":"Fonction","bodyHtml":"

Une fonction est une unité de programme autonome qui regroupe des instructions destinées à accomplir une opération précise. Elle favorise la réutilisation du code, améliore sa lisibilité et facilite sa maintenance.

"}],"contentHtml":null},{"widthPercent":35,"blocks":[{"id":"6a2c72eacd8b16860fb45110","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"typeRetour maFonction( params ) {\n\t...\n}","language":"text","filename":"prog.txt","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"typeRetour maFonction( params ) {\n\t...\n}","language":"text","filename":"prog.txt"}],"contentHtml":null}]},{"id":"6a2c73becd8b16860fb45114","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

En programmation C, pour créer une fonction il faut réfléchir à un certain nombre d'informations :

Un nom valideUn type de retour

Une fonction en C est délimitée par des accolades { ... } elle possède un nom qui ne peut pas commencer par un chiffre ou par un caractère spécial. On précise le type de retour de la fonction au dessus appelé typeRetour, ce type désigne ce que renvoie la fonction. On peut utiliser un type natif au C, en importer ou alors créer son propre type.

"},{"id":"6a2c8514ee991169ebf5bf5b","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a2c8526ee991169ebf5bf5c","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Prenons en compte une fonction somme qui permet de calculer la somme de 2 entiers et de la renvoyer.

"},{"id":"6a2c854eee991169ebf5bf5d","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \n \nint somme(int a, int b){\n\treturn a+b;\n}","language":"c","filename":"somme.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \n \nint somme(int a, int b){\n\treturn a+b;\n}","language":"c","filename":"somme.c"},{"id":"6a2c8561ee991169ebf5bf5f","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On a alors une fonction qui s'appelle somme, cette dernière doit renvoyer un entier (type int en C) elle possède deux paramètres entiers a et b et retourne l'addition des deux.

Pas d'inquiétude la notion de "type" arrive bientôt !

"}]},{"id":"6a2c8662ee991169ebf5bf65","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Si votre fonction doit retourner un certain type T et que vous vous tromper dans la définition de votre fonction, la compilation va alors échouer et vous ne pourrez donc pas lancer votre programme.

"},{"id":"6a2c7499cd8b16860fb45115","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Le point d'entrée en C"},{"id":"6a2c74b0cd8b16860fb45116","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Lorsqu’un programme commence à s’exécuter il appellera toujours main( )en premier. C’est une fonction qui permet de diriger les appels aux autres fonctions du programme. Regardons alors ce qu’il se passe si on essaie d'exécuter un programme sans fonction main().

"},{"id":"6a2c7554cd8b16860fb45118","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":"

","blocks":[{"id":"6a2c7decdd482e846f15fa7c","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On considère une fonction permettant de calculer la somme de deux entiers a et b.

"},{"id":"6a2c8214ee991169ebf5bf59","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Okay, pas de panique étudions l'erreur de plus près.

La ligne qui nous intéresse le plus est la ligne 2, elle indique undefined reference to 'main', en français qu'il n'y a aucune référence vers la fonction main, et ça colle parfaitement avec ce que je disais au départ. La programmation C est une suite de fonction dont une principale : la fonction main. Sans elle un programme ne peut pas être lancé, c'est exactement ce qu'illustre cette exemple. Ainsi pour résoudre le problème, il suffit d'ajouter une fonction main en dessous de la fonction somme et d'appeler la fonction.

"}]},{"id":"6a2c8350ee991169ebf5bf5a","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

La fonction main possède quelques contraintes comme le fait qu'elle ne peut pas être définie comme statique (avec le mot clé static) car elle doit être visible par l'environnement d'exécution du programme (le système d'exploitation et le code de démarrage fourni par l'implémentation C).

La raison est que static donne à une fonction une liaison interne (internal linkage), ce qui signifie qu'elle n'est accessible que dans le fichier source où elle est définie. Or, lorsque le programme démarre, le code d'initialisation doit pouvoir appeler main comme point d'entrée du programme. La norme C exige donc que main ait une définition conforme et ne soit pas déclarée static.

"},{"id":"6a359f83b28f900f0a7ab4eb","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Ainsi, l'exemple ci-dessus devient compilable et exécutable en ajoutant une fonction main(), c'est elle qui sera appelée en premier au lancement du programme. Voici une correction et un exemple d'utilisation de la fonction somme(a, b).

"},{"id":"6a359fdab28f900f0a7ab4ec","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}\r\n\r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}","language":"c","filename":"somme.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}\r\n\r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}","language":"c","filename":"somme.c","terminal":"gcc somme.c -o somme\r\n./somme\r\nLa somme de 4 est 5 est : 9","terminalLanguage":"bash"},{"id":"6a35a042b28f900f0a7ab4ee","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Tout est question d'ordre"},{"id":"6a36f9db6acf9d55efe5f9dd","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Contexte"},{"id":"6a35a055b28f900f0a7ab4ef","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$25"},{"id":"6a35a0efb28f900f0a7ab4f0","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}\r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}","language":"c","filename":"somme.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}\r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}","language":"c","filename":"somme.c","terminal":"gcc somme.c -o somme\r\nsomme.c: In function ‘main’:\r\nsomme.c:4:47: error: implicit declaration of function ‘somme’ [-Wimplicit-function-declaration]\r\n 4 | printf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n | ^~~~~","terminalLanguage":"bash"},{"id":"6a35a153b28f900f0a7ab4f3","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

L'erreur affichée dans le terminal au moment de la compilation indique qu'il y a une erreur sur la ligne 4, il précise en fait qu'il y a une déclaration implicite sur la fonction somme puis, il termine par montrer l'emplacement exact de l'erreur, ici c'est au moment d'appeler la fonction somme sur la ligne 4.

"},{"id":"6a36f9f96acf9d55efe5f9de","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Solution : les prototypes de fonction"},{"id":"6a36fa146acf9d55efe5f9df","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Le prototype d’une fonction en C est une déclaration qui indique au compilateur le nom de la fonction, le type de la valeur qu’elle retourne ainsi que les types de ses paramètres, sans fournir son implémentation. Il sert à informer le compilateur de l’existence de la fonction avant son utilisation dans le programme, ce qui permet de vérifier que les appels à cette fonction sont corrects (nombre et types des arguments) et d’éviter certaines erreurs de compilation. Un prototype se termine par un point-virgule. Ainsi, même si la définition complète de la fonction apparaît plus loin dans le code, le compilateur connaît déjà sa signature et peut contrôler sa bonne utilisation.

"},{"id":"6a36fa766acf9d55efe5f9e0","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n\r\nint somme(int, int); // pas besoin de nommer les paramètres\r\n \r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}\r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}","language":"c","filename":"somme.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n\r\nint somme(int, int); // pas besoin de nommer les paramètres\r\n \r\nint main(){\r\n\tprintf(\"La somme de 4 et 5 est : %d\", somme(4, 5));\r\n\treturn 0;\r\n}\r\n \r\nint somme(int a, int b){\r\n\treturn a+b;\r\n}","language":"c","filename":"somme.c","terminal":"gcc somme.c -o somme\r\n./somme\r\nLa somme de 4 et 5 est : 9","terminalLanguage":"bash"},{"id":"6a3843cb3159eeba535239b9","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Ne te préoccupe pas des %..⁣ présentsdans la fonction printf( ), nous en parlerons au moment venu.

"},{"id":"6a36fbd96acf9d55efe5f9e2","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Les types en C"},{"id":"6a3842703159eeba535239b8","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$26"},{"id":"6a3844c339df1aadfb79b341","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Le type caractère"},{"id":"6a384c8062243585f4927b83","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Le mot clé char désigne un objet de type caractère, ce dernier peut contenir n’importe quel caractère que la machine utilise. Le plus souvent, un objet de type char est codé sur 1 octet (= 8 bits) et les caractères pris en compte sont ceux qui correspondent au codage ASCII.

Table ASCII

"},{"id":"6a38452c39df1aadfb79b343","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

En programmation C, chaque caractère est aussi déterminé à l'aide de sa valeur décimale, il est alors possible de les considérer comme des entiers et d'effectuer des opérations arithmétiques sur eux.

"},{"id":"6a38456b39df1aadfb79b344","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a38457439df1aadfb79b345","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On considère une variable a qui contient le caractère 'a' et on souhaite afficher le caractère 'b' à partir de a. On sait grâce à la table ASCII que la différence entre le code décimal de b et le code décimal de a vaut , il faut donc ajouter à la variable contenant 'a' pour obtenir 'b'.

"},{"id":"6a3848f83f8b4a7e44cf46b5","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include\r\n \r\nint main( ){\r\n char a = 'a';\r\n char b = a+1;\r\n printf(\"%c\", b);\r\n}","language":"c","filename":"main.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include\r\n \r\nint main( ){\r\n char a = 'a';\r\n char b = a+1;\r\n printf(\"%c\", b);\r\n}","language":"c","filename":"main.c","terminal":"gcc main.c -o prog && ./prog\r\nb","terminalLanguage":"bash"}]},{"id":"6a384bcb3f8b4a7e44cf46ba","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"info","title":"Preshot les chaînes de caractères","bodyHtml":"

Une variable de type char ne peut contenir qu’un seul et unique caractère. Pour pouvoir stocker plusieurs caractères, il faudra utiliser :

Un tableau de charUn pointeur vers char

Ces deux aspects seront évoqués plus tard dans ce cours.

"},{"id":"6a384d4107a38344bf40269c","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

En conséquence, cela implique directement qu’une variable de type char contenant plusieurs caractères déclenchera une erreur et empêchera la compilation de votre programme.

"},{"id":"6a384d9a07a38344bf40269d","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Un objet de type char ne peut contenir qu’un seul caractère, et en réalité chaque caractère représente une valeur numérique qui correspond en fait à son codage dans la table ASCII.

"},{"id":"6a384dad07a38344bf40269e","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Ainsi, on peut avoir besoin d’afficher la valeur d’une variable de type char sous forme de caractère ou sous forme numérique. Cela est évidemment possible en langage C.

"},{"id":"6a384dba07a38344bf40269f","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a384dbf07a38344bf4026a0","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Programme permettant d'afficher le caractère A et son codage associé en décimal.

"},{"id":"6a384ddb07a38344bf4026a1","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include\r\n \r\nint main( ){\r\n char a = 'A';\r\n printf(\"%c\\n\", a); // Afficher le caractère\r\n printf(\"%d\", a); // Afficher la valeur numérique\r\n}","language":"c","filename":"main.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include\r\n \r\nint main( ){\r\n char a = 'A';\r\n printf(\"%c\\n\", a); // Afficher le caractère\r\n printf(\"%d\", a); // Afficher la valeur numérique\r\n}","language":"c","filename":"main.c","terminal":"gcc main.c -o prog && ./prog\r\nA\r\n65","terminalLanguage":"bash"},{"id":"6a384e1107a38344bf4026a3","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Où 65 représente le code ASCII de la lettre A.

Pour le moment, ne nous préoccupons pas de %c et %d, on en reparle un peu après. Pour spoiler un peu on peut les voir comme des formats qui permettent de dire je veux afficher la valeur dans un certain type de la variable truc.

"}]},{"id":"6a384e6d07a38344bf4026a4","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Le type entier"},{"id":"6a384e7c07a38344bf4026a5","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Les entiers sont représentés par le mot clé int, qui peut être précédé :

d’un attribut de précision short ou longd’un attribut de représentation signed ou unsigned

"},{"id":"6a384e8d07a38344bf4026a7","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

La taille d’une variable dépend aussi de la machine sur laquelle vous codez.

"},{"id":"6a384e9a07a38344bf4026a8","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$27"},{"id":"6a384ebb07a38344bf4026aa","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

unsigned pour des valeurs positives.signed pour les valeurs positives et négatives.short petite taillelong grande tailleLa taille des entiers selon le format peut dépendre aussi du système sur Windows par exemple on note certaines différences entre 32 et 64 bits. Le compilateur peux aussi jouer un rôle.

"},{"id":"6a384f2807a38344bf4026ab","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a384f2e07a38344bf4026ac","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Si on souhaite définir un entier non signé, il suffit de spécifier le type de l’entier choisit, un nom de variable puis une valeur. Dans la pratique si on choisit que la variable var contiendra 155 alors, en programmation C on écrira :

"},{"id":"6a384f4107a38344bf4026ad","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"unsigned int var = 155;","language":"c","filename":"exemple.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"unsigned int var = 155;","language":"c","filename":"exemple.c"}]},{"id":"6a384f7507a38344bf4026af","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"info","title":"Comparaison de taille","bodyHtml":"

La taille d’un short int est comprise entre la taille d’un objet de type char et la taille d’un objet de type int, on peut aussi le noter :

"},{"id":"6a384fc307a38344bf4026b0","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Les types flottants"},{"id":"6a384fce07a38344bf4026b1","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$28"},{"id":"6a3850ac07a38344bf4026b2","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Il est possible de convertir un flottant vers un entier, cela peut néanmoins entraîner une parte de précision.Les arrondis peuvent entraîner des erreurs à cause de leur représentation en binaire.

"},{"id":"6a3850b607a38344bf4026b3","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a3850bb07a38344bf4026b4","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main( ){\r\n float var = 14.5f;\r\n double val = 14.2;\r\n}","language":"c","filename":"exemple.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main( ){\r\n float var = 14.5f;\r\n double val = 14.2;\r\n}","language":"c","filename":"exemple.c"}]},{"id":"6a3850e107a38344bf4026b7","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Par défaut, les flottant sont de type double alors c’est pour cette raison que si il est de type float on ajoute un f à la fin.

"},{"id":"6a3850fb07a38344bf4026b8","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"L'opérateur sizeof(...)"},{"id":"6a38510d07a38344bf4026b9","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

L’opération sizeof permet de déterminer la taille (en octets) d’un type de données ou d’une variable. Ce dernier se révèle très utilise lorsqu’il faut gérer la mémoire, et pour travailler avec les structures complexes.

"},{"id":"6a38511b07a38344bf4026ba","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Utiliser sizeof pour un type de données"},{"id":"6a38512d07a38344bf4026bb","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Il est possible d’obtenir la taille d’un type de donnée spécifié lors de l’appel de l’opérateur.

Les types de données sont int, char, float, …

Ainsi, il suffit d’écrire sizeof(type_de_donnees).

"},{"id":"6a38514f07a38344bf4026bd","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a38515507a38344bf4026be","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include\r\n \r\nint main( ){\r\n printf(\"Taille d'un entier : %d\", sizeof(int));\r\n printf(\"Taille d'un caractère : %d\", sizeof(char));\r\n printf(\"Taille d'un flottant : %d\", sizeof(float));\r\n return 0;\r\n}","language":"c","filename":"types.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include\r\n \r\nint main( ){\r\n printf(\"Taille d'un entier : %d\", sizeof(int));\r\n printf(\"Taille d'un caractère : %d\", sizeof(char));\r\n printf(\"Taille d'un flottant : %d\", sizeof(float));\r\n return 0;\r\n}","language":"c","filename":"types.c","terminal":"gcc types.c -o types && ./types\r\nTaille d'un entier : 4\r\nTaille d'un caractère : 1\r\nTaille d'un flottant : 4","terminalLanguage":"bash"}]},{"id":"6a38519c07a38344bf4026c0","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

La taille des données peut changer selon votre système mais en général, les tailles données ci-dessus sont dans la majeure partie des cas celles-ci.

"},{"id":"6a3851a507a38344bf4026c1","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Utiliser sizeof sur une variable"},{"id":"6a3851b307a38344bf4026c2","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a3851bc07a38344bf4026c4","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include\r\n \r\nint main( ){\r\n int a = 1452; \r\n printf(\"Taille de la variable a : %d\", sizeof(a));\r\n return 0;\r\n}","language":"c","filename":"types.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include\r\n \r\nint main( ){\r\n int a = 1452; \r\n printf(\"Taille de la variable a : %d\", sizeof(a));\r\n return 0;\r\n}","language":"c","filename":"types.c","terminal":"gcc types.c -o types && ./types\r\nTaille de la variable a : 4","terminalLanguage":"bash"}]},{"id":"6a3851e307a38344bf4026c6","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Il est évidemment possible de calculer la taille des tableaux et des structures mais nous verrons ces aspects plus tard dans ce cours.L’opérateur sizeof est évalué à la compilation, ce qui signifie qu’il n’a pas d’impact sur la performance à l’exécution.

"},{"id":"9cad0000000000cc00000007","blockType":"contentBox","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"fond":"discret","bordure":"fine","rayon":"md","ombre":"aucune","remplissage":"md","image":null,"blockName":null,"blocks":[{"id":"9cad0000000000cc00000008","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":null,"level":"h5","text":"sizeof sur chaque famille de types"},{"id":"9cad0000000000cc00000009","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \n\nint main(void) {\n printf(\"char : %zu octet\\n\", sizeof(char));\n printf(\"int : %zu octets\\n\", sizeof(int));\n printf(\"float : %zu octets\\n\", sizeof(float));\n printf(\"double : %zu octets\\n\", sizeof(double));\n return 0;\n}","language":"c","filename":"tailles.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":true,"wordWrap":false,"maxLines":0,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \n\nint main(void) {\n printf(\"char : %zu octet\\n\", sizeof(char));\n printf(\"int : %zu octets\\n\", sizeof(int));\n printf(\"float : %zu octets\\n\", sizeof(float));\n printf(\"double : %zu octets\\n\", sizeof(double));\n return 0;\n}","language":"c","filename":"tailles.c","terminal":"char : 1 octet\nint : 4 octets\nfloat : 4 octets\ndouble : 8 octets","terminalLanguage":"bash"}]},{"id":"6a38520e07a38344bf4026c7","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Caster une variable en C"},{"id":"6a38522107a38344bf4026c8","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Le terme “caster une variable” ça veut dire convertir un type de variable en un autre. On utilise ainsi la syntaxe suivante en langage C. (type_var) var

"},{"id":"6a38525e07a38344bf4026cc","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a38526307a38344bf4026cd","blockType":"contentColumns","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"plain","sizingMode":"percent","layout":"2-equal","gap":"1rem","alignItems":"start","columns":[{"widthPercent":null,"blocks":[{"id":"6a38526b07a38344bf4026d0","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main() {\r\n double x = 5.8;\r\n int y;\r\n \r\n y = (int) x; // cast explicite de double vers int\r\n \r\n printf(\"x = %f\\n\", x);\r\n printf(\"y = %d\\n\", y);\r\n \r\n return 0;\r\n}","language":"c","filename":"exemple1.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main() {\r\n double x = 5.8;\r\n int y;\r\n \r\n y = (int) x; // cast explicite de double vers int\r\n \r\n printf(\"x = %f\\n\", x);\r\n printf(\"y = %d\\n\", y);\r\n \r\n return 0;\r\n}","language":"c","filename":"exemple1.c","terminal":"gcc exemple1.c -o ex && ./ex\r\nx = 5.8\r\ny = 5","terminalLanguage":"bash"}],"contentHtml":null},{"widthPercent":null,"blocks":[{"id":"6a38526f07a38344bf4026d1","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"int a = 10;\r\ndouble b = 3.5;\r\n \r\n// Cast implicite (devient un double)\r\ndouble result1 = a + b; // a est converti en double\r\n \r\n// Cast explicite\r\nint result2 = (int)b; // b devient 3","language":"c","filename":"exemple2.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"int a = 10;\r\ndouble b = 3.5;\r\n \r\n// Cast implicite (devient un double)\r\ndouble result1 = a + b; // a est converti en double\r\n \r\n// Cast explicite\r\nint result2 = (int)b; // b devient 3","language":"c","filename":"exemple2.c"}],"contentHtml":null}]}]},{"id":"6a3852e807a38344bf4026d4","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Portée des variables"},{"id":"6a3852f907a38344bf4026d5","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$29"},{"id":"6a38533407a38344bf4026d6","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a38533b07a38344bf4026d7","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main() {\r\n int j = 0, c;\r\n printf(\"j=%d et c=%d\", j, c);\r\n return 0;\r\n}","language":"c","filename":"exemple.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main() {\r\n int j = 0, c;\r\n printf(\"j=%d et c=%d\", j, c);\r\n return 0;\r\n}","language":"c","filename":"exemple.c","terminal":"j=0 et c=-1392444720\r\nj=0 et c=-1370719536\r\nj=0 et c=1561864912","terminalLanguage":"bash"},{"id":"6a38535a07a38344bf4026d9","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Ainsi, tant qu’une variable n’est pas explicitement initialisée/définie, alors elle contient une valeur indéterminée.

"}]},{"id":"6a3853a207a38344bf4026da","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Variable locale"},{"id":"6a3853b507a38344bf4026dc","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

C’est la déclaration à l’intérieur d’un bloc. Dans ce cas la variable est dite LOCALE et est accessible uniquement dans ce même bloc.

"},{"id":"6a3853bd07a38344bf4026dd","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a3853c207a38344bf4026de","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"void maFonction() {\r\n int x = 5; // portée locale\r\n printf(\"%d\\n\", x); // Pas d'erreur ici\r\n}\r\nprintf(\"%d\\n\", x); // Erreur, x n'est pas visible ici","language":"c","filename":"locale.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"void maFonction() {\r\n int x = 5; // portée locale\r\n printf(\"%d\\n\", x); // Pas d'erreur ici\r\n}\r\nprintf(\"%d\\n\", x); // Erreur, x n'est pas visible ici","language":"c","filename":"locale.c"}]},{"id":"6a3853d707a38344bf4026e0","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Variable globale"},{"id":"6a3853e807a38344bf4026e1","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Déclaration en dehors de toute fonction, elle est appelée variable GLOBALE et est accessible partout dans le fichier.

"},{"id":"6a3853eb07a38344bf4026e2","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a3853f007a38344bf4026e3","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"int y = 10; // portée globale\r\n \r\nvoid afficher() {\r\n printf(\"%d\\n\", y);\r\n}","language":"c","filename":"globale.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"int y = 10; // portée globale\r\n \r\nvoid afficher() {\r\n printf(\"%d\\n\", y);\r\n}","language":"c","filename":"globale.c"}]},{"id":"6a38541307a38344bf4026e5","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

On peut aussi avoir accès à une variable globale partout dans d’autres fichiers en l’exportant avec extern.

"},{"id":"6a38542907a38344bf4026e7","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a38542e07a38344bf4026e8","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On souhaite déclarer la variable compteur dans le premier fichier et y accéder dans le fichier, on va alors exporter cette dernière.

"},{"id":"6a38544b07a38344bf4026e9","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"int compteur = 0; // Définition de la variable globale\r\n...","language":"c","filename":"fichier1.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}},{"code":"extern int compteur; // Déclaration : \"Je sais qu'elle est définie ailleurs\"\r\n...","language":"c","filename":"fichier2.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"int compteur = 0; // Définition de la variable globale\r\n...","language":"c","filename":"fichier1.c"}]},{"id":"6a38548807a38344bf4026ec","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Retour sur la fonction printf( )…"},{"id":"6a38549e07a38344bf4026ed","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Je ne sais pas si tu as remarqué mais quand on veut afficher la taille ou la valeur d’une variable par exemple, on précise à l’intérieur de printf ce qu’on appelle le format. En gros, on dit qu’on souhaite afficher la valeur d’une certaine variable dans un certain format.

On utilise le caractère % pour chaque variable suivit de l’initiale associé au format dans lequel on souhaite afficher la variable. On considère deux variables que l’on souhaite afficher dans un format bien précis alors de manière générale, on utilisera printf comme suit :

"},{"id":"6a3854c107a38344bf4026ee","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"printf(\"message %format1 ... %format2\", var1, var2);","language":"c","filename":"printf.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"printf(\"message %format1 ... %format2\", var1, var2);","language":"c","filename":"printf.c"},{"id":"6a3983f3e653ab8202f5807c","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

La fonction printf() contiendra autant autant de paramètres supplémentaires qu'il y a de format dans la chaîne à afficher !

"},{"id":"6a398544e653ab8202f5807d","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a398551e653ab8202f5807e","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On souhaite afficher la valeur entière, puis caractère d’une variable. Ainsi on codera :

"},{"id":"6a39855be653ab8202f5807f","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main( ){\r\n char lettre = \"A\";\r\n printf(\"Format entier : %d et format caractère : %c.\", lettre, lettre);\r\n return 0;\r\n} ","language":"c","filename":"main.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main( ){\r\n char lettre = \"A\";\r\n printf(\"Format entier : %d et format caractère : %c.\", lettre, lettre);\r\n return 0;\r\n} ","language":"c","filename":"main.c","terminal":"gcc main.c -o main && ./main\r\nFormat entier : 65 et format caractère A.","terminalLanguage":"bash"}]},{"id":"6a398588e653ab8202f58081","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$2a"},{"id":"6a398651e653ab8202f58082","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"info","title":"Allignement du texte","bodyHtml":"

Le texte est aligné automatiquement à droite, alors lorsque la variable s’affiche sur plus de caractère, le nombre fournit est ignoré.

"},{"id":"6a3986ace653ab8202f58083","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a3986b4e653ab8202f58084","blockType":"contentColumns","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"plain","sizingMode":"percent","layout":"2-equal","gap":"1rem","alignItems":"start","columns":[{"widthPercent":null,"blocks":[{"id":"6a3986c1e653ab8202f58087","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Allignement à droite"},{"id":"6a3986eee653ab8202f58089","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 4;\r\n printf(\"Le nombre n vaut %6d et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"droite.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 4;\r\n printf(\"Le nombre n vaut %6d et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"droite.c","terminal":"Le nombre n vaut 4 et voilà.","terminalLanguage":"bash"}],"contentHtml":null},{"widthPercent":null,"blocks":[{"id":"6a3986dae653ab8202f58088","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Allignement à gauche"},{"id":"6a39870ee653ab8202f5808b","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 4;\r\n printf(\"Le nombre n vaut %-6d et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"gauche.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 4;\r\n printf(\"Le nombre n vaut %-6d et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"gauche.c","terminal":"Le nombre n vaut 4 et voilà.","terminalLanguage":"bash"}],"contentHtml":null}]}]},{"id":"6a398733e653ab8202f5808d","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

On peut ajouter deux nombres séparés par un point . très utilise sur les réels pour spécifier sur combien de caractère il est affiché puis sa précision.

"},{"id":"6a398742e653ab8202f5808e","blockType":"courseExample","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"","bodyHtml":null,"blocks":[{"id":"6a398751e653ab8202f5808f","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

On souhaite afficher le nombre sur caractères avec une précision après la virgule de 2 chiffres significatifs.

"},{"id":"6a39876ce653ab8202f58090","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 12.874;\r\n printf(\"Le nombre n vaut %10.2lf et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"size_precision.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#include \r\n \r\nint main()\r\n{\r\n int n = 12.874;\r\n printf(\"Le nombre n vaut %10.2lf et voilà.\", n);\r\n return 0;\r\n}","language":"c","filename":"size_precision.c","terminal":"Le nombre n vaut 12.87 et voilà.","terminalLanguage":"bash"}]},{"id":"6a39879de653ab8202f58092","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"$2b"},{"id":"6a3aad532ccd0f54e3492016","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h3","text":"Les constantes"},{"id":"6a3aad732ccd0f54e3492017","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Généralités"},{"id":"6a3aad822ccd0f54e3492018","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

En C une constante représente une donnée dont la valeur ne peux pas changer après sa définition. Contrairement aux variables, les constantes garantissent que leur valeur ne changera pas tout au long du programme. Il existe deux manières de déclarer des constantes :

Avec le mot clé constAvec la directive préprocesseur #define

On utilise les constantes pour une meilleure lisibilité, maintenabilité du code et sécurité puisqu’elle empêche la modification de la valeur.

"},{"id":"6a3aadac2ccd0f54e3492019","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h4","text":"Définir une constante"},{"id":"6a3aadba2ccd0f54e349201a","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h5","text":"En utilisant le mot clé const"},{"id":"6a3aadcf2ccd0f54e349201b","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"const int TEINTE = 14;\r\nTEINTE = 130; // Erreur : on ne peut pas modifier une constante","language":"c","filename":"constante.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"const int TEINTE = 14;\r\nTEINTE = 130; // Erreur : on ne peut pas modifier une constante","language":"c","filename":"constante.c"},{"id":"6a3aae0f2ccd0f54e3492020","blockType":"contentColumns","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"plain","sizingMode":"percent","layout":"2-equal","gap":"1rem","alignItems":"center","columns":[{"widthPercent":null,"blocks":[{"id":"6a3aae1f2ccd0f54e3492023","blockType":"contentCallout","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"variant":"remark","title":"","bodyHtml":"

Toute modification impliquera une erreur de compilationLa constante doit être initialisée pendant sa déclaration

"}],"contentHtml":null},{"widthPercent":null,"blocks":[{"id":"6a3aae252ccd0f54e3492024","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"const int VITESSE;\r\nVITESSE = 140; // Erreur à la compilation","language":"c","filename":"constante.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"const int VITESSE;\r\nVITESSE = 140; // Erreur à la compilation","language":"c","filename":"constante.c"}],"contentHtml":null}]},{"id":"6a3aae522ccd0f54e3492026","blockType":"contentHeading","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"eyebrow":"","level":"h5","text":"En utilisant #define"},{"id":"6a3aae622ccd0f54e3492027","blockType":"contentCode","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"files":[{"code":"#define PI 3.14159","language":"c","filename":"define.c","meta":{"highlightLines":[],"focusedLineNumbers":[],"addedLineNumbers":[],"removedLineNumbers":[],"showLineNumbers":false,"wordWrap":false,"maxLines":10,"notes":[],"folds":[],"backgrounds":[],"inline":[]}}],"code":"#define PI 3.14159","language":"c","filename":"define.c"},{"id":"6a3aae772ccd0f54e3492029","blockType":"contentRichText","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"contentHtml":"

Dans notre exemple PI est une constante symbolique.Le préprocesseur remplace chaque occurrence de PI par 3.14159 dans le programme.Pas de type directement associé (attention aux erreurs)

"},{"id":"9cad0000000000cc00000001","blockType":"contentBox","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"fond":"accent","bordure":"barre","rayon":"md","ombre":"aucune","remplissage":"md","image":null,"blockName":null,"blocks":[{"id":"9cad0000000000cc00000002","blockType":"courseKeyPoints","presentation":{"largeur":"normale","alignement":"gauche","margeHaut":"defaut","margeBas":"defaut","theme":"auto","animation":"aucune"},"title":"Pièges classiques à retenir","items":[{"pointHtml":"

Oublier return 0; dans main, ou utiliser une fonction avant de l'avoir déclarée (pas de prototype).

"},{"pointHtml":"

Confondre %d, %c, %f dans printf/scanf : le format doit correspondre exactement au type de la variable.

"},{"pointHtml":"

Comparer un flottant à une valeur exacte avec == : les arrondis binaires rendent la comparaison peu fiable.

"},{"pointHtml":"

Caster sans réfléchir à la perte de précision ((int) sur un flottant tronque, il n'arrondit pas).

"}]}]}],"children":"$L2c"}]]}]