C++手记

Mundaneman

已于 2024-09-08 16:26:51 修改

阅读量1.2k

点赞数 15

文章标签： c++ 开发语言学习

于 2024-09-08 15:31:46 首次发布

本文链接：https://blog.csdn.net/tcben/article/details/142004609

版权

总是还没得到就在想着失去

前言

手记

一、register

据说现在已经不推荐且不用了。

（register 是 C++ 中的一个存储类说明符，但其使用在现代 C++ 中已经不推荐，并且在 C++17 及之后的标准中被废弃。以下是关于 register 的详细说明：）

但是由于遇到了，还是记一下
register 是 C 和 C++ 中的一个存储类说明符，用于提示编译器将变量存储在寄存器中，而不是在内存中，以提高访问速度。
这种提示通常用于对性能有较高要求的场合，例如循环中的计数变量。

注意事项:
提示性质: register 只是一个建议，编译器可以忽略这个建议，特别是寄存器资源有限时。
不允许获取地址: 对 register 变量不能使用取地址运算符 &，因为寄存器没有内存地址。
现代 C++ 的情况:

在 C++17 中，register 被正式移除，因为现代编译器已经非常优化，能够自动选择将哪些变量放入寄存器中，而不需要程序员的建议。

现在，直接使用 register 会导致编译警告或错误，取决于编译器和编译标准的设置。但是我用vscode还是能跑应该与gcc的版本有关

二、constexpr

constexpr 是 C++ 中的一个关键字，用于定义常量表达式，主要目的是在编译时执行计算，提高性能和代码安全性。

constexpr 是 C++11 引入的关键字，用于指示编译器在编译时对表达式求值，而不是在运行时。
通过 constexpr，可以定义编译时常量、编译时函数，从而减少运行时的计算开销，提高程序的效率。

常量变量: 定义在编译时即可确定的常量。
常量函数: 定义的函数可以在编译时执行，返回一个常量值。
编译时计算: 使用 constexpr 可以使得一些复杂的计算在编译阶段完成，减少运行时的计算负担。

编译时执行: 使用 constexpr 声明的函数和变量，其值在编译时就必须是确定的。

必须是常量: constexpr 函数的参数和返回值都必须是常量表达式。

内联执行: constexpr 函数默认是 inline 的。

返回值要求: constexpr 函数的返回值必须是可以在编译时计算的表达式。

逐渐增强: 在 C++14 及之后，constexpr 函数的功能得到了增强，允许更复杂的逻辑，如条件语句和循环。

三、内联函数（inline）

内联函数的概念：

内联函数是指在编译过程中，编译器将函数的代码直接插入到每个调用点，而不是通过函数调用的方式（即压栈、跳转等）来执行。这种方式可以减少函数调用的开销。

inline 关键字：
使用 inline 关键字可以建议编译器将函数定义为内联函数。如下：

inline int add(int a, int b) {
    return a + b;
}

减少了函数调用的开销，如函数调用栈的建立和销毁。
提高了代码执行效率，因为将代码直接嵌入可以避免多次的跳转和返回。

内联执行有助于 constexpr 函数在编译时被完全展开，确保编译时计算的执行。
内联行为并不会改变 constexpr 函数的主要特性，即在编译时求值的能力，但它也有助于优化运行时性能。

四、size_t

size_t 是 C 和 C++ 中一种用于表示对象大小或计数的无符号整数类型。
size_t 的全称是 size type，意为“尺寸类型”。
它是标准库中定义的一种无符号整数类型，用于表示对象的大小（如数组、字符串、内存块等）或数组的索引。
size_t 被用于表示对象的大小或内存块的尺寸。例如，malloc() 函数返回的指针需要传入一个 size_t 类型的参数，表示要分配的内存字节数。

它是无符号的，因此避免了负数索引的错误，更适合用于数组、字符串等的下标索引。
sizeof 运算符返回值的类型就是 size_t，用于表示内存大小。
size_t 的大小根据编译器和系统架构自动调整，确保可以在不同平台上正确表示对象的大小（例如 32 位系统上为 4 字节，64 位系统上为 8 字节）。

