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)2= (5)10 devient (00010100)2=(20)10 
  >> 
 a = a  >>2 ou a  >>= 2 
 Insère deux 0 à la gauche de a  
le décalage à droite est une division par 2
 (00000101)2= (5)10 devient (00000001)2=(1)10 
 ET & 
 a = a & 1; ou a &= 1;
 fait un "ET" logique sur la valeur binaire
 (00000101)2 ET (00000001)2
donne :
(00000001)2=(1)10
 OU | 
 a = a | 8; ou a |= 8;
 fait un "OU" logique sur la valeur binaire
 (00000101)2 OU (00001000)2
donne :
(00001101)2=(13)10
 OU exclusif ^ 
 a = a ^ 9; ou a ^= 9;
 fait un "OU" logique sur la valeur binaire
 (00000101)2 XOR (00001001)2
donne :
(00001100)2=(12)10
 Negation ~ 
 ~a 
 fait une négation sur la valeur binaire
 a=(00000101)2 
~a donne :
(11111010)2





  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 31(-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 à 232-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é 40 à 4 294 967 295 int a=28968;
float Flottant (réel) 43.4*10-38 à 3.4*1038[-10308, 10308] float a=4.89;
double Flottant double 8 1.7*10-308 à 1.7*10308 float a=4.89;
long double Flottant double long 10 3.4*10-4932 à 3.4*104932 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
&x 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
8000valeur de l'adresse 8000
adresse valeur
8004valeur de l'adresse 8004
char* p
p++
adresse valeur
8000valeur de l'adresse 8000
adresse valeur
8001valeur de l'adresse 8001
double* p
p++
adresse valeur
8000valeur de l'adresse 8000
adresse valeur
8008valeur de l'adresse 8008
long double* p
p++
adresse valeur
8000valeur de l'adresse 8000
adresse valeur
8010valeur 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

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 44485256606468727680
données  … 0001 0002 0003000400050006000700080009001000110012 ...
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  … 000000120000003200000052 ...
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(1000*sizeof(int));
calloc() allouer de l'espace en mémoire et initialise en plus l'objet pointé p=(int*)malloc(1000*sizeof(int));
calloc() allouer de l'espace en mémoire et initialise en plus l'objet pointé p=(int*)malloc(1000*sizeof(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__);
conpilation 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 */ /* International keyboard syms */ /* Numeric keypad */ /* Arrows + Home/End pad */ /* Function keys */ /* Key state modifier keys */ /* Miscellaneous function keys */

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 */

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 */

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,

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,

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,

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 */

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 threadhttp://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 threadvoid 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 threadint pthread_attr_init(pthread_attr_t *);
pthread_attr_destroy()détruit l'objet d'attributs de threadint 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 mutexint 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)