# C++类型系统深度解析：内置类型与自定义类型的对比

## 引言：类型系统的核心价值

在C++编程中，类型系统不仅是语法的基础，更是程序安全性和性能的保障。从基本的内置类型到复杂的自定义类型，理解它们的特性、差异和适用场景，对于编写高效可靠的代码至关重要。本文将深入探讨C++类型系统的内在机制，对比分析内置类型与自定义类型的设计哲学和应用实践。

## 第一部分：内置类型体系

### 基础类型特性

```cpp

#include <iostream>

#include <type_traits>

#include <limits>

void basic_type_properties() {

    std::cout << "=== C++内置类型特性 ===" << std::endl;

    

    // 1. 整数类型

    std::cout << "\n整数类型:" << std::endl;

    std::cout << "char 大小: " << sizeof(char) << " 字节" 

              << "，范围: " << (int)std::numeric_limits<char>::min() 

              << " 到 " << (int)std::numeric_limits<char>::max() << std::endl;

    

    std::cout << "int 大小: " << sizeof(int) << " 字节" 

              << "，范围: " << std::numeric_limits<int>::min() 

              << " 到 " << std::numeric_limits<int>::max() << std::endl;

    

    std::cout << "long long 大小: " << sizeof(long long) << " 字节" 

              << "，范围: " << std::numeric_limits<long long>::min() 

              << " 到 " << std::numeric_limits<long long>::max() << std::endl;

    

    // 2. 浮点类型

    std::cout << "\n浮点类型:" << std::endl;

    std::cout << "float 大小: " << sizeof(float) << " 字节" 

              << "，精度: " << std::numeric_limits<float>::digits10 << " 位" << std::endl;

    

    std::cout << "double 大小: " << sizeof(double) << " 字节" 

              << "，精度: " << std::numeric_limits<double>::digits10 << " 位" << std::endl;

    

    std::cout << "long double 大小: " << sizeof(long double) << " 字节" 

              << "，精度: " << std::numeric_limits<long double>::digits10 << " 位" << std::endl;

    

    // 3. 类型特性查询

    std::cout << "\n类型特性:" << std::endl;

    std::cout << "int 是否有符号: " << std::is_signed<int>::value << std::endl;

    std::cout << "char 是否有符号: " << std::is_signed<char>::value << " (实现定义)" << std::endl;

    std::cout << "double 是浮点数: " << std::is_floating_point<double>::value << std::endl;

    std::cout << "void* 是指针: " << std::is_pointer<void*>::value << std::endl;

}

// 类型别名和类型推导

void type_aliases_and_deduction() {

    std::cout << "\n=== 类型别名与推导 ===" << std::endl;

    

    // 1. 类型别名

    using Byte = unsigned char;

    using IntPtr = int*;

    using Array10 = int[10];

    

    Byte b = 255;

    IntPtr p = nullptr;

    Array10 arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    

    std::cout << "Byte 大小: " << sizeof(Byte) << std::endl;

    std::cout << "Array10 大小: " << sizeof(Array10) << std::endl;

    

    // 2. auto 类型推导

    auto x = 42;            // int

    auto y = 3.14;          // double

    auto z = "Hello";       // const char*

    

    std::cout << "\nauto 推导结果:" << std::endl;

    std::cout << "x 类型: " << typeid(x).name() << std::endl;

    std::cout << "y 类型: " << typeid(y).name() << std::endl;

    std::cout << "z 类型: " << typeid(z).name() << std::endl;

    

    // 3. decltype 类型查询

    int i = 10;

    const int& ri = i;

    decltype(ri) rj = i;    // const int&

    decltype(i) j = 20;     // int

    

    std::cout << "\ndecltype 示例:" << std::endl;

    std::cout << "ri 类型: " << typeid(ri).name() << std::endl;

    std::cout << "rj 类型: " << typeid(rj).name() << std::endl;

}

// 内置类型的操作特性

void builtin_type_operations() {

    std::cout << "\n=== 内置类型操作 ===" << std::endl;

    

    // 1. 算术运算

    int a = 10, b = 3;

    std::cout << "整数运算:" << std::endl;

    std::cout << a << " + " << b << " = " << a + b << std::endl;

    std::cout << a << " / " << b << " = " << a / b << " (整数除法)" << std::endl;

    

    double da = 10.0, db = 3.0;

    std::cout << "\n浮点运算:" << std::endl;

    std::cout << da << " / " << db << " = " << da / db << " (浮点除法)" << std::endl;

    

    // 2. 位运算

    unsigned int flags = 0b1010;  // 二进制字面量

    unsigned int mask = 0b0010;

    

    std::cout << "\n位运算:" << std::endl;

    std::cout << "flags: " << std::bitset<8>(flags) << std::endl;

    std::cout << "flags & mask: " << std::bitset<8>(flags & mask) << std::endl;

    std::cout << "flags | mask: " << std::bitset<8>(flags | mask) << std::endl;

    

    // 3. 指针运算

    int array[5] = {10, 20, 30, 40, 50};

    int* ptr = array;

    

    std::cout << "\n指针运算:" << std::endl;

    std::cout << "*ptr = " << *ptr << std::endl;

    std::cout << "*(ptr + 2) = " << *(ptr + 2) << std::endl;

    std::cout << "ptr[3] = " << ptr[3] << std::endl;

}

```

