resume C

Language C

avant propo
pour inclure des variables dans le main	int main(int argc, char *argv[])
pour inclure les fichier de prototype et les bibliothèque	#include <stdio.h>
pour compiler :	cc prog.c [w/W/Werror/Wall/g/o]	execution: a.out
pour compiler en choisissant le nom de l’exécutable	cc –o progprog.c	execution : prog
prérequis	sudo apt-get install libsdl2-2.0-0 libsdl2-dev libsdl2-image-2.0-0 libsdl2-mixer-2.0-0 libsdl2-mixer-dev libsdl2-image-dev	execution : prog

Règles typographiques
opérateur	ecriture	exemple
'	Les caractères	'a' \|\| '2'
" "	chaîne de caractères	"bonjour"
/* */	les commentaires	/* mon commentaire */

opérateur arithmétique
+	Addition	(x + y)
-	Soustraction	(x - y)
*	Multiplication	(x * y)
/	Division	(x / y)
%	Modulo (Restede la division entière)	(x % y)
*	Multiplication	(x * y)
-	Négation	-x
i += 3; i *= j; i /= (j+3)	racourci	i = i + 3; i = i * j; i = i / (j+3);
++i; i = i + 1; ou i++;	incrémentation	change la valeur avant de faire le calcul change la valeur après avoir fait le calcul
--i; i = i + 1; ou i--;	décrémentation	change la valeur avant de faire le calcul change la valeur après avoir fait le calcul
Les Booleen
VRAI	toute valeur différente de 0	a=-2; donne VRAI
FAUX	toute valeur égale à 0	a=0; donne FAUX

expression logique
==	Egalité
!=	Différence
< <= > >=	Inégalité	inférieur inférieur ou égal supérieur supérieur ou égal
!a	le Non logique	si a est égal à 0 alors non a vaux VRAI
a = ((i > 1) && (k <= 3));	le ET	&&
a = ((i > 1) \|\| (k <= 3));	le OU	&&
variable=((a>b)?a:b)	condition?expression1:expression2	si la condition est vérifié l'expression prend la valeur de l'expression1 sinon la 2

opérations binaires
opérateur	ecriture	explication	exemple
<<	a = a << 2 ou a <<= 2	Insère deux 0 à la droite de a le décalage à gauche est une multiplication par 2	(00000101)₂= (5)₁₀ devient (00010100)₂=(20)₁₀
>>	a = a >>2 ou a >>= 2	Insère deux 0 à la gauche de a le décalage à droite est une division par 2	(00000101)₂= (5)₁₀ devient (00000001)₂=(1)₁₀
ET &	a = a & 1; ou a &= 1;	fait un "ET" logique sur la valeur binaire	(00000101)₂ ET (00000001)₂ donne : (00000001)₂=(1)₁₀
OU \|	a = a \| 8; ou a \|= 8;	fait un "OU" logique sur la valeur binaire	(00000101)₂ OU (00001000)₂ donne : (00001101)₂=(13)₁₀
OU exclusif ^	a = a ^ 9; ou a ^= 9;	fait un "OU" logique sur la valeur binaire	(00000101)₂ XOR (00001001)₂ donne : (00001100)₂=(12)₁₀
Negation ~	~a	fait une négation sur la valeur binaire	a=(00000101)₂ ~a donne : (11111010)₂

Lecture/écriture sur ES standard
Affichage sur sortie standard	printf( )	printf(«i= %d, j = %d», i, j);
Saisiede valeursau clavier	scanf()	scanf(«%d», &j);

