Justification

Les bons programmeurs C++ connaissent bien les structures, qu'ils les utilisent régulièrement ou non. Il existe des variations dans la façon dont elles sont définies, et une bonne maîtrise de ces subtilités contribuera à garantir l'efficacité du développement.

Réponse correcte :

1. La première définition ne définit que le type. Elle n'instancie pas la structure. La seconde ne crée pas du tout de type. Elle instancie plutôt "pomme" pour l'utilisation dans le champ d'application actuel.
2. L'exemple de code nécessite un type "pomme", ce qui signifie que la première définition est la bonne.

Drapeaux rouges :

Ne pas connaître la différence entre ces deux bribes de code n'est pas critique, car la question est triviale et sera prise en compte lors de la compilation. Cependant, cela tend à suggérer que le candidat n'a pas beaucoup d'expérience avec le langage.

4 - Définissez les termes suivants qui sont couramment utilisés dans ce langage :

1. Classe d'amis
2. Opérateur surchargé
3. Variable statique
4. Variable protégée

Justification

Le C++ partage la terminologie avec d'autres langues, il est donc important que les questions d'entretien sondent les connaissances du candidat en ce qui concerne les domaines pour lesquels il peut y avoir des ambiguïtés ou des différences. Une situation similaire se produit lorsque les développeurs de bases de données migrent vers d'autres plateformes. Oracle et MySQL supportent tous deux le langage de requête structuré (SQL), mais il existe des différences qui peuvent entraîner des retards dans la transition. Cette question indiquera, au minimum, la familiarité du prospect avec la terminologie.

Réponse correcte :

1. A classe d'amis est un qui est autorisé à accéder aux membres privés et protégés de toute classe qui l'a déclaré comme ami. La propriété n'est pas héritée (les sous-classes d'amis ne deviennent pas automatiquement amies), et n'est pas transitoire (les amis des amis ne sont pas des amis).

   La compréhension des classes d'amis est précieuse pour le développement et le débogage, et ce serait un drapeau rouge si le candidat n'en avait jamais entendu parler dans le contexte de la conception OO. Cela dit, la syntaxe et l'utilisation sont simples, et peuvent être facilement référencées tant que le programmeur sait que la technique existe.

2. Les opérateurs surchargés sont ceux pour lesquels la fonctionnalité par défaut a été modifiée. Cette fonctionnalité permet de personnaliser les opérateurs en langage de programmation, comme le signe de la fiche (+).

   Un exemple trivial est l'utilisation d'un signe plus dans la concaténation des chaînes de caractères :
   int : 1 + 1 = 2
   chaîne de caractères : "Amazon" + "interview de programmation" = "interview de programmation Amazon".

   Il est certain que tout programmeur C++ connaît bien les opérateurs surchargés. Cette approche est couramment utilisée dans les classes de stockage personnalisées pour accéder aux données et les modifier. La syntaxe de la surcharge d'un opérateur spécifique pour une classe est simple, de sorte qu'une démonstration du codage d'un opérateur sans référence n'est pas importante. Cependant, il est essentiel de savoir que l'on peut utiliser "+" au lieu d'écrire une fonction "plus(...)" peu esthétique.

3. Les variables statiques sont stockées dans une mémoire statique, parfois appelée tasplutôt que sur le stack. Il est important de savoir que ces variables ne sont initialisées qu'une seule fois et que la portée persiste pendant toute l'exécution.

   Une variable statique à l'intérieur d'une fonction gardera une trace de sa valeur après la fin de la fonction, et restera inchangée lors des appels ultérieurs à la même fonction. Elle est similaire à une variable globale, mais avec une accessibilité limitée à la fonction.

   Tous les programmeurs C++ devraient savoir ce que signifie le mot-clé "static", et comment déclarer cette classe de stockage. Les variables statiques ne sont pas utilisées dans toutes les applications, mais le fait de n'en avoir jamais entendu parler doit être considéré comme un signal d'alarme.   

4. Lorsqu'une fonction variable ou membre est définie comme protégé à l'intérieur de sa classe, elle implique un type d'accès restreint qui est similaire à privé. La différence est qu'il est accessible par ses sous-classes, ou classes dérivées.

   Le mot-clé est assez courant, et les programmeurs C++ devraient en être bien conscients. Dans les hiérarchies de classes très simples sans classes dérivées, il est clair que la fonctionnalité n'est pas nécessaire. En même temps, il s'agit d'un élément important à prendre en compte lors de la conception d'une hiérarchie de classes.

5 - Dans une hiérarchie de classes orientée objet, qu'est-ce que l'héritage multiple ? Dans quelles circonstances le problème du diamant se pose-t-il ?

