TODO:[5] please fix all in free time
重复了和另一篇

C 与 C++、java 的 区别

基础知识与坑

程序执行入口

The default program entry function is main, but can be changed in two situations:

1. use stupid #define xxx main in header file to replace the name which maybe ignored by silly search bar in VSCODE.
2. use -exxx compile flag

语句末尾的分号

• 在 C++ 中，是否需要在语句的末尾使用分号（;）取决于上下文。
• C++ 语法的基本规则是：分号用来标识一条语句的结束，而有些结构并不是严格的语句，因此不需要分号。

• 声明（变量、类、结构体、枚举、函数原型、类型别名）：都需要分号作为结束。
• 函数定义、控制语句（如 if, while, for）、复合语句（{}） 不需要分号。
• 预处理指令（如 #define, #include）：不需要分号，因为它们不是 C++ 语法层面的内容。
• 作用域结束的 } 不需要分号，但声明类或结构体时 } 后要加分号。

总结来说，分号用来结束语句，包括声明、表达式和执行体等，但当你定义一个复合结构（如函数定义、控制语句）时，不需要分号来结束复合结构的定义。

逗号运算符（Comma）

• 逗号运算符是一个序列点：从左到右计算每个逗号分隔表达式。结果具有右操作数的类型和值。.
• https://en.wikipedia.org/wiki/Comma_operator

重名变量的优先级

1
2
3
4
5
6
7
8
9
10

int getKthAncestor(int node, int k) {
    int node= getKthAncestor(saved[node],--k);  
    return node;
}
 //为什么第二行的node会提前被修改为0，导致传入函数getKthAncestor的saved[node]的node值为0
 //如下去掉int，也不会错。因为int node 会初始化node为0
 int getKthAncestor(int node, int k) {
    node= getKthAncestor(saved[node],--k);  
    return node;
}

根据C++的作用域规则，内层的局部变量会覆盖外层的同名变量。因此，在第二行的语句中，node引用的是函数参数中的node，而不是你想要的之前定义的node。

为了避免这个问题，你可以修改代码，避免重复定义变量名。例如，可以将第二行的变量名改为newNode或其他不同的名称，以避免与函数参数名冲突。

运算符优先级

运算符性质：

• 接受的操作数，
• 优先级，
  • 特殊：逻辑和(&&)先于逻辑或(||)、四则运算先于位运算
  • 位运算优先级低于判断符号，记得写括号。
  • 赋值(=)优先级最低
• 结合性，
  • 左结合性： 大部分运算(加减乘除)
  • 右结合性：赋值运算符。程序会先计算它右边的表达式的值，然后再计算它左边的表达式的值
• 返回值
  • 赋值运算符的返回值是赋值后左操作数的引用

变量类型以及Macro constants

https://en.cppreference.com/w/cpp/language/types

https://en.cppreference.com/w/cpp/types/integer

1
2
3
4
5
6
7
8

//返回与平台相关的数值类型的极值
std::numeric_limits<double>::max()
std::numeric_limits<int>::min()

#include<limits.h>
INT_MAX
FLT_MAX (or DBL_MAX ) 
-FLT_MAX (or -DBL_MAX ) 

关键词

1
2
3
4
5

extern 
const
constexpr //C++11引入的关键字，用于编译时的常量与常量函数。
volatile    //是指每次需要引用某个变量的数据时，都必须从内存原地址读取,而不是编译器优化后寄存器间接读取.(必须写回内存，为了多进程并发而设计的。)
inline 

static 关键字

static 作⽤：控制变量的存储⽅式和作用范围(可⻅性)。

1. 修饰局部变量
   • 存放位置：栈区 -> 静态数据区(data段或者bss段)
   • 生命周期：程序结束才会释放
   • 作用域：还是局部代码块
2. 修饰函数与全局变量
   • 使其作用范围由全工程文件可见变成了本文件可见

1
2
3
4
5
6

#ifndef GLOBALS_H
#define GLOBALS_H

extern bool encounteredAclops;

#endif // GLOBALS_H

1
2
3

#include "globals.h"

bool encounteredAclops = false;

1
2
3
4
5
6
7
8

#include "globals.h"

void someFunction() {
    if (!encounteredAclops) {
        // Do something
        encounteredAclops = true;
    }
}

1
2
3
4
5
6
7
8

static bool encounteredAclops = false;

void someFunction() {
    if (!encounteredAclops) {
        // Do something
        encounteredAclops = true;
    }
}

1
2
3
4
5
6
7
8
9

#ifndef ACLOPS_MANAGER_H
#define ACLOPS_MANAGER_H

class AclopsManager {
public:
    static bool encounteredAclops;
};

#endif // ACLOPS_MANAGER_H

1
2
3

#include "AclopsManager.h"

bool AclopsManager::encounteredAclops = false;

1
2
3
4
5
6
7
8

#include "AclopsManager.h"

void someFunction() {
    if (!AclopsManager::encounteredAclops) {
        // Do something
        AclopsManager::encounteredAclops = true;
    }
}

1. 修饰类内函数
   • 静态成员函数：使用”static”修饰的成员函数称为静态成员函数。静态成员函数与类的对象无关，可以在没有创建对象的情况下直接通过类名调用。这意味着它们不需要通过类的对象来访问，而是属于整个类的。举例
   • 静态成员函数没有隐式的this指针，因此不能直接访问非静态成员变量和非静态成员函数。静态成员函数可以访问类的静态成员变量和其他静态成员函数。
   • static 成员函数不能被 virtual 修饰， static 成员不属于任何对象或实例，所以加上 virtual没有任何实际意义；
     * 静态成员函数没有 this 指针，虚函数的实现是为每⼀个对象分配⼀个vptr 指针，⽽ vptr 是通过 this 指针调⽤的，所以不能为 virtual；虚函数的调⽤关系，this->vptr->ctable->virtual function。
2. 修饰类内的变量
   • 存放位置：栈区 -> 静态数据区(data段或者bss段)
   • 生命周期：程序结束才会释放
     • 意味着下一次调用函数时，静态局部变量将保持上一次调用时的值。
   • 由于不再属于某个类对象，可以直接通过类名初始化 int MyClass::staticVariable = 10;

1
2
3
4
5

