Lorsqu'un programme en C est compilé puis exécuté, les arguments fournis après le nom du programme dans la ligne de commande correspondent aux paramètres du main déclarés de la manière suivante :
int main(int argc, char *argv[])
Dans cette déclaration, argc correspond au nombre total d'arguments passes (nom de commande inclus) et argv est un tableau de chaines de caractères contenant tous les arguments sous forme textuelle.
A titre d'exemple, le programme suivant affiche tous les arguments qui lui sont passés en ligne de commande (dont son propre nom).
#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
for (i=0; i<argc; i++)
printf("%s\n",argv[i]);
return 0;
}
essayez ce programme de la façon suivante :
Lors de son exécution, un programme peut accéder aux variables d'environnements héritées de son processus père. Pour cela, il existe une version un peu plus longue du main :
int main(int argc, char *argv[], char *envp[])où envp contient les valeurs des variables d'environnement. Malheureusement, bien que largement répandue, cette solution n'est pas au standard POSIX et ne permet pas au processus qui l'utilise de modifier son environnement. Une meilleure solution est d'utiliser les fonctions getenv, setenv et putenv en conjonction avec la variable environ. Questions :
Le systeme défini un ensemble de fonctions pour lire le texte saisi et/ou écrire à l'écran. Ces fonctions sont déclarées dans stdio.h qu'il faut donc inclure au début de tout programme désirant les utiliser :
#include <stdio.h>Fonctions simples :
int putchar(int c); int getchar(void);renvoient EOF sur fin de fichier (=fin du texte) ou erreur. Attention : la valeur renvoyée par ces fonctions est bien de type int. Lorsque getchar lit un caractère ordinaire, seul l'octet de poids faible de cet entier est non nul (il peut donc être convertit en char sans problèmes). En revanche une fin de fichier est indiquée par EOF qui est un valeur entière qui est codée sur plus d'un octet.
int puts(const char *s); char *gets(char *s);renvoient EOF (puts) ou NULL (gets) sur erreur. Attention : ceci est montré pour la culture, ne JAMAIS utiliser gets qui ne permet pas de limiter le nombre de caractères écrits en mémoire lors de la lecture. Ceci peut constituer un trou de sécurite dans un programme en permettant une attaque dite par "buffer overflow".
les fameux printf et scanf
int printf(const char *format, ...); int scanf(const char *format, ...);Les fonctions printf et scanf ont un nombre d'arguments variable. Le premier argument, qui est nécessaire, est le format qui décrit la façon dont les choses vont être lues ou écrites. Il comporte des caractères constants à afficher ou à lire tels quels et des spécifications de conversion (qui commancent par %) qui indiquent comment interpréter les arguments suivants.
Specifications de format les plus usuelles :
| %d | un entier en notation decimale |
|---|---|
| %o, %x | un entier en notation octale ou hexadecimale |
| %c | un caractere |
| %s | une chaine de caracteres |
| %f, %e ou %g | un flottant en ecriture normale, scientifique ou la plus appropriee |
Modificateurs (a placer entre le % et la lettre) :
| nombre | nombre de caractere minimal sur lequel lire/ecrire |
|---|---|
| l | indique un argument long (long int ou bien double) |
| h | indique un argument court (short int) |
Quelques remarques :
Arguments : il viennent dans l'ordre des specifications juste apres le format. Pour scanf, ils sont precedes de & (passage par adresse).
exemples:
printf("Bonjour\n"); /* que des constantes */
printf("Un entier %d, un caractere %c, un flottant %g et une chaine %s",
10,'a',3.0,"\n");
int i;
char c;
long int mon_entier;
double un_flottant;
scanf("%d %c %ld %lg ",&i,&c,&mon_entier,&un_flottant);
printf("Un entier %10d, un caractere %c, un entier long %ld, un flottant %lg\n",
i,c,mon_entier,un_flottant);
printf("Plusieurs fois le meme : %d %d %d ... et une derniere %d\n",i,i,i,i);
Questions :
Un système de fichiers est un outil fourni par le système. Il met à la disposition de l'utilisateur un moyen de stocker un document ou de facon générale un élément d'information. On peut y lire ou y écrire (pour simplifier, on ne fera pas les deux en meme temps).
Principes de tout systeme de fichier :FILE *fopen(const char *path, const char *mode);ouvre un fichier de nom path selon le mode indique : "r" pour lecture et "w" pour ecriture. Retourne le flux correspondant ou NULL sur erreur.
int feof(FILE *stream);vrai si la fin du flux stream a été atteinte (suite à l'echec d'une lecture précédente).
int fclose(FILE *stream);ferme le flux stream (valeur de retour indique si une erreur s'est produite).
int fputc(int c, FILE *stream);
int fgetc(FILE *stream);
int fputs(const char *s, FILE *stream);
char *fgets(char *s, int size, FILE *stream);
/* celle ci est sure contrairement a gets (grace a size) */
int fprintf(FILE *stream, const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
Flux deja ouverts par defaut :
| stdin | clavier (ouvert en lecture) |
|---|---|
| stdout | ecran (ouvert en ecriture) |
| stderr | ecran (ouvert en ecriture, reserve a l'affichage des messages d'erreur) |
Exemple : programme qui lit un fichier appelé TD4.html et en affiche le contenu :
#include <stdio.h>
#include <stdlib.h> /* pour exit */
int main()
{
FILE *fichier;
char c;
fichier = fopen("TD4.html","r");
if (fichier == NULL)
{
fprintf(stderr,"Erreur d'ouverture du fichier\n");
exit(1);
}
fscanf(fichier,"%c",&c);
while (!feof(fichier))
{
printf("%c",c);
fscanf(fichier,"%c",&c);
}
fclose(fichier);
return 0;
}
Questions :