pointeur intelligent avec constructeur explicite me fait une erreur

Question

Je suis en train de construire mon propre pointeur intelligent qui me permettra de le déclarer comme ceci:

SmartPtr<MyClass> ptr = new MyClass; 

Je veux que le constructeur soit explicite si je l'ai fait comme ceci:

template<class T> 
class SmartPtr 
{ 
public: 
    SmartPtr(); 
    explicit SmartPtr(T* _ptr); 
    explicit SmartPtr(const SmartPtr& other); 
} 

Cependant, lorsque je tente de le déclarer comme je l'ai mentionné au-dessus, je reçois l'erreur suivante:

error: conversion from ‘MyClass*’ to non-scalar type ‘SmartPtr<MyClass>’ requested 

Je sais que l'erreur est due au fait que la copie CTOR a une syntaxe spéciale avec '=' et qu'une conversion CTOR ne peut pas être déclarée dans cette méthode. Ma question est, existe-t-il une méthode pour garder la syntaxe requise que j'ai mentionnée ci-dessus, et avoir un CTOR explicite?

Answer 1

My question is, is there any method to keep the required syntax I mentioned above, and have an explicit CTOR?

Probablement pas. Cette syntaxe est copy initialization et nécessite un constructeur non-explicite.

Notez que le constructeur de copie n'a pas besoin d'être explicite. S'il est explicite, vous ne pourrez pas passer SmartPtr à une fonction qui l'accepte par valeur.

---

Une autre façon de construire votre pointeur avec une surcharge de syntaxe minimum est d'ajouter une fonction d'usine et de l'utiliser comme:

template<class T> 
SmartPtr<T> make_ptr(T* p) { 
    return SmartPtr<T>{p}; 
} 

auto ptr = make_ptr(new MyClass); 

Ou, quelque chose de semblable à std::make_shared<>:

auto ptr = make_ptr<MyClass>();