static auto thread_core_map = GetCpuAffinityMap(device_id);
// 根据条件重新初始化
if (/* 条件 */) {
    thread_core_map = GetCpuAffinityMap(device_id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>

class MyClass {
public:
    static void staticFunction() {
        std::cout << "This is a static member function." << std::endl;
    }
};

int main() {
    MyClass::staticFunction(); // 直接通过类名调用静态成员函数
    return 0;
}

const 关键字

当const修饰基本数据类型时，可以将其放置在类型说明符的前面或后面，效果是一样的。const关键字用于声明一个常量，即其值在声明后不可修改。

1
2

const int constantValue1 = 10; // const在类型说明符前
int const constantValue2 = 20; // const在类型说明符后

当const关键字位于指针变量或引用变量的左侧时，它用于修饰指针所指向的变量，即指针指向的内容为常量。当const关键字位于指针变量或引用变量的右侧时，它用于修饰指针或引用本身，即指针或引用本身是常量。

1. 修饰指针指向的变量, 它指向的值不能修改：

   1 2 3 4

   int x = 5; const int* ptr = &x; // 指向常量整数的指针 // *ptr = 10; // 错误：不能通过const指针修改值 x = 10; // 合法：可以修改变量本身的值

2. 修饰指针本身 ，它不能再指向别的变量，但指向（变量）的值可以修改。：

   1 2 3 4

   const int y = 10; int* const ptr = &y; // 常量指针指向整数 // ptr = &x; // 错误：不能修改指针本身 // *ptr = 5; // 合法：可以修改常量变量的值

3. const int *const p3; //指向整形常量 的 常量指针 。它既不能再指向别的常量，指向的值也不能修改。

explicit

在C++, explicit 是一个关键字，用于修饰单参数构造函数，用于禁止隐式类型转换。

当一个构造函数被声明为 explicit 时，它指示编译器在使用该构造函数进行类型转换时只能使用显式调用，而不允许隐式的类型转换发生。

通过使用 explicit 关键字，可以防止一些意外的类型转换，提高代码的清晰性和安全性。它通常用于防止不必要的类型转换，特别是在单参数构造函数可能引起歧义或产生意外结果的情况下。

preprocessor directive

• #include_next 的作用是
  在寻找头文件时的头文件搜索优先级里，去除该文件所在的当前目录，主要是为C++头文件的重名问题提供一种解决方案。
  • 正确的用法：代码b.cpp想使用
    自己拓展修改的stdlib.h, 那么在代码的目录下创建stdlib.h，并在该文件里#include_next "stdlib.h" 防止递归引用。

define、 const、 typedef、 inline

• define：
  • define是一个预处理器指令，用于创建宏定义。它在编译之前对源代码进行简单的文本替换。可以用来定义常量、函数宏和条件编译等。
  • 优势：灵活性上占优，特别是在需要获取文件名、行号或控制编译(不同平台编译)时行为的场景
  • 缺点：宏的调试和排错难度相对较高，因为宏的展开发生在编译前，出错时通常不容易直接定位到宏展开的具体代码。相比函数，宏的类型检查不严格，容易导致隐含的错误。
  • 例如：#define PI 3.14159，在代码中将PI替换为3.14159。

1
2

#define TO_STRING(x) #x
#define CONCAT_AND_PRINT(a, b) printf("Concatenation: %s\n", TO_STRING(a##b));

1
2
3
4
5
6
7
8
9

int main() {
    int HelloWorld = 42;

    // 使用字符串化操作
    printf("%s\n", TO_STRING(HelloWorld)); // 输出: HelloWorld

    // 使用标记粘贴操作和字符串化操作
    CONCAT_AND_PRINT(Hello, World);        // 输出: Concatenation: HelloWorld
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#define REGISTER_OPTION_CACHE(type, valueName, ...)                 \
    static thread_local type valueName##Value;                      \
    static thread_local bool valueName##Initialized = false;        \
    inline type GetWithCache##valueName() {                         \
        if (!valueName##Initialized) {                              \
            valueName##Value = __VA_ARGS__();                       \
            valueName##Initialized = true;                          \
        }                                                           \
        return valueName##Value;                                    \
    }                                                               \
    inline void SetWithCache##valueName(type value) {               \
        valueName##Value = value;                                   \
        valueName##Initialized = true;                              \
    }

1

REGISTER_OPTION_CACHE(int, MyValue, 42);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static thread_local int MyValueValue;
static thread_local bool MyValueInitialized = false;

inline int GetWithCacheMyValue() {
    if (!MyValueInitialized) {
        MyValueValue = 42;  // 使用了 __VA_ARGS__
        MyValueInitialized = true;
    }
    return MyValueValue;
}

inline void SetWithCacheMyValue(int value) {
    MyValueValue = value;
    MyValueInitialized = true;
}

• const：

  • const用于声明一个常量，指示标识符的值在程序执行期间不能被修改。
  • const可以用于变量、函数参数、函数返回类型和成员函数。使用const可以提高代码的可读性和安全性。
  • 例如：const int MAX_VALUE = 100;，声明一个名为MAX_VALUE的常量。

• typedef：

  • typedef用于为数据类型创建别名。它可以用于为复杂的数据类型提供更简洁的名称，增强代码的可读性和可维护性。
  • typedef创建的别名可以像原始类型一样使用，并且不会引入新的类型，只是为已有类型提供了一个新的名称。
  • 例如：typedef int Age;，为int类型创建了一个别名Age。

• inline：

  • inline用于声明内联函数，它是一种编译器的建议，用于将函数的定义直接插入到调用处，以避免函数调用的开销。
  • 内联函数通常在函数体较小且频繁调用的情况下使用，可以提高程序的执行效率。
  • inline关键字只是给编译器一个提示，编译器可以选择忽略该提示。在大多数情况下，编译器会自动进行内联优化。
  • 例如：inline int add(int a, int b) { return a + b; }，声明了一个内联函数add。

• define主要用于宏定义，const用于声明常量，typedef用于创建类型别名，inline用于内联函数的声明。

#ifndef & #pragma once

为了避免同一个文件被include多次，C/C++中有两种方式，一种是#ifndef方式，一种是#pragma once方式。在能够支持这两种方式的编译器上，二者并没有太大的区别，但是两者仍然还是有一些细微的区别。

new & delete

• new和delete 相对于 malloc/free 分配和释放堆空间。
  • 额外会执行构造函数和析构函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructing MyClass" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructing MyClass" << std::endl;
    }
};

int main() {
    // 使用new动态分配内存，并调用构造函数
    MyClass* obj = new MyClass();

    // 执行一些操作...

    // 使用delete释放内存，并调用析构函数
    delete obj;

    return 0;
}

namespace

namespace 会影响 typedef 的作用范围，但不会直接限制 #define 宏的作用范围。

头文件

• 相互引用，前置声明
• include头文件其实就是将对应的头文件内容贴在include的位置

函数的特殊写法

函数传参

1. 值传递
2. 引用传递
3. 指针传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//值传递
change1(n);
void change1(int n){
    n++;
}

//引用传递，操作地址就是实参地址 ，只是相当于实参的一个别名，在符号表里对应是同一个地址。对它的操作就是对实参的操作
    change2(n);
    void change2(int &n){
        n++;
    }
    //特殊对vector
    void change2(vector<int> &n)
    //特殊对数组
    void change2(int (&n)[1000])

//指针传递，其实是地址的值传递
change3(&n);
void change3(int *n){
    *n=*n+1;
}

引用传递和指针传递的区别：

• 引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
• 不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
• 一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

指针传递和引用传递的使用情景：

1. 函数内部修改参数并且希望改动影响调用者。
2. 当一个函数实际需要返回多个值，而只能显式返回一个值时，可以将另外需要返回的变量以指针/引用传递

闭包、匿名函数

1
2
3
4
5
6
7
8

auto add = [](int x) {
    return [x](int y) {
        return x + y;
    };
};

auto add5 = add(5);
std::cout << add5(3); // 输出 8

• 匿名函数是一种没有被绑定标识符的函数
• lambda 是一种匿名函数
• lambda 可以表示闭包

