Autotest de maˆıtrise du langage C
Chaque question propose plusieurs r´eponses possibles dont une, plusieurs ou ´eventuellement z´ero sont correctes. Il faut cocher toutes les r´eponses correctes.
IQ. 1 Le langage C est un langage
orient´e objet fonctionnel Ximp´eratif Xtyp´e statiquement typ´e dynamiquement
IQ. 2 Le langage C fut d´evelopp´e par X
D. Ritchie et K. Thompson B. Kernighan et D. Ritchie
B. Stroustrup B. Gates S. Jobs
IQ. 3 L’instructionn = n + 1;est ´equivalente `a X
n++; X++n; *n++; *++n; Xn += 1; n + 1 = n;
IQ. 4 La d´eclaration d’un pointeurpsur un entier se fait par X
int* p; int p*; int[] p; int p[]; int& p; int p&;
IQ. 5 R´ecup´erer l’adresse d’une variablense fait par
*n; n*; []n; n[]; X&n; n&;
IQ. 6 La d´eclaration d’une fonctionfprenant un tableautd’entiers en param`etre se fait par X
f(int* t) f(int t*) f(int[] t); Xf(int t[]); c’est impossible.
IQ. 7 La d´eclaration d’une fonctionfretournant un tableau d’entiers se fait par
int* f() int[] f() int[f()] int(f[]); Xc’est impossible.
IQ. 8 Le type des chaˆınes de caract`eres en C est
char Xchar* Xchar [] string n’existe pas
Il n’y pas de type, `a proprement parl´e, pour les chaˆınes en C, mais comme les chaˆınes sont repr´esent´ees par des tableaux de caract`eres avec un caract`ere ’\0’ `a la fin, on utilise les types char*ouchar [].
IQ. 9 Quelle syntaxe permet d’acc´eder `a l’objet point´e par un pointeurpet de le modifier ? X
*p = a p = a &p = a c’est impossible
IQ. 10 Quelle syntaxe permet de modifier un pointeurp?
*p = a Xp = a &p = a c’est impossible
IQ. 11 La syntaxe p->f()est ´equivalente `a
p[f()] *(p.f()) *p.f() X(*p).f() n’existe pas
IQ. 12 La syntaxe p[n]est ´equivalente `a
p+n X*(p+n) *p+n p*n n’existe pas
IQ. 13 Apr`es la d´eclarationint n = 0, la valeur de l’expressionn = nest
true false X0 1 2 aucune ne compile pas
La valeur d’une affectation est la valeur affect´ee.
IQ. 14 Apr`es la d´eclarationint n = 0, la valeur de l’expressionn += nest
true false X0 1 2 aucune ne compile pas
IQ. 15 Apr`es la d´eclarationint n = 0, la valeur de l’expressionn <= nest
true false 0 X1 2 aucune ne compile pas
Il s’agit d’une comparaison avec l’op´erateur d’ordre non strict <=. La valeur est donc 1 qui repr´esentetrue en C.
IQ. 16 Apr`es la d´eclarationint n = 0, la valeur de l’expressionn == nest
true false 0 X1 2 aucune ne compile pas
Il s’agit d’une comparaison avec l’op´erateur d’´egalit´e==. La valeur est donc1qui repr´esente trueen C.
IQ. 17 Apr`es la d´eclarationint n = 0, la valeur de l’expressionn != nest
true false X0 1 2 aucune ne compile pas
Il s’agit d’une comparaison avec l’op´erateur d’in´egalit´e!=. La valeur est donc0qui repr´esente falseen C.
IQ. 18 Apr`es l’ex´ecution du fragment de code int n = 0; n = !n;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
L’op´erateur!est la n´egation logique. Il transforme0en1et inversement car0et1repr´esentent falseet trueen C.
IQ. 19 Apr`es l’ex´ecution du fragment de codeint n = 0; n = n++;, la variablena la valeur X
0 1 2 3 impr´evisible ne compile pas
L’expressionn++donne la valeur denavant de l’avoir incr´ement´e. C’est donc la mˆeme valeur qui est ensuite affect´ee `anpar l’op´erateur=.
IQ. 20 Apr`es l’ex´ecution du fragment de codeint n = 0; n = ++n;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
L’expression++ndonne la valeur denapr`es l’avoir incr´ement´e. Cette valeur est ensuite affect´ee
`
anpar l’op´erateur=.
IQ. 21 Apr`es l’ex´ecution du fragment de codeint n = 1; int* p = &n; p++;, la variable n a la valeur
0 X1 2 3 impr´evisible ne compile pas
L’instruction p++incr´ementepet laisse inchang´ee la valeur den.
IQ. 22 Apr`es l’ex´ecution du fragment de code int m = 1; int n = 1; int* p = &m; int*
q = &n; n = p == q;, la variablena la valeur X
0 1 2 3 impr´evisible ne compile pas
Apr`es les initialisations, les pointeurs p et q contiennent les adresses des variables m et n.
L’expressionp == q teste si ces deux adresses sont ´egales et retourne donc0 puisqu’il s’agit de variables diff´erentes.
IQ. 23 Apr`es l’ex´ecution du fragment de code int m = 1; int n = 1; int* p = &m; int*
q = &n; n = *p == *q;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
Apr`es les initialisations, les pointeurs p et q contiennent les adresses des variables m et n.
Les expressions *pet*qd´esignentmet n. L’expression*p == *qteste si les valeurs de ces deux variables sont ´egales et retourne donc1.
IQ. 24 Apr`es l’ex´ecution du fragment de code int m = 1; int n = 1; int* p = &m; int*
q = &n; n = &p == &q;, la variablena la valeur X
0 1 2 3 impr´evisible ne compile pas
L’expression &p == &qteste si les adresses des deux pointeurs pet q sont ´egales et retourne donc0puisqu’il s’agit de deux variables diff´erentes.
IQ. 25 Apr`es l’ex´ecution du fragment de codeint n = 1; int* p = &n; *p++;, la variablen a la valeur
0 X1 2 3 impr´evisible ne compile pas
Apr`es les initialisations, le pointeur p contient l’adresse de n et *p d´esigne l’emplacement de n. L’instruction *p++ est implicitement parenth´es´ee *(p++). Elle incr´emente pet retourne la valeur*p, c’est-`a-dire la valeur de nqui reste inchang´ee.
IQ. 26 Apr`es l’ex´ecution du fragment de codeint n = 1; int* p = &n; ++*p;, la variablen a la valeur
0 1 X2 3 impr´evisible ne compile pas
Le parenth´esage implicite de l’expression est ++(*p). Apr`es les initialisations, le pointeur p contient l’adresse denet *pd´esigne l’emplacement de n. L’expression incr´ementen qui prend la valeur2.
IQ. 27 Apr`es l’ex´ecution du fragment de code int n = 1; int* p = &(n+n); n = *p;, la variablena la valeur
0 1 2 3 impr´evisible Xne compile pas
L’op´erateur&ne peut s’appliquer qu’`a un emplacement et donc pas `a une expression comme n+nqui d´esigne une valeur mais pas un emplacement.
IQ. 28 Apr`es l’ex´ecution du fragment de code int n = 1; int* p = &n; n = *p+1;, la va- riablena la valeur
0 1 X2 3 impr´evisible ne compile pas
Le parenth´esage implicite de l’expression estn = (*p)+1. Apr`es les initialisations, le pointeurp contient l’adresse de n et *pd´esigne l’emplacement den. L’expression affecte `a la variable n la valeur2.
IQ. 29 Apr`es l’ex´ecution du fragment de code int n = 1; int* p = &n; n = *(p+1);, la variablena la valeur
0 1 2 3 Ximpr´evisible ne compile pas
p+1est l’adresse de l’emplacement qui suit celui de la variablen. L’utilisation de cet emplace- ment d´epend des autres variables. L’expression affecte `anla valeur contenue dans cet emplacement en l’interpr´etant comme un entier.
IQ. 30 Apr`es l’ex´ecution du fragment de code int n = 1; n++++;, la variablena la valeur
0 1 2 3 impr´evisible Xne compile pas
L’expressionn++d´esigne une valeur et pas un emplacement. L’op´erateur++ne peut donc pas ˆ
etre appliqu´e.
IQ. 31 Apr`es l’ex´ecution du fragment de codeint n = 1; int* p = &n; int** q = &p; ++**q;, la variablena la valeur
0 1 X2 3 impr´evisible ne compile pas
Le parenth´esage implicite de l’expression est++(*(*q)). Apr`es les initialisations, le pointeurp contient l’adresse denet le pointeurql’adresse dep. Les expressions*qet **qd´esignent respec- tivementpetn. L’instruction++**p;incr´ementen.
IQ. 32 Apr`es l’ex´ecution du fragment de code int n = 0; int m = 1; n = m = n;, la va- riablena la valeur
X
0 1 2 3 impr´evisible ne compile pas
Le parenth´esage implicite de l’expression est n = (m = n). L’expression m = n affecte la va- leur 0 `a la variable m et donne la valeur 0. L’expression globale affecte alors la valeur 0 `a la variablen.
IQ. 33 Apr`es l’ex´ecution du fragment de code int n = 0; n = n == n;, la variable n a la valeur
0 X1 2 3 impr´evisible ne compile pas
Le parenth´esage implicite de l’expression estn = (n == n). L’expression n == nest un test d’´egalit´e et donne la valeur1qui repr´esente la valeurtrueen C. L’expression globale affecte alors la valeur1`a la variablen.
IQ. 34 Apr`es l’ex´ecution du fragment de codeint n = 0; n = n++ + n++;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
Quel que soit l’ordre d’´evaluation des deux expressions n++ le r´esultat est 1. La premi`ere expressionn++´evalu´ee donne0et la seconde1et la somme est toujours1.
IQ. 35 Lors de l’ex´ecution du fragment de codeint n = 1; f(n++, n++);, la fonctionfest appel´ee avec les valeurs
1,1 1,2 2,1 2,2 Ximpr´evisible ne compile pas
La norme du C++ n’impose pas l’ordre d’´evaluation des param`etres d’un appel de fonction et laisse le compilateur choisir. Si le premier param`etre est ´evalu´e en premier, la fonctionfre¸coit 1,2et s’il est ´evalu´e en second, la fonctionfre¸coit2,1.
IQ. 36 La fonctionfest d´efinie parint f(int n){ return n+1; }. Apr`es l’ex´ecution du frag- ment de codeint n = f(1);, la variablena la valeur
0 1 X2 3 impr´evisible ne compile pas
IQ. 37 La fonction f est d´efinie par int f(int* p){ return *p+1; }. Apr`es l’ex´ecution du fragment de codeint n = 1; n = f(n);, la variablena la valeur
0 1 2 3 impr´evisible Xne compile pas
La fonction f prend une adresse en param`etre alors que l’appel `a f est fait avec une valeur enti`ere.
IQ. 38 La fonction f est d´efinie par int f(int* p){ return *p+1; }. Apr`es l’ex´ecution du fragment de codeint n = 1; n = f(&n);, la variablena la valeur
0 1 X2 3 impr´evisible ne compile pas
IQ. 39 La fonction f est d´efinie par int f(int* p){ return *p+1; }. Apr`es l’ex´ecution du fragment de codeint n = f(&1);, la variablena la valeur
0 1 2 3 impr´evisible Xne compile pas
L’op´erateur&ne peut s’appliquer qu’`a un emplacement et donc pas `a une constante comme1.
IQ. 40 La fonction fest d´efinie parint* f(){ int n = 1; return &n; }. Apr`es l’ex´ecution du fragment de codeint n = *f();, la variablena la valeur
0 1 2 3 Ximpr´evisible ne compile pas
La fonctionfretourne l’adresse de sa variable localendont l’emplacement est lib´er´e au retour de la fonction.
IQ. 41 La fonctionfest d´efinie parint* f(int* p){ int n = 1; return p; }. Apr`es l’ex´ecution du fragment de codeint n = 2; n = *f(&n);, la variablena la valeur
0 1 X2 3 impr´evisible ne compile pas
IQ. 42 La fonctionfest d´efinie parvoid f(int* p, int* q){ int t = *p; *p = *q; *q = t; }. Quels sont les appels `a la fonctionfqui ´echangent les valeurs des variablesmetn.
f(m, n) f(*m, *n) Xf(&m, &n) f(!m, !n) f(m+n, m-n) Il faut passer en param`etre `a la fonctionfles adresses des variablesmetn.
La fonctionlenest d´efinie de la fa¸con suivante.
int len(char* s) { char* t = s;
while(*s++ != ’\0’);
return s-t;
}
IQ. 43 Dans le fragment de code len("abc");, la fonction lenretourne la valeur
-1 0 3 X4 impr´evisible ne compile pas
La fonctionlenincr´emente le pointeurs`a chaque caract`ere lu, y compris le caract`ere’\0’de fin de chaˆıne. Elle retourne donc la longueur de la chaˆıne incr´ement´ee de 1pour ce caract`ere.
IQ. 44 Dans le fragment de codechar* s = "abc"; len(s);, la fonctionlenretourne la va- leur
-1 0 3 X4 impr´evisible ne compile pas
IQ. 45 Dans le fragment de code char s[] = {’a’, ’b’, ’c’}; len(s);, la fonction len retourne la valeur
-1 0 3 4 Ximpr´evisible ne compile pas
Le tableau scontient une suite de caract`eres non termin´ee par le caract`ere’\0’. Il n’est pas possible de pr´evoir o`u va s’arrˆeter le parcours de la fonctionlen.
IQ. 46 Apr`es la d´eclarationint t[] = {1, 2, 3};, le tableautcontient les valeurs 0, 0, 0 X1, 2, 3 impr´evisible ne compile pas IQ. 47 Apr`es la d´eclarationint[] t = {1, 2, 3};, le tableautcontient les valeurs
0, 0, 0 1, 2, 3 impr´evisible Xne compile pas Il s’agit de la syntaxe de Java pour les tableaux qui n’est pas valide en C.
IQ. 48 Apr`es la d´eclarationint* t = {1, 2, 3};, le tableau tcontient les valeurs 0, 0, 0 1, 2, 3 3, 2, 1 impr´evisible Xne compile pas La d´eclarationint* t;d´eclare un pointeur qui ne peut ˆetre initialis´e avec une suite de valeurs enti`eres. La variable tne peut contenir qu’une adresse.
IQ. 49 Apr`es l’ex´ecution du fragment int t[] = {1, 2, 3}; t = t;, le tableau t contient les valeurs
0, 0, 0 1, 2, 3 impr´evisible Xne compile pas Il n’y a pas d’affectation entre tableaux en C. L’instructiont = t;n’est pas valide.
IQ. 50 Apr`es l’ex´ecution du fragmentint t[] = {1, 2, 3}; int n = &t == t;, la variablen a la valeur
true false 0 X1 impr´evisible ne compile pas Par convention, l’adresse d’un tableau est le tableau lui-mˆeme.
IQ. 51 Apr`es l’ex´ecution du fragmentint s[] = {1, 2, 3}; int t[] = s;, le tableautcontient les valeurs
0, 0, 0 1, 2, 3 impr´evisible Xne compile pas Il n’est pas possible, en C, d’initialiser un tableau avec un autre tableau.
IQ. 52 Apr`es l’ex´ecution du fragmentint s[] = {1, 2, 3}; int t[] = {1, 2, 3}; int n
= s == t;, la variablena la valeur X
0 1 2 6 impr´evisible ne compile pas
L’expressions == tteste si les deux tableaux se trouvent `a la mˆeme adresse et retourne donc la valeur0.
IQ. 53 Apr`es l’ex´ecution du fragmentint t[] = {1, 2, 3}; *t = 3;, le tableau tcontient les valeurs
3, 3, 3 X3, 2, 3 1, 3, 3 impr´evisible ne compile pas L’expression*test ´equivalent `at[0] et d´esigne la premi`ere case du tableaut.
IQ. 54 Apr`es l’ex´ecution du fragmentint t[] = {1, 2, 3}; int* p = t; p[1] = 3, le ta- bleautcontient les valeurs
3, 3, 3 3, 2, 3 X1, 3, 3 impr´evisible ne compile pas Apr`es les initialisations, le pointeur p contient l’adresse de la premi`ere case du tableau t.
Comme les cases des tableaux sont num´erot´ees `a partir de 0, p[1] d´edigne la seconde case du tableaut.
IQ. 55 Apr`es l’ex´ecution du fragment de code int t[] = {1, 2, 3};
for(int i = 1; i < 3; i++) t[i] += t[i-1];le tableautcontient les valeurs
1, 2, 3 X1, 3, 6 1, 1, 1 impr´evisible ne compile pas La boucleforeffectue les deux affectationst[1] = t[1] + t[0]puist[2] = t[2] + t[1].
Le tableautet la fonctionsumsont d´efinis de la fa¸con suivante.
int t[] = { 1, 2, 3, 4, 5 };
int sum(int t[], int n) { int s = 0;
for (int i = 0; i < n; ++i) s += t[i];
return s;
}
IQ. 56 Quels sont les appels `a sum qui calculent la somme des quatre premi`eres valeurs du tableautet retournent la valeur10?
X
sum(t, 4) sum(t[1], 4) sum(t[0], 4)
sum(&t, 4) Xsum(&t[0], 4) sum(*t, 4)
Il faut passer en param`etre `a la fonctionsuml’adresse de la premi`ere case du tableau qui est donn´ee par les expressions tet&t[0].
IQ. 57 Quels sont les appels `a sum qui calculent la somme des quatre derni`eres valeurs du tableautet retournent la valeur14?
X
sum(t+1, 4) sum(&t+1, 4) sum(*(t+1), 4) sum(t[1], 4) Xsum(&t[1], 4) sum(*t+1, 4)
Il faut passer en param`etre `a la fonctionsuml’adresse de la deuxi`eme case du tableau qui est donn´ee par les expressions t+1et &t[1].
Le typePest d´efini de la fa¸con suivante.
typedef struct { int x;
int y;
} P;
IQ. 58 La d´eclaration d’une fonctionfprenant en param`etre une valeur de type Pse fait par X
f(P p) f(P* p) f(P& p) f(P p[]) c’est impossible.
IQ. 59 La d´eclaration d’une fonctionfretournant une valeur de typePse fait par X
P f() P* f() P& f() P[] f() c’est impossible.
IQ. 60 Apr`es l’ex´ecution du fragment de codeP p = {1, 2}; P q = p; int n = q.y, la va- riablena la valeur
0 1 X2 3 impr´evisible ne compile pas
IQ. 61 Apr`es l’ex´ecution du fragment de codeP p = {1, 2}; int* q = &p.x; int n = *q;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
Apr`es les initialisations, le pointeurq contient l’adresse de l’attribut x de la structure p. La variablenre¸coit donc la valeur1.
IQ. 62 Apr`es l’ex´ecution du fragment de codeP p = {1, 2}; P* q = &p; int n = q->x;, la variablena la valeur
0 X1 2 3 impr´evisible ne compile pas
Apr`es les initialisations, le pointeurq contient l’adresse de la structure p. L’expressionq->x qui est ´equivalente `a(*q).xd´esigne donc l’attributxde la structurep. La variablenre¸coit donc la valeur1.
IQ. 63 La d´eclaration d’une fonction F qui prend en param`etre une fonction f (prenant en param`etre un entier et retournant un entier) et qui retourne un entier se fait par
X
int F(int f(int)) int F(int *f(int)) Xint F(int (*f)(int))
int F(int f, int n) c’est impossible.
IQ. 64 Apr`es les deux d´eclarationstypedef int (*fun)(int); fun F(fun f) {return f;}, l’expressionF(f)(2)est valide sifest d´efini par
X
int f(int n) { return n; } int f(int* p) { return *p; } int* f(int* p) { return p; } int* f(int n) { return &n; } int f() { return 0; }
ne compile pas