由于 size_t 是无符号类型，它能够避免与负值相关的错误，从而更安全地用于描述大小和计数。
size_t 的大小适配当前系统架构，确保能表示系统允许的最大内存大小，而不像固定宽度的整数类型那样受限。
size_t 是 ANSI C 和 C++ 标准定义的类型，使代码在不同平台上的表现一致且可移植。

五、std::

std:: 是 C++ 标准库的命名空间 std 的标识符，代表 standard（标准）。在 C++ 中，std 命名空间包含了所有 C++ 标准库的类、函数、变量和对象等。使用 std:: 前缀是为了访问这些标准库的功能：类、函数、变量等，确保代码使用的是标准库的实现，而不是用户自定义的同名实现，并且避免与用户自定义的代码发生命名冲突。

六、命名空间

命名空间 (namespace)
命名空间是 C++ 提供的用于组织代码的机制，主要目的是避免命名冲突。例如，不同的库中可能有同名的函数、类或变量，使用命名空间可以将这些名称隔离开来，防止冲突。

七、std::aligned_alloc

这是一个 C++ 标准库函数，用于分配一块指定对齐方式的内存。

void* std::aligned_alloc(std::size_t alignment, std::size_t size);

这段代码的主要目的是分配一段特定对齐方式的内存，而不仅仅是一般的动态内存分配。这种方式常用于需要高效访问内存的应用，如科学计算、图形处理、音视频处理等。

对齐内存能让 CPU 更高效地访问数据，因为对齐的内存块往往符合处理器的缓存线和内存访问优化策略。

所谓缓存线：

处理器缓存 (Cache)
缓存的作用：缓存是处理器内部的一种高速存储器，用于临时存储经常使用的数据和指令。其目的是减少处理器访问主内存的次数，从而提高程序执行速度。
层级结构：缓存一般分为多级，如 L1（Level1）、L2、L3 缓存，L1 最靠近处理器核心，速度最快，但容量最小。L2 和 L3 离核心稍远，速度较慢但容量更大。
缓存线 (Cache Line)
定义：缓存是以“缓存线”为最小存储单位的。缓存线是一块连续的内存区域，大小通常是 32、64、128 字节（不同处理器可能不同）。
加载机制：当处理器需要读取某个内存地址的数据时，它不会仅加载该单个字节，而是会把整个包含该地址的缓存线加载到缓存中。
缓存行命中和未命中：
命中 (Hit)：数据已经在缓存中，可以快速访问。
未命中 (Miss)：数据不在缓存中，需要从主内存加载，导致更高的延迟。

回到正题 void* std::aligned_alloc(std::size_t alignment, std::size_t size);
alignment：指定对齐要求（以字节为单位），必须是 2 的幂。对齐方式决定了分配的内存地址是对齐值的整数倍，通常用于提升性能，尤其是在 SIMD 运算或需要严格内存对齐的硬件上。
alignment：指定所需的内存对齐方式，以字节为单位。对齐方式必须是 2 的幂，如 16、32、64 等。
size：要分配的内存大小（以字节为单位），必须是 alignment 的倍数。

八、void*

void* 是 C 和 C++ 中的一种指针类型，称为通用指针或无类型指针。它可以指向任何类型的数据，但本身没有类型信息，因此不能直接用于解引用或指针运算。void* 的主要用途是实现通用性和灵活性，尤其在需要处理不同数据类型的场合，例如内存分配、通用数据结构等。

void* 是一种指针类型，表示指向未知类型的指针。
它不能直接解引用（即不能直接访问指向的数据），因为没有数据类型信息。

通用性：void* 可用于实现与数据类型无关的操作。例如，标准库中的 malloc 函数返回 void*，允许它分配内存而不指定内存块的具体类型。
数据转换：void* 可以通过类型转换（类型强制转换）转换为任何其他类型的指针。这使得它在需要与多种数据类型交互时非常有用。
函数参数：用于函数参数时，void* 可以接受任意类型的指针，常用于通用接口设计，如回调函数的上下文指针。
数据结构：例如，通用链表、哈希表等需要存储不同类型的数据时，常使用 void* 指针来实现多态。

使用 void* 的注意事项:

安全性：由于 void* 没有类型信息，误用可能导致类型不匹配或指针错误，因此在使用时必须确保类型转换正确。
类型转换：在使用 void* 之前，必须将它转换为正确的类型指针（如 int*、float*），否则无法正确操作数据。
性能：void* 的使用不会自动进行类型检查，因此对类型安全性有更高的要求。在进行转换和操作时可能会引入运行时错误。

九、static_cast

是 C++ 提供的四种类型转换操作符之一（其他包括 dynamic_cast、const_cast 和 reinterpret_cast），主要用于在编译时执行类型转换。它提供了一种类型安全的转换方式，用于在相关类型之间进行显式转换。static_cast 可以进行多种类型转换操作，但不包括动态类型检查。

static_cast<new_type>(expression)

new_type：要转换成的目标类型。
expression：要转换的表达式。

十、基类与派生类

基类（Base Class）
定义: 基类是一个被其他类继承的类。它通常包含一些共同的属性和方法，这些属性和方法可以被派生类共享。
功能: 基类提供基本的功能和接口，供派生类扩展或重写。

class BaseClassName {
    // 访问修饰符
public:
    // 公有成员，也可以只是变量
    void somePublicFunction();

protected:
    // 保护成员，也可以只是变量
    int someProtectedVariable();

private:
    // 私有成员，也可以只是变量
    void somePrivateFunction();
};

public: 公有成员可以被任何类访问。
protected: 保护成员只能被基类及其派生类访问。
private: 私有成员只能在基类内部访问。

派生类（Derived Class）
定义: 派生类是从基类继承的类。它可以继承基类的属性和方法，同时也可以添加新的属性和方法或重写基类的方法。
功能: 派生类可以实现更具体的功能，扩展基类的能力。

class DerivedClass : access_specifier BaseClass {
    // 派生类成员（属性和方法）
};

十一、函数类别

11.1 成员函数：

属于类的一部分，用于操作类的成员变量，是面向对象编程的基础。

成员函数是定义在类中的函数，专门用于操作类的对象。它们可以访问和修改类的成员变量，提供对象的行为实现。
成员函数分为普通成员函数、构造函数、析构函数、虚函数、常成员函数和静态成员函数等。

11.2 全局函数：

在类外定义的函数，无法直接访问类的私有成员。
定义在类外的普通函数，不属于任何类。
全局函数可以在整个程序中访问，并且不能直接访问类的私有成员，但是可以间接通过调用存在的公有成员函数来访问。
例子：

#include <iostream>

class MyClass {
private:
    int privateValue;  // 私有成员变量，不能直接被全局函数访问

public:
    MyClass(int value) : privateValue(value) {}  // 构造函数，用于初始化私有成员

    // 公有成员函数，用于访问私有成员
    int getValue() const {
        return privateValue;
    }

    // 公有成员函数，用于设置私有成员
    void setValue(int value) {
        privateValue = value;
    }
};

// 全局函数
void displayValue(MyClass obj) {
    // 直接访问私有成员会导致编译错误
    // std::cout << obj.privateValue << std::endl;  // 错误：无法访问类的私有成员

    // 通过公有成员函数间接访问私有成员
    std::cout << "Value: " << obj.getValue() << std::endl;
}

int main() {
    MyClass myObj(10);  // 创建对象，并初始化私有成员
    displayValue(myObj);  // 调用全局函数，输出对象的私有成员值

    myObj.setValue(20);  // 修改私有成员值
    displayValue(myObj);  // 再次调用全局函数，输出修改后的值

    return 0;
}

11.3 构造函数和析构函数：

用于对象的创建和销毁，管理对象的生命周期。

构造函数是类的特殊成员函数，与类名相同，无返回类型。用于在对象创建时初始化对象。
构造对象、分配资源、初始化成员变量。

析构函数是类的特殊成员函数，名称与类名相同但带有波浪号 ~，无参数且无返回值。
在对象销毁时自动调用，用于清理资源，释放内存。

11.4 虚函数：

支持多态，通过基类指针或引用调用派生类的重写版本。
虚函数是基类中使用 virtual 关键字声明的成员函数，允许派生类重写，支持多态性。
通过基类指针或引用调用派生类的重写版本。

