从析构类中的多个成员说起

你有没有遇到过这种情况，一个类的构造函数中new了很多个成员变量，在析构函数中回收内存时，写了一遍又一遍 下面的代码：

if (ptr != nullptr) {
	delete ptr;
	ptr = nullptr;
}

看一个例子：
B.h

#ifndef SAFEDELETE_B_H
#define SAFEDELETE_B_H


class B {
public:
    explicit B();
    ~B();
};


#endif //SAFEDELETE_B_H

B.cpp

#include <iostream>
#include "B.h"

B::B() {

}

B::~B() {
    std::cout << "destroy B..." << std::endl;
}

C.h

#ifndef SAFEDELETE_C_H
#define SAFEDELETE_C_H


class C {
public:
    explicit C();
    ~C();
};


#endif //SAFEDELETE_C_H

C.cpp

#include <iostream>
#include "C.h"

C::C() {

}

C::~C() {
    std::cout << "destroy C..." << std::endl;
}

A.h

#ifndef SAFEDELETE_A_H
#define SAFEDELETE_A_H
#include "B.h"
#include "C.h"

class A {
public:
    explicit A();
    ~A();

private:
    B* b{nullptr};
    C* c{nullptr};
};

#endif //SAFEDELETE_A_H

A.cpp

#include <iostream>
#include "A.h"

A::A() {
    b = new B();
    c = new C();
}

A::~A() {
    if (b != nullptr) {
        delete b;
        b = nullptr;
    }
    if (c != nullptr) {
        delete c;
        c = nullptr;
    }
    std::cout << "destroy A..." << std::endl;
}

在A的析构函数中释放b、c的内存时，写了6行代码，如果有20甚至更多数量的成员时，析构函数就显得很臃肿。
这种情况在使用Qt的时候尤为常见，一个类中可能有数十个控件，最后回收内存的时候，光写delete都有将近百十行代码。这时候，如果再有编码规范限制你一个函数不能超过50行，是不是很崩溃？你可能会说，没关系我可以抽几个函数出来，这样确实也能解决问题，但是纯粹为了抽函数而抽不是最佳方法，下面分享另一种更实用的方法——函数模板。

什么是函数模板

C++的函数模板是‌泛型编程的基础，‌它允许定义一种与类型无关的通用函数‌。‌通过使用模板，‌可以编写出适用于多种数据类型的函数，‌而无需为每种类型单独编写代码。‌函数模板的定义以关键字template开始，‌后跟模板参数列表，‌通常是typename T，‌其中T是一个占位符，‌代表任意类型。‌在函数模板的定义中，‌可以使用T来代表函数的参数类型、‌返回值类型或函数体内的变量类型。‌当调用函数模板时，‌编译器会根据实参的类型自动推断出模板参数T的具体类型，‌从而生成相应类型的函数实例。‌这种机制极大地提高了代码的复用性和灵活性‌。

使用函数模板

看到这种重复代码，相信你已经想到了有没有一种通用的方法可以解决不同类对象的析构问题，答案是肯定的。
使用函数模板，将类型忽略，就可以写出下面的函数：

template<typename T>
void safeDelete(T *&ptr) {
    if (ptr != nullptr) {
        delete ptr;
        ptr = nullptr;
    }
}

在A类中加入模板函数，修改析构函数：
A.cpp

#include <iostream>
#include "A.h"

A::A() {
    b = new B();
    c = new C();
}

A::~A() {
    safeDelete(b);
    safeDelete(c);
    std::cout << "destroy A..." << std::endl;
}

// 使用函数模板
template<typename T>
void A::safeDelete(T *&ptr) {
    if (ptr != nullptr) {
        delete ptr;
        ptr = nullptr;
    }
}

在main函数中delete A类的对象，

#include <iostream>
#include "A.h"

using namespace std;

int main() {
    A* a = new A();
    delete a;
    a = nullptr;

    return 0;
}

运行结果：

使用函数模板就可以解决析构函数中写太多if的问题，代码看起来也很优雅！