c++ | baozi's page

const

const位于星号左侧，const用于修饰指针指向的变量；const位于星号右侧，const修饰指针本身

int b = 500;
const int* a = &b; [1]
int const *a = &b; [2]
int* const a = &b; [3]
const int* const a = &b; [4]

1和2是等价的，都表示指向常量的指针，3表示指针本身不可变，但是指向的内容可变

int a = 10;
int* const p = &a;
*p = 20; //合法
int b = 20;
p = &b;	//不合法，Cannot assign to readonly type int * const

int a

static

被static修饰的变量只能在当前文件访问，函数同理

// a.cpp 文件
static int a = 10;  // static 修饰全局变量
int main() {
    a++;  // 合法，可以在当前文件中访问 a
    return 0;
}

// b.cpp 文件
extern int a;  // 声明 a
void foo() {
    a++;  // 非法，会报链接错误，其他文件无法访问 a
}

修饰局部变量

void foo() {
    static int count = 0;  // static 修饰局部变量
    count++;
    cout << count << endl;
}

int main() {
    foo();  // 输出 1
    foo();  // 输出 2
    foo();  // 输出 3
    return 0;
}

extern

用于声明外部变量

File1.c

#include <stdio.h>

int globalVar = 42;  // 定义全局变量

void printVar() {
    printf("globalVar = %d\n", globalVar);
}

file2.c

#include <stdio.h>

extern int globalVar;  // 声明外部变量

void modifyVar() {
    globalVar = 100;  // 修改外部变量
}

函数同理，extern还可以链接c和c++，用extern声明一个函数是c语言，则该函数可以在c++文件中使用

#include <stdio.h>

void hello() {
    printf("Hello from C!\n");
}

c++

#include <iostream>

extern "C" void hello();  // 告诉编译器这个函数是 C 语言的

int main() {
    hello();  // 调用 C 代码中的 hello() 函数
    return 0;
}

vector

#include<vector>

// 声明
vector<int> vec1; //声明空的vector
vector<int> vec2(5); // 声明大小为5的vector
vector<int> vec3(5, 10); //声明大小为5且值都为10的vector
vector<int> vec4{1, 2, 3, 4, 5}; //初始化
vector<int> vec5(vec4); // 用另一个vecotr初始化

// 用法
vec.push_back(x); //在末尾添加元素
vec.emplace_back(x);	//在末尾添加元素，比push_back更快，push_back需要先构造，再复制，emplace_back直接在容器内构造，不需要复制
vec.pop_back(); //删除最后一个元素
int num = vec.back(); //获取最后一个元素
vec.erase(vec.begin() + 1); //删除指定位置的元素
vec.erase(vec.begin() + 1, vec.edn() - 1); // 删除指定范围的元素
vec.clear(); // 清空vector
int n = vec.size(); // 获取vec的大小
vec.resize(x); //动态调整大小，x比n大补0， x比n小，超出的部分移除
sort(vec.begin(), vec.end()); // 升序
sort(vec.begin(), vec.end(), greater<int>()); // 降序
int it = find(vec.begin(), vec.end(), 3); //查找值为3的元素
vec.remove(vec.begin(), vec.end(), 5); // 将值为5的元素移动到容器末尾
if (!vec.empty())；	//判空
int sum = accumulate(vec.begin(), vec.end(), 0)	//求和，初始值为0
int max_num = *max_element(vec.begin(), vec.end())//数组中的最大值
vec.insert(vec.end(), vec.begin(), vec.end())	//在vec的后面添加vec例如123->123123z
//在一个vector的后面添加另一个vector
vector<int> vec1 = {1, 2, 3};
vector<int> vec2 = {4, 5, 6};
vec1.insert(vec1.end(), vec2.begin(), vec2.end());
// 二维数组
int row = 3;
int col = 4;
vector<vector<int>> nums(row, vector<int>(4));

atoi stoi

const char* str = "abc";

// atoi
int result = atoi(str); //将字符串转换为数字

// stoi
try {
  std::string str = "abc";
  int result = std::stoi(str);
} catch (const std::invalid_argument& e) {
  std::cout << "Invalid argument:" << e.what() << std::endl;
}

stoi提供了更安全的方式

tolower, toupper