### 类型转换与提升

```cpp

#include <typeinfo>

void type_conversion_and_promotion() {

    std::cout << "=== 内置类型转换 ===" << std::endl;

    

    // 1. 隐式类型转换

    std::cout << "\n隐式转换:" << std::endl;

    

    char c = 'A';

    int i = c;              // 整型提升：char → int

    std::cout << "char 'A' → int: " << i << std::endl;

    

    int num = 42;

    double d = num;         // 浮点提升：int → double

    std::cout << "int 42 → double: " << d << std::endl;

    

    // 2. 算术转换

    std::cout << "\n算术转换:" << std::endl;

    

    int x = 10;

    double y = 3.14;

    auto result1 = x + y;   // int提升为double

    std::cout << "int + double → " << typeid(result1).name() 

              << ": " << result1 << std::endl;

    

    unsigned int u = 100;

    int s = -50;

    auto result2 = u + s;   // 有符号转为无符号

    std::cout << "unsigned + signed → " << typeid(result2).name() 

              << ": " << result2 << std::endl;

    

    // 3. 显式类型转换

    std::cout << "\n显式转换:" << std::endl;

    

    double pi = 3.14159;

    int int_pi = static_cast<int>(pi);  // 截断

    std::cout << "static_cast<double → int>: " << int_pi << std::endl;

    

    void* vptr = &pi;

    double* dptr = static_cast<double*>(vptr);  // void*转换

    std::cout << "通过void*转换后的值: " << *dptr << std::endl;

    

    // 4. 类型退化

    std::cout << "\n类型退化:" << std::endl;

    

    int arr[5] = {1, 2, 3, 4, 5};

    std::cout << "数组类型: " << typeid(arr).name() << std::endl;

    

    auto decayed = arr;      // 数组退化为指针

    std::cout << "退化后类型: " << typeid(decayed).name() << std::endl;

}

```

## 第二部分：自定义类型体系

### 结构体与类

