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.
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.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
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)
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.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
git is great because Linus did it, mercurial is better because he didn't.
Discord NaN. Mon site.