模板类
模板编程可以带来更加灵活、通用、高效和安全的代码,尤其在 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 类型
}
智能指针模板类
是 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;
}
};
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;
}
};
//测试代码
// 假设有一个需要管理的类
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;
}
}
这里实现了一个简单的 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();
}
Singleton 类模板使用了模板元编程技术,通过静态成员函数 getInstance 返回单例对象的引用。这样可以确保只有一个实例被创建,并且在程序的整个生命周期中保持活动。