1
#include <iostream>
2
// 函数重载示例
3
int add(int a, int b) {
4
    std::cout << "调用int版本add()" << std::endl;
5
    return a + b;
6
}
7
double add(double a, double b) {
8
    std::cout << "调用double版本add()" << std::endl;
9
    return a + b;
10
}
11

12
// 注意：返回类型不同但参数列表相同，不是函数重载（会编译错误）
13
// float add(int a, int b) { return a + b; }  // 编译错误
14

15
int main() {
16
    int i = add(1, 2);           // 调用int版本
17
    double d = add(1.5, 2.5);    // 调用double版本
18
    return 0;
19
}

1
#include <iostream>
2

3
class Vector {
4
public:
5
    Vector(double x = 0.0, double y = 0.0) : x_(x), y_(y) {}
6

7
    // 重载+运算符
8
    Vector operator+(const Vector& rhs) const {
9
        return Vector(x_ + rhs.x_, y_ + rhs.y_);
10
    }
11

12
    // 重载<<运算符（全局函数）
13
    friend std::ostream& operator<<(std::ostream& os, const Vector& v) {
14
        os << "(" << v.x_ << ", " << v.y_ << ")";
15
        return os;
16
    }
17

18
private:
19
    double x_;
20
    double y_;
21
};
22

23
int main() {
24
    Vector v1(1.0, 2.0);
25
    Vector v2(3.0, 4.0);
26
    Vector v3 = v1 + v2;  // 使用重载的+运算符
27
    std::cout << "v1 + v2 = " << v3 << std::endl;  // 使用重载的<<运算符
28
    return 0;
29
}

1
v1 + v2 = (4, 6)

1
#include <iostream>
2
#include <string>
3

4
// 通用模板
5
template <typename T>
6
class Printer {
7
public:
8
    void print(const T& value) {
9
        std::cout << "通用模板: " << value << std::endl;
10
    }
11
};
12

13
// 模板特化（针对int类型）
14
template <>
15
class Printer<int> {
16
public:
17
    void print(const int& value) {
18
        std::cout << "int特化模板: " << value << std::endl;
19
    }
20
};
21

22
// 模板特化（针对std::string类型）
23
template <>
24
class Printer<std::string> {
25
public:
26
    void print(const std::string& value) {
27
        std::cout << "string特化模板: " << value << std::endl;
28
    }
29
};
30

31
int main() {
32
    Printer<double> d_printer;
33
    Printer<int> i_printer;
34
    Printer<std::string> s_printer;
35

36
    d_printer.print(3.14);    // 使用通用模板
37
    i_printer.print(42);       // 使用int特化模板
38
    s_printer.print("Hello");  // 使用string特化模板
39

40
    return 0;
41
}

1
通用模板: 3.14
2
int特化模板: 42
3
string特化模板: Hello

1
#include <iostream>
2

3
// CRTP基类
4
template <typename Derived>
5
class Shape {
6
public:
7
    void draw() {
8
        // 静态多态调用：编译期确定调用哪个drawImpl
9
        static_cast<Derived*>(this)->drawImpl();
10
    }
11
};
12

13
// 派生类：圆形
14
class Circle : public Shape<Circle> {
15
public:
16
    void drawImpl() {
17
        std::cout << "绘制圆形" << std::endl;
18
    }
19
};
20

21
// 派生类：矩形
22
class Rectangle : public Shape<Rectangle> {
23
public:
24
    void drawImpl() {
25
        std::cout << "绘制矩形" << std::endl;
26
    }
27
};
28

29
// 通用绘制函数（静态多态）
30
template <typename ShapeType>
31
void drawShape(Shape<ShapeType>& shape) {
32
    shape.draw();  // 编译期确定调用哪个drawImpl
33
}
34

35
int main() {
36
    Circle circle;
37
    Rectangle rectangle;
38

39
    drawShape(circle);     // 编译期确定调用Circle::drawImpl()
40
    drawShape(rectangle);  // 编译期确定调用Rectangle::drawImpl()
41

42
    return 0;
43
}

1
绘制圆形
2
绘制矩形

1
#include <iostream>
2

3
// 模板元编程：编译期计算阶乘
4
template <int N>
5
struct Factorial {
6
    static constexpr int value = N * Factorial<N - 1>::value;
7
};
8

9
// 特化版本：终止条件
10
template <>
11
struct Factorial<0> {
12
    static constexpr int value = 1;
13
};
14

15
int main() {
16
    // 编译期计算，运行时直接使用结果
17
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;
18
    std::cout << "Factorial<10>::value = " << Factorial<10>::value << std::endl;
19

20
    return 0;
21
}

1
Factorial<5>::value = 120
2
Factorial<10>::value = 3628800