Les formats
caractère	%c
entiers (%4d: entier sur 4 caractères)	%d
entier octal (précédé d'un «0»)	%o
hexadécimal (précédé de «0x»)	%x
flottant (%.3f: avec 3 nombres aprés la virgule)	%f
flottant en notation exponentielle (ex : 2.5e5)	%e, %E
flottant (%fou %e)	%g
chaîne de caractères	%s
pointeur (une adresse mémoire)	%p
caractère spéciaux dans les chaines de caractères
Retour à la ligne	\n
Tabulation	\t
Retour chariot	\r
Backspace	\b
Sonnerie	\a
Guillemet	\"
Quote	\'
Anti-slash	\\
pourcentage	%%

type de données
Type de donnée	Signification	Taille (en octets)	Plage de valeurs acceptée	exemple
char	Caractère	1	[-128 à 127]	char a='a'; ou char a=65;
unsigned char	Caractère non signé	1	[0 à 255]	char b='b'; ou char b=66;
short int	Entier court	2	-32 768 à 32 767	int a=-2;
unsigned short int	Entier court non signé	2	0 à 65 535	int a=2;
int	Entier	2 (sur processeur 16 bits) 4 (sur processeur 32 bits)	-32 768 à 32 767 [-2 ³¹(-2 147 483 648 ) à 2 ^31-1 (2 147 483 647) ] ;	int a=2;
unsigned int	Entier non signé	2 (sur processeur 16 bits) 4 (sur processeur 32 bits)	0 à 65 535 [0 à 2³²-1 (4 294 967 295)]	int a=2567789;
long int	Entier long	4	-2 147 483 648 à 2 147 483 647	int a=-9825738;
unsigned long int	Entier long non signé	4	0 à 4 294 967 295	int a=28968;
float	Flottant (réel)	4	3.410^-38 à 3.410³⁸[-10³⁰⁸, 10³⁰⁸]	float a=4.89;
double	Flottant double	8	1.710^-308 à 1.710³⁰⁸	float a=4.89;
long double	Flottant double long	10	3.410^-4932 à 3.410⁴⁹³²	float a=4.89;

d'autre type
struct	permet de définir un type	///	struct<nom de la structure>{ les champs};	struct liste_t{ int valeur; struct list_t *next; };
typedef	permet de redéfinir un type	///	typedef<type>,<nouveau type1>,<nouveau type2>	typedef struct liste_t{ int valeur; struct list_t *next; };montype1,montype2

les pointeurs

variable/pointeur

explication

adresse

appel l'adresse de la variable x

108976

int *p;

une variable de type pointeur

par défault contien 1.

p=&t;
*p=(int *)&tab;
*p=tab;

p se trouve désormais à la meme adresse que x

on dit que p pointe sur x

incrémenter un pointeur

opération

avant

après

int* p
p++

adresse	valeur
8000	valeur de l'adresse 8000

adresse	valeur
8004	valeur de l'adresse 8004

char* p
p++

adresse	valeur
8000	valeur de l'adresse 8000

adresse	valeur
8001	valeur de l'adresse 8001

double* p
p++

adresse	valeur
8000	valeur de l'adresse 8000

adresse	valeur
8008	valeur de l'adresse 8008

long double* p
p++

adresse	valeur
8000	valeur de l'adresse 8000

adresse	valeur
8010	valeur de l'adresse 8010

les pointeurs
variable/pointeur	adresse	valeur	explication
int age =10;	177450	10	à l'adresse 177450 on met int 10
age	==>	10	on récupère la valeur
&age	177450	<==	on récupère l'adresse
int *pointeur_sur_age =null	189098	null	on crée un pointeur vide
pointeur_sur_age	==>	0	on récupère la valeur
&pointeur_sur_age	140734429775552	<==	on récupère l'adresse
int *pointeurSurAge = &age;	177450	devient la valeur de age	on attribu au pointeur l'adresse de la variable age
*pointeur_sur_age;	==>	10	on pointe sur l'adresse de la valeur de la variable age

exemples de pointeurs

int t1[3];

on obtient trois int en mémoire

int t1[3] = { 1, 2, 3 };

adresses …	8	12	16	20
données …	0001	0002	0003	...

int *p1;

on obtient un pointeur de int en mémoire.

int *p1 = &t1[0];

adresses …	24	32
données …	00000008	....

int t2[4][3];

on obtient quatre tableaux de trois int, soit douze int en mémoire.

int t2[4][3] = {{1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}};

adresses …	32	36	40	44	48	52	56	60	64	68	72	76	80
données …	0001	0002	0003	0004	0005	0006	0007	0008	0009	0010	0011	0012	...

int **p2;

on obtient un pointeur de pointeur de int en mémoire.

int **p2 = &p1;

adresses …	80	88
données …	00000024	...

int *t3[3];

on obtient trois pointeurs de int en mémoire;

int *t3[3] = { &t1[1], &t2[0][0], &t2[1][2] };

adresses …	88	96	104	112
données …	00000012	00000032	00000052	...

int (*p3)[3];

on obtient un pointeur de tableau de 3 int en mémoire.

int (*p3)[3] = &t2[3];

adresses …	112	120
données …	00000068	...

quelques fonctions
printf(["format"],[donnée]);	afficher	printf("la variable a vaux: %d",a);
scanf(["format"],[donnée]);	récupérer une entrée	scanf("%s",c);
strcat(chaine1,"mot");	concatène deux chaines	strcat(animal,"ot");
strncat(chaine1,chaine2);	concatène la chaine2 avec la chaine1	strncat(chaine1,chaine2);
strnlen(variable);	strlenest une fonction qui calcule la longueur d'une chaîne de caractères (sans compter le caractère\0	strnlen(t);
typedef [type] [nouveau-type];	permet de changer l'expression d'un type (à placer avant les variable globales)	typedef int entier; entier i,j=2;
strcpy(animal,felin);	copie une chaine dans une autre et complete par des \0	strcpy(animal,"tigre");
strncpy(animal,felin);	copie une chaine dans une autre et complete par des \0 plus sécurisé si dépassement	strncpy(animal,"tigre");
strcmp(animal,felin);	comparre deux chaines de caractères (dans l'ordre lexicographique (attention ne pas utiliser == qui compare les adresses)	if (strcmp(s1,s2)>0){printf("%s est après %s dans le dictionnaire",s1,s2);}else {printf("%s et %s sont identiques",s1,s2) }
strncmp(animal,felin);	comparre deux chaines de caractères et permet de controler la longueur de la comparaison	???
struct	permet de définir une structure constructeur	???
getnlimit()	connaitre la pile	???
sizeof()	connaitre la la taille d'une donnée quelqu'onque	printf("taille d'un entier : %d \n",sizeof(int));
allocation dynamique malloc et free
malloc()	allouer de l'espace en mémoire exemple alloué 1000 place de int en mémoire	p=(int)malloc(1000sizeof(int));
calloc()	allouer de l'espace en mémoire et initialise en plus l'objet pointé	p=(int)malloc(1000sizeof(int));
calloc()	allouer de l'espace en mémoire et initialise en plus l'objet pointé	p=(int)malloc(1000sizeof(int));

les macros
#define IDENTIFIANT chaîne	chaîne est une séquence de caractères Toute occurrence de IDENTIFIANT dans le texte sera emplacé par chaîne	#define PI 3.14159 #Define MSG(F) printf(#F)== MSG(test mess);//printf("test mess");
_FILE_	nom du fichier source courant	printf(``%s a été compilé le %s\n``,__FILE__,__DATE__);
_LINE_	numéro de ligne courant	ex
_TIME_	heure de compilation du fichier courant	ex
_DATE_	date de compilation du fichier courant	printf(``%s a été compilé le %s\n``,__FILE__,__DATE__);

compilation conditionelle

les flux vers et par les fichiers #include < stdio.h >

stdin

fichier standard d’entrée (souvent associé au clavier)

stdout

fichier standard de sortie (souvent l’écran). Les fonctions d’accès associées utilisent une technique de tampon (buffer) pour les écritures qui lui sont associées;

stderr

fichier standard d’erreur. Ce fichier correspond lui aussi le plus souvent à l’écran mais les écritures sont non tamponnées

caractère par caractère

int getchar(void)

lecture d’un caractère
retourne un entier contenant la valeur du caractère lu, ou EOF
en fin de fichier la fonction retourne EOF

int putchar(int)

Permet d’écrire un caractère sur stdout;
Retourne la valeur du caractère écrit (considéré comme un entier).
conditions d’erreur: en cas d’erreur la fonction retourne EOF.

ligne par lignes ( Le caractère de fin de ligne a une valeur entière égale à 10 et est représenté par l’abréviation '\n'. )

char *gets(char *) ;

Permet de lire une ligne sur stdin;

int putchar(char *);

écriture d’une chaîne de caractères, suivie d’un retour chariot sur stdout.

lecture écriture formatée

int scanf(const char *, ...);

lecture formatée sur stdin.

int printf (const char *, ...);

écriture formatée sur stdout.

Fichiers

fopen

mode	lecture	écriture	crée le fichier	vide le fichier	position du flux
r	X				début
r+	X	X			début
w		X	X	X	début
w+	X	X	X	X	début
a		X	X		fin
a+	X	X	X		fin

FILE* fopen(const char* restrict chemin, const char* restrict mode)

fclose

permet de fermer le fichier

int fclose(FILE * flux);

fgetc
getc (macro)

lecture d’un caractère (unsigned char)

int fgetc(FILE*); =>caractère par caractère
char *fgets(char *,int, FILE *); =>ligne par ligne

ungetc

permet de remettre un caractère dans le buffer de lecture associé à un flux d’entrée

int ungetc(int, FILE *); =>caractère par caractère

fputc
putc (macro)

écrit dans le fichier associé décrit par le second argument un caractère spécifié dans le premier argument

int fputc (int, FILE *); =>caractère par caractère
int fputs(constchar *, FILE *); =>ligne par ligne

sdl2	libsdl2-dev
sudo apt-get install libsdl2-2.0-0	pour l'interface graphique
sudo apt-get install libsdl2-dev	pour l'interface graphique
sudo apt-get install libsdl2-image-dev	pour lire les images
sudo apt-get install libsdl2-ttf-2.0-0	pour lire le texte

typedef enum {
/* The keyboard syms have been cleverly chosen to map to ASCII */
SDLK_UNKNOWN = 0,
SDLK_FIRST = 0,
SDLK_BACKSPACE = 8,
SDLK_TAB = 9,
SDLK_CLEAR = 12,
SDLK_RETURN = 13,
SDLK_PAUSE = 19,
SDLK_ESCAPE = 27,
SDLK_SPACE = 32,
SDLK_EXCLAIM = 33,
SDLK_QUOTEDBL = 34,
SDLK_HASH = 35,
SDLK_DOLLAR = 36,
SDLK_AMPERSAND = 38,
SDLK_QUOTE = 39,
SDLK_LEFTPAREN = 40,
SDLK_RIGHTPAREN = 41,
SDLK_ASTERISK = 42,
SDLK_PLUS = 43,
SDLK_COMMA = 44,
SDLK_MINUS = 45,
SDLK_PERIOD = 46,
SDLK_SLASH = 47,
SDLK_0 = 48,
SDLK_1 = 49,
SDLK_2 = 50,
SDLK_3 = 51,
SDLK_4 = 52,
SDLK_5 = 53,
SDLK_6 = 54,
SDLK_7 = 55,
SDLK_8 = 56,
SDLK_9 = 57,
SDLK_COLON = 58,
SDLK_SEMICOLON = 59,
SDLK_LESS = 60,
SDLK_EQUALS = 61,
SDLK_GREATER = 62,
SDLK_QUESTION = 63,
SDLK_AT = 64,
/*
Skip uppercase letters
*/
SDLK_LEFTBRACKET = 91,
SDLK_BACKSLASH = 92,
SDLK_RIGHTBRACKET = 93,
SDLK_CARET = 94,
SDLK_UNDERSCORE = 95,
SDLK_BACKQUOTE = 96,
SDLK_a = 97,
SDLK_b = 98,
SDLK_c = 99,
SDLK_d = 100,
SDLK_e = 101,
SDLK_f = 102,
SDLK_g = 103,
SDLK_h = 104,
SDLK_i = 105,
SDLK_j = 106,
SDLK_k = 107,
SDLK_l = 108,
SDLK_m = 109,
SDLK_n = 110,
SDLK_o = 111,
SDLK_p = 112,
SDLK_q = 113,
SDLK_r = 114,
SDLK_s = 115,
SDLK_t = 116,
SDLK_u = 117,
SDLK_v = 118,
SDLK_w = 119,
SDLK_x = 120,
SDLK_y = 121,
SDLK_z = 122,
SDLK_DELETE = 127,
/* End of ASCII mapped keysyms */

/* International keyboard syms */

SDLK_WORLD_0 = 160, /* 0xA0 */
SDLK_WORLD_1 = 161,
SDLK_WORLD_2 = 162,
SDLK_WORLD_3 = 163,
SDLK_WORLD_4 = 164,
SDLK_WORLD_5 = 165,
SDLK_WORLD_6 = 166,
SDLK_WORLD_7 = 167,
SDLK_WORLD_8 = 168,
SDLK_WORLD_9 = 169,
SDLK_WORLD_10 = 170,
SDLK_WORLD_11 = 171,
SDLK_WORLD_12 = 172,
SDLK_WORLD_13 = 173,
SDLK_WORLD_14 = 174,
SDLK_WORLD_15 = 175,
SDLK_WORLD_16 = 176,
SDLK_WORLD_17 = 177,
SDLK_WORLD_18 = 178,
SDLK_WORLD_19 = 179,
SDLK_WORLD_20 = 180,
SDLK_WORLD_21 = 181,
SDLK_WORLD_22 = 182,
SDLK_WORLD_23 = 183,
SDLK_WORLD_24 = 184,
SDLK_WORLD_25 = 185,
SDLK_WORLD_26 = 186,
SDLK_WORLD_27 = 187,
SDLK_WORLD_28 = 188,
SDLK_WORLD_29 = 189,
SDLK_WORLD_30 = 190,
SDLK_WORLD_31 = 191,
SDLK_WORLD_32 = 192,
SDLK_WORLD_33 = 193,
SDLK_WORLD_34 = 194,
SDLK_WORLD_35 = 195,
SDLK_WORLD_36 = 196,
SDLK_WORLD_37 = 197,
SDLK_WORLD_38 = 198,
SDLK_WORLD_39 = 199,
SDLK_WORLD_40 = 200,
SDLK_WORLD_41 = 201,
SDLK_WORLD_42 = 202,
SDLK_WORLD_43 = 203,
SDLK_WORLD_44 = 204,
SDLK_WORLD_45 = 205,
SDLK_WORLD_46 = 206,
SDLK_WORLD_47 = 207,
SDLK_WORLD_48 = 208,
SDLK_WORLD_49 = 209,
SDLK_WORLD_50 = 210,
SDLK_WORLD_51 = 211,
SDLK_WORLD_52 = 212,
SDLK_WORLD_53 = 213,
SDLK_WORLD_54 = 214,
SDLK_WORLD_55 = 215,
SDLK_WORLD_56 = 216,
SDLK_WORLD_57 = 217,
SDLK_WORLD_58 = 218,
SDLK_WORLD_59 = 219,
SDLK_WORLD_60 = 220,
SDLK_WORLD_61 = 221,
SDLK_WORLD_62 = 222,
SDLK_WORLD_63 = 223,
SDLK_WORLD_64 = 224,
SDLK_WORLD_65 = 225,
SDLK_WORLD_66 = 226,
SDLK_WORLD_67 = 227,
SDLK_WORLD_68 = 228,
SDLK_WORLD_69 = 229,
SDLK_WORLD_70 = 230,
SDLK_WORLD_71 = 231,
SDLK_WORLD_72 = 232,
SDLK_WORLD_73 = 233,
SDLK_WORLD_74 = 234,
SDLK_WORLD_75 = 235,
SDLK_WORLD_76 = 236,
SDLK_WORLD_77 = 237,
SDLK_WORLD_78 = 238,
SDLK_WORLD_79 = 239,
SDLK_WORLD_80 = 240,
SDLK_WORLD_81 = 241,
SDLK_WORLD_82 = 242,
SDLK_WORLD_83 = 243,
SDLK_WORLD_84 = 244,
SDLK_WORLD_85 = 245,
SDLK_WORLD_86 = 246,
SDLK_WORLD_87 = 247,
SDLK_WORLD_88 = 248,
SDLK_WORLD_89 = 249,
SDLK_WORLD_90 = 250,
SDLK_WORLD_91 = 251,
SDLK_WORLD_92 = 252,
SDLK_WORLD_93 = 253,
SDLK_WORLD_94 = 254,
SDLK_WORLD_95 = 255, /* 0xFF */

/* Numeric keypad */

SDLK_KP0 = 256,
SDLK_KP1 = 257,
SDLK_KP2 = 258,
SDLK_KP3 = 259,
SDLK_KP4 = 260,
SDLK_KP5 = 261,
SDLK_KP6 = 262,
SDLK_KP7 = 263,
SDLK_KP8 = 264,
SDLK_KP9 = 265,
SDLK_KP_PERIOD = 266,
SDLK_KP_DIVIDE = 267,
SDLK_KP_MULTIPLY = 268,
SDLK_KP_MINUS = 269,
SDLK_KP_PLUS = 270,
SDLK_KP_ENTER = 271,
SDLK_KP_EQUALS = 272,

/* Arrows + Home/End pad */

SDLK_UP = 273,
SDLK_DOWN = 274,
SDLK_RIGHT = 275,
SDLK_LEFT = 276,
SDLK_INSERT = 277,
SDLK_HOME = 278,
SDLK_END = 279,
SDLK_PAGEUP = 280,
SDLK_PAGEDOWN = 281,

/* Function keys */

SDLK_F1 = 282,
SDLK_F2 = 283,
SDLK_F3 = 284,
SDLK_F4 = 285,
SDLK_F5 = 286,
SDLK_F6 = 287,
SDLK_F7 = 288,
SDLK_F8 = 289,
SDLK_F9 = 290,
SDLK_F10 = 291,
SDLK_F11 = 292,
SDLK_F12 = 293,
SDLK_F13 = 294,
SDLK_F14 = 295,
SDLK_F15 = 296,

/* Key state modifier keys */

SDLK_NUMLOCK = 300,
SDLK_CAPSLOCK = 301,
SDLK_SCROLLOCK = 302,
SDLK_RSHIFT = 303,
SDLK_LSHIFT = 304,
SDLK_RCTRL = 305,
SDLK_LCTRL = 306,
SDLK_RALT = 307,
SDLK_LALT = 308,
SDLK_RMETA = 309,
SDLK_LMETA = 310,
SDLK_LSUPER = 311, /* Left "Windows" key */
SDLK_RSUPER = 312, /* Right "Windows" key */
SDLK_MODE = 313, /* "Alt Gr" key */
SDLK_COMPOSE = 314, /* Multi-key compose key */

/* Miscellaneous function keys */

SDLK_HELP = 315,
SDLK_PRINT = 316,
SDLK_SYSREQ = 317,
SDLK_BREAK = 318,
SDLK_MENU = 319,
SDLK_POWER = 320, /* Power Macintosh power key */
SDLK_EURO = 321, /* Some european keyboards */
SDLK_UNDO = 322, /* Atari keyboard has Undo */
/* Add any other keys here */
SDLK_LAST} SDLKey;

le reseau
#include <winsock2.h> ou #include <winsock.h>	bibliothèque pour les socket
int socket(int domain, int type, int protocol); socket(AF_INET,SOCK_STREAM,0)	int domain
		PF_UNIX, PF_LOCAL	communication locale
		PF_INET	Protocoles Internet IPv4
		PF_INET6	Protocoles Internet IPv6
		PF_IPX	IPX - Protocoles Novell
		PF_NETLINK	Interface utilisateur noyau
		PF_X25	Protocole ITU-T X.25 / ISO-8208
		PF_AX25	Protocole AX.25 radio amateur
		PF_ATMPVC	Accès direct ATM PVCs
		PF_APPLETALK	Appletalk
		PF_PACKET	Interface paquet bas-niveau
	int type
		SOCK_STREAM	Support de dialogue garantissant l'intégrité, fournissant un flux de données binaires, et intégrant un mécanisme pour les transmissions de données hors-bande.
		SOCK_DGRAM	Transmissions sans connexion, non garantie, de datagrammes de longueur maximale fixe.
		SOCK_SEQPACKET	Dialogue garantissant l'intégrité, pour le transport de datagrammes de longueur fixe. Le lecteur doit lire le paquet de données complet à chaque appel système récupérant l'entrée.
		SOCK_RAW	Accès direct aux données réseau.
		SOCK_RDM	Transmission fiable de datagrammes, sans garantie de l'ordre de délivrance.
		SOCK_PACKET	Obsolète, à ne pas utiliser dans les programmes actuels
	int protocol	cat /etc/protocols Le protocole à utiliser sur la socket est indiqué par l'argument protocol. Normalement, il n'y a qu'un seul protocole par type de socket pour une famille donnée, auquel cas l'argument protocol peut être nul. Néanmoins, rien ne s'oppose à ce que plusieurs protocoles existent, auquel cas il est nécessaire de le spécifier. Le numéro de protocole dépend du domaine de communication de la socket.
	ERREURS
		EACCES	La création d'une telle socket n'est pas autorisée.
		EAFNOSUPPORT	L'implémentation ne supporte pas la famille d'adresses indiquée.
		EINVAL	Protocole inconnu, ou famille de protocole inexistante.
		EMFILE	La table des fichiers est pleine.
		ENFILE	La limite du nombre total de fichiers ouverts sur le système a été atteinte.
		ENOBUFS ou ENOMEM	Pas suffisamment d'espace pour allouer les tampons nécessaires. La socket ne peut être créée tant que suffisamment de ressources ne seront pas libérées.
		EPROTONOSUPPORT	Le type de protocole, ou le protocole lui-même n'est pas disponible dans ce domaine de communication.
int bind(int sockDesc, struct sockaddr* adSock,size_t tailleAd)
	sockDesc	descripteur de la socket à attacher.
	adSock	structure qui contient les éléments de l’adresse externe.
	tailleAd	taille en octets de adSock, sizeof(adSock)
struct hostent* gethostbyname(char* nomMachine)	Alloue et renvoie l’adresse d’une structure de type struct hostent. On peut ensuite adresser le paquet sur le réseau.
	struct hostent{ char* h_name; /* nom canonique de la machine / char* h_aliases; /* tableau des autres nom d’alias / int h_addrtype; / domaine de l’adresse/ int h_length; / longueur de l’adresse / char* h_addr_list; /* tableau des adresses IP */}	????
	#define h_addr h_addr_list[0]	???
int setsockopt(int sodkDesc, int niveau, int option, void* valeurOpt, int longValeurOpt)	Modifie les caractéristiques d’une socket. Par exemple, change la taille des tampons, autorise le broadcast…
getsockopt, setsockopt	Lire / écrire les options d'une socket.
	SO_DEBUG	autorise l'enregistrement d'information de débug ging
	SO_REUSEADDR	autorise la réutilisation de l'adresse locale
	SO_KEEPALIVE	valide la transmission périodique automatique*
	SO_DONTROUTE	inhibe le routage en émission
	SO_LINGER	persistence des messages restants en cas de rup ture de liaison
	SO_BROADCAST	autorise la diffusion des messages
	SO_OOBINLINE	valide la réception de messages hors-bande
	SO_SNDBUF	fixe la taille du buffer d'émission
	SO_RCVBUF	fixe la taille du buffer de réception
	SO_SNDLOWAT	fixe le seuil minimum du buffer en émission
	SO_RCVLOWAT	fixe le seuil minimum du buffer en réception
	SO_SNDTIMEO	lit la valeur de timeout en émission (seulement en lecture)
	SO_RCVTIMEO	lit la valeur de timeout en réception (seulement en lecture)
	SO_TYPE	lit le type de socket (seulement en lecture)
int listen(int sockfd, int backlog);	marque la socket référencée par sockfd comme une socket passive, c'est-à-dire comme une socket qui sera utilisée pour accepter les demandes de connexions entrantes en utilisan
	sockfd	descripteur de fichier qui fait référence à une socket de type SOCK_STREAM ou SOCK_SEQPACKET
	backlog	définit une longueur maximale jusqu'à laquelle la file des connexions en attente pour sockfd peut croître. Si une nouvelle connexion arrive alors que la file est pleine, le client reçoit une erreur indiquant ECONNREFUSED, ou, si le protocole sous-jacent supporte les retransmissions, la requête peut être ignorée afin qu'un nouvel essai réussisse.
	ERREURS
		EADDRINUSE	Une autre socket est déjà à l'écoute sur le même port.
		EBADF	sockfd n'est pas un descripteur valide
		ENOTSOCK	L'argument sockfd n'est pas une socket.
		EOPNOTSUPP	Le type de socket ne supporte pas l'appel système listen().
int accept(int sockfd, struct sockaddr adresse, socklen_t longueur);	accept() est employé avec les sockets utilisant un protocole en mode connecté (SOCK_STREAM et SOCK_SEQPACKET). Il extrait la première connexion de la file des connexions en attente de la socket sockfd à l'écoute, crée une nouvelle socket connectée, et renvoie un nouveau descripteur de fichier qui fait référence à cette socket. La nouvelle socket n'est pas en état d'écoute. La socket originale sockfd n'est pas modifiée par l'appel système.
	sockfd	sockfd est une socket qui a été créée avec la fonction socket(2), attachée à une adresse avec bind(2), et attend des connextions après un appel listen(2).
	adresse	adresse est un pointeur sur une structure sockaddr. La structure sera remplie avec l'adresse du correspondant se connectant, telle qu'elle est connue par la couche de communication. Le format exact du paramètre adresse dépend du domaine dans lequel la communication s'établit
	ERREURS
		EAGAIN ou EWOULDBLOCK	La socket est non bloquante et aucune connexion n'est présente dans la file.
		EBADF	sockfd n'est pas un descripteur valide
		ECONNABORTED	Une connexion a été abandonnée.
		EINTR	L'appel système a été interrompu par l'arrivée d'un signal avant qu'une connexion valide ne survienne
		EINVAL	La socket n'est pas en attente de connexion, ou addrlen n'est pas valide (par exemple, est négative).
		EMFILE	La limite par processus du nombre de descripteurs de fichier ouverts a été atteinte.
		ENFILE	La limite du nombre total de fichiers ouverts sur le système a été atteinte.
		ENOTSOCK	Le descripteur n'est pas celui d'une socket.
		EOPNOTSUPP	La socket de référence n'est pas de type SOCK_STREAM.
		EFAULT	adresse n'est pas dans l'espace d'adressage accessible en écriture.
		ENOBUFS, ENOMEM	Par assez de mémoire disponible. En général, cette erreur est due à la taille limitée du tampon des sockets, et pas à la mémoire système proprement dite.
		EPROTO	Erreur de protocole.
		EPERM	Les règles du pare-feu interdisent la connexion.
waitpid()	suspend l'exécution du processus appelant jusqu'à ce que le fils spécifié par son pid ait changé d'état. Par défaut, waitpid() n'attend que les fils terminés, mais ce comportement est modifiable avec l'argument options
	< -1	attendre la fin de n'importe lequel des processus fils dont le GID du processus est égal à la valeur absolue de pid.
	-1	attendre n'importe lequel des processus fils.
	0	attendre n'importe lequel des processus fils dont le GID du processus est égal à celui du processus appelant.
	>	attendre n'importe lequel des processus fils dont le PID est égal à pid.
	WNOHANG	revenir immédiatement si aucun fils n'est achevé.
	WUNTRACED	revenir si un fils est bloqué (mais non suivi par ptrace(2)). L'état des fils suivis est fourni même sans cette option. traced
	WCONTINUED (Depuis Linux 2.6.10)	revenir si un fils bloqué a été relancé par la délivrance du signal SIGCONT.
	http://manpagesfr.free.fr/man/man2/wait.2.html

le multi threading
#include <pthread.h> compiler avec -pthread.	bibliothèque pour les thread	http://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_key_create.html
pthread_create();	pthread_create() crée un nouveau thread s'exécutant simultanément avec le thread appelant. Le nouveau thread exécute la fonction start_routine en lui passant arg comme premier argument. Le nouveau thread s'achève soit explicitement en appelant pthread_exit(3), ou implicitement lorsque la fonction start_routine s'achève. Ce dernier cas est équivalent à appeler pthread_exit(3) avec la valeur renvoyée par start_routine comme code de sortie.	int pthread_create(pthread_t thread_id,const pthread_attr_t attr,void(routine)(void ),void arg);	thread_id : identificateur (unique pour ce processus) rempli parl’appel.! attr: permet de changer les attributs (politique d’ordonnancement, si le thread est ou non joignable...).NULL⇒attributs par défaut.! routine: fonction de démarrage du thread.!arg: argument de cette fonction.! Le masque des signaux hérité,!L’ensemble de signaux pendants vide
pthread_join()	Ses arguments sont dans l'ordre : Le thread à attendre. La valeur de retour de la fonction du thread th. L'appel de cette fonction met en pause l'exécution du thread appelant jusqu'au retour de la fonction. Si aucun problème n'a eu lieu, elle retourne 0(zéro) et la valeur de retour du thread est passé à l'adresse indiquée (second argument) si elle est différente de NULL. En cas de problème, la fonction retourne une des valeurs suivantes : ESRCH : Aucun thread ne correspond à celui passé en argument. EINVAL : Le thread a été détaché ou un autre thread attend déjà la fin du même thread. EDEADLK : Le thread passé en argument correspond au thread appelant.	int pthread_join(pthread_t, void **);
pthread_setcancelstate()		int pthread_setcancelstate(int, int *);
pthread_setcanceltype()		int pthread_setcanceltype(int, int *);
pthread_setconcurrency()		int pthread_setconcurrency(int);
pthread_setschedparam()		int pthread_setschedparam(pthread_t, int ,const struct sched_param *);
pthread_setspecific()		int pthread_setspecific(pthread_key_t, const void *);
pthread_testcancel()		void pthread_testcancel(void);
pthread_once()		int pthread_once(pthread_once_t , void ()(void));
pthread_getconcurrency()		int pthread_getconcurrency(void);
pthread_getschedparam()		int pthread_getschedparam(pthread_t, int , struct sched_param );
*pthread_getspecific()		void *pthread_getspecific(pthread_key_t);
pthread_create()		int pthread_create(pthread_t , const pthread_attr_t ,void ()(void ), void );
pthread_detach()		int pthread_detach(pthread_t);
pthread_equal()		int pthread_equal(pthread_t, pthread_t);
pthread_exit()	sortir du thread	void pthread_exit(void *);
pthread_cancel()		int pthread_cancel(pthread_t);
pthread_cleanup_push()		void pthread_cleanup_push(void), void );
pthread_cleanup_pop()		void pthread_cleanup_pop(int);
Les attributs attr
de thread sont utilisés pour spécifier les paramètres de pthread_create ().Un objet attribut peut être utilisé dans plusieurs appels à pthread_create (),avec ou sans modifications entre les appels.
pthread_attr_init()	initialise l'objet d'attributs de thread	int pthread_attr_init(pthread_attr_t *);
pthread_attr_destroy()	détruit l'objet d'attributs de thread	int pthread_attr_destroy(pthread_attr_t *);
pthread_attr_getdetachstate()		int pthread_attr_getdetachstate(const pthread_attr_t , int );
pthread_attr_getguardsize()		int pthread_attr_getguardsize(const pthread_attr_t , size_t );
pthread_attr_getinheritsched()		int pthread_attr_getinheritsched(const pthread_attr_t , int );
pthread_attr_getschedparam()		int pthread_attr_getschedparam(const pthread_attr_t ,struct sched_param );
pthread_attr_getschedpolicy()		int pthread_attr_getschedpolicy(const pthread_attr_t , int );
pthread_attr_getscope()		int pthread_attr_getscope(const pthread_attr_t , int );
pthread_attr_getstackaddr()		int pthread_attr_getstackaddr(const pthread_attr_t , void *);
pthread_attr_getstacksize()		int pthread_attr_getstacksize(const pthread_attr_t , size_t );
pthread_attr_setdetachstate()		int pthread_attr_setdetachstate(pthread_attr_t *, int);
pthread_attr_setguardsize()		int pthread_attr_setguardsize(pthread_attr_t *, size_t);
pthread_attr_setinheritsched()		int pthread_attr_setinheritsched(pthread_attr_t *, int);
pthread_attr_setschedparam()		int pthread_attr_setschedparam(pthread_attr_t ,const struct sched_param );
pthread_attr_setschedpolicy()		int pthread_attr_setschedpolicy(pthread_attr_t *, int);
pthread_attr_setscope()		int pthread_attr_setscope(pthread_attr_t *, int);
pthread_attr_setstackaddr()		int pthread_attr_setstackaddr(pthread_attr_t , void );
pthread_attr_setstacksize()		int pthread_attr_setstacksize(pthread_attr_t *, size_t);
Les conditions cond
Opérations sur les conditionsATTENTION: doit toujours être associée à un mutex, pour éviter les accès concurrents où un thread se prépare à attendre une condition et un autre signale la condition juste avant que le premier n'attende réellement .
pthread_cond_broadcast()		int pthread_cond_broadcast(pthread_cond_t *);
pthread_cond_destroy()		int pthread_cond_destroy(pthread_cond_t *);
pthread_cond_init()		int pthread_cond_init(pthread_cond_t , const pthread_condattr_t );
pthread_cond_signal()		int pthread_cond_signal(pthread_cond_t *);
pthread_cond_timedwait()		int pthread_cond_timedwait(pthread_cond_t ,pthread_mutex_t , const struct timespec *);
pthread_cond_wait()		int pthread_cond_wait(pthread_cond_t , pthread_mutex_t );
Les conditionsattribut condattr
Avec une variable de condition, un thread peut se bloquer atomiquement jusqu'à ce qu'une condition soit remplie. La condition est testée sous la protection d'un verrou mutuel d'exclusion (mutex).
pthread_condattr_destroy()		int pthread_condattr_destroy(pthread_condattr_t *);
pthread_condattr_getpshared()		int pthread_condattr_getpshared(const pthread_condattr_t , int );
pthread_condattr_init()		int pthread_condattr_init(pthread_condattr_t *);
pthread_condattr_setpshared()		int pthread_condattr_setpshared(pthread_condattr_t *, int);
pthread_key_create()		int pthread_key_create(pthread_key_t , void ()(void *));
pthread_key_delete()		int pthread_key_delete(pthread_key_t);
Les mutex mutex
Un mutex est un objet d'exclusion mutuelle (MUTual EXclusion), et est très pratique pour protéger des données partagées de modifications concurrentes et pour implémenter des sections critiques.
pthread_mutex_destroy()	détruit le mutex	int pthread_mutex_destroy(pthread_mutex_t *);
pthread_mutex_getprioceiling()		int pthread_mutex_getprioceiling(const pthread_mutex_t , int );
pthread_mutex_init()	initialise un mutex (verou) qui permet de spécifier les donnée à protéger si par exemple : plusieurs thread accèdent accèdents aux mêmes données et les modifient en même temps	int pthread_mutex_init(pthread_mutex_t , const pthread_mutexattr_t );
pthread_mutex_lock()	Verrouiller un mutex, consiste à établir une zone critique, c'est-à-dire la zone où plusieurs threads ont l'occasion de modifier ou de lire une même variable en même temps.	int pthread_mutex_lock(pthread_mutex_t *);
pthread_mutex_setprioceiling()		int pthread_mutex_setprioceiling(pthread_mutex_t , int, int );
pthread_mutex_trylock()		int pthread_mutex_trylock(pthread_mutex_t *);
pthread_mutex_unlock()		int pthread_mutex_unlock(pthread_mutex_t *);
Les mutex attributs mutexattr
Les attributs de création de mutex peuvent être spécifiés lors de leur création en les passant en tant que second argument à pthread_mutex_init(3). Passer une valeur NULL est équivalent à un objet attributs de mutex avec tous les attributs positionnés à leur valeur par défaut.
pthread_mutexattr_destroy()		int pthread_mutexattr_destroy(pthread_mutexattr_t *);
pthread_mutexattr_getprioceiling()		int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t ,int );
pthread_mutexattr_getprotocol()		int pthread_mutexattr_getprotocol(const pthread_mutexattr_t , int );
pthread_mutexattr_getpshared()		int pthread_mutexattr_getpshared(const pthread_mutexattr_t , int );
pthread_mutexattr_gettype()		int pthread_mutexattr_gettype(const pthread_mutexattr_t , int );
pthread_mutexattr_init()		int pthread_mutexattr_init(pthread_mutexattr_t *);
pthread_mutexattr_setprioceiling()		int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
pthread_mutexattr_setprotocol()		int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
pthread_mutexattr_setpshared()		int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
pthread_mutexattr_settype()		int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
blocage des pipe? rwlock
utilisée pour initialiser une lecture / écriture
pthread_rwlock_destroy()		int pthread_rwlock_destroy(pthread_rwlock_t *);
pthread_rwlock_init()		int pthread_rwlock_init(pthread_rwlock_t ,const pthread_rwlockattr_t );
pthread_rwlock_rdlock()		int pthread_rwlock_rdlock(pthread_rwlock_t *);
pthread_rwlock_tryrdlock()		int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
pthread_rwlock_trywrlock()		int pthread_rwlock_trywrlock(pthread_rwlock_t *);
pthread_rwlock_unlock()		int pthread_rwlock_unlock(pthread_rwlock_t *);
pthread_rwlock_wrlock()		int pthread_rwlock_wrlock(pthread_rwlock_t *);
blocages attributs rwlockattr
les attributs lecture / écriture
pthread_rwlockattr_destroy()		int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
pthread_rwlockattr_getpshared()		int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t ,int );
pthread_rwlockattr_init()		int pthread_rwlockattr_init(pthread_rwlockattr_t *);
pthread_rwlockattr_setpshared()		int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);

