Quel type de base ne fait pas partie du standard C++ ?

bool

int

double

real

wchar

Quel sera l'affichage résultant du code suivant ?

void swap(int x, int y) {

int t=x; x=y; y=t;
cout << x << y;
}

void main() {
int a=1, b=2;
swap(a, b);
cout << a << b;
}

01

12
Les entiers étant passés par valeur, la permutation effectuée dans la fonction swap est sans
effet sur a et b.

Quel est le rôle principal du constructeur d'une classe ?

Allouer la mémoire nécessaire à une instance de cette classe

Initialiser une instance de cette classe

 Renvoyer l'adresse de l'objet

Défragmenter la mémoire

Quel est le rôle principal du destructeur d'une classe ?

Libérer la mémoire occupée par un objet

Détruire un objet

Libérer les ressources de l'objet

Défragmenter la mémoire

Que valent a et b après ces 4 instructions :

(1) int a=1, b=2;

(2) a++;
(3) b=a++;
(4) a=--b;

a=1, b=1
après (1) a=1, b=2 après (2) a=2, b=2 après (3) a=3, b=2 après (4) a=1, b=1

a=1, b=2

a=2, b=1

a=2, b=2

Dans quelle situation la zone d'initialisation des membres est-elle indispensable ?

Pour initialiser des membres de type pointeur

Pour initialiser les membres 'static'

Pour initialiser les membres de type référence ou const

Les membres de type référence ou const ne peuvent pas être affectés dans le constructeur. Ils
doivent donc être initialisés ce qui ne peut se faire que dans la zone d'initialisation des
membres.

Pour initialiser des membres de type tableau

Identifiez l'assertion erronée au sujet des fonctions 'inline' :

Elles peuvent contenir plusieurs instructions

Elles doivent être 'static'

Elles améliorent les performance du programme

Elles sont expansées à l'endroit de chaque appel

Qu'est-ce qui est nécessaire pour le polymorphisme dynamique ?

Des méthodes surchargées

Des méthodes constantes

Des méthodes abstraites

Des méthodes virtuelles

Le mot-clé 'virtual' placé devant une méthode permet de mettre en œuvre le mécanisme
nécessaire au polymorphisme.

Quelle instruction permet de réémettre l'exception courante ?

throw;

throw();

throw();

rethrow;

Quelle fonctionnalité nous offre le RTTI ?

1) La découverte dynamique (lors de l'exécution) des méthodes des classes.

2) La possibilité de faire des casts plus explicites et sécurisés.
3) La connaissance du type exact d'un objet à partir d'un pointeur ou d'une référence.
 Les réponses 2 et 3

Les réponses 1, 2 et 3

Comment créer un objet si tous les constructeurs de sa classe sont privés ?

C'est impossible

Il faut préciser le namespace

Il faut passer par une méthode statique

Seules les classes dérivées peuvent le faire

Que contient la STL ?

Les nouvelles fonctions d'entrée/sortie (NIO)

Un Framework de serveur d'applications

Une bibliothèque de composants graphiques

Des conteneurs génériques

Quel(s) opérateur(s) peut(peuvent) être surchargé(s) ?

[]

()

Tous

Quel sera l'affichage résultant du code suivant ?

for(int n=0; n<=3 ; n++) {

if (n=0) cout << " n=0";
else cout << " n=" << n;
}

n=0 n=1 n=2

n=0 n=1 n=2 n=3

n=0 n=1 n=2 n=3 n=4 n=5 etc…

n=0 n=0 n=0 n=0

n=0 n=0 n=0 n=0 n=0 n=0 etc…

Attention ! Dans le test if( n=0 ), n=0 est une affectation qui remet systématiquement n à la
valeur 0. On ne sort donc jamais de la boucle...

Soit les 3 booléen suivants :

bool a = false, b = false, c = true;
Quelle est la valeur de l'instruction suivante :
a || b && c;

true

false

-1

Quelque chose d'autre que true ou false

Quelle instruction n'appelle PAS l'opérateur d'affectation de la classe A ?

(avec A a1; et A& ra1 = a1;)

A a = a1;
La première instruction est une initialisation. C'est le constructeur de copie qui est appelé et
non l'opérateur d'affectation.

a = a1;

a.operator=(a1);

ra1 = a;

Combien d'appels au constructeur de copie sont-ils induits par le code suivant :

(.h) List reverse(const List l);
(.cpp) List listeA;
List listeB = reverse(listeA);

Que se passe-t'il si l'on ne définit pas de constructeur dans une classe ?

La compilation échoue

Un constructeur qui ne fait rien est généré par le compilateur

Un constructeur qui initialise les membres à 0 (ou null) est généré par le compilateur

Un constructeur qui lève une exception INVALID_CTOR est généré par le compilateur.

Que se passe-t'il si l'on ne définit pas d'opérateur d'affectation dans une classe ?

La compilation échoue

Un opérateur = qui ne fait rien est généré par le compilateur

Un operateur = qui fait une copie membre à membre est généré par le compilateur

Un operateur = qui fait un appel au constructeur de copie est généré par le compilateur

Un operateur = qui lève une exception INVALID_OPERATION est généré par le

compilateur.

Quelle est la signature du constructeur de copie d'une classe T ?

const T& T::T(const T& original) { … }

T& T::T(const T& original) { … }

T T::T(T original) { … }
 T::T(const T original) { … }

T::T(T original) { … }

T::T(const T& original) { … }

Un constructeur de copie, comme n'importe quel constructeur n'a pas de type de retour et son
paramètre unique, du même type que la classe est forcément passé par référence (const ou
non).

Qu'est-ce qu'il n'est pas possible de faire dans une classe abstraite ?

Définir une méthode avec un corps

Définir un constructeur sans paramètre

Définir un destructeur virtuel pur

Le destructeur d'une classe de base étant systématiquement appelé par le système, il ne doit
jamais être virtuel pur (=0)

Définir un destructeur non virtuel

Soit le code suivant :

int i = 10;
const int IC = 20;
const int * pic;

Laquelle des affectations suivantes est illégale ?

pic = &IC;

pic = &i;

*pic = IC;
pic est un pointeur sur un entier constant. Donc *pic est une constante qui ne saurait être
affectée.

i = *pic;

Que peut-on facilement utiliser à la place de l'héritage privé pour arriver au même
résultat ?

Agregation + délégation
 Héritage virtuel

Le mot clé 'friend'

La surcharge de l'opérateur []

Soit une classe T et t un objet de type T. Quelle fonction faut-il implémenter pour
pouvoir écrire le code suivant :
cout << t ;

void T::operator << (ostream & os) { … }

void operator << (const T& t, ostream & os) { … }

ostream& T::operator << (ostream & os) { … }

ostream& operator << (ostream & os, const T& t) { … }