16.6 Efficacité et flexibilité
Dans cet article, l'amorce C ++ utilise deux exemples de pointeurs intelligents
La différence dans la façon dont shared_ptr et unique_ptr spécifient les suppresseurs est en fait la différence entre les fonctions de ces deux classes.
Voyons d'abord comment définir le suppresseur de shared_ptr
Apprenez du site Web de csdn
https://blog.csdn.net/hp_cpp/article/details/103452196
Passez le pointeur de la fonction dans le constructeur:
#include <iostream>
#include <zconf.h>
#include "template.h"
using namespace std;
class Simple{
};
void deleter(Simple *)
{
cout<<"Deleter function called"<<endl;
}
// 构造函数传递自定义删除器指针
int main() {
std::shared_ptr<Simple> p1(new Simple[5],deleter);
return 0;
}
Utiliser des foncteurs dans le constructeur
Nous pouvons regarder un exemple comme celui-ci
class Deleter
{
public:
void operator() (Simple *x) {
std::cout << "Deleter function called" << std::endl;
delete[] x;
}
};
// 构造函数传递自定义删除器指针
int main() {
Deleter del;
std::shared_ptr<Simple> p1(new Simple[5],del);
return 0;
}
Grâce à la surcharge d'opérateurs, nous pouvons surcharger la classe en une méthode d'appel de type fonction
Deleter del;
Simple* data = new Simple();
del(data);
Cela déclenchera également la fonction Deleter appelée
expression lambda?
Je ne comprends vraiment pas ce contenu, je ne sais pas ce qu'est lambda
std::shared_ptr<Sample> p3(new Sample[5], [](Sample *x) {
std::cout << "Deleter function called" << std::endl;
delete[] x;
});
La première fois que j'ai entendu parler de cette chose en C ++
Jetons un coup d'œil à cette expression lambda:
Il s'avère qu'une expression lambda est une fermeture, ce que nous disons comme une fonction anonyme en PHP. Elle n'est utilisée qu'une seule fois, donc il n'y a pas besoin du nom de la fonction. Il y a aussi des fermetures dans js.
Une des expressions lambda les plus simples
[] {} ();
void f()
{
}
int main()
{
f();
}
Si vous comprenez cela, la fonction ci-dessus est très facile à comprendre
#include <memory>
#include <cstring>
#include <vector>
#include <stdio.h>
#include <iostream>
#include <zconf.h>
#include "template.h"
using namespace std;
class Simple{
};
// 构造函数传递自定义删除器指针
int main() {
std::shared_ptr<Simple> p1(new Simple[5],[](Simple* x){
std::cout << "Deleter function called" << std::endl;
delete[] x;
});
return 0;
}
La quatrième méthode consiste à utiliser default_delete
std::shared_ptr<Simple> p (new Simple[5],std::default_delete<Simple[]>());
Jetons un coup d'œil à la façon dont unique_ptr spécifie le suppresseur
L'unique_ptr ne sera pas répété, définissez simplement la fonction dans le modèle, puis effectuez l'implémentation lorsque les paramètres sont passés.
Pour plus de détails, veuillez vous référer à csdn
https://blog.csdn.net/hp_cpp/article/details/103210135
Pour résumer
Enfin, nous pouvons voir que shared_ptr ne sauvegarde pas directement le suppresseur en tant que membre, car le type du suppresseur ne sera pas tant qu'il ne sera pas exécuté. En fait, le type du suppresseur peut être modifié à tout moment. Le type du suppresseur Le deleter unique_ptr est au moment de la compilation. Comme vous le savez, unique_ptr évite la surcharge de l'appel indirect du deleter. En liant le suppresseur au moment de l'exécution, shared_ptr permet aux utilisateurs de recharger le suppresseur plus facilement.