第四篇 C++元模板编程以及模板类的具体实现_c++ 模板元编程

模板类

模板编程可以带来更加灵活、通用、高效和安全的代码，尤其在 C++ 中，模板编程被广泛应用于实现通用的数据结构、算法库以及提供高性能的代码

主要有以下优点：

• 通用性和灵活性：模板编程使得代码可以编写成通用的形式，从而能够处理多种不同类型的数据。通过模板编程，可以编写出适用于不同数据类型的通用算法和数据结构，提高了代码的通用性和灵活性。
• 性能优化：模板编程可以在编译期间进行很多工作，包括优化代码、内联函数、消除冗余代码等，从而提高程序的性能。通过模板特化和内联展开等技术，可以生成高效的代码。
• 类型安全：使用模板可以在编译期对类型进行检查，从而避免一些运行时的类型错误。模板能够提供更好的类型安全性，使得代码更加健壮和可靠。
• 代码复用：通过模板编程，可以编写出高度复用的代码，避免重复的劳动，并且可以确保所有实例化的代码都是经过严格测试和验证的。
• 元编程：模板编程还可以用于进行元编程，即在编译期间生成代码。这样可以实现一些在运行期无法完成的任务，如计算、条件判断、类型处理等，从而提高程序的灵活性和性能

模板函数的实现

// 定义一个模板结构体 IsPointer，用于判断类型是否为指针类型
template <typename T>
struct IsPointer {
    static const bool value = false;
};

template <typename T>
struct IsPointer<T*> {
    static const bool value = true;
};

// 利用 IsPointer 类型结构体判断是否为指针类型，并输出结果
template <typename T>
void CheckIfPointer() {
    if (IsPointer<T>::value) {
        std::cout << "类型 " << typeid(T).name() << " 是指针类型\n";
    } else {
        std::cout << "类型 " << typeid(T).name() << " 不是指针类型\n";
    }
}


// 假设有一个需要管理的类
class MyClass {
public:
    void greet() {
        std::cout << "Hello from MyClass!" << std::endl;
    }
};

//测试代码
void test(){
	CheckIfPointer<int>();      // 检查 int 类型
    CheckIfPointer<float*>();   // 检查 float* 类型
    CheckIfPointer<std::string>();  // 检查 std::string 类型
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

智能指针模板类

是 C++ 中的一个重要概念，用于管理动态分配的内存，可以帮助避免内存泄漏和悬空指针等问题。下面是智能指针的一些好处：

• 自动内存管理：智能指针可以自动管理内存的生命周期，在对象不再需要时自动释放内存，避免了手动调用 delete 或 free 的繁琐操作。
• 避免内存泄漏：由于智能指针会在其作用域结束时自动释放内存，因此可以有效避免因忘记释放内存而导致的内存泄漏问题。
• 避免悬空指针：智能指针会在对象销毁后将指针置为 nullptr，避免了悬空指针的问题，使得程序更加健壮。
• 方便拷贝和赋值：智能指针通常实现了拷贝构造函数和赋值运算符重载，使得对指针的使用更加方便和安全。
• 提高代码可维护性：使用智能指针可以减少手动管理内存的复杂性，降低出错的可能性，从而提高代码的可维护性和可读性。
• 支持多线程：一些智能指针（如 std::shared_ptr）提供了引用计数的机制，可以在多线程环境下安全地共享对象所有权。

智能指针模板类的实现

//TODO: 实现一个智能指针模板类
//原理：利用类在构造时初始化，析构时销毁的特性，
//把一个类的内存管理委托到模板类上面，实现内存自动管理
template <class T>
class SmartPointer {
private:
    T* ptr;

public:
    SmartPointer(T* p) : ptr(p) {}

    ~SmartPointer() {
        delete ptr;
    }

    T& operator*() {
        return *ptr;
    }

    T* operator->() {
        return ptr;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

SmartPointer 是一个模板类，它接受一个模板参数 T，表示指针指向的类型。在类中包含一个私有指针 ptr，用于管理动态分配的内存。构造函数接受一个指向 T 类型对象的指针，并将其存储在 ptr 中。析构函数负责释放 ptr 指向的内存。此外，重载了 * 和 -> 运算符，以便通过智能指针访问指向的对象。

//TODO： 实现共享指针，在智能指针的基础上加上引用计数，
//通过适当增加和减少引用计数，可以确保正确地共享资源并在不再需要时释放资源
template <class T>
class SharedPointer {
private:
    T* ptr;
    int* refCount;

public:
    SharedPointer(T* p) : ptr(p), refCount(new int(1)) {}

    SharedPointer(const SharedPointer<T>& other) : ptr(other.ptr), refCount(other.refCount) {
        (*refCount)++;
    }

    ~SharedPointer() {
        (*refCount)--;
        std::cout << "~SharedPointer()" << std::endl;
        if (*refCount == 0) {
            delete ptr;
            delete refCount;
        }
    }

    SharedPointer<T>& operator=(const SharedPointer<T>& other) {
        if (this != &other) {
            (*refCount)--;
            if (*refCount == 0) {
                delete ptr;
                delete refCount;
            }

            ptr = other.ptr;
            refCount = other.refCount;
            (*refCount)++;
        }
        return *this;
    }

    T& operator*() {
        return *ptr;
    }

    T* operator->() {
        return ptr;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

//测试代码
// 假设有一个需要管理的类
class MyClass {
public:
    void greet() {
        std::cout << "Hello from MyClass!" << std::endl;
    }
};

typedef SmartPointer<MyClass> myClassPtr;
typedef SharedPointer<MyClass> myClassSharedPtr;

void test(){
	myClassPtr ptr = new MyClass();
    myClassSharedPtr  sharedPtr1 = new MyClass();
    ptr->greet();
    {
        myClassSharedPtr  sharedPtr2 = sharedPtr1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这里实现了一个简单的 SharedPtr 类模板，其中包含了引用计数 refCount。通过适当增加和减少引用计数，可以确保正确地共享资源并在不再需要时释放资源，确保资源在适当时机被释放。

单例模板类的实现

#include <iostream>

template <typename T>
class Singleton {
public:
    static T& getInstance() {
        static T instance;
        return instance;
    }
};

//测试代码
class MySingleton {
private:
    MySingleton() {} // Private constructor to prevent instantiation

public:
    void doSomething() {
        std::cout << "Doing something in MySingleton" << std::endl;
    }
};

void test() {
	MySingleton& singleton = Singleton<MySingleton>::getInstance();
    singleton.doSomething();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Singleton 类模板使用了模板元编程技术，通过静态成员函数 getInstance 返回单例对象的引用。这样可以确保只有一个实例被创建，并且在程序的整个生命周期中保持活动。