HCB full linux coding!!
TOUS LES CODES SOURCES ONT ETE COMPILE AVEC CC !!! (suse 6.4)
Langage C Lexique
Index: Les données numériques
Les opérateurs mathématiques
Les opérateurs logiques
Les opérateurs composés
Les constantes caractères
Les sorties formatées
La librairie standart <stdio.h> :
ASPRINTF
CLEARERR
CTERMID
CUSERID
DBPRINTF
FCLOSE
FCLOSEALL
FEOF
FERROR
FFLUSH
FGETC
FGETPOS
FGETS
FILENO
FLOCKFILE
FOPEN
FPRINTF
FPUTC
FPUTS
FREAD
FREOPEN
FSCANF
FSEEK
FSEEKO
FSETPOS
FTELL
FTELLO
FTRYLOCKFILE
FUNLOCKFILE
FWRITE
GETC
GETCHAR
GETDELIM
GETLINE
GETS
GETW
PCLOSE
PERROR
POPEN
PRINTF
PUTS
PUTC
PUTCHAR
PUTW
REMOVE
RENAME
REWIND
SCANF
SNPRINTF
STDERR
STDIN
STDOUT
TMPMAN
UNGETC
VASPRINTF
VDPRINTF
VFPRINTF
VSCANF
VSNPRINTF
Incrémentation ++ et décrémentation --
ARGC et ARGV
Liste des mots clé réservés
Classement des fonctions standart avec les includes
Classement des fonctions les plus utilisée de STDIO.H
Les donnees numériques
Type de variable Fonction Octects Valeurs
=================================================================================
caractère char 1 - 128 à 127
entier int 2 - 32768 à 32767
entier court short 2 - 32768 à 32767
entier long long 4 - 2147483648 à 2147483647
caractère non signé unsigned char 1 0 à 255
entier non signé unsigned int 2 0 à 65535
entier court non signé unsigned short 2 0 à 65535
entier long non signé unsigned long 4 0 à 4294967295
virgule flotante float 4 1,2E-38 à 3,4E38
virgule flotante double 8 2,2E-308 à 1,8E308
virgule flotante long double 12
Les opérateur mathématique
+ adition
- soustraction
* multiplication
/ division
% modulo
++ incrémentation ajoute 1
-- décrémentation enleve 1
Les opérateurs de comparaisons
== égal
> supérieur à
< inférieur à
>= supérieur ou égal
<= inférieur ou égal
!= différent de
Les opérateurs logiques
&& et
|| ou
! non
Les opérateurs composés
+= addition composée x = x + y
-= soustraction composée x = x - y
*= multiplication composée x = x * y
/= division composée x = x / y
%= modulo composé x = x % y
<< décalage à gauche
>> décalage à droite
[] indexation
() appel de fonction
Les constantes caractères
\\ caractère \ (\134)
\' caractere ' (apostrophe)
\" caractère " guillemet)
\b backspace
\f formfeed
\n linefeed
\r return
\a bell
\t tabulation
Les sorties formatées
%c pour l'impression des caractères
%d pour l'impression des nombres
%i pour l'impression des nombres
%x affichage d'un entier
%o affichage d'un entier en notation octale
%u affichage d'un entier en notation décimale
%s pour recopier une chaine de caracter avec char, ou l'argv[0]
%f impression d'un nombre avec FLOAT
%g imprime les nombres utilisant des exposants inférieur à 3
La librairie standart <stdio.h>
Que choisir entre VOID et INT?
Seul la fin du programme de la fonction principal main() change.
Quand on la déclare en VOID le code se termine par return;
et par exit; quand on déclare main en int:
int main(int argc,char *argv[])
{
exit;
}
* Avec int main on ne peut plus utiliser le type void();
* Une différence d'utilisation pour perror et herror
Fonction FOPEN, FCLOSE
FOPEN permet de créér des fichiers textes avec de différents modes:
r Ouverture du fichier en mode lecture. Renvoie un NULL si il existe pas
w Ouverture du fichier en mode écriture. Si le fichier existe pas il est créé automatiquement
a Mode de mise à jour.Le fichier est créé si il existe pas.Ajoute les informations dans le fichier
déjà existant à la suite du texte enregistré.
b Ecriture en mode binaire.
r+ Mode lecture et écriture.Le fichier est créé si il existe pas,les informations sont écrasés si l'on
fais des enregistrements avec ce mode.
w+ pareil que r+
a+ pareil que a
#include <stdio.h>
main()
{
FILE *fp;
char filename[10],mode[6];
while(1)
{
printf("\Nom du fichier à créér: ");
gets(filename);
printf("Entrez le mode d'ouverture: ");
gets(mode);
if ((fp = fopen(filename, mode)) != NULL)
{
fclose(fp);
return;
}
}
}
Fonction FPUTC
Fonctionne comme PUTCHAR sauf que l'on doit utiliser STDOUT
#include <stdio.h>
void main()
{
int count;
for (count = 14; < 128;)
fputc(count++,stdout);
}
Fonction FREAD
FREAD est utilisé pour lire les donnéés d'un fichier écrite avec la fonction FWRITE.
#include <stdio.h>
#define SIZE 20
void main()
{
int count, myfile[SIZE];
FILE *fp
for (count = 0; count < SIZE; count++)
myfile[SIZE] = 1 * count;
if ((fp = fopen("http://frenchezines.free.fr/tries/hcbhs/test.txt", "rb")) == NULL)
{
fprintf(stderr, "error can't open");
exit(1);
}
if ((fread(myfile, sizeof(int), SIZE, fp) != SIZE)
{
fprintf(stderr, "error can't write");
exit(1);
}
fclose(fp);
}
Fonction FWRITE
FWRITE permet de pouvoir enregistrer du texte, dans un fichier qu'il créé à son ouverture.
#include <stdio.h>
#define SIZE 20
void main()
{
int count, myfile[SIZE];
FILE *fp
for (count = 0; count < SIZE; count++)
myfile[SIZE] = 1 * count;
if ((fp = fopen("http://frenchezines.free.fr/tries/hcbhs/test.txt", "wb")) == NULL)
{
fprintf(stderr, "error can't open");
exit(1);
}
if ((fwrite(myfile, sizeof(int), SIZE, fp) != SIZE)
{
fprintf(stderr, "error can't write");
exit(1);
}
fclose(fp);
}
Fonction GETS
Cette fonction a pour but de lire une chaîne tapée au clavier et ensuite de pouvoir
la recopier à l'aide de la sortie formatée %s.
#include <stdio.h>
void main()
{
char mytext[30];
puts("tapez votre texte (max 30): ");
gets(mytext);
printf("%s\n",mytext);
}
Fonction GETCHAR et PUTCHAR
Meme fonction que GETS sauf que le texte est recopié avec PUTCHAR.
Traduction de while: tant que on n'est pas pressé entrée alors on recopier le texte
#include
void main()
{
int ch;
while ((ch = getchar()) != '\n')
putchar(ch);
return;
}
PRINTF et FPRINTF
FPRINTF et PRINTF les célébres hello world, on ne peut les oublier...
#include <stdio.h>
void main()
{
printf("hello world\n");
fprintf("hello world\n");
}
Fonction PUTCHAR
#include <stdio.h>
void main()
{
int count;
for (count = 14; count < 128)
putchar(count++);
}
La fonction PUTS
La fonction PUTS[] elle aussi permet d'afficher du texte mais cette fois sous forme de
messages initialisé dans un type CHAR.
#include <stdio.h>
void main(){
char *mess[] = { "hi", "and" , "welcome", "to", "asmbeginer" };
int x;
for (x=0; x<5; x++)
puts(mess[x]);
return;
}
Pour les commentaires sur la boucle for:
* Pour x = 0 ; x inferieur à 5; on continue à l'infinie
* et on imprime le texte mess
La fonction PUTC
PUTC correspond à PUTCHAR sous windows et à la même fonction que PUTS.
* Voir FPTUC, remplacer fptuc(count++,stdout); par putc(count++,stdout); .
La fonction REMOVE
REMOVE sert a renomer un fichier à l'aide d'une variable.
#include <stdio.h>
void main()
{
char myfile[10]; /* taille du fichier de dix caracteres maximum */
printf("Nom du fichier: ");
gets(myfile);
if (remove(myfile) == 0)
printf("le fichier %s à été supprimé\n",myfile);
else
fprintf(stderr, "Erreur fichier non trouvé %s\n"; myfile);
}
La fonction RENAME
RENAME sert à renomer un fichier à l'aide de deux variables.
#include <stdio.h>
void main()
{
char myfile[10], newfile[10];
printf("nom du fichier actuel: ");
gets(myfile);
printf("Nouveau nom: ');
gets(newfile);
if (rename(myfile, newfile) == 0)
printf("%s renomé: %s", myfile,newfile);
else
fprintf(stderr, "erreur lors du changement de nom :%s", myfile);
}
La fonction REWIND et FTELL
FTELL sert à lire la position d'un caractere dans un texte ou une mémoire.
REWIND sert à remettre à zéro cette mémoire
Le programme qui suit créé un fichier texte du nom de essai.txt, et y inscrit les lettres de l'alphabet.
A l'aide d'un buffer appelé BUFLEN 6, nous permettra avec la fonction FTELL d'afficher les lettres
de 5 en 5.Le programme va afficher les résultats suivants:
abcde position 5 , fghhi positon 10 , appel de rewind() abcde position 5
#include <stdio.h>
#define BUFLEN 6
void main()
{
char msg[] = "abcdefghijklmnopqrstuvwxyz";
FILE *fp;
char buf[BUFLEN];
if ((fp = fopen("essai.txt", "w")) == NULL)
{
fprintf(stderr, "error can't open");
exit(1);
}
if (fputs(msg, fp) == EOF)
{
fprintf(stderr, "error can't write in this file");
exit(1);
}
fclose(fp);
if ((fp = fopen("essai.txt", "r")) == NULL)
{
fprintf(stderr, "error can't open");
exit(1);
}
printf("\n position = %ld", ftell(fp));
fgets(buf, BUFLEN, fp);
printf("\n\n%s position: %ld\n", buf, ftell(fp));
fgets(buf,BUFLEN, fp);
printf("\n %s , position : %ld", buf, ftell(fp));
rewind(fp); /* remise à zéro */
printf(" positon %ld", ftel(fp));
}
La fonction SCANF
#include <stdio.h>
#define QUIT 2
main()
{
int choix = 0;
while(choix != QUIT)
{
choix = mymenu();
if (choix ==1)
{
system("clear");
puts("hello");
}
}
}
int mymenu()
{
int lecture = 0;
do
{
puts("1 - afficher le texte");
puts("2 - sortir");
scanf("%d", &lecture);
}while (lecture < 1 || lecture > 2);
return lecture;
}
* SCANF dans cette fonction a pour rôle de "scanner" le choix des saisies.
* Si vous aviez utilisé un void mymenu() il aurait fallu remplacer return lecture; par exit lecture;.
* On aurait pu aussi mettre PRINTF à la place de PUTS.
La fonction TMPNAM
TMPNAM est utilisé pour la création de fichier temporaire dans le répertoire /tmp.
#include <stdio.h>
void main()
{
char buffer[10], *c;
tmpnam(buffer);
c = tmpnam(NULL);
printf(" %s\n", buffer);
printf(" %s", c);
}
Utilisation des incrémentations ++ et décrémentations --
Ce programme affiche les résultats suivants:
987654 123456
876543 234567
765432 345678
654321 456789
543210 56789
#include <stdio.h>
void main()
{
int a,b,c,d,e,f,g,h,i,j,k,l;
a = 10;
b = 9;
c = 8;
d = 7;
e = 6;
f = 5;
g = 1;
h = 2;
i = 3;
j = 4;
k = 5;
l = 6;
system("clear");
printf("\n %d%d%d%d%d%d %d%d%d%d%d%d", --a, --b, --c, --d, --e, --f, g++,h++,i++,j++,k++,l++);
printf("\n %d%d%d%d%d%d %d%d%d%d%d%d", --a, --b, --c, --d, --e, --f, g++,h++,i++,j++,k++,l++);
printf("\n %d%d%d%d%d%d %d%d%d%d%d%d", --a, --b, --c, --d, --e, --f, g++,h++,i++,j++,k++,l++);
printf("\n %d%d%d%d%d%d %d%d%d%d%d%d", --a, --b, --c, --d, --e, --f, g++,h++,i++,j++,k++,l++);
printf("\n %d%d%d%d%d%d %d%d%d%d%d", --a, --b, --c, --d, --e, --f, g++,h++,i++,j++,k++,l++);
printf("\n");
return;
}
ARGV et ARGC
Les arguments sont des valeurs que l'on utilise pour diverse fonction que l 'on definie sois meme
dans notre code (ARGC) et son renvoyer par une valeur: ARGV.
ARGC=1 ARGC=2
shema: ./myprog 127.0.0.1 80
ARGV[0] ARGV[1] ARGV[2]
./argc k 1 argument
./argc k k 2 arguments
./argc k k k 3 arguments
./argc k k k k 4 arguments
./argc k k k k k 5 arguments
./argc k k k k k k 6 arguments
La fonction ARGC , toujours à déclarer en entier INT et ARGV à déclarer en CHAR au début du code pour
l'affichage des caractères.
En voici un usage simple de son utilisation:
#include <stdio.h>
void main(int argc, char *argv[])
{
}
Ici argc et argv sont donc déclarés dans la fonction d'appel main(),mais rien nous empêche de le placer
de la façon suivante:
void main()
{
int argc;
char *argv[];
}
Exemple avec six arguments: arg.c
Compilation : cc -o arg arg.c
#include <stdio.h>
void main(int argc,char *argv[])
{
if (argc>6) {
printf(" pas assez d'argument\n");
return;
}
if (argc !=1) {
printf("ok\n");
}
if (argc !=2) {
printf(" gnagna \n");
exit(0);
}
if (argc !=3) {
printf(" hello\n");
exit(0);
}
if (argc !=4) {
printf(" coucou\n");
exit(0);
}
if (argc !=5) {
printf(" grouik\n");
exit(0);
}
}
Listing des mots réservés par le compilateur
asm fais appel aux macros assembleur
auto stockage par defaut
break permet de sortir d'une instruction for , while, switch , do while
case * fonction switch, gere les branchement
char pour l'affichage des caractères
const empêche la modification d'une variable
continue redémare les boucle for, do while ..
default Affiche du texte par defaut, dans la fonction SWITCH
do fonction FAIRE.. s'utilise avec la boucle WHILE (while(1) do .. tant que, on fait..)
double * voir opérateur
else s'utilise avec l'instruction IF peut se traduire par: ALORS
enum est utilisé pour recevoir des donnéés précises
extern est utilisé pour déclarer des variables dans une include ou autre source
float * voir opérateur
for permet de "boucler" une fonction
goto permet de sauter d'une boucler à l'autre avec un "label"
if répète une instruction tant qu'une condition est vraie ou fausse
int gére les valeurs entières
long * voir donnéés numérique
register gére le stockage d'une mémoire dans un registre
return fonction de sortie ( exit)
short même fonction que int
signed peut recevoir des valeurs positives ou négatives
sizeof renvoie la taille d'un nombre (octet)
static utiliser pour regrouper des variables de type différents
struct mot permettant de regrouper plusieurs variables
switch pour la gestion de "choix multiple"
typedef permet de créér un "synonymes" pour une variable ou fonction
union sert à gérer l'espace mémoire des variables
unsigned Cet attribut ne peut contenir que des valeurs positives
void mot clé servant à gérer les fonctions d'appel du code
volatile Attribut signifiant qu'une variable peut être modifiée
while Boucle d'instruction qui provoque une répétition d'un code jusqua ce qu'une condition soit vraie.
Classement des fonctions les plus utilisées de <stdio.h>
clearerr void clearerr
fclose int fclose
fcloseall int fcloseall
feof int feof
flush int flush
fgetc int fgetc
fgetpos int fgetpos
fgets char *fgets
fopen FILE *fopen
fprintf int fprintf
fputc int fputc
fputs int fputs
fread size_t fread
freopen FILE *freopen
fseek int fseek
sprintf int sprintf
tmpfile FILE *tmpfile
tmpnam char *tmpnam
ungetc int ungetc
vprintf int vprintf
vsprintf int fsprintf
Listing des fonctions standart /usr/include
alarm <unistd.h>
asctime <time.h>
atexit <stdlib.h>
calloc <stdlib.h>
catclose <nl_types.h>
catgets <ltnl_types.h>
catopen <ltnl_types.h>
cfgetispeed <termios.h>
cfgetopseed <termios.h>
cfsetispeed <termios.h>
cfsetospeed <termios.h>
chdir <unistd.h>
chmod <sys/stat.h>
chown <unistd.h>
close <unistd.h>
closedir <dirent.h>
creat <sys/types.h>
<sys/stat.h>
<fcntl.h>
*nécéssite les 3 includes
ctime <time.h>
dup <unistd.h>
dup2 <unistd.h>
execl <stio.h>
execle <stdio.h>
execlp <stdio.h>
execv <stdio.h>
execve <stdio.h>
execvp <stdio.h>
exit <stdlib.h>
fchmod <sys/stat.h>
fchown <sys/stat.h>
fclose <stdio.h>
fcntl <sys/types.h>
<unistd.h>
<fcntl.h>
fdopen <stdio.h>
fflush <stdio.h>
fgets <stdio.h>
fileno <stdio.h>
fopen <stdio.h>
fork <unistd.h>
fprintf <stdio.h>
fputc <stdio.h>
fputs <stdio.h>
fread <stdio.h>
free <stdlib.h>
freopen <stdio.h>
fscanf <stdio.h>
fseek <stdio.h>
fstat <sys/types.h>
<sys/stat.h>
fwrite <stdio.h>
getcwd <unistd.h>
getegid <unistd.h>
getenv <unistd.h>
getgid <unistd.h>
getpgrp <unistd.h>
getpid <unistd.h>
getppid <unistd.h>
getpwnam <unistd.h>
getpwuid <unistd.h>
gets <stdio.h>
getuid <unistd.h>
gmtime <time.h>
isatty <unistd.h>
kill à déclarer en INT
link <unistd.h>
lseek <unistd.h>
malloc <stdlib.h>
memchr <string.h>
memcmp <string.h>
memcpy <string.h>
memmove <string.h>
memset <string.h>
mkdir <sys/types.h>
mkfifo <sys/types.h>
<sys/stat.h>
open <sys/types.h>
<sys/stat.h>
int open()
opendir <dirent.h>
pause <unistd.h>
int pause()
perror gestion des erreurs
pipe <unistd.h>
putc <stdio.h>
raise * INT
rand <stdlib.h>
read <unistd.h>
readdir <dirent.h>
realloc <stdlib.h>
rename <unistd.h>
rmdir <unistd.h>
setbuf <stdio.h>
setgid <unistd.h>
setlocale <locale.h>
setsid <unistd.h>
setvbuf <stdio.h>
sigaction <signal.h>
sigaddset <signal.h>
sigdelset <signal.h>
sigemptyset <signal.h>
sigfillset <signal.h>
sigismember <signal.h>
siglongjmp <signal.h>
signal <signal.h>
sigsetjmp <signal.h>
sigsuspend <signal.h>
sprintf <stdio.h>
srand <stdlib.h>
sscanf <stdio.h>
stat <sys/types.h>
<sys/stat.h>
srtcat <string.h>
srtchr <string.h>
strcmp <string.h>
strcpy <string.h>
strcspn <string.h>
strncmp <string.h>
strncpy <string.h>
strpbrk <string.h>
strchr <string.h>
strspn <string.h>
strstr <string.h>
system <stdlib.h>
tcdrain <termios.h>
tcflush <termios.h>
tcgetattr <termios.h>
time <time.h>
times <sys/times.h>
tmpfile <stdio.h>
tmpnam <stdio.h>
ttyname <unistd.h>
ulimit <ulimit.h>
umask <sys/stat.h>
ungetc <stdio.h>
unlink <unistd.h>
wait <sys/types.h>
<sys/wait.h>
waitpid <sys/wait.h>
write <unistd.h>