Systeme

int getpagesize(void) (LEGACY)	renvoie le nombre d’octets dans une page mémoire, où "page" est un bloc de longueur fixe, unité d’allocation de mémoire et de mappage de fichiers effectuée par mmap (2).
int access(const char *,int)	vérifie si le processus appelant peut accéder au chemin du fichier. Si chemin est un lien symbolique, il est déréférencé.
unsigned int alarm(unsigned int)	La fonction alarm() arme le timer ITIMER_REAL avec une durée de nb_sec secondes. A l'écoulement de ce délai (au minimum), le processus reçoit le signal SIGALRM. Le timer est alors désarm
int brk(void *)	positionne la fin du segment de données (le premier mot mémoire hors de la zone accessible) à l'adresse spécifiée par addr. Cette valeur doit être raisonnable, le système doit avoir suffisamment de mémoire, et le processus ne doit pas dépasser sa taille maximale de segment de données
int chdir(const char *)	remplace le répertoire de travail courant du processus appelant par celui indiqué dans le chemin path.
int chroot(const char *) (LEGACY)	change le répertoire racine du processus appelant en celui spécifié dans chemin. Ce répertoire sera utilisé pour les chemins commençant par /. Le répertoire racine est hérité par tous les enfants du processus appelant.
int chrown(const char *,uid_t,gid_t)	Modifie le propriétaire ou le groupe (ou les deux) d'un fichier. chemin est le nom du fichier dont vous souhaitez modifier le propriétaire ou le groupe. propriétaire est l'ID utilisateur (UID) du nouveau propriétaire du fichier. groupe est l'ID de groupe (GID) du nouveau groupe pour le fichier.
int close(int)	ferme le descripteur fd, de manière à ce qu'il ne référence plus aucun fichier, et puisse être réutilisé. Tous les verrouillages d'enregistrement (voir fcntl(2)) sur le fichier qui lui était associé, appartenant au processus, sont supprimés (quelque soit le descripteur qui fut utilisé pour obtenir le verrouillage).Si fd est le dernier descripteur de fichier faisant référence à la description de fichier ouvert sous-jacente (voir open(2)), les ressources associéesà la description de fichier ouvert sont libérées. Si le descripteur était la dernière référence sur un fichier supprimé avec unlink(2), le fichier est effectivement effacé.
size_t confstr(int,char *,size_t)	fournit la valeur d'une chaîne de caractères dépendante de la configuration.
char crypt(const char , const char *)
char ctermid(char s)
char cuserid(char s) (LEGACY)
int dup(int)
int dup2(int)
void encrypt(char[64],int)
int execl(const char ,const char ,...)
int execle(const char ,const char ,...)
int execlp(const char ,const char ,...)
int execv(const char ,char const [])
int execve(const char ,char const [],char *const [])
int execvp(const char ,char const [])
void _exit(int)
int fchown(int,uid_t,gid_t)
int fchdir(int)
int fdatasync(int)
pid_t fork(void)
long int fpathconf(int,int)
int fsync(int)
int ftruncate(int,off_t)
char getcwd(char ,size_t)
int getdtablesize(void) (LEGACY)
gid_t getegid(void)
uid_t getegid(void)
gid_t getgid(void)
int getgroups(int,gid_t [])
long gethostid(void)
char *getlogin(void)
int getlogin_r(char *,size_t)
int getopt(int, char * const[],const char *)
int getpagesize(void) (LEGACY)
pid_t getpgid(pid_t)
pid_t getpgrp(void)
pid_t getppid(void)
pid_t getsid(pid_t)
pid_t getpuid(void)
char getwd(char )
int isatty(int)
int lchown(const char *,uid_t,gid_t)
int link(const char ,const char )
int lockf(int,int,off_t)
off_t lseek(int,off_t,int)
int nice(int)
long int pathconf(const char *,int)
int pause(void)
int pipe(int [2])
ssize_t pread(int,void *, size_t,off_t)
int pthread_atfork(void ()(void),void ()(void),void(*)(void))
ssize_t pwrite(int,const void*,size_t,off_t)
ssize_t read(int,void *,size_t)
int readlink(const char ,char , size_t)
int rmdir(const char *)
void *sbrk(intptr_t)
int setgid(gid_t)
int setpgid(pid_t,pid_t)
pid_t setpgrp(void)
int setregid(gid_t,gid_t)
int setreuid(uid_t,uid_t)
pid_t setsid(void)
int setuid(uid_t)
unsigned int sleep(unsigned int)
void swab(const void ,void ,ssize_t)
void sync(void)
long int sysconf(int)
pid_t tcgetpgrp(int)
int tcsetpgrp(int,pid_t)
int truncate(const char *,off_t)
char ttyname_r(int,char *,size_t)
useconds_t ualarm(useconds_t,useconds_t)
int unlink(const char *)
int usleep(useconds_t)
pid_t vfork(void)
ssize_t write(int,const void *,size_t)