• Lambda在C++中的实现方式

传参默认值

虽然理论上可以通过类似void f(bool x = true)来实现默认值。

1
2
3
4
5
6
7

// 函数声明
void bar(int a = 10);

// 函数定义
void bar(int a) {
    std::cout << "a: " << a << std::endl;
}

1
2
3
4
5
6
7
8
9
10
11
12

// hpp
void SetDeterministic();
void SetDeterministic(bool isOpapi = true);

//cpp
void SetDeterministic() {
    SetDeterministic(true);
}
void SetDeterministic(bool isOpapi)
{
    //xxx
}

类型变参模板

1
2
3
4
5
6
7
8

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

1
2
3
4
5
6
7
8
9
10

template <
    typename T,
    typename U = T,
    typename = typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type>
class Wrapper {
public:
    void function() {
        // 实现
    }
};

个数变参模板

1
2
3
4
5
6
7
8

#include <stdarg.h>
void Error(const char* format, ...)
{
    va_list argptr;
    va_start(argptr, format);
    vfprintf(stderr, format, argptr);
    va_end(argptr);
}

VA_LIST 是在C语言中解决变参问题的一组宏，变参问题是指参数的个数不定，可以是传入一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有实际的名称与之相对应，用起来是很灵活。

1. 首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；
2. 然后用VA_START宏初始化变量刚定义的VA_LIST变量；
3. 然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；
4. 最后用VA_END宏结束可变参数的获取。

系统提供了vprintf系列格式化字符串的函数，用于编程人员封装自己的I/O函数。

1
2
3

int vprintf  / vscanf   (const char * format, va_list ap);                  // 从标准输入/输出格式化字符串 
int vfprintf / vfsacanf (FILE * stream, const char * format, va_list ap);   // 从文件流 
int vsprintf / vsscanf  (char * s, const char * format, va_list ap);        // 从字符串

返回多个数

使用结构体

1
2
3
4
5
6
7
8
9

struct RowAndCol { int row;int col; };

RowAndCol r(string fn) {
    /*...*/
    RowAndCol result;
    result.row = x;
    result.col = y;
    return result;
}

左值与右值

在 C++ 中，左值（lvalue） 和 右值（rvalue） 是两个重要的概念，用来描述表达式的值和内存的关系。它们帮助开发者理解变量的生命周期、赋值和对象管理，特别是在现代 C++ 中引入了右值引用后，优化了移动语义和资源管理。

1. 左值（lvalue）

左值（lvalue，locatable value） 是指在内存中有明确地址、可持久存在的对象，可以对其进行赋值操作。通俗地说，左值是能够取地址的值，可以出现在赋值操作符的左边。

特点：

• 左值具有持久的内存地址。
• 左值可以取地址（使用 & 运算符）。
• 左值通常表示已经存在的变量或对象。

1
2
3
4

int x = 10;   // x 是左值
int* p = &x;  // 可以取 x 的地址

x = 20;       // 可以对左值进行赋值

2. 右值（rvalue）

右值（rvalue，readable value） 是没有明确地址、临时存在的对象，不能对其进行赋值操作。它们通常是字面值常量或表达式的结果。右值只能出现在赋值操作符的右边，表示一个临时对象或数据。

特点：

• 右值是临时的，通常会在表达式结束时销毁。
• 右值不能取地址（即不能使用 & 获取右值的地址）。
• 右值表示表达式的计算结果或临时对象。

1
2

int y = 10;       // 10 是右值
int z = y + 5;    // y + 5 是右值表达式

3. 现代 C++ 中的右值引用（rvalue reference）

C++11 引入了 右值引用，即通过 && 符号表示。这使得右值也能通过引用进行操作，特别是在实现移动语义（move semantics）和避免不必要的拷贝时非常有用。右值引用允许我们通过右值管理资源，避免性能上的损失。

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = std::move(vec1);  // vec1 资源移动到 vec2

    std::cout << "vec1 size: " << vec1.size() << std::endl;
    std::cout << "vec2 size: " << vec2.size() << std::endl;

    return 0;
}

4. 区分左值与右值

通常，左值是表示持久存在的对象，可以通过取地址符 & 获取其地址，而右值是临时的、短暂存在的值，不能直接获取其地址。理解这两者对于编写高效的 C++ 代码和使用现代特性（如右值引用和移动语义）非常重要。

• 左值（lvalue） 是可以取地址的值，通常是变量或持久的对象。
• 右值（rvalue） 是临时值，通常是表达式的结果或字面量。
• 右值引用（&&）是 C++11 引入的新特性，用来优化资源管理和避免不必要的拷贝操作。

C++11: 花括号初始化列表

使用

在C++98/03中我们只能对普通数组和POD(plain old data，简单来说就是可以用memcpy复制的对象)类型可以使用列表初始化，如下：

1
2
3
4
5
6
7
8

//数组的初始化列表： 
int arr[3] = {1,2,3}
//POD类型的初始化列表：
struct A
{
 int x;
 int y;
}a = {1,2};

在C++11中初始化列表被适用性被放大，可以作用于任何类型对象的初始化。如下：

1
2
3
4
5
6
7
8
9

X x1 = X{1,2};
X x2 = {1,2}; // 此处的'='可有可⽆
X x3{1,2};
X* p = new X{1,2};

//列表初始化也可以用在函数的返回值上
std::vector<int> func() {
    return {};
}

变量类型的适用范围

聚合类型可以进行直接列表初始化

聚合类型包括

1. 普通数组，如int[5]，char[]，double[]等
2. 一个类，且满足以下条件：
   1. 没有用户声明的构造函数
   2. 没有用户提供的构造函数(允许显示预置或弃置的构造函数)
   3. 没有私有或保护的非静态数据成员
   4. 没有基类
   5. 没有虚函数
   6. 没有{}和=直接初始化的非静态数据成员
   7. 没有默认成员初始化器

原理

对于一个聚合类型，使用列表初始化相当于使用std::initializer_list对其中的相同类型T的每个元素分别赋值处理，类似下面示例代码；

1
2
3
4
5
6
7
8

struct CustomVec {
    std::vector<int> data;
    CustomVec(std::initializer_list<int> list) {
        for (auto iter = list.begin(); iter != list.end(); ++iter) {
            data.push_back(*iter);
        }
    }
};

优势

1. 方便，且基本上可以替代括号初始化
2. 可以使用初始化列表接受任意长度
3. 可以防止类型窄化，避免精度丢失的隐式类型转换

参考文献

1. https://zh.cppreference.com/

2. https://leetcode-cn.com/problems/path-with-maximum-gold/solution/huang-jin-kuang-gong-by-leetcode-solutio-f9gg/

3. https://blog.csdn.net/qq_33221533/article/details/82119031

4. ⼩贺 C++ ⼋股⽂ PDF 的作者，电⼦书的内容整理于公众号「herongwei」

5. https://blog.csdn.net/hailong0715/article/details/54018002

https://shaojiemike.notion.site/C-11-a94be53ca5a94d34b8c6972339e7538a

解释性语言