```cpp

#include <string>

#include <iostream>

// 1. 结构体（默认public访问权限）

struct Point {

    // 数据成员

    double x;

    double y;

    

    // 构造函数

    Point(double x_val = 0.0, double y_val = 0.0) 

        : x(x_val), y(y_val) {}

    

    // 成员函数

    void move(double dx, double dy) {

        x += dx;

        y += dy;

    }

    

    double distance_to_origin() const {

        return std::sqrt(x * x + y * y);

    }

    

    // 运算符重载

    Point operator+(const Point& other) const {

        return Point(x + other.x, y + other.y);

    }

    

    // 类型转换运算符

    operator std::string() const {

        return "(" + std::to_string(x) + ", " + std::to_string(y) + ")";

    }

};

// 2. 类（默认private访问权限）

class Circle {

private:

    Point center;

    double radius;

    

public:

    // 构造函数

    Circle(const Point& c = Point(), double r = 1.0)

        : center(c), radius(r) {

        if (radius <= 0) {

            throw std::invalid_argument("半径必须为正数");

        }

    }

    

    // 访问器（getter）

    Point get_center() const { return center; }

    double get_radius() const { return radius; }

    

    // 修改器（setter）

    void set_center(const Point& c) { center = c; }

    void set_radius(double r) {

        if (r <= 0) throw std::invalid_argument("半径必须为正数");

        radius = r;

    }

    

    // 业务方法

    double area() const {

        return 3.14159 * radius * radius;

    }

    

    double circumference() const {

        return 2 * 3.14159 * radius;

    }

    

    bool contains(const Point& p) const {

        double dx = p.x - center.x;

        double dy = p.y - center.y;

        return (dx * dx + dy * dy) <= (radius * radius);

    }

    

    // 友元函数

    friend std::ostream& operator<<(std::ostream& os, const Circle& c);

};

std::ostream& operator<<(std::ostream& os, const Circle& c) {

    os << "Circle{center=(" << c.center.x << ", " << c.center.y 

       << "), radius=" << c.radius << "}";

    return os;

}

void class_vs_struct_demo() {

    std::cout << "=== 类与结构体对比 ===" << std::endl;

    

    // 结构体使用

    Point p1(1.0, 2.0);

    Point p2(3.0, 4.0);

    

    std::cout << "\n结构体示例:" << std::endl;

    std::cout << "p1: " << static_cast<std::string>(p1) << std::endl;

    std::cout << "p2: " << static_cast<std::string>(p2) << std::endl;

    

    Point p3 = p1 + p2;

    std::cout << "p1 + p2 = " << static_cast<std::string>(p3) << std::endl;

    

    // 类使用

    Circle c(p1, 5.0);

    

    std::cout << "\n类示例:" << std::endl;

    std::cout << c << std::endl;

    std::cout << "面积: " << c.area() << std::endl;

    std::cout << "周长: " << c.circumference() << std::endl;

    

    Point test_point(2.0, 3.0);

    std::cout << "点" << static_cast<std::string>(test_point) 

              << " 在圆内: " << std::boolalpha << c.contains(test_point) << std::endl;

}

// 3. 枚举类（强类型枚举）

enum class Color : uint8_t {

    Red = 1,

    Green = 2,

    Blue = 3,

    Yellow = Red | Green  // 位运算组合

};

enum class Priority : int {

    Low = 1,

    Medium = 2,

    High = 3

};

class TrafficLight {

private:

    Color current_color;

    

public:

    TrafficLight() : current_color(Color::Red) {}

    

    void change() {

        switch (current_color) {

            case Color::Red:

                current_color = Color::Green;

                break;

            case Color::Green:

                current_color = Color::Yellow;

                break;

            case Color::Yellow:

                current_color = Color::Red;

                break;

            default:

                break;

<"tiantian.juchengbibu.com">

<"tt.aekt.cn">

<"tt.baiyng.com">

        }

    }

    

    Color get_color() const { return current_color; }

    

    std::string color_name() const {

        switch (current_color) {

            case Color::Red: return "Red";

            case Color::Green: return "Green";

            case Color::Blue: return "Blue";

            case Color::Yellow: return "Yellow";

            default: return "Unknown";

        }

    }

};

void enum_class_demo() {

    std::cout << "\n=== 枚举类示例 ===" << std::endl;

    

    TrafficLight light;

    

    std::cout << "初始颜色: " << light.color_name() << std::endl;

    

    light.change();

    std::cout << "第一次变化: " << light.color_name() << std::endl;

    

    light.change();

    std::cout << "第二次变化: " << light.color_name() << std::endl;

    

    // 枚举类的类型安全

    Color color = Color::Red;

    Priority priority = Priority::High;

    

    // 错误：不能直接比较不同的枚举类

    // if (color == priority) { ... }

    

    // 正确：显式转换后比较

    if (static_cast<int>(color) == static_cast<int>(priority)) {

        std::cout << "数值相等但类型不同" << std::endl;

    }

}

```

### 高级自定义类型