11.5 内联函数：

用于减少小型函数的调用开销。
内联函数（Inline Function）
内联函数使用 inline 关键字定义，提示编译器将函数代码直接插入调用点，以减少函数调用开销。
提高小型、频繁调用函数的执行效率。

11.6 常成员函数：

保证函数不会修改类的状态。
常成员函数在函数签名后加 const，表示该函数不会修改对象的成员变量。
保证函数不修改类的状态，确保安全性。

11.7 静态成员函数：

不依赖于对象的成员函数，直接通过类名调用。
静态成员函数使用 static 关键字声明，不依赖于对象，可以直接通过类名调用。
不访问对象的成员，只能访问静态成员变量。

11.8 友元函数：

可以访问类的私有成员，但不是类的一部分。
友元函数使用 friend 关键字声明，不属于类，但可以访问类的私有成员。
在类外实现功能，同时访问类的私有成员。

11.9 友元函数与虚函数

#include <iostream>

class Base {
private:
    int value;

public:
    Base(int v) : value(v) {}

    // 声明虚函数，允许派生类重写
    virtual void display() {
        std::cout << "Base class display: " << value << std::endl;
    }

    // 声明友元函数
    friend void showFriend(Base& obj);
};

// 实现友元函数，不能参与重写
void showFriend(Base& obj) {
    std::cout << "Friend function accessing Base class: " << obj.value << std::endl;
}

class Derived : public Base {
public:
    Derived(int v) : Base(v) {}

    // 重写基类的虚函数
    void display() override {
        std::cout << "Derived class display" << std::endl;
    }
    
    // 注意：友元函数不能在派生类中重写
    // void showFriend(Derived& obj) { ... } // 这是一个独立的函数，无法作为重写
};

int main() {
    Base* b = new Derived(10);

    // 调用派生类重写的虚函数，表现多态性
    b->display();

    // 调用友元函数，无法表现多态性，也不能重写
    showFriend(*b);

    delete b;
    return 0;
}

虚函数的重写：
display() 是一个虚函数，在基类中声明为虚函数，在派生类 Derived 中被重写。当通过基类指针 b->display() 调用时，程序会根据对象的实际类型调用 Derived 类的版本，实现了多态。

友元函数的调用：
showFriend(Base& obj) 是一个友元函数，定义在类的外部，具有访问 Base 私有成员的权限。
showFriend 不能被派生类重写，因为它不属于 Base 类，也不属于 Derived 类。即使在派生类中定义一个同名函数，它们也是完全独立的函数，不涉及重写关系。

友元函数不能被派生类重写，因为它们不属于类成员，而是类外部的普通函数。
虚函数是类的成员函数，允许通过继承机制被派生类重写，实现多态性。
友元函数的主要作用是访问类的私有和保护成员，而虚函数则是用于支持多态和动态绑定的机制，两者在概念和用途上有本质区别。

十二、成员初始化列表

: privateData(p1), protectedData(p2) 是成员初始化列表。它在构造函数的函数体 {} 之前，用来初始化类的成员变量。
这种初始化方式直接在成员初始化列表中进行赋值，而不是在构造函数的函数体内赋值。
成员初始化列表的语法是 : member1(value1), member2(value2), …，用于直接初始化类成员。
privateData(p1) 表示用参数 p1 初始化成员变量 privateData。
protectedData(p2) 表示用参数 p2 初始化成员变量 protectedData。
例子：

#include <iostream>

class Base {
private:
    int privateData;       // 私有成员变量
protected:
    int protectedData;     // 保护成员变量

public:
    // 构造函数，使用成员初始化列表初始化成员变量
    Base(int p1, int p2) : privateData(p1), protectedData(p2) {
        std::cout << "Base constructor called." << std::endl;
    }

    // 显示成员变量的值
    void show() {
        std::cout << "Private data: " << privateData << std::endl;
        std::cout << "Protected data: " << protectedData << std::endl;
    }
};

int main() {
    // 创建 Base 类的对象，初始化成员变量
    Base obj(10, 20);
    obj.show();  // 输出成员变量的值
    return 0;
}