C++类模板与泛型编程

C++类模板与泛型编程

类模板是C++泛型编程的核心，允许定义与类型无关的数据结构。模板在编译期实例化，为每种类型生成专门的代码。

类模板的基本定义使用template语法。

#include
#include
#include

template
class Array {
T* data_;
size_t size_;
public:
explicit Array(size_t n) : data_(new T[n]()), size_(n) {
std::cout << "Array of " << n << " elements\n";
}

~Array() { delete[] data_; }

Array(const Array& other) : data_(new T[other.size_]), size_(other.size_) {
for (size_t i = 0; i < size_; ++i) data_[i] = other.data_[i];
}

Array& operator=(const Array& other) {
if (this != &other) {
T* new_data = new T[other.size_];
for (size_t i = 0; i < other.size_; ++i) new_data[i] = other.data_[i];
delete[] data_;
data_ = new_data;
size_ = other.size_;
}
return *this;
}

T& operator[](size_t i) { return data_[i]; }
const T& operator[](size_t i) const { return data_[i]; }
size_t size() const { return size_; }

T* begin() { return data_; }
T* end() { return data_ + size_; }
const T* begin() const { return data_; }
const T* end() const { return data_ + size_; }
};

void class_template_basic() {
Array ints(5);
for (size_t i = 0; i < ints.size(); ++i) ints[i] = i * 10;

for (int v : ints) std::cout << v << " ";
std::cout << "\n";

Array doubles(3);
doubles[0] = 1.5;
doubles[1] = 2.5;
doubles[2] = 3.5;

Array strings(2);
strings[0] = "Hello";
strings[1] = "World";
}

模板参数可以是类型、非类型或模板模板参数。

template
class FixedArray {
T data_[N];
public:
T& operator[](size_t i) { return data_[i]; }
const T& operator[](size_t i) const { return data_[i]; }
constexpr size_t size() const { return N; }

T* begin() { return data_; }
T* end() { return data_ + N; }
};

void non_type_params() {
FixedArray arr;
for (size_t i = 0; i < arr.size(); ++i) arr[i] = i * i;

for (int v : arr) std::cout << v << " ";
std::cout << "\n";

std::cout << "Size: " << arr.size() << "\n";
}

模板特化为特定类型提供特殊实现。

template
class TypeProcessor {
public:
void process(T value) {
std::cout << "Generic: " << value << "\n";
}
};

template<>
class TypeProcessor {
public:
void process(int value) {
std::cout << "Specialized for int: " << value * 2 << "\n";
}
};

template<>
class TypeProcessor {
public:
void process(const std::string& value) {
std::cout << "String length: " << value.length() << "\n";
}
};

void template_specialization() {
TypeProcessor dp;
dp.process(3.14);

TypeProcessor ip;
ip.process(42);

TypeProcessor sp;
sp.process("Hello");
}

类模板偏特化。

template
class Resource {
public:
void use() {
std::cout << "Generic resource\n";
}
};

template
class Resource {
T* ptr_;
public:
explicit Resource(T* p) : ptr_(p) {}
~Resource() { delete ptr_; }

T* operator->() { return ptr_; }
T& operator*() { return *ptr_; }

void use() {
std::cout << "Managed resource\n";
}
};

template
class Resource {
T* ptr_;
public:
explicit Resource(T* p) : ptr_(p) {}

T* operator->() { return ptr_; }
T& operator*() { return *ptr_; }
};

继承类模板。

template
class Base {
protected:
T value_;
public:
explicit Base(T v) : value_(v) {}
virtual void show() { std::cout << value_ << "\n"; }
};

template
class Derived : public Base {
U extra_;
public:
Derived(T v, U e) : Base(v), extra_(e) {}
void show() override {
std::cout << this->value_ << ", " << extra_ << "\n";
}
};

void template_inheritance() {
Derived d(42, "answer");
d.show();
}

模板成员函数。

class Utils {
public:
template
static T max(T a, T b) {
return a > b ? a : b;
}

template
static T min(T a, T b) {
return a < b ? a : b;
}
};

void template_members() {
std::cout << "Max(3, 7): " << Utils::max(3, 7) << "\n";
std::cout << "Min(3.14, 2.71): " << Utils::min(3.14, 2.71) << "\n";
}

类模板是STL的基础，STL中的容器、迭代器和算法都是类模板的应用。