解释型语言没有严格编译汇编过程，由解释器将代码块按需要变运行边翻译给机器执行。因此解释型语言一度存在运行效率底，重复解释的问题。但是通过对解释器的优化!可以提高解释型语言的运行效率。

Python 与大多数解释型语言一样，确实是将源代码编译为一组虚拟机指令，并且 Python 解释器是针对相应的虚拟机实现的。这种中间格式被称为 “字节码”。

Python 字节码

Python 以 .pyc 结尾的 “ 字节码(bytecode)” 文件(二进制文件)，一般位于__pycache__ 的子目录中，可以避免每次运行 Python 时去重新解析源代码。

1

python -m py_compile file.py  # 生成单个pyc文件

pyo优化文件

pyo文件是源代码文件经过优化编译后生成的文件，是pyc文件的优化版本。编译时需要使用-O和-OO选项来生成pyo文件。在Python3.5之后，不再使用.pyo文件名，而是生成文件名类似“test.opt-n.pyc的文件。

1

python -O -m py_compile test.py

Python 虚拟机

CPython 使用一个基于栈的虚拟机。（你可以 “推入” 一个东西到栈 “顶”，或者，从栈 “顶” 上 “弹出” 一个东西来）。

CPython 使用三种类型的栈：

1. 调用栈(call stack)。这是运行 Python 程序的主要结构。它为每个当前活动的函数调用使用了一个东西 —— “ 帧(frame)”
2. 在每个帧中，有一个 **计算栈(evaluation stack)**（也称为 数据栈(data stack)）。这个栈就是 Python 函数运行的地方，运行的 Python 代码大多数是由推入到这个栈中的东西组成的，操作它们，然后在返回后销毁它们。
3. 在每个帧中，还有一个**块栈(block stack)**。它被 Python 用于去跟踪某些类型的控制结构：循环、try / except 块、以及 with 块，全部推入到块栈中，当你退出这些控制结构时，块栈被销毁。

C vs Python

运行流程区别

python的传统运行执行模式：录入的源代码转换为字节码，之后字节码在python虚拟机中运行。代码自动被编译，之后再解释成机器码在CPU中执行。

c编译器直接把c源代码编译成机器码。过程比python执行过程少了字节码生成和虚拟机执行字节码过程。所以自然比python快。

深、浅拷贝

Python append() 与深拷贝、浅拷贝

python赋值只是引用，别名

1
2
3
4
5
6
7
8

list.append('Google')   ## 使用 append() 添加元素
alist.append( num ) # 浅拷贝 ，之后修改num 会影响alist内的值

import copy
alist.append( copy.deepcopy( num ) ) # 深拷贝

# delete
del list[2]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

original_list = [1, 2, 3]

for item in original_list:
    item *= 2 # 每个元素是不可变的

print(original_list) 

original_list = [[1,2,3], [2], [3]]

for item in original_list:
    item.append("xxx") # 每个元素是可变的

print(original_list) 

# [1, 2, 3]
# [[1, 2, 3, 'xxx'], [2, 'xxx'], [3, 'xxx']]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def fun0(a):
    a = [0,0] # a在修改后，指向的地址发生改变，相当于新建了一个值为[0,0]

def fun(a):
    a[0] = [1,2]
    
def fun2(a):
    a[:] = [10,20]
    
b = [3,4]
fun0(b)
print(b)
fun(b)
print(b)
fun2(b)
print(b)

# [3, 4]
# [[1, 2], 4]
# [10, 20]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def fun1(l):
    l.append("0")
    return l 

def fun2(l):
    return l

if __name__=="__main__":
    l = [1,2,3,4,5]

    rel2 = fun2(l)
    print(rel2)   
    rel1 = fun1(l)
    print(rel1)   
    print(rel2)   
 
# [1, 2, 3, 4, 5]
# [1, 2, 3, 4, 5, '0']
# [1, 2, 3, 4, 5, '0']

逻辑

setup

setup安装包的过程，请看pip package一文。

import

命名空间（namespace）可以基本理解成每个文件是一个，通过import来使用

触发 __init__.py

• 当你导入一个包时，Python 会执行该包目录下的 __init__.py 文件。如果没有这个文件，Python 会认为这个目录不是一个包，因此 import 语句会失败。
• __init__.py 负责初始化这个包，可以定义一些包级别的变量、函数或导入包的其他子模块。

行为：

• 每次导入包时，__init__.py 文件只会在第一次导入时被执行一次。如果模块已经被导入到当前的命名空间，再次 import 不会重新执行 __init__.py，除非你强制重新加载（比如用 importlib.reload()）。
• import 的执行会触发模块的初始化，类似于 C++ 中构造函数的概念，但不是在对象级别，而是在模块级别。

1
2
3
4
5

# example/__init__.py
print("Initializing the package")

def hello():
    print("Hello from the package")

1
2
3
4

import example
# 输出 "Initializing the package"
example.hello()
# 输出 "Hello from the package"

入口

• 在Python中,if __name__ == "__main__"这种写法通常出现在模块中,它的作用是控制模块的执行流程。
• 当一个模块被导入时,Python解释器会自动将这个模块的__name__属性设置为模块名称。但是如果模块是被直接运行的,则__name__属性会被设置为字符串__main__。
• 所以if name == “main”可以用来区分模块是被导入运行还是被直接运行:
• 如果模块是被导入的,if语句不会执行。因为模块的__name__不等于__main__。
• 如果模块是被直接运行的,if语句会执行。因为模块的__name__等于__main__。

清理与释放

程序结束时的清理行为（类似析构函数的操作）

在 Python 中，并没有像 C++ 那样显式的析构函数。模块或对象的清理一般通过以下方式实现：

• 对象的析构：当一个 Python 对象的引用计数降为零时，Python 会自动调用该对象的 __del__ 方法进行资源清理。这个机制类似于 C++ 的析构函数，但触发时机取决于 Python 的垃圾回收机制。

1
2
3
4
5
6
7
8
9

class MyClass:
    def __init__(self):
        print("Object created")
    
    def __del__(self):
        print("Object destroyed")

obj = MyClass()
# 程序结束时，或者当 obj 的引用计数降为 0 时，触发 __del__()

• 模块的清理：当程序结束时，Python 会尝试清理已加载的模块。这个过程会调用模块内一些特殊的钩子函数来进行必要的清理工作。虽然 Python 没有直接为模块提供析构函数，但是你可以使用 atexit 模块来注册一个函数，确保在程序结束时执行。

示例：使用 atexit 实现模块级别的清理操作

1
2
3
4
5
6
7
8
9

import atexit

def cleanup():
    print("Cleaning up resources before program exit")

# 注册一个清理函数，在程序结束时自动调用
atexit.register(cleanup)

print("Program is running")

输出：

1
2

Program is running
Cleaning up resources before program exit

• atexit 模块允许你注册多个函数，它们会在解释器关闭之前按注册顺序依次执行。
• 这种机制相当于 C++ 中的全局或静态对象析构函数的功能，确保在程序结束时执行一些清理工作。

模块的生命周期总结

