sizeof在C++中的应用及差异

# 1. C++ 中数据类型的介绍

#### 1.1 基本数据类型
在 C++ 中，基本数据类型包括整型和浮点型。整型用于表示整数值，包括有符号和无符号两种类型，可用来存储整数数据。而浮点型用于表示带有小数部分的数值，分为单精度和双精度浮点型。

- ##### 1.1.1 整型
整型主要包括int、short、long和long long等类型，通过这些类型可以存储不同范围的整数值，如int通常是4个字节。

- ##### 1.1.2 浮点型
浮点型包括float和double两种类型，分别用来表示单精度和双精度浮点数，double类型的精度比float更高。

基本数据类型在 C++ 编程中起着基础作用，程序员需要根据需求选择合适的数据类型来存储数据，以确保数据的准确性和高效性。

# 2. 内存管理与指针

#### 2.1 内存分配与释放

在 C++ 中，内存分配方式通常有两种：栈内存和堆内存。栈内存是一种自动分配和自动释放的内存，适合存储函数参数和局部变量。堆内存则由程序员手动分配和释放，对于动态内存需求非常灵活。

##### 2.1.1 栈内存

栈内存通过在函数中声明变量实现。当函数被调用时，这些变量会被自动分配到栈内存上，函数执行完毕后会被自动释放。栈内存的大小有限，不适合存储大量或超出作用域的数据。

##### 2.1.2 堆内存

堆内存的分配使用 `new` 操作符，释放使用 `delete` 操作符。使用堆内存需要程序员手动管理内存的生命周期，确保及时释放以防止内存泄漏。堆内存适合存储动态大小的数据结构，如动态数组等。

#### 2.2 指针的概念与应用

指针是 C++ 中非常重要的概念，它存储变量的内存地址。通过指针可以直接访问内存中的数据，实现对数据的引用和操作。在指针的概念基础上，有一系列的指针应用，包括指针的基本操作、指针和数组、指针和函数指针。

##### 2.2.1 指针的基本操作

指针的基本操作包括指针声明、取地址操作 `&`、取值操作 `*` 等。通过指针，可以实现数据的交换、动态内存分配等高级操作。

int num = 10;
int *ptr = # // 定义指针并初始化为 num 的地址
*ptr = 20;       // 修改 ptr 指向的值为 20

##### 2.2.2 指针和数组

指针和数组在 C++ 中有着密切的联系。数组名本身就是一个指针常量，存储数组首元素的地址。通过指针可以实现数组元素的遍历、访问和修改。

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr; // 将数组名赋给指针
for (int i = 0; i < 5; i++) {
    cout << *(ptr + i) << " "; // 输出数组元素
}

##### 2.2.3 指针和函数指针

函数指针是指向函数的指针变量，通过函数指针可以实现函数调用和回调机制。函数指针的类型必须与所指向函数的返回类型和参数类型相匹配。

void printHello() {
    cout << "Hello, World!" << endl;
}

void (*funcPtr)() = &printHello; // 定义函数指针并指向 printHello 函数
funcPtr(); // 调用函数指针，输出 "Hello, World!"

通过对内存管理和指针的学习，能够更好地理解程序内存存储机制和数据访问方式，为后续深入学习打下坚实基础。

# 3.1 类与对象

#### 3.1.1 定义类

在面向对象编程中，类是一种用户自定义的数据类型，用来描述具有相同属性和行为的对象。通过类可以封装数据和函数，实现代码的重用和维护。一个类通常包含数据成员和成员函数两部分，数据成员用来描述对象的状态，成员函数用来定义对象的行为。下面以一个简单的学生类为例来说明。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")

# 创建对象
stu1 = Student("Alice", 20)
stu2 = Student("Bob", 22)

# 调用成员函数
stu1.display()
stu2.display()

#### 3.1.2 类的成员函数

类的成员函数用来操作对象的数据成员，是类的一部分。在成员函数内部，可以访问对象的数据成员，并执行相应的操作。成员函数可以分为普通成员函数和静态成员函数两种。普通成员函数需要通过对象来调用，而静态成员函数属于类的函数，可以直接用类名调用。

class Calculator:
    @staticmethod
    def add(x, y):
        return x + y

    def subtract(self, x, y):
        return x - y

# 调用静态成员函数
result1 = Calculator.add(3, 4)

# 调用普通成员函数
calc = Calculator()
result2 = calc.subtract(5, 2)

### 3.2 继承与多态

#### 3.2.1 继承的基本概念

继承是面向对象编程的核心概念之一，用来描述类与类之间的关系。一个类可以继承另一个类的属性和行为，从而实现代码的复用和扩展。在继承关系中，被继承的类称为基类或父类，继承的类称为派生类或子类。子类可以继承父类的成员，并可以通过重写父类的方法来实现多态的效果。

#### 3.2.2 虚函数与多态性

在C++中，通过虚函数和指针可以实现多态性。虚函数是在基类中使用关键字`virtual`声明的函数，在派生类中可以用相同的函数名重新定义虚函数，通过基类指针或引用调用虚函数时，根据对象的实际类型来确定调用的是哪个版本的函数。这就是多态性的体现。

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Drawing a circle")

class Rectangle(Shape):
    def draw(self):
        print("Drawing a rectangle")

# 多态性的体现
shapes = [Circle(), Rectangle()]
for shape in shapes:
    shape.draw()

#### 3.2.3 抽象类与纯虚函数

抽象类是含有纯虚函数的类，不能实例化对象，只能作为基类供其他类继承。纯虚函数是在基类中声明但没有定义的虚函数，派生类必须实现纯虚函数才能被实例化。通过抽象类和纯虚函数可以实现接口、多态和封装等面向对象编程的特性。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof")

