Bonjour OC,

récemment, j'ai parlé à un spécialiste du C++ qui m'a conseillé en exercice de recoder la création des pointeurs intelligents.

Il  m'a dit que c'est un très bon exercice pour moi. Et que cela me ferait progresser. Il m'a dit que cela peut se coder en quelques pages.

Pour l'instant, j'aimerais mieux comprendre la problématique, l'architecture générale...

Il est clair qu'il est hors de question que je demande ici la réponse, sinon ce ne sera plus un exercice

Est-ce que vous pourriez me donner quelques guidances et directives pour mieux comprendre la direction à prendre ?

Peut-être éventuellement des liens avec de la documentation qui ne contiennent pas la réponse, pour mieux comprendre le projet.

Je vous serai très reconnaissant.

Merci

-
Edité par pseudo-simple 26 octobre 2018 à 7:04:20

Hum... Je dirai de commencer plus simple (je préfère les matrices qui font travailler plus de choses)

Derrière un pointeur intelligent il y a un nombre conséquent de subtilités.

- le plus simple est le scoped_ptr (implémenté chez boost). On est vraiment dans le minimaliste

- un que l'on pourrait croire simple, l'unique_ptr, demande de comprendre les rvalue références et tout ce qui gravite autour -- maitrise déjà l'implémentation d'une clase valeur comme une matrice à la sauce 98 pour commencer

- un qui est un chouilla plus simple, le shared_ptr, tape dans les notions de comptage de référence. Cela a l'air simple de prime abord, mais pas tant que cela. Surtout que pour que cela soit pertinent, il faut aborder les notions d'incrément et de comparaison atomique. Les castings sont à prendre en compte.

Bref, c'est vraiment complexe. Et je pense honnêtement que c'est prématuré. Implémente une matrice, implémente le javaquarium, en chemin tu manipuleras des pointeurs intelligents, et tu regarderas ensuite comment on les définit. Pédagogiquement parlant, cela me parait bien plus pertinent.

Essaye déjà std::unique_ptr et la fonction std::make_unique. Cela te permettra de bien voir les variadic templates, les constructeurs de déplacements.

Ensuite, tu peux essayer de l'implémenter avec son deleter, en effet std::unique_ptr peut prendre en paramètre template un deleter, ce qui le rend très intéressant pour les interfaces C.

Exemple:

std::unique_ptr<SDL_Window, void (*)(SDL_Window*)> w(
    SDL_CreateWindow("test", 0, 0, 640, 480, 0),
    SDL_DestroyWindow
); 

Ici, lorsque w sera détruit, ce sera fait en appelant SDL_DestroyWindow.

-
Edité par markand 26 octobre 2018 à 9:02:27

Avant de pouvoir les refaire, il faut déjà savoir bien les utiliser, donc se manger toute la documentation, la comprendre et les appliquer dans des exercices simples.

C'est un spécialiste ou un expert C++ ? Ce n'est pas la même chose ! <joke>

Je ne suis pas sûr que tu as le niveau pour écrire une implémentation correcte des smart ptr. Mais je suis sûr que tu es assez tétu pour le faire même si on te dit que c'est une mauvaise idée.

Je te propose une façon différentes d'aborder cet exercice. (Qui est en fait d'approcher historiquement ce problème et de faire une approche TDD Test Driven Development).

1. Quels sont les problèmes que l'on veut résoudre ?

Les pointeurs intelligents sont une solution a plusieurs problèmes. Mais lesquels ? Il faut comprendre les problèmes qui se posent pour trouver une solution pertinente.

Un code simple :

void foo() 
{
    ... pleins de lignes de code ici
    Object* p = new Object();
    ... pleins de lignes de code ici
    p->doSomething();
    ... pleins de lignes de code ici
    delete p;
    ... pleins de lignes de code ici
}

Quels sont les problèmes potentiels ? (On ne sait pas ce que fait "Object" ou "doSomething", ou ce que contient le reste du code. On regarde TOUS les problèmes qui peuvent se poser.)

2. Les tests unitaires

Écrire des tests unitiaires qui vont reproduire ces erreurs. (On va fait au plus simple : pas besoin d'utiliser un framework de tests. On va faire 1 test = un programme)

3. Solutions non RAII

Et-il possible de corriger ce code, de façon a résoudre les problèmes ? Sans créer de classe RAII.

4. Solutions RAII

Ecrire une implementation d'une classe RAII qui résoud ces problèmes. (Prends la semantique de unique_ptr)

-
Edité par gbdivers 26 octobre 2018 à 14:39:03

Avant de t'attaquer aux pointeurs intelligents, commence par implémenter une capsule RAII.
Les pointeurs intelligents sont basés sur cela.

Pour avoir déjà bricolé ce genre de truc, je confirme ce qu'on dit mes VDD boost::scoped_ptr c'est tranquille, un uinque_ptr, c'est déjà nettement plus tendu, quant au couple shared/weak, c'est carrément l'horreur. Commence plutôt par vector et string, mine de rien, ce n'est pas aussi évident que ça en à l'air (particulièrement une implémentation de string avec le small string optimization) et gros avantage, tu as des milliards d'exemples  d'utilisations.

-
Edité par int21h 27 octobre 2018 à 19:30:39