• 初始化：当模块被导入时，Python 会执行模块的顶层代码，包括 __init__.py 文件。这相当于模块的 “构造” 过程。
• 对象的析构：在 Python 中，通过垃圾回收机制和 __del__ 方法来管理对象的生命周期。通常情况下，当对象不再被引用时，会自动触发清理。
• 程序结束时的清理：Python 提供了 atexit 模块来执行程序结束时的资源清理操作。你可以在模块中注册一些函数，确保在程序退出时执行清理任务。

语法

装饰器 decorator

@能在最小改变函数的情况下，包装新的功能。^1

1
2
3
4
5
6
7
8
9
10
11
12

def use_logging(func):

    def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()
    return wrapper

@use_logging
def foo():
    print("i am foo")

foo()

下划线

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

函数传参

解包

• 解包是指将一个容器（如列表、元组或字典）的内容拆分并分配给多个变量或作为参数传递给函数。
• Python 提供了简洁的语法来实现这一点，使用 * 和 ** 分别解包可迭代对象和字典。

1
2

def __call__(self, *input, **kwargs):
    result = self.forward(*input, **kwargs)

1
2

obj = SomeClass()
obj(1, 2, 3, key1='value1', key2='value2')

解包可迭代对象

1
2
3
4
5

def example_function(a, b, *args):
    print(f"a: {a}, b: {b}")
    print("Additional positional arguments:", args)

example_function(1, 2, 3, 4, 5)

1
2

a: 1, b: 2
Additional positional arguments: (3, 4, 5)

1
2
3
4
5
6
7
8

def another_function(a, b, *, x, y):
    print(f"a: {a}, b: {b}, x: {x}, y: {y}")

# 下面的调用会报错，因为 x 和 y 必须是关键字参数
# another_function(1, 2, 3, 4)

# 正确的调用方式
another_function(1, 2, x=3, y=4)

1

a: 1, b: 2, x: 3, y: 4

1
2
3
4
5
6

def sum_three_numbers(x, y, z):
    return x + y + z

numbers = [1, 2, 3]
result = sum_three_numbers(*numbers)
print(result)  # 输出：6

解包字典

• 在函数定义中，** 用于将传入的关键字参数打包成一个字典；
• 而在函数调用中，** 则用于将字典解包为关键字参数。

1
2
3
4
5

def example_function(a, b, **kwargs):
    print(f"a: {a}, b: {b}")
    print("Additional arguments:", kwargs)

example_function(1, 2, x=3, y=4)

1
2

a: 1, b: 2
Additional arguments: {'x': 3, 'y': 4}

1
2
3
4
5

def another_function(a, b, x, y):
    print(f"a: {a}, b: {b}, x: {x}, y: {y}")

args_dict = {'x': 3, 'y': 4}
another_function(1, 2, **args_dict)

1

a: 1, b: 2, x: 3, y: 4

DEBUG

段错误

1. 开启 Python 的调试模式：
   通过设置环境变量启用 Python 的调试信息，这有助于捕获异常和详细的堆栈信息。

   1	export PYTHONMALLOC=debug

2. 使用 faulthandler 模块：
   Python 提供了一个 faulthandler 模块，可以用来捕获段错误并打印堆栈信息。你可以在程序的开头添加以下代码来启用它：

   1 2	import faulthandler faulthandler.enable()

   这将会在段错误发生时输出堆栈跟踪。

3. 查看 Python 调试输出：
   启动 Python 程序时，通过 faulthandler 打印堆栈信息，或通过 GDB 调试 Python 解释器。如果 Python 解释器发生崩溃，faulthandler 会帮助你定位错误。

doctest

函数的单元测试

打印当前堆栈

traceback.print_stack()

VizTracer时间性能分析

1
2
3
4
5
6
7
8
9
10

from viztracer import VizTracer

tracer = VizTracer(max_stack_depth=2)  # 限制记录的调用栈深度为2，常用为 50和120
tracer.start()

# 你的代码
your_function()

tracer.stop()
tracer.save("result.json")

icecream for debug

1
2

from pprint import pprint
pprint(obj)

• 优雅打印对象：函数名，结构体
• 打印行号和栈（没用输入时
• 允许嵌套（会将输入传递到输出
• 允许带颜色ic.format(*args)获得ic打印的文本
• debug ic.disable()and ic.enable()
• 允许统一前缀 ic.configureOutput(prefix='Debug | ')
• 不用每个文件import

1
2
3
4
5
6
7

from icecream import ic
ic(STH)

from icecream import install
install()

ic.configureOutput(prefix='Debug -> ', outputFunction=yellowPrint)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import datetime
import inspect
from icecream import ic

def ic_with_timestamp(*args):
    # Get the current frame's information
    frame = inspect.currentframe().f_back  # Get the caller's frame
    filename = frame.f_code.co_filename  # File where the function is called
    lineno = frame.f_lineno  # Line number where the function is called

    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    # Format the output to include timestamp, file, and line number
    return '\n\n%s %s:%d shaojieLog >| ' % (timestamp, filename, lineno)

# Configure icecream to use this custom output function
ic.configureOutput(prefix=ic_with_timestamp)

# Example usage
ic("This is a test message.")

1
2
3
4
5

import datetime
def ic_with_timestamp(*args):
    return '\n\n%s shaojieLog >| ' % datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

ic.configureOutput(prefix=ic_with_timestamp)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import datetime
import inspect
from icecream import ic

# Initialize a variable to store the time of the last ic call
last_ic_time = None
initial_ic_time = datetime.datetime.now()  # Set the initial time when the script starts

# Define a custom function that prepends the time since the last ic call, file name, and line number
def ic_with_timestamp(*args):
    global last_ic_time
    current_time = datetime.datetime.now()

    # Calculate the time difference if there was a previous ic call
    if last_ic_time is not None:
        time_diff = current_time - last_ic_time
        time_diff_str = f" (+{time_diff.total_seconds():.2f}s)"
    else:
        time_diff_str = ""

    # Calculate the time since the initial call
    time_since_initial = current_time - initial_ic_time
    time_since_initial_str = f" [Total time: {time_since_initial.total_seconds():.2f}s]"

    # Update last_ic_time to the current time
    last_ic_time = current_time

    return f'\n\n{current_time.strftime("%Y-%m-%d %H:%M:%S")}{time_diff_str}{time_since_initial_str} shaojieLog |> '
ic.configureOutput(prefix=ic_with_timestamp)

1
2
3
4
5
6
7
8

# Disable icecream
ic.disable()

# This message will be hidden
ic("This message will NOT be shown")

# Re-enable icecream
ic.enable()

1
2
3
4

from icecream import ic
import sys

ic.configureOutput(outputFunction=sys.stdout.write)

1

python3.8 setup.py build bdist_wheel 2>&1 | tee compile.log

如果你只想捕获标准错误的输出，并将其保存到日志文件，可以使用以下命令：

1
python3.8 setup.py build bdist_wheel 1>&2 | tee compile.log


或将 `stderr` 和 `stdout` 单独重定向：

1
python3.8 setup.py build bdist_wheel 2>compile.log

性能优化 与 可视化

定位 Python 中 setup.py 脚本运行缓慢的 热点，可以通过多种方式进行性能分析，具体步骤取决于你想了解的性能细节。以下是几种常见的方法来定位性能瓶颈。

