C-III [52-68]

C-III : sommaire

C-III 1

Fonctions

C-III 2

Définition

En-tête :	[classe_alloc] type_retour ident (params)
Corps :	{
	déclaration_des_variables_locales
	liste_d'instructions
	}

Remarques :

- Pas d'imbrication de déclarations de fonctions.

- Récursivité croisée : déclarer la fonction avant

- Déclaration explicite de la fonction nécessaire avant son utilisation (uniquement en C++).

- Fonction principale (int main()).

C-III 3

Exemples

void hello (void)

{

printf("hello\n");

}

// Calcul de la moyenne

float moyenne (float x, float y)

{

return ((x+y)/2);

}

// Longueur d'une chaîne

int strlen (char s[])

{

int i=0;

while(s[i]!='\0') i++;

return i;

}

C-III 4

Retour d'une fonction

Le type de retour d'une fonction est FACULTATIF.
Attention : le type int est utilisé par défaut.
Le type de retour d'une fonction doit être un type prédéfini (int, double), un type dérivé (int &, int *), un type utilisateur (classe, ...) ou void (à utiliser lorsque la fonction ne retourne rien).
--> tout SAUF des tableaux et des fonctions (dans ces cas là, utiliser des pointeurs).
Instructions de retour :
- return; pour une fonction retournant un void
- return expression ;
  Le résultat de expression doit être du type indiqué comme type de retour.
Sortie d'une fonction (et du programme)
- exit (entier) ;
  --> sortie du programme avec un code de retour correspondant à la valeur entière de l'argument.

C-III 5

Arguments d'une fonction

Arguments avec une valeur par défaut (C++ uniquement).

int g(int i, int j=0, int k=1);

Si un argument a une valeur par défaut, alors tous les suivants doivent aussi avoir une valeur par défaut.

int g(int i, int j=0, int k, int l=1); // Erreur
Nombre variable d'arguments (...).
int plus(int first, ...);
Arguments constants : interdiction de modification des paramètres avec l'utilisation de const.

void essai(const int &a, int&b);

C-III 6

Passage d'arguments par valeur

void echange1(int a, int b)

{

int tmp = a;

a=b;

b = tmp;

}

Appel de echange1 par :

int x,y;

echange1(x, y);

--> L'échange n'a lieu qu'à l'intérieur de echange1.

Le passage d'arguments tableaux, chaînes et fonctions par valeur est impossible : il n'existe pas !!!

C-III 7

Fonction main

Rappel : Tout programme exécutable C ou C++ doit contenir une fonction main.
L'exécution du programme commence par l'exécution de cette fonction.
Sous Unix, le Shell appelle la fonction main avec 3 args :

argc: : nb. d'args du programme.
argv: : les args du programme
argv[0] --> nom du programme
argv[i] --> i-eme argument (1 £i £ argc)
envp: : l'environnement du processus.

Il faut déclarer la fonction main comme : int main(int argc , char *argv[], char *envp[])
ou
int main(int argc , char *argv[])
ou
int main(void)

C-III 8

argc, argv : exemple

// echo.cc

// Version simplifiée du programme echo

int main(int argc , char *argv[])

{

int i;

for(i=1; i<argc; i++) {

printf("%s",argv[i]);

}

putchar('\n');

}

Utilisation :

> echo

> echo hello

hello

> echo a b c

a b c

C-III 9

Structure des programmes

Structure des programmes
Notion de bloc

C-III 10

Structure des programmes

Programme	ÜÞ	ensemble de fichiers (ou ``modules'')
Module	ÜÞ	suite de déclarations
Déclaration	ÜÞ	déclaration de variable ou de fonction

Pour obtenir un programme exécutable : il doit exister une fonction principale de nom main.

C-III 11

Notion de ``bloc''

Bloc : ensemble d'instructions placées entre accolades.

Exemples :

corps d'une fonction;
corps d'une boucle : while (n>1) {...}

Rappels :

``global'' ÜÞ hors de tout bloc;
``local'' ÜÞ dans un bloc.
--> les fonctions sont forcément ``globales'';
--> les variables sont ``globales'' ssi elles sont définies hors de tout bloc, ``locales'' sinon.

C-III 12

Exemple

float v;

globale

float f(float x)

// fonction f : globale

// paramètre x : local à la fonction

{ int i; // locale à la fonction

float v=0.5; // locale à la fonction

for(i=0;i<10;i++) {

float v; // locale au bloc

... // cache la valeur de v=0.5

// ATTENTION Exple purement pédagogique

// A NE PAS REPRODUIRE

}

... // v = 0.5

}

int main(void)

{

f(3.4);

f(v);

}

