FAQ CConsultez toutes les FAQ

1
2
3
4
double f(double x, int n) 
{ 
    ... 
}

1
2
3
4
5
double f(x, n) 
double x; int n; 
{ 
    ... 
}

1
2
double f(); /* Les parenthèses, toujours vides, qui suivent f servent à indiquer que f est une fonction. */ 
/* Sans elles, la ligne définirait plutôt une variable globale de type double nommée f.                  */

1
2
3
4
void reset(int n) 
{ 
    n = 0; 
}

1
2
int a = 10; 
reset(a);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h> 
  
void reset(int * adr); 
  
int main(void) 
{ 
    int a = 10; 
  
    reset(&a); 
    printf("a = %d\n", a); /* affiche "a = 0" */ 
  
    return 0; 
} 
  
void reset(int * adr) 
{ 
    *adr = 0; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h> 
#include <math.h> 
  
void decomposer_nombre(double x, double * ptr1, double * ptr2); 
  
int main(void) 
{ 
    double x, e, d; 
  
    printf("x = "); 
    scanf("%lf", &x); /* Supposons que l'utilisateur tape 2.5 */ 
  
    decomposer_nombre(x, &e, &d); /* On donne une entrée (x), on obtient deux sorties (e et d) */ 
  
    printf("e = %f\n", e); /* Pour x = 2.5, affiche e = 2.000000 */ 
    printf("d = %f\n", d); /* Pour x = 2.5, affiche d = 0.500000 */ 
  
    return 0; 
} 
  
void decomposer_nombre(double x, double * ptr1, double * ptr2) 
{ 
    /* Nous allons mettre dans *ptr1 la partie entière de x */ 
    /* et dans *ptr2 sa partie décimale                     */ 
  
    *ptr1 = floor(x); 
    *ptr2 = x - *ptr1; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h> 
#include <string.h> 
  
void get_string(char * Buffer, size_t BufferLen) 
{ 
    /* On ne peut pas utiliser strcpy car cette fonction 
    ne permet pas d'indiquer le nombre max de caractères qu'on veut copier */ 
    strncpy(Buffer, "MaChaine", BufferLen); 
  
    /* Il est possible que Buffer n'ait pas pu contenir toute la chaine ... */ 
    Buffer[BufferLen - 1] = '\0'; 
} 
  
int main(void) 
{ 
    char Buffer[100]; 
  
    get_string(Buffer, sizeof(Buffer)); 
    printf("%s\n", Buffer); 
  
    return 0; 
}

1
2
3
4
int (*func(void))(const char *) 
{ 
    return puts; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h> 
  
typedef int F(const char *); 
  
F * func(void); 
  
int main(void) 
{ 
    func()("Bonjour."); /* <=> puts("Bonjour."); */ 
    return 0; 
} 
  
F * func(void) 
{ 
    return puts; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h> 
#include <stdarg.h> 
  
void printf_total(const char * format, ...); 
  
int main(void) 
{ 
    print_total("Le total est : %d\n", 1, 2, 3, 4, 0); 
    return 0; 
} 
  
/* Fonction print_total : affiche la somme des arguments */ 
  
void printf_total(const char * format, ...) 
{ 
    int total = 0; 
    va_list ap; 
    int arg; 
  
    va_start(ap, format); 
  
    while ((arg = va_arg(ap, int)) != 0) 
        total += arg; 
  
    printf(format, total); 
  
    va_end(ap); 
}

1
2
3
4
enum { 
    OPTION1 = 1 << 0, 
    OPTION2 = 1 << 1 
};

void foo(int options)

foo(OPTION1 | OPTION2)

options & OPTION1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h> 
  
enum { 
    OPTION1 = 1 << 0, 
    OPTION2 = 1 << 1 
}; 
  
void foo(int); 
  
int main(void) 
{ 
    foo(OPTION1 | OPTION2); 
    return 0; 
} 
  
void foo(int options) 
{ 
    if (options & OPTION1) 
        printf("OPTION1 trouve\n"); 
    if (options & OPTION2) 
        printf("OPTION2 trouve\n"); 
}