方法 1: 使用 cProfile 进行性能分析

cProfile 是 Python 标准库中用于进行性能分析的工具。你可以用它来跟踪 setup.py 执行时的函数调用并找到性能瓶颈。

cProfile + snakeviz + gprof2dot

1

./gprof2dot.py -f pstats Diff.status | dot -Tpng -o ./output/Diff.png

1.1 使用 cProfile 分析 setup.py

你可以通过 cProfile 运行 setup.py 并生成分析报告：

1

python -m cProfile -o setup.prof setup.py install

这将运行 setup.py 并将性能分析结果保存到 setup.prof 文件中。

1.2 可视化分析报告

使用 pstats 或者第三方工具 snakeviz 来分析 setup.prof：

1. 使用 pstats 来查看分析结果：

   1	python -m pstats setup.prof

   然后，你可以在 pstats 交互式界面中输入命令，比如：

   • sort cumtime 按总耗时排序。
   • stats 查看函数调用的分析结果。

2. 安装 snakeviz 来生成Web图形化报告：

   1	pip install snakeviz

   运行 snakeviz 来可视化分析结果：

   1	snakeviz setup.prof # deploy to 127.0.0.1:8080

   这样可以生成一个图形化的界面，显示每个函数的执行时间以及调用关系，让你更直观地看到性能瓶颈。

3. 使用 gprof2dot 生成调用关系图片：

   安装 gprof2dot 工具：pip install gprof2dot

   使用 gprof2dot 将 cProfile 生成的 output.prof 转换为 .dot 文件：gprof2dot -f pstats output.prof | dot -Tsvg -o output.svg

   这里的 -f pstats 表示输入的格式是 cProfile 生成的 pstats 文件。这个命令会将结果转换为 SVG 格式的火焰图，保存为 output.svg。

   打开生成的 SVG 文件，查看火焰图。

4. 生成火焰图： flameprof

   1. 正常的火焰图说明了上到下的调用关系，倒置火焰图说明了底层最耗时的元素。
   2. python flameprof.py input.prof > output.svg

5. 生成火焰图(有详细文件路径)： flamegraph

   1. flameprof --format=log requests.prof | xxx_path/flamegraph.pl > requests-flamegraph.svg

方法 3: 使用 line_profiler 进行逐行性能分析

如果你想深入了解 setup.py 的某个函数或一组函数的逐行性能，可以使用 line_profiler 工具来分析代码的逐行执行时间。

3.1 安装 line_profiler

1

pip install line_profiler

3.2 添加装饰器

首先，在 setup.py 中找到你想要分析的函数，添加 @profile 装饰器（在 line_profiler 中的分析模式下使用）：

1
2
3

@profile
def some_function():
    # Your function code

3.3 运行 line_profiler

你可以使用 kernprof.py 来运行 setup.py 并生成逐行性能报告：

1

kernprof -l -v setup.py install

这将运行 setup.py 并生成一份逐行性能分析报告，显示每一行代码的耗时。

方法 4: 使用 Py-Spy 进行实时性能分析(推荐!!!)

Py-Spy 是一个 Python 的取样分析器，它可以在不修改代码的情况下对 Python 程序进行性能分析，并生成实时的性能报告。

4.1 安装 Py-Spy

1

pip install py-spy

4.2 运行 Py-Spy 对 setup.py 进行分析

你可以在执行 setup.py 的同时运行 Py-Spy 进行取样分析：

1

py-spy top -- python setup.py install

这会生成一个实时的报告，类似于 top 命令，显示当前正在运行的 Python 函数以及其消耗的 CPU 时间。

4.3 生成火焰图

如果你希望生成一个更直观的火焰图，可以使用 py-spy 生成火焰图文件：

1

py-spy record -o profile.svg -- python setup.py install

然后你可以打开 profile.svg 文件，查看一个交互式的火焰图，清晰展示函数调用的时间分布。

方法 5: 使用 strace 分析系统调用

如果 setup.py 涉及大量的 I/O 操作（比如读写文件或安装依赖包），可能是这些操作导致了性能瓶颈。你可以使用 strace 来分析 setup.py 的系统调用，找到 I/O 操作的瓶颈。

1

strace -tt -T -o strace.log python setup.py install

• -tt 选项会显示每个系统调用的时间戳。
• -T 会显示每个系统调用耗时。
• -o 将结果输出到 strace.log 文件中。

通过查看 strace.log，你可以找出系统调用中哪些操作耗时过长。

总结

1. 使用 cProfile 或 Py-Spy 进行函数级别的性能分析，找出执行慢的函数。
2. 如果需要更细粒度的逐行分析，使用 line_profiler 来分析慢的部分。
3. 如果怀疑是 I/O 问题，用 strace 来检查系统调用。
4. 使用 time 在脚本中插入计时代码，快速定位长时间的执行步骤。

这些工具可以帮助你定位和修复 setup.py 运行缓慢的热点。

虚拟环境venv

1
2
3
4
5
6
7
8

python3 -m venv name

#在Windows上，运行:
name\Scripts\activate.bat # poweshell运行activate.ps1
#在Unix或MacOS上，运行:
source name/bin/activate
#（这个脚本是为bash shell编写的。如果你使用 csh 或 fish shell，你应该改用 activate.csh 或 activate.fish 脚本。）
python3 setup.py install

实践

1. 并行调用shell命令，超时kill
2. 基于Pipe的自定义多进程进度条

数据快速写入和读取文件

任意变量使用pickle

1
2
3
4
5

# 使用二进制
with open('my_dict.json', 'wb') as f: 
    pickle.dump(my_dict, f)
with open('my_dict.json', 'rb') as f:
    loaded_dict = pickle.load(f)

可以序列化的使用json

1
2
3
4
5
6
7
8

import json
# 将 dict 保存为 JSON 格式
with open('my_dict.json', 'w') as f:
    json.dump(my_dict, f)

# 加载 dict
with open('my_dict.json', 'r') as f:
    loaded_dict = json.load(f)

多个变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 将多个变量组织成字典或列表
data = {
    "scaAvgTime": scaAvgTime,
    "var2": var2,
    "var3": var3
}

result_file = "result.json"

# 将数据写入JSON文件
with open(result_file, "w") as f:
    json.dump(data, f)

# 读取JSON文件
with open(result_file, "r") as f:
    data = json.load(f)

# 获取保存的变量值
scaAvgTime = data["scaAvgTime"]
var2 = data["var2"]
var3 = data["var3"]

参考文献

https://zhuanlan.zhihu.com/p/39259061

基础杂项

auto的使用

• 当你想要拷贝range的元素时，使用 for(auto x : range).
• 当你想要修改range的元素时，使用 for(auto && x : range)
• 当你想要只读range的元素时，使用 for(const auto & x : range).

容器间的转换

使用begin end

1
2
3
4
5

vector<int>& nums1
unordered_set<int> nums_set(nums1.begin(), nums1.end());

unordered_set<int> result;
return vector<int>(result.begin(), result.end());

以下是整理和改正后的迭代器笔记。

迭代器知识

随机访问迭代器