```cpp

#include <memory>

#include <vector>

#include <algorithm>

// 1. 模板类

template<typename T>

class Container {

private:

    std::vector<T> items;

    

public:

    Container() = default;

    

    void add(const T& item) {

        items.push_back(item);

    }

    

    void remove(const T& item) {

        items.erase(std::remove(items.begin(), items.end(), item), items.end());

    }

    

    bool contains(const T& item) const {

        return std::find(items.begin(), items.end(), item) != items.end();

    }

    

    size_t size() const {

        return items.size();

    }

    

    // 迭代器支持

    typename std::vector<T>::iterator begin() { return items.begin(); }

    typename std::vector<T>::iterator end() { return items.end(); }

    typename std::vector<T>::const_iterator begin() const { return items.begin(); }

    typename std::vector<T>::const_iterator end() const { return items.end(); }

};

// 2. 继承与多态

class Shape {

public:

    virtual ~Shape() = default;

    

    virtual double area() const = 0;

    virtual double perimeter() const = 0;

    virtual void draw() const = 0;

    

    virtual std::string type() const {

        return "Shape";

    }

};

class Rectangle : public Shape {

private:

    double width;

    double height;

    

public:

    Rectangle(double w, double h) : width(w), height(h) {

        if (w <= 0 || h <= 0) {

            throw std::invalid_argument("宽度和高度必须为正数");

        }

    }

    

    double area() const override {

        return width * height;

    }

    

    double perimeter() const override {

        return 2 * (width + height);

    }<"tt.fajining.com">

    

    void draw() const override {

        std::cout << "绘制矩形: " << width << "x" << height << std::endl;

    }

    

    std::string type() const override {

        return "Rectangle";

    }

};

class Triangle : public Shape {

private:

    double a, b, c;  // 三边长度

    

public:

    Triangle(double side1, double side2, double side3) 

        : a(side1), b(side2), c(side3) {

        if (!is_valid()) {

            throw std::invalid_argument("无效的三角形边长");

        }

    }

    

    double area() const override {

        // 海伦公式

        double s = perimeter() / 2;

        return std::sqrt(s * (s - a) * (s - b) * (s - c));

    }

    

    double perimeter() const override {

        return a + b + c;

    }

    

    void draw() const override {

        std::cout << "绘制三角形: 边长(" << a << ", " << b << ", " << c << ")" << std::endl;

    }

    

    std::string type() const override {

        return "Triangle";

    }

    

private:

    bool is_valid() const {

        return (a > 0 && b > 0 && c > 0) &&

               (a + b > c) && (a + c > b) && (b + c > a);

    }

};

// 3. 智能指针作为自定义类型的一部分

class ResourceManager {

private:

    class Resource {

    public:

        std::string name;

        std::vector<int> data;

        

        Resource(const std::string& n, size_t size) : name(n), data(size) {

            std::cout << "创建资源: " << name << std::endl;

        }

        

        ~Resource() {

            std::cout << "销毁资源: " << name << std::endl;

        }

        

        void process() {

            std::cout << "处理资源: " << name 

                      << ", 大小: " << data.size() << std::endl;

        }

    };

    

    std::vector<std::shared_ptr<Resource>> resources;

    

public:

    std::shared_ptr<Resource> create_resource(const std::string& name, size_t size) {

        auto resource = std::make_shared<Resource>(name, size);

        resources.push_back(resource);

        return resource;

    }

    

    void cleanup() {

        // 移除所有未使用的资源

        resources.erase(

            std::remove_if(resources.begin(), resources.end(),

                [](const std::shared_ptr<Resource>& res) {

                    return res.use_count() == 1;  // 只有资源管理器持有

                }),

            resources.end()

        );

    }

    

    size_t count_resources() const {

        return resources.size();

    }<"tt.dongzei.com">

};

void advanced_types_demo() {

    std::cout << "=== 高级自定义类型示例 ===" << std::endl;

    

    // 模板类使用

    Container<int> int_container;

    int_container.add(10);

    int_container.add(20);

    int_container.add(30);

    

    std::cout << "\n模板容器:" << std::endl;

    std::cout << "容器大小: " << int_container.size() << std::endl;

    std::cout << "包含20: " << std::boolalpha << int_container.contains(20) << std::endl;

    

    // 继承与多态

    std::vector<std::unique_ptr<Shape>> shapes;

    shapes.push_back(std::make_unique<Rectangle>(3.0, 4.0));

    shapes.push_back(std::make_unique<Triangle>(3.0, 4.0, 5.0));

    

    std::cout << "\n多态形状:" << std::endl;

    for (const auto& shape : shapes) {

        std::cout << shape->type() 

                  << " - 面积: " << shape->area()

                  << ", 周长: " << shape->perimeter() << std::endl;

        shape->draw();

    }

    

    // 智能指针管理

    ResourceManager manager;

    

    std::cout << "\n资源管理:" << std::endl;

    auto res1 = manager.create_resource("Data1", 100);

    auto res2 = manager.create_resource("Data2", 200);

    

    {

        auto res3 = manager.create_resource("Data3", 300);

        res3->process();

        std::cout << "临时资源计数: " << manager.count_resources() << std::endl;

    }

    

    std::cout << "临时资源离开作用域后计数: " << manager.count_resources() << std::endl;

    

    manager.cleanup();

    std::cout << "清理后计数: " << manager.count_resources() << std::endl;

}

```