Justification

Cette question teste la profondeur des connaissances du candidat par rapport aux principes orientés objet qui sont couramment utilisés en C++. Bien que la question ne porte pas spécifiquement sur le langage, cet entretien de programmation couvre de multiples perspectives. Il est donc utile d'évaluer la familiarité avec le paradigme.  

Réponse correcte :

L'héritage multiple n'est pas pris en charge par toutes les langues de la POO. Il est cependant pris en charge par le C++. Il décrit une situation dans laquelle un objet ou une classe hérite de caractéristiques, telles que des fonctions membres ou des variables, de plus d'une classe parente. Comparez cela à l'héritage unique, où un objet ou une classe est limité à l'héritage d'un seul parent.

Bien que cette fonctionnalité soit puissante, elle peut conduire au problème des diamants.

Pensez à la classe supérieure : "A", qui comporte deux sous-classes "B1" et "B2". Chacune des classes enfantines hérite séparément de la classe mère, "A". C'est lorsqu'un troisième niveau, "C", est ajouté que le problème peut se poser. Il ne peut se produire que si la sous-classe "C" hérite à la fois de "B1" et de "B2".

En outre, elle n'aura lieu que s'il existe une méthode définie dans "A" qui est remplacée à la fois dans "B1" et "B2", mais qui n'est pas remplacée dans "C". Si cette méthode est invoquée par "C", il existe alors une ambiguïté quant à la méthode à utiliser.

Il n'est pas important de savoir comment ce problème est résolu en C++. Il faut plutôt reconnaître que le problème existe et doit être pris en compte lors de la conception d'une hiérarchie de classes.

Drapeaux rouges :

Si le candidat ne sait pas ce qu'est l'héritage multiple, cela suggère un manque d'expérience en matière de conception orientée objet. Bien qu'elle ne soit pas critique pour toutes les applications, la POO fait partie intégrante du C++.

6 - La récursion est une technique courante utilisée dans la programmation C++. Quels sont les avantages et les inconvénients de l'utilisation de la récursion ? Donnez un exemple pour lequel la récursion est bien adaptée.

Justification

La récursion est une technique souvent utilisée par les programmeurs qui permet de simplifier le codage. Qu'il s'agisse de programmer à partir d'une ardoise vierge, d'ajouter des fonctionnalités ou de maintenir une base de code existante, un développeur est pratiquement assuré de voir ou d'utiliser la récursion. Il y a des éléments spécifiques à prendre en compte lors du développement ou du débogage d'une fonction récursive, c'est pourquoi il est important de bien connaître cette technique.

Réponse correcte :

La définition la plus simple est qu'une fonction récursive est une fonction qui s'appelle elle-même.

Le principal avantage est qu'il permet d'obtenir un code plus simple et plus élégant. Il est donc plus facile à développer et, du moins théoriquement, il y a moins d'erreurs.

Le principal inconvénient est que la récursion est souvent plus lente en pratique que son homologue itérative. Cette performance n'est pas attribuable à la complexité, mais plutôt au fait qu'une fonction récursive utilise plus de mémoire. Chaque appel de fonction récursive réserve de l'espace supplémentaire sur la pile, ce qui la fait croître. Si la récursivité est trop "profonde", c'est-à-dire qu'elle va trop longtemps avant de revenir, elle peut entraîner une erreur de "débordement de pile".

Examples de puits suited situations

Les structures arborescentes, telles qu'un arbre de recherche binaire, sont très bien adaptées à la récursion. De même, lorsqu'il existe un nombre variable (ou très important) de boucles imbriquées, la version récursive sera beaucoup plus élégante. Les algorithmes de tri tels que le tri par fusion, le tri rapide et le tri par bulles sont tous plus faciles à mettre en œuvre de manière récursive.

Drapeaux rouges :

La récursivité est une technique qui est abordée dès le début de la formation d'un programmeur. Le candidat doit certainement être capable de la décrire, et savoir aussi qu'elle consomme plus de mémoire (espace de pile) que la version itérative du même algorithme. De plus, savoir qu'elle est bien adaptée aux structures arborescentes est trivial.

Bonus

Le moyen d'éviter une consommation excessive de mémoire et l'erreur de débordement de pile est d'utiliser la récursion de queue (également appelée optimisation de la récursion de queue), tant qu'elle est prise en charge par le compilateur. Le fait de savoir que cela existe, sans décrire son fonctionnement ou la façon de le coder, doit quand même être considéré comme un plus. Il est évident qu'une connaissance approfondie de la récursion de la queue de l'avion résume l'objectif de la question initiale.