C-III 13

Portée d'un nom

5 niveaux de portée pour un nom : bloc, fonction, classe, fichier, programme.
Liaison interne à un fichier : l'entité ne peut être désignée que dans le fichier où elle est définie.
- entité globale static,
- fonction globale inline,
- typedef, enum,
- objet const non déclaré extern.
Liaison externe à un fichier : l'entité peut être désignée depuis un autre fichier.
- déclaration extern explicite,
- par défaut, tout objet global non-const, non-static,
- par défaut, toute fonction non-static,
- classe ou structure globale.
--> du côté import, elle doit être déclarée extern.
* Pas de liaison possible lorsque l'entité est locale et ne peut être désignée hors du bloc.

C-III 14

Entrées/Sorties (suite)

Entrées/Sorties formatées.

C-III 15

E/S en C : Spécification des formats

``format'' : chaîne de caractères utilisée dans printf, scanf, ..., constituée de caractères ordinaires et/ou de directives de conversions.
directive de conversion : transformer le contenu d'une variable en une chaîne de caractères.
Elle commence par le caractère '%', suivi :
- d'un indicateur (facultatif) modifiant la signification de la conversion :
  
  - cadrage à gauche
  
  + un signe + ou - sera ajouté
  
  # format alternatif qui combiné à o ajoute un '0' devant le nombre, combiné à x ajoute un 'X', ...
- d'un nombre (facultatif) indiquant la taille minimale du champ concerné,
- du caractère 'l' (facultatif) précisant que le nombre entier est un entier long,

C-III 16

E/S en C : Spécification des formats (suite)

d'un caractère indiquant le format de conversion :

d decimal o octal x hexa u unsigned

c character s string f float ...

Remarque : pour imprimer un % ¾® %%

#include <stdio.h>

int lectecr3 (void) {

char c;

while (scanf("%c",&c)==1) printf("%c",c);

return 0;

}

...

int alpha, m, n;

printf("Entrez la valeur de alpha: ");

scanf("%d", &alpha);

printf("S[%d]=%d, M[%d]=%.2f\n",

n, sum, n, (float) sum / n);

C-III 17

#include <stdio.h>

int main(void)

{

int i = 456;

long int l = 123123123L;

unsigned int ui = 45645U;

unsigned long int ul = 2123123123UL;

double d = 12.678;

printf("En décimal : \n");

printf("i = %d (%%d) l = %ld (%%ld) ui = %u (%%u)\n'', i,l,ui);

printf(``ul = %lu (%%lu) d = %f (%%f) \n", ul, d);

printf("En octal : \n");

printf("ui = %o (%%o) ul = %lo(%%lo) \n", ui, ul);

printf("En hexadécimal : \n");

printf("ui = %X (%%X) ul = %lX (%%lX) \n", ui, ul);

printf("Affichage du signe : \n");

printf(" |% d| (%% d) |%+d| (%%+d) |%d| (%%d)\n", -i, -i, -i);

printf(" |% d| (%% d) |%+d| (%%+d) |%d| (%%d) \n", i, i, i);

printf("Affichage octal, hexadécimal : \n");

printf(" |%x| (%%x) |%#x| (%%#x) backslashn", i, i);

printf(" |%X| (%%X) |%#X| (%%#X) \n", i, i);

printf(" |%o| (%%o) |%#o| (%%#o)\n", i, i);

printf("Affichage des flottants : \n");

printf("|%7.2f| (%%7.2f) |%07.2f| (%%07.2f) |%-7.2f| (%%-7.2f)\n",d,d,d);

}

En décimal : 
i = 456 (%d) l = 123123123 (%ld) ui = 45645 (%u) 
ul = 2123123123 (%lu) d = 12.678000 (%f) 
En octal : 
ui = 131115 (%o) ul = 17643044663(%lo) 
En hexadécimal : 
ui = B24D (%X) ul = 7E8C49B3 (%lX) 
Affichage du signe : 
 |-456| (% d) |-456| (%+d) |-456| (%d) 
 | 456| (% d) |+456| (%+d) |456| (%d) 
Affichage octal, hexadécimal : 
 |1c8| (%x) |0x1c8| (%#x)
 |1C8| (%X) |0X1C8| (%#X)
 |710| (%o) |0710| (%#o)
Affichage des flottants : 
|  12.68| (%7.2f) |0012.68| (%07.2f) |12.68  | (%-7.2f)

-	cadrage à gauche
+	un signe + ou - sera ajouté
#	format alternatif qui combiné à o ajoute un '0' devant le nombre, combiné à x ajoute un 'X', ...

d decimal	o octal	x hexa	u unsigned
c character	s string	f float	...