#include <cctype>
string str = "Hello World";
string res;
for (char ch : str) {
  res += tolower(ch); //转为小写
}
for (char ch : str) {
  res += toupper(ch); //转为大写
}

// 更简单的方法
for (char ch : str) {
  ch ^= 32;
}
// 'A'(65) ⊕ 32 = 'a'(97)
// 'a'(97) ⊕ 32 = 'A'(65)

unordered_map

哈希表

// 声明
unordered_map<char ch, int n> my_map;
my_map.insert({'a', 2}); 	// 插入元素
my_map[b] = 1; // 如果键不存在会创建并初始化
// 遍历
for (const auto& pair: my_map) {
  cout << pair.first << pait.second << endl;
}
// find的用法
auto it = umap.find("a");
if (it != umap.end()) {
    std::cout << "Found: " << it->first << " -> " << it->second << std::endl;
} else {
    std::cout << "Not found!" << std::endl;
}
// count,返回键是否存在（0 或 1）
if (umap.count("a") > 0) {
    std::cout << "Key exists!" << std::endl;
}

sort

//基础用法
vector<int> nums = {2, 3, 1, 0, 4};
sort(nums.begin(), nums.end());	// 默认升序
sort(nums.begin(), nums.end(), std::greater());	//降序排列
// 自定义排序
struct Student {
    std::string name;
    int score;
};

// 自定义排序规则
bool compareStudents(const Student& a, const Student& b) {
    if (a.score == b.score)  // 分数相同，按姓名排序
        return a.name < b.name;
    return a.score > b.score; // 分数降序
}

引用和指针

int a = 10;
int &b = a;
b = 20;
cout << a << endl;	// 20

b是a的引用，就是给a起个别名，对b进行操作实际上就是对a进行操作

1 2	int* a = null; int& b; //error

指针可以指向空，但是引用不能为空

int a = 10;
int &b = a;
int c = 30;
int &b = c;	//error

指针可以随意改变（除const修饰外），引用一旦绑定就不可以再改变

静态链接和动态链接

.cpp文件经过预处理成为.i文件，.i文件经过编译后成为.s文件，.s文件经过汇编后成为目标文件，即.o，静态链接将该.o文件和其他目标文件以及库文件链接起来，这个过程称为静态链接。

而动态链接将这个过程推迟到了运行时，由操作系统装载程序加载库

静态链接的代码装载速度快，但是文件体积大

动态链接的速度慢，但是文件体积小

c和c++的区别

c只支持基本数据类型，还有结构体、枚举、联合；c++支持类和对象
c++有封装的特性、有构造函数和析构函数、c++支持函数重载，可以定义同名但是参数列表不同的函数；c都做不到
c++有异常处理机制；c没有
c没有引用&

delete

释放new申请的空间，会调用析构函数

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "构造函数" << std::endl;
    }
    ~MyClass() {
        std::cout << "析构函数" << std::endl;
    }
};

int main() {
    MyClass* obj = new MyClass();
    delete obj;
    return 0;
}

作用域解析操作符

访问全局变量

#include <iostream>

int num = 20;

void test() {
    int num = 10;
    std::cout << "test1:" << num << std::endl;
    std::cout << "test2" << ::num << std::endl;
}

int main() {
    int num = 30;
    test();
    std::cout << "test3:" << num << std::endl;
    std::cout << "test4:" << ::num << std::endl;
    return 0;
}

访问命名空间中的标识符

#include <iostream>

namespace MyNamespace {
    int val = 20;
}

int main() {
    std::cout << MyNamespace::val << std::endl;
    return 0;
}

访问修饰符

public:可以在任何函数中访问

protected:只能在类中或者类的子类中访问

private：只能在类中访问

strlen 和sizeof

char ch[] = "Hello World";
std::string str = "Hello World";
std::cout << sizeof(ch) << std::endl;	//12
std::cout << strlen(ch) << std::endl;	//11
std::cout << sizeof(str) << std::endl;	//24(windows|macos) 32(linux)

对于char ch[]类型，是c风格的字符串，在末尾会自动加\0

sizeof会统计末尾的\0

strlen不统计

string 和char ch[]

string在堆上分配内存，sizeof获取的是string类的大小

char ch[]在栈上分配内存