7 - Des pointeurs intelligents ont été introduits en C++11 pour aider à la gestion de la mémoire et prévenir les fuites de mémoire. Les questions suivantes concernent l'allocation de la mémoire pour les données utilisées dans le programme, quel que soit leur type.

1. Décrivez brièvement la différence entre :

   unique_ptr<>
   shared_ptr<>
   weak_ptr<>

2. Dans le code suivant, quel est le meilleur choix de pointeur intelligent (remplacer ? ?? par le bon choix), et pourquoi ? Qu'arrive-t-il à la mémoire réservée au "p" lorsque la fonction est abandonnée ?

void printModifiedArray(int *nums, int length)
{
	// Allocate memory for a new array used only in this function
	std::???_ptr p(new int[length]);

	// Copy the int data with the proper size of data type
	std::memcpy(p.get(), nums, sizeof(int)*length); 

	// Iterate through the elements in the array
	for (int a = 0; a < length; a++)
	{
		// Call the destructive shiftInt() function
		shiftInt(p[a]);
		// Output the modified numbers from the array
		std::cout << p[a] << " ";
	}

	// Conclude with a newline escape sequence
	std::cout << endl;
}

Justification

L'allocation de mémoire et les erreurs de pointage sont traditionnellement parmi les problèmes les plus difficiles à détecter et à réparer en C++. Un grand nombre de bibliothèques de gestion de la mémoire développées indépendamment ont aidé les développeurs pendant de nombreuses années. Avec la publication de la norme C++11, l'introduction des pointeurs intelligents a permis de résoudre ces problèmes difficiles et de longue date. Les développeurs à tous les niveaux doivent être compétents dans leur utilisation.

Réponse correcte :

1. Un pointeur unique (unique_ptr) est un pointeur intelligent qui va automatiquement désallouer la mémoire réservée dès qu'elle est hors de portée. Un seul pointeur unique (unique_ptr) peut pointer vers une ressource, il est donc illégal (au moment de la compilation) de faire une copie d'un pointeur unique (unique_ptr).
2. Un pointeur partagé (shared_ptr) est également un pointeur intelligent qui désocculte automatiquement la mémoire réservée une fois qu'elle est hors de portée. Cependant, une seule ressource peut être référencée simultanément par plusieurs pointeurs partagés. Un compteur de référence interne est utilisé pour garder une trace du nombre de shared_ptr pour une ressource donnée. S'il n'y a pas de références, la mémoire est libérée. Ceci est susceptible de poser le problème de la dépendance circulaire dans les cas où deux ou plusieurs pointeurs partagés se référencent mutuellement.
3. Un pointeur faible (weak_ptr) fait en effet référence à la mémoire, mais ne peut pas l'utiliser avant d'être converti en pointeur partagé. Cela se fait en utilisant la fonction membre lock(). L'utilisation de pointeurs faibles est une façon courante de traiter le problème des dépendances circulaires. Il n'y a pas de comptage de références, mais en tant que tel, la ressource est d'abord vérifiée dès que lock() est appelé. Si la mémoire est encore disponible, elle est alors utilisable en tant que pointeur partagé. Cependant, si elle avait été désallouée auparavant, le lock() échouerait.
   
   

Dans l'extrait de code, le meilleur choix est l'unique_ptr. Certes, un shared_ptr fonctionnera, mais il est inefficace de devoir conserver des références lorsque la fonction ne fait pas appel à une ressource partagée. Les développeurs C++ sont connus pour utiliser exclusivement des pointeurs partagés, bien que cela soit mal vu en raison de la dégradation des performances qui en découle. Une suggestion d'utiliser le ptr_faible indiquerait que le candidat n'a aucune expérience des pointeurs intelligents.

Lorsque la fonction revient, si la mémoire réservée à p est détenu par un unique_ptr ou un shared_ptr alors il sera automatiquement désaffecté.

Drapeaux rouges :

Si le candidat n'a aucune connaissance des pointeurs intelligents ou de la façon de les utiliser, cela indique un manque d'expérience dans une partie importante du langage de programmation. Les pointeurs intelligents ont été introduits en C++11, et bien qu'un développeur C/C++ chevronné puisse s'en passer, il ne faut pas négliger l'avantage qui découle de leur utilisation. 

8 - La conversion de type explicite d'une variable, également appelée "casting", est une opération souvent utilisée en C++. Il existe plusieurs fonctions, chacune ayant ses propres propriétés.

1. Dans quelles circonstances faut-il utiliser le dynamic_cast?
2. Pourquoi reinterpret_cast est-il considéré comme dangereux ?
3. Dans le code suivant, quel type de casting choisiriez-vous, le cas échéant, pour rendre la variable mot de passe inscriptible ?