class Cat(Animal):
    def speak(self):
        print("Meow")

# 多态性的体现
animals = [Dog(), Cat()]
for animal in animals:
    animal.speak()

# 4. 模板与泛型编程

#### 4.1 模板的介绍
模板是 C++ 中一种强大的泛型编程特性，可以让我们编写通用的代码，使得数据类型独立于算法，增加代码的复用性和灵活性。模板分为函数模板和类模板两种形式。

##### 4.1.1 函数模板
函数模板允许我们编写与数据类型无关的通用函数，通过在函数定义中使用类型参数来实现泛型编程。例如，下面是一个简单的函数模板示例，实现了两个数的交换功能:

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    swap(x, y); // 调用函数模板
    return 0;
}

##### 4.1.2 类模板
类模板允许我们定义通用类，其中至少一个成员变量或成员函数的类型是模板参数。通过类模板，我们可以实现通用的数据结构（如容器）或算法。

template <typename T>
class Pair {
private:
    T first;
    T second;
public:
    Pair(T f, T s) : first(f), second(s) {}
    T getFirst() { return first; }
    T getSecond() { return second; }
};

int main() {
    Pair<int> p(1, 2); // 创建一个存储整数的Pair实例
    return 0;
}

#### 4.2 模板特化与偏特化
除了最基本的模板形式外，C++ 还支持模板特化和偏特化，通过这些方式可以对特定类型做定制化处理，增强模板的灵活性和适用性。

##### 4.2.1 类模板特化
对模板类的特定数据类型进行特殊化处理，可以为特定类型提供不同的实现方式。

// 类模板的特化示例
template<>
class Pair<char> {
private:
    char first;
    char second;
public:
    Pair(char f, char s) : first(f), second(s) {}
    char getMax() { return (first > second) ? first : second; }
};

int main() {
    Pair<char> p('a', 'b');
    cout << p.getMax() << endl; // 输出最大值
    return 0;
}

##### 4.2.2 函数模板偏特化
函数模板的偏特化允许我们为某些模板参数提供定制化实现，这在某些特定场景下非常有用。

// 函数模板的偏特化示例
template <typename T1, typename T2>
class Box {
public:
    void print() { cout << "General Box" << endl; }
};

// 偏特化版本，当 T1 为 int 时的特定实现
template <typename T2>
class Box<int, T2> {
public:
    void print() { cout << "Box for integers" << endl; }
};

int main() {
    Box<float, char> b1;
    b1.print(); // 输出 General Box

    Box<int, char> b2;
    b2.print(); // 输出 Box for integers

    return 0;
}

##### 4.2.3 模板元编程
模板元编程是利用模板实现在编译期间进行计算的技术，通过递归展开模板生成代码，实现一些在运行时无法完成的操作。

// 模板元编程示例：计算阶乘
template <int n>
struct Factorial {
    static const int value = n * Factorial<n - 1>::value;
};

template <>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    cout << Factorial<5>::value << endl; // 输出 120
    return 0;
}

# 5. 异常处理与安全性

异常处理是程序中重要的一部分，可以帮助我们更好地管理错误情况，保证程序的稳定性和安全性。本章将介绍异常处理机制以及与异常相关的内存安全和异常安全的编程技巧。

- #### 5.1 异常处理机制

- ##### 5.1.1 异常的概念与分类

在 C++ 中，异常是程序在运行时发生的意外情况，例如除以零、空指针引用等。异常主要分为标准异常和自定义异常两种类型。标准异常由 C++ 标准库提供，如 `std::invalid_argument`、`std::runtime_error` 等；而自定义异常是程序员根据需要定义的异常类型。

- ##### 5.1.2 try-catch块的使用

在程序中，我们可以使用 try-catch 块来捕获和处理异常。try 块用于包裹可能抛出异常的代码，catch 块用于捕获特定类型的异常并进行处理。如果 try 块中的代码抛出异常，程序会跳转至最匹配的 catch 块处理异常。

- #### 5.2 内存安全和异常安全

- ##### 5.2.1 内存泄漏与悬垂指针

内存泄漏是指程序动态分配的内存未被正确释放导致内存资源无法再被访问和利用。悬垂指针则是指指向已被释放内存的指针。这些问题会导致程序运行效率下降，甚至崩溃。因此，在程序开发中需要及时释放动态分配的内存，避免出现内存泄漏和悬垂指针。

- ##### 5.2.2 异常安全的编程技巧

为了保证程序在抛出异常后仍能维持良好的状态，我们需要在设计中考虑异常安全性。这包括强异常安全性、基本异常安全性和无异常安全性等级。编写具有异常安全性的代码需要遵循一些编程技巧，如使用 RAII 管理资源，保证函数不抛出异常时对象仍处于有效状态等。

#include <iostream>
#include <memory>

void riskyOperation() {
    // 模拟出现异常的危险操作
    throw std::runtime_error("An error occurred during the operation.");
}

int main() {
    std::unique_ptr<int> ptr(new int(5));

    try {
        riskyOperation();
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

代码分析与总结：
- 在上面的示例中，我们使用 `try-catch` 块捕获 `riskyOperation` 函数抛出的异常，并输出异常信息。
- 异常处理是保证程序稳定性的重要手段，能够在程序出现问题时进行适当处理，避免程序崩溃。
- 在使用动态分配内存时，应注意及时释放资源，避免内存泄漏和悬垂指针的问题。

流程图示例：

graph TD;
    A[开始] --> B{异常发生?};
    B -- 是 --> C[异常处理];
    C --> D[结束];
    B -- 否 --> D;