智能指针的模板和指针的自动删除

Question

我在一个网站上遇到过这个简单的代码。我没有完全理解。如果有人可以逐行分解代码并解释，对我很有帮助。

这是用于创建智能指针模板的代码（自动删除指针是创建此类指针的主要座右铭）

#include <iostream>    
using namespace std;

template <class T>
class SmartPtr {
    T* ptr;

public:
    explicit SmartPtr(T* p = NULL) {
        ptr = p;
    }
    ~SmartPtr() {
        delete(ptr);
    }
    T& operator*() {
        return *ptr;
    }
    T* operator->() {
        return ptr;
    }
};

int main() {
    SmartPtr<int> ptr(new int());
    *ptr = 20;

    cout << *ptr;
    return 0;
}

Answer 1

您的类SmartPtr 封装了T 类型的指针，并重载了成员访问 和取消引用运算符 以允许访问封装的指针。此外，它在调用其析构函数时释放封装指针指向的分配内存。

你的课有评论：

template <class T>
class SmartPtr {
    T* ptr; // encapsulated pointer of type T

public:
    // constructor for SmartPtr class which assigns the specified pointer to the
    // encapsulated pointer
    explicit SmartPtr(T* p = NULL) {
        ptr = p;
    }
    // destructor for SmartPtr class which frees up the the allocated memory
    // pointed by the encapsulated pointer
    ~SmartPtr() {
        delete(ptr);
    }
    // overloads the dereference operator for SmartPtr class to allow syntax
    // like: *instance = value;
    T& operator*() {
        return *ptr;
    }
    // overloads the member access operator for SmartPtr class to allow syntax
    // like: instance->member();
    T* operator->() {
        return ptr;
    }
};

---

SmartPtr 类的用法显示在您提供的 main 函数中：

SmartPtr<int> ptr(new int());
*ptr = 20;

第一行执行class template instantiation 并通过调用构造函数以newly 创建的int 作为参数构造一个对象(ptr)。

第二行调用重载的解引用运算符并将值20 分配给封装的指针。这一行相当于：

ptr.operator*() = 20;

Answer 2

“逐行分解”有点过分了，以后尽量把个别不明白的部分提一下。但既然代码不多...

#include <iostream>
using namespace std;
template <class T> //make it a template in order to be able to store any type
class SmartPtr {
T *ptr; //wrapped pointer
public: explicit SmartPtr(T *p = NULL) { ptr = p; } //basic constructor

//delete pointer when the object dies.
//Note that this means that this is meant to be a unique pointer, 
//a shared pointer would have to count occurencies first
 ~SmartPtr() { delete(ptr); } 

//dereference operator to manipulate the content. 
//I prefer to go with T& instead of T & to make it clear that it is
//"reference of type T"
T & operator * () {  return *ptr; }
//bad operator which exposes the pointer itself.
//Make this const, like const T* operator -> () const { ... }
//else this could be used for the constructor again,
//leading to undefined behaviour when the pointer is deleted twice
T * operator -> () { return ptr; } }; //class ending brace at bad position

int main(){
SmartPtr<int> ptr(new int());
*ptr = 20;
cout << *ptr;
return 0; }