## 第三部分：类型特性对比分析

### 内存布局与对齐

```cpp

#include <iostream>

#include <cstddef>

#include <type_traits>

struct MemoryLayoutExample {

    char c;     // 1字节

    int i;      // 4字节（可能需要对齐）

    double d;   // 8字节

    short s;    // 2字节

};

struct PackedLayout {

    char c;

    int i;

    double d;

    short s;

} __attribute__((packed));  // GCC/Clang打包属性

#pragma pack(push, 1)

struct PackedLayoutMSVC {

    char c;

    int i;

    double d;

    short s;

};

#pragma pack(pop)

class VirtualClass {

public:

    virtual void method() {}  // 添加虚函数表指针

    int data;

};

void memory_layout_analysis() {

    std::cout << "=== 内存布局对比 ===" << std::endl;

    

    // 内置类型

    std::cout << "\n内置类型大小:" << std::endl;

    std::cout << "char: " << sizeof(char) << " 字节" << std::endl;

    std::cout << "int: " << sizeof(int) << " 字节" << std::endl;

    std::cout << "double: " << sizeof(double) << " 字节" << std::endl;

    std::cout << "void*: " << sizeof(void*) << " 字节" << std::endl;

    

    // 结构体内存布局

    std::cout << "\n结构体内存布局:" << std::endl;

    std::cout << "MemoryLayoutExample 大小: " << sizeof(MemoryLayoutExample) 

              << " 字节" << std::endl;

    std::cout << "对齐要求: " << alignof(MemoryLayoutExample) << " 字节" << std::endl;

    

    std::cout << "成员偏移量:" << std::endl;

    std::cout << "  c: " << offsetof(MemoryLayoutExample, c) << std::endl;

    std::cout << "  i: " << offsetof(MemoryLayoutExample, i) << std::endl;

    std::cout << "  d: " << offsetof(MemoryLayoutExample, d) << std::endl;

    std::cout << "  s: " << offsetof(MemoryLayoutExample, s) << std::endl;

    

    // 打包结构

    std::cout << "\n打包结构大小: " << sizeof(PackedLayout) << " 字节" << std::endl;

    

    // 类与结构体对比

    std::cout << "\n类与结构体对比:" << std::endl;

    struct PlainStruct {

        int a, b, c;

    };

    

    class PlainClass {

        int a, b, c;

    public:

        PlainClass(int x, int y, int z) : a(x), b(y), c(z) {}

    };<"tt.bajilin.com">

    

    std::cout << "PlainStruct 大小: " << sizeof(PlainStruct) << std::endl;

    std::cout << "PlainClass 大小: " << sizeof(PlainClass) << std::endl;

    

    // 多态类

    std::cout << "\n多态类内存开销:" << std::endl;

    std::cout << "VirtualClass 大小: " << sizeof(VirtualClass) << std::endl;

    std::cout << "虚函数表指针大小: " << sizeof(void*) << std::endl;

    

    // 空类

    class EmptyClass {};

    

    std::cout << "\n空类大小: " << sizeof(EmptyClass) << " 字节" << std::endl;

    std::cout << "空类对齐: " << alignof(EmptyClass) << " 字节" << std::endl;

}

// 类型特性工具类

template<typename T>

void print_type_info(const char* name) {

    std::cout << name << ":" << std::endl;

    std::cout << "  大小: " << sizeof(T) << " 字节" << std::endl;

    std::cout << "  对齐: " << alignof(T) << std::endl;

    std::cout << "  平凡可复制: " << std::is_trivially_copyable<T>::value << std::endl;

    std::cout << "  标准布局: " << std::is_standard_layout<T>::value << std::endl;

    std::cout << "  POD类型: " << std::is_pod<T>::value << std::endl;

}

void type_traits_comparison() {

    std::cout << "\n=== 类型特性对比 ===" << std::endl;

    

    // 内置类型

    print_type_info<int>("int");

    print_type_info<double>("double");

    

    // 自定义类型

    struct TrivialStruct {

        int x;

        double y;

    };

    

    class NonTrivialClass {

        std::string data;  // 包含非平凡类型

    public:

        NonTrivialClass() {}

        ~NonTrivialClass() {}

    };

    

    print_type_info<TrivialStruct>("TrivialStruct");

    print_type_info<NonTrivialClass>("NonTrivialClass");

}

```