• 定义：随机访问迭代器是一种迭代器类型，允许在常数时间内访问序列中的任何元素，并支持灵活的迭代器操作。

• 运算支持：

  • 支持指针算术运算，如 + 和 - 运算符，允许轻松地在迭代器位置上进行移动。
  • 支持下标运算符 []，使其用法与指针类似。
  • 例如，对于一个指向数组的随机访问迭代器 it，可以通过 *(it + i) 或 it[i] 语法访问第 i 个元素。

• 使用场景：

  • STL 容器：vector 和 deque 都提供随机访问迭代器。
  • 算法：一些标准库算法（例如 std::sort、std::nth_element）要求输入的迭代器必须是随机访问迭代器，以便快速定位和排序。

正向迭代器与反向迭代器

• 概述：在 C++ 中，容器一般提供正向迭代器（begin() 到 end()）和反向迭代器（rbegin() 到 rend()），二者在遍历方向上相反。

• 转换：正向迭代器和反向迭代器可以相互转换，但类型不同，需要显式转换。

  • 正向迭代器到反向迭代器：可以将一个正向迭代器转换为反向迭代器。

    1 2	Iterator it; // 假设 it 是正向迭代器 std::reverse_iterator<Iterator> rit(it); // 将 it 转换为反向迭代器 rit

  • 反向迭代器到正向迭代器：反向迭代器的 base() 成员函数可以返回一个指向反向迭代器当前元素的下一个位置的正向迭代器。

    1 2	std::reverse_iterator<Iterator> rit; Iterator it = rit.base(); // 转换为正向迭代器，指向 rit 所指位置的后一个元素

• 注意：

  • 反向迭代器 rit.base() 指向的并不是 rit 当前元素本身，而是 rit 指向元素的下一个位置。

反向遍历

C++ 提供了 rbegin() 和 rend() 来支持容器的反向遍历：

• rbegin() 返回一个反向迭代器，指向容器的最后一个元素。
• rend() 返回一个反向迭代器，指向容器反向遍历时的“结束位置”，即第一个元素之前的一个位置。
• 在循环中，注意使用 ++it 而非 --it，因为反向迭代器的递增操作相当于在正向迭代器上进行递减操作。

1
2
3
4
5

for (auto it = collection.rbegin(); it != collection.rend(); ++it) {
    std::cout << *it << std::endl;
    // 或者如果是键值对容器：
    // std::cout << it->first << ", " << it->second << std::endl;
}

1
2
3
4
5

auto it = showedPositive.end();
while (it != showedPositive.begin()) {
    --it;  // 注意：先递减迭代器，再访问元素
    std::cout << *it << std::endl;
}

前后第k个元素

• std::prev 函数接受两个参数：一个是指向迭代器的参数，另一个是整数偏移量。它返回从指定迭代器开始向前移动指定偏移量后的迭代器。
• std::next 函数接受两个参数：一个是指向迭代器的参数，另一个是整数偏移量。它返回从指定迭代器开始向后移动指定偏移量后的迭代器。

1
2
3
4
5
6

auto prevIt = std::prev(it);

auto next2It = std::next(it, 2);

auto it2 = it;
advance(it2,k);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

template <typename InputIt, typename Distance>
void advance(InputIt& it, Distance n) {
    if constexpr (std::is_same_v<std::random_access_iterator_tag,
                typename std::iterator_traits<InputIt>::iterator_category>) {
        it += n; //如果迭代器是随机访问迭代器（后面解释），它会使用 += 运算符来移动；
    } else {
        if (n >= 0) {
            while (n--) {
                ++it; //否则，它会使用循环来移动。
            }
        } else {
            while (n++) {
                --it;
            }
        }
    }
}

bitset

bitset类型存储二进制数位。

初始化

1
2
3
4
5
6
7

std::bitset<16> foo;
std::bitset<16> bar (0xfa2);
std::bitset<16> baz (std::string("0101111001"));

//foo: 0000000000000000
//bar: 0000111110100010
//baz: 0000000101111001

格式转换

将数转化为其二进制的字符串表示

1
2
3

int i = 3;
string bin = bitset<16>(i).to_string(); //bin = "0000000000000011"
bin = bin.substr(bin.find('1'));        //bin = "11"

pair

1
2
3
4
5
6
7
8

#include <utility>
pair<T1, T2> p1;            //创建一个空的pair对象（使用默认构造），它的两个元素分别是T1和T2类型，采用值初始化。
pair<T1, T2> p1(v1, v2);    //创建一个pair对象，它的两个元素分别是T1和T2类型，其中first成员初始化为v1，second成员初始化为v2。
make_pair(v1, v2);          // 以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。
p1 < p2;                    // 两个pair对象间的小于运算，其定义遵循字典次序：如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。
p1 == p2；                  // 如果两个对象的first和second依次相等，则这两个对象相等；该运算使用元素的==操作符。
p1.first;                   // 返回对象p1中名为first的公有数据成员
p1.second;                 // 返回对象p1中名为second的公有数据成员

tuple

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <tuple> // 包含 tuple

std::tuple<int, std::string, double> t1(1, "one", 1.0);

// 使用 make_tuple 函数
auto t2 = std::make_tuple(2, "two", 2.5);

//使用 tuple 时，访问/修改元素使用 std::get<index>。
std::cout << "Tuple t2: ("
            << std::get<0>(t2) << ", "
            << std::get<1>(t2) << ", "
            << std::get<2>(t2) << ")"
            << std::endl;

char 与 字符串

元音与index的相互映射

1
2
3
4

string vowel = "AEIOUaeiou";
if vowel.find(c) != std::string::npos;

voewl[0] = 'A';

string

初始化与读取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

std::string s0 ("Initial string");

// constructors used in the same order as described above:
std::string s1;
std::string s2 (s0);
std::string s3 (s0, 8, 3);
std::string s4 ("A character sequence");
std::string s5 ("Another character sequence", 12);
std::string s6a (10, 'x');
std::string s6b (10, 42);      // 42 is the ASCII code for '*'
std::string s7 (s0.begin(), s0.begin()+7);

std::cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3;
std::cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6a: " << s6a;
std::cout << "\ns6b: " << s6b << "\ns7: " << s7 << '\n';

//output
s1: 
s2: Initial string
s3: str
s4: A character sequence
s5: Another char
s6a: xxxxxxxxxx
s6b: **********
s7: Initial

读取空格分割的

1
2
3
4
5

stringstream txt(s);
string word;
while(txt>>word){
    // to do
}

增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// inserting into a string
#include <iostream>
#include <string>

std::string str="to be question";
std::string str2="the ";
std::string str3="or not to be";
std::string::iterator it;

// used in the same order as described above:
str.insert(6,str2);                 // to be (the )question
str.insert(10,"to be ");            // to be not (to be )that is the question
it = str.insert(str.begin()+5,','); // to be(,) not to be: that is the question
str.insert(6,str3,3,4);             // to be (not )the question
str.insert(10,"that is cool",8);    // to be not (that is )the question
str.insert(str.end(),3,'.');       // to be, not to be: that is the question(...)
str.insert(15,1,':');               // to be not to be(:) that is the question
// ???
str.insert (it+2,str3.begin(),str3.begin()+3); // (or )