### 性能特性对比

```cpp

#include <chrono>

#include <vector>

#include <algorithm>

class PerformanceAnalyzer {

public:

    template<typename Func>

    static double measure_time(Func func, int iterations = 1000) {

        auto start = std::chrono::high_resolution_clock::now();

        

        for (int i = 0; i < iterations; ++i) {

            func();

        }

        

        auto end = std::chrono::high_resolution_clock::now();

        return std::chrono::duration<double, std::micro>(end - start).count() / iterations;

    }

};

// 性能测试类型

struct Point2D {

    double x, y;

    

    Point2D(double x = 0, double y = 0) : x(x), y(y) {}

    

    Point2D operator+(const Point2D& other) const {

        return Point2D(x + other.x, y + other.y);

    }

    

    double dot(const Point2D& other) const {

        return x * other.x + y * other.y;

    }

};

class Point2DClass {

private:

    double x_, y_;

    

public:

    Point2DClass(double x = 0, double y = 0) : x_(x), y_(y) {}

    

    Point2DClass add(const Point2DClass& other) const {

        return Point2DClass(x_ + other.x_, y_ + other.y_);

    }

    

    double dot(const Point2DClass& other) const {

        return x_ * other.x_ + y_ * other.y_;

    }

    

    double x() const { return x_; }

    double y() const { return y_; }

};

void performance_comparison() {

    std::cout << "=== 性能特性对比 ===" << std::endl;

    

    const int size = 10000;

    const int iterations = 100;

    

    // 1. 内存访问模式测试

    std::cout << "\n1. 内存访问模式测试:" << std::endl;

    

    // 内置类型数组

    std::vector<double> builtin_array(size);

    for (int i = 0; i < size; ++i) {

        builtin_array[i] = i * 0.1;

    }

    

    // 结构体数组

    std::vector<Point2D> struct_array(size);

    for (int i = 0; i < size; ++i) {

        struct_array[i] = Point2D(i * 0.1, i * 0.2);

    }

    

    // 类对象数组

    std::vector<Point2DClass> class_array;

    class_array.reserve(size);

    for (int i = 0; i < size; ++i) {

        class_array.emplace_back(i * 0.1, i * 0.2);

    }

    

    // 测试求和操作

    auto builtin_sum = [&]() {

        double sum = 0;

        for (const auto& val : builtin_array) {

            sum += val;

        }

        return sum;

    };

    

    auto struct_sum = [&]() {

        Point2D sum;

        for (const auto& point : struct_array) {

            sum = sum + point;

        }

        return sum;

    };

    

    auto class_sum = [&]() {

        Point2DClass sum;

        for (const auto& point : class_array) {

            sum = sum.add(point);

        }

        return sum;

    };

    

    double time_builtin = PerformanceAnalyzer::measure_time(builtin_sum, iterations);

    double time_struct = PerformanceAnalyzer::measure_time(struct_sum, iterations);

    double time_class = PerformanceAnalyzer::measure_time(class_sum, iterations);

    

    std::cout << "内置类型数组求和: " << time_builtin << " μs" << std::endl;

    std::cout << "结构体数组求和: " << time_struct << " μs" << std::endl;

    std::cout << "类对象数组求和: " << time_class << " μs" << std::endl;

    

    // 2. 函数调用开销测试

    std::cout << "\n2. 函数调用开销测试:" << std::endl;

    

    auto test_inline = []() {

        volatile int result = 0;  // 防止优化

        for (int i = 0; i < 1000; ++i) {

            result += i * i;  // 内联操作

        }

        return result;

    };

    

    // 非内联函数

    int __attribute__((noinline)) non_inline_compute(int n) {

        volatile int result = 0;

        for (int i = 0; i < n; ++i) {

            result += i * i;

        }

        return result;

    }

    

    auto test_non_inline = [&]() {

        return non_inline_compute(1000);

    };

    

    double time_inline = PerformanceAnalyzer::measure_time(test_inline, 10000);

    double time_non_inline = PerformanceAnalyzer::measure_time(test_non_inline, 10000);

    

    std::cout << "内联操作: " << time_inline << " μs" << std::endl;

    std::cout << "非内联函数调用: " << time_non_inline << " μs" << std::endl;

    std::cout << "调用开销: " << (time_non_inline - time_inline) << " μs" << std::endl;

    

    // 3. 虚函数调用开销

    std::cout << "\n3. 虚函数调用开销测试:" << std::endl;

    

    class Base {

    public:

        virtual int compute() { return 0; }

        virtual ~Base() = default;

    };

    

    class Derived : public Base {

    public:

        int compute() override { return 42; }

    };

    

    std::vector<std::unique_ptr<Base>> objects(1000);

    for (auto& obj : objects) {

        obj = std::make_unique<Derived>();

    }

    

    auto test_virtual = [&]() {

        int sum = 0;

        for (const auto& obj : objects) {

            sum += obj->compute();

        }

        return sum;

    };

    

    // 对比非虚函数

    class NonVirtual {

    public:

        int compute() { return 42; }

    };

    

    std::vector<NonVirtual> non_virtual_objects(1000);

    

    auto test_non_virtual = [&]() {

        int sum = 0;

        for (auto& obj : non_virtual_objects) {

            sum += obj.compute();

        }

        return sum;

    };

    

    double time_virtual = PerformanceAnalyzer::measure_time(test_virtual, 1000);

    double time_non_virtual = PerformanceAnalyzer::measure_time(test_non_virtual, 1000);

    

    std::cout << "虚函数调用: " << time_virtual << " μs" << std::endl;

    std::cout << "非虚函数调用: " << time_non_virtual << " μs" << std::endl;

    std::cout << "虚函数开销: " << (time_virtual - time_non_virtual) << " μs" << std::endl;

}

```