1
2
3
4
5
6
7
8
9
10
11
12
13

std::string s = "C+";
char ch = '+';

s.push_back(ch);
s += ch; //string::operator+=, which is overloaded for chars and internally calls to the push_back() function.
s.append(1, ch); //1*ch个字符
s.append("abcd"); //后面添加abcd字符串

std::stringstream ss;
ss << s << ch;
ss >> s;

s.insert(s.length(), 1, ch);

1
2
3
4
5

//连接 string, 很简单。
str1 = str1 + str2;
//连接 char * , src 和 dest 所指内存区域不可以重叠且 dest 必须有足够的空间来容纳 src 的字符串。结果返回指向 dest 的指针。
#include <cstring>
strcat(dest, src);

删

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// string::erase
#include <iostream>
#include <string>

int main ()
{
std::string str ("This is an example sentence.");
std::string str1(str) ;
std::cout << str << '\n';
                                        // "This is an example sentence."
str.erase (10,8);                        //            ^^^^^^^^
//去除index=10的连续8个元素，

//去除从index=3开始的所有元素, 后面全删除
str1.erase (3);
// "Thi"

std::cout << str << '\n';
                                        // "This is an sentence."
str.erase (str.begin()+9);               //           ^
//去除itr指向的元素
std::cout << str << '\n';
                                        // "This is a sentence."
str.erase (str.begin()+5, str.end()-9);  //       ^^^^^
//去除[first,last).的元素
std::cout << str << '\n';
                                        // "This sentence."
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

std::string s = "C,C++,Java,";
if (!s.empty()) {
s.pop_back();
}

if (!s.empty()) {
s.resize(s.size() - 1);
}

if (!s.empty()) {
s.erase(std::prev(s.end()));
}

if (!s.empty()) {
s.erase(s.size() - 1);
}

改

1
2
3
4

// Copy three characters of s1 (starting
// from position 1)
//第一个参数是要截取的字符串，第二个参数是截取的开始位置，第三个参数是截取长度（可选）1。如果没有指定长度，则子字符串将延续到源字符串的结尾。
string r = s1.substr(1, 3);

1
2
3
4
5
6
7
8

// Take any string
string s = "dog:cat";
// Find position of ':' using find()
int pos = s.find(":");
// Copy substring after pos(include pos)
string sub = s.substr(pos);
// Copy substring before pos(not include pos)
string sub = s.substr(0 , pos);

1

reverse(greeting.begin(),greeting.end());

查

1
2
3
4

//总长度
len = str3.size();
// strlen 大部分情况结果和size一样，但是字符串里有\0, strlen会提前返回。
len = strlen(s1);

1
2

string s;
for(auto && x : s)

1
2

printf("%s", your_string.c_str()); //不推荐
cout << your_string;

1
2
3
4
5
6

// log1 中找空格
int pos1 = log1.find_first_of(" ");

// 判断是否找到
if(s.find(goal) != string::npos){
}

1
2
3

#include <cctype>  // 对应 isdigit 函数
// 判断数字
bool isDigit1 = isdigit(log1[pos1 + 1]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
#include <string>

bool hasPrefix(const std::string& str, const std::string& prefix) {
    return str.compare(0, prefix.size(), prefix) == 0;
}

int main() {
    std::string text = "Hello, world!";
    std::string prefix = "Hello";

    if (hasPrefix(text, prefix)) {
        std::cout << "The string starts with the prefix." << std::endl;
    } else {
        std::cout << "The string does not start with the prefix." << std::endl;
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
#include <string>

bool hasPrefix(const std::string& str, const std::string& prefix) {
    return str.find(prefix) == 0;
}

int main() {
    std::string text = "Hello, world!";
    std::string prefix = "Hello";

    if (hasPrefix(text, prefix)) {
        std::cout << "The string starts with the prefix." << std::endl;
    } else {
        std::cout << "The string does not start with the prefix." << std::endl;
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
#include <string>

int main() {
    std::string text = "Hello, world!";
    std::string prefix = "Hello";

    if (text.starts_with(prefix)) {
        std::cout << "The string starts with the prefix." << std::endl;
    } else {
        std::cout << "The string does not start with the prefix." << std::endl;
    }

    return 0;
}

1
2
3

size_t rfind(const std::string& str, size_t pos = std::string::npos) const;
size_t rfind(const char* s, size_t pos = std::string::npos) const;
size_t rfind(char c, size_t pos = std::string::npos) const;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
#include <string>

int main() {
    std::string text = "Hello, world! Hello, C++!";
    size_t pos = text.rfind("Hello");

    if (pos != std::string::npos) {
        std::cout << "'Hello' found at position: " << pos << std::endl;
    } else {
        std::cout << "'Hello' not found." << std::endl;
    }

    return 0;
}

1

'Hello' found at position: 14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
#include <string>

int main() {
    std::string text = "abcdefgabc";
    size_t pos = text.rfind('a');

    if (pos != std::string::npos) {
        std::cout << "'a' found at position: " << pos << std::endl;
    } else {
        std::cout << "'a' not found." << std::endl;
    }

    return 0;
}

1

'a' found at position: 7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
#include <string>

int main() {
    std::string text = "Hello, world! Hello, C++!";
    size_t pos = text.rfind('o', 10);

    if (pos != std::string::npos) {
        std::cout << "'o' found at position: " << pos << std::endl;
    } else {
        std::cout << "'o' not found." << std::endl;
    }

    return 0;
}

1

'o' found at position: 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <vector>
#include <regex> //important

// 解析字符串中的所有单个数字和范围
void parseNumbers(const std::string& input, std::vector<std::pair<int, int>>& ranges) {
    // 在 C++ 中，使用 R"(...)" 定义原始字符串，可以避免转义字符
    std::regex rangePattern(R"(\b(\d+)\s+to\s+(\d+)\b)");  // 匹配范围形式

    std::smatch match;
    std::string::const_iterator searchStart(input.cbegin());

    // 找到所有的范围
    while (std::regex_search(searchStart, input.cend(), match, rangePattern)) {
        int start = std::stoi(match[1]);
        int end = std::stoi(match[2]);
        ranges.emplace_back(start, end);
        searchStart = match.suffix().first;  // 更新搜索起点
    }


}

int main() {
    std::string input = "undo xxx aaa 1 2 4 to 10";
    std::vector<std::pair<int, int>> ranges;

    parseNumbers(input, ranges);


    // 输出范围

    return 0;
}

顺序容器与关联容器

• 顺序容器包括vector、deque、list、forward_list、array、string，

  • 支持快速顺序访问元素。

• 关联容器包括set、map，

  • 支持高效的关键字查找和访问。
  • 不支持顺序容器的位置相关的操作。原因是关联容器中元素是根据关键字存储的，这些操作对关联容器没有意义。
  • 也不支持构造函数或插入操作这些接受一个元素值和一个数量值得操作。

关联容器和顺序容器有着根本的不同：关联容器中的元素是按关键字来保存和访问的。与之相对，顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。

二叉树

存储方式

链表，或者数组(如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。)

链式结构如下，注意左右孩子节点