## 第四部分：类型选择策略

### 类型选择决策树

```cpp

#include <iostream>

#include <string>

#include <type_traits>

class TypeSelectionGuide {

public:

    enum class UseCase {

        DATA_CONTAINER,     // 数据容器

        BUSINESS_LOGIC,     // 业务逻辑

        INTERFACE,          // 接口定义

        ALGORITHM,          // 算法实现

        RESOURCE_MANAGER,   // 资源管理

        CONFIGURATION       // 配置数据

    };

    

    enum class PerformanceRequirement {

        CRITICAL,           // 性能关键

        IMPORTANT,          // 性能重要

        MODERATE,           // 性能适中

        LOW                 // 性能要求低

    };

    

    enum class MemoryConstraint {

        EXTREME,            // 极度受限

        TIGHT,              // 严格限制

        MODERATE,           // 适中限制

        GENEROUS            // 限制宽松

    };

    

    struct Requirements {

        UseCase use_case;

        PerformanceRequirement performance;

        MemoryConstraint memory;

        bool requires_polymorphism;

        bool needs_encapsulation;

        bool will_be_copied_frequently;

    };

    

    static std::string recommend_type(const Requirements& req) {

        // 决策逻辑

        if (req.use_case == UseCase::DATA_CONTAINER) {

            if (req.memory == MemoryConstraint::EXTREME) {

                return "使用内置类型数组或std::array";

            } else if (req.will_be_copied_frequently) {

                return "使用平凡可复制的结构体";

            } else {

                return "使用标准容器类模板";

            }

        }

        

        if (req.use_case == UseCase::BUSINESS_LOGIC) {

            if (req.requires_polymorphism) {

                return "使用抽象基类和具体派生类";

            } else if (req.needs_encapsulation) {

                return "使用具有私有成员的类";

            } else {

                return "使用结构体或简单类";

            }

        }

        

        if (req.use_case == UseCase::INTERFACE) {

            if (req.requires_polymorphism) {

                return