C++ 常用 - 技术栈

[1. 字符串操作](#1. 字符串操作)
- [1.1 字符串比较 strcmp](#1.1 字符串比较 strcmp)
- [1.2 转为字符串类型 to_string](#1.2 转为字符串类型 to_string)
- [1.3 字符串相加](#1.3 字符串相加)
- [1.4 char 转 int s-'0'](#1.4 char 转 int s-'0')
- [1.5 string 转 int stoi()](#1.5 string 转 int stoi())
[2. C++和Python使用区别](#2. C++和Python使用区别)
- [2.1 循环中的可迭代对象长度](#2.1 循环中的可迭代对象长度)
- [2.2 C++ 字符串操作](#2.2 C++ 字符串操作)
- - [2.2.1 reverse(s.begin(), s.begin() + n) 翻转](#2.2.1 reverse(s.begin(), s.begin() + n) 翻转)
- [2.3 C++ 各类型长度](#2.3 C++ 各类型长度)
- [2.4 C++ 数组/容器各元素初始化是否为0](#2.4 C++ 数组/容器各元素初始化是否为0)
- [2.5 list和vector](#2.5 list和vector)
- - [2.5.1 list 和 vector 指定位置插入元素 .insert()](#2.5.1 list 和 vector 指定位置插入元素 .insert())
  - [2.5.2 list 和vector 排序](#2.5.2 list 和vector 排序)
- [2.6 字符数字转数值](#2.6 字符数字转数值)
- [2.7 list和queue](#2.7 list和queue)
- - [2.7.1 删除头元素并返回，list.pop(0)](#2.7.1 删除头元素并返回，list.pop(0))
  - [2.7.2 删除头元素不返回，list.remove(0)、queue.pop()](#2.7.2 删除头元素不返回，list.remove(0)、queue.pop())
  - [2.7.3 只读取头/尾元素](#2.7.3 只读取头/尾元素)
  - [2.7.4 队尾添加元素 queue.push()](#2.7.4 队尾添加元素 queue.push())
- [2.8 C++ 传值/引用/指针(地址)](#2.8 C++ 传值/引用/指针(地址))
- - [2.8.1 传值，调用函数内从新构造一个res对象，不改变原有res](#2.8.1 传值，调用函数内从新构造一个res对象，不改变原有res)
  - [2.8.2 引用与指针的区别](#2.8.2 引用与指针的区别)
  - [2.8.3 传引用](#2.8.3 传引用)
  - [2.8.4 传指针](#2.8.4 传指针)
[3. 声明vector/array](#3. 声明vector/array)

1. 字符串操作

1.1 字符串比较 strcmp

头文件 string.h；
变量需要传指针；
返回>0 则第一个字符串比第二个字符串大，反之则小，=0则表示两个字符串相同。

cpp 复制代码

# include <iostream>
# include <stdio.h>
# include <string.h>

using namespace std;

int main() {
    
    string s = "123";
    char* p = &s[0];
    // char* p = "123"; // 或者
    
    if (!strcmp(p, "123")) {
        printf("%s \n", p);
    }
    
    printf("%d", strcmp("213", "123"));
    
    return 0;
}
/**
123 
1
*/

1.2 转为字符串类型 to_string

cpp 复制代码

# include <iostream>
# include <string>

using namespace std;

int main() {
    cout<<to_string(1.1);
    return 0;
}
// 1.100000

1.3 字符串相加

s1 + s2
s1.append(s2)

cpp 复制代码

# include <iostream>
# include <stdio.h>

using namespace std;

int main() {
    
    string s1 = "123";
    string s2 = "45";
    
    cout << s1 + s2<<endl;
    
    s1.append(s2);
    cout << s1;
    
    return 0;
}

1.4 char 转 int s-'0'

'9' - '0' >>> 9
int('1') >>> 49（ascii 码)

1.5 string 转 int stoi()

cpp 复制代码

# include <iostream>
using namespace std;

int main() {
    string s = "23";
    cout<<stoi(s);
    return 0;
}

2. C++和Python使用区别

2.1 循环中的可迭代对象长度

C++ 中，for循环中写明a.size()，每次循环这个值是重新计算的；

cpp 复制代码

# include "iostream"
# include <vector>
using namespace std;

int main() {
	vector<int> a(10);
	int cnt = 0;
	for (int i = 0; i < a.size(); i ++) {
		cnt += 1;
		a.pop_back();
	}
	cout<< cnt <<endl;
	return 0;
}
/**
* 循环中a的长度变化，每次循环对比的边界也变化；
* 输出为 5 
*/

Python 中 for 循环len(a)，循环中a变化r循环仍采用刚开始执行循环时计算的len(a)

python 复制代码

a = [1, 2, 3]

cnt = 0
for i in range(len(a)):
    cnt += 1
    a.pop()

print(cnt, a)
'''
3 []
'''

while循环，python3和C++，while条件中的长度计算是可变的，即每次循环都会重复计算。

2.2 C++ 字符串操作

2.2.1 reverse(s.begin(), s.begin() + n) 翻转

#include <algorithm>

cpp 复制代码

#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    string s = "abcde";
    // 翻转[0, 2)
    reverse(s.begin(), s.begin() + 2);
    cout<< s <<endl;
    
    return 0;
}
/**
 * bacde
 * /

2.3 C++ 各类型长度

cpp 复制代码

// 1字节 = 8位
char 8
int 4
long long 8
double 8
float 4
32位 long 4 
	 long double 12 
	 char* 4
64位 long 8 
	 long double 16 
	 char* 8

2.4 C++ 数组/容器各元素初始化是否为0

cpp 复制代码

int a[10];  不默认初始化为0
int a[10] = {0}; 默认初始化为0
int a[n] = {0}; 报错：变量大小的数组不能初始化
class Solution {
public:
    int a[10];
    int cuttingRope(int n) {
        return a[9]; 
    }
}; 默认初始化为0

vector<int> a(10); 默认初始化为0
vector<int> a(10, 1); 初始化为1

2.5 list和vector

2.5.1 list 和 vector 指定位置插入元素 .insert()

list.insert(idx, val) idx 整数
vector.insert(vector.begin(), val) 在第0各位置插入元素，vector.begin() + 1 指定第1个位置插入

2.5.2 list 和vector 排序

python3 list排序
sort & sorted list排序
C++ vector排序

cpp 复制代码

// 默认升序
sort(nums.begin(), nums.end());

2.6 字符数字转数值

cpp 复制代码

# 获取的是ascii码值
int('0') >>> 48
int('1') >>> 49

# 将字符数字专为int类
'1' - '0' >>> 1

Python

python 复制代码

int('0') >>> 0

2.7 list和queue

2.7.1 删除头元素并返回，list.pop(0)

python 复制代码

node = list.pop(0) # 传索引0，删除头元素并返回

2.7.2 删除头元素不返回，list.remove(0)、queue.pop()

python 复制代码

queue.pop() # 默认删除头元素不返回
list.remove(0) # 传索引0，删除头元素不返回

2.7.3 只读取头/尾元素

python 复制代码

list[0]
list[-1]

queue.front()
queue.back()

2.7.4 队尾添加元素 queue.push()

python 复制代码

list.append(x)

queue.push(x)
区别于 vector.push_back()

2.8 C++ 传值/引用/指针(地址)

2.8.1 传值，调用函数内从新构造一个res对象，不改变原有res

cpp 复制代码

// 函数内对res操作不改变函数外res
// 返回res与传入res地址不同，两个独立的res

void fc(vector<int> res) {
	res.push_back(1);
	return res;
}
vector<int> res;
fc(res);

2.8.2 引用与指针的区别

引用，是参数对象(某块内存)的别名，引用的大小即参数对象的大小；
指针，内容是参数对象的地址，与参数对象不是一个东西；
指针可以为空，但引用不为空，是一个已存在的对象的别名；
指针可以改变指向对象，引用不可改边代表对象；
C++中传引用更佳，保留传指针主要为了兼容C。

2.8.3 传引用

cpp 复制代码

// 函数内对res的操作 即是对函数外res操作
// 区别在于函数定义时的 & ！！！！
// 调用与传值没区别
void fc(vector<int>& res) {
	res.push_back(1);
	return res;
}
vector<int> res;
fc(res);

2.8.4 传指针

cpp 复制代码

// 函数内对res的操作 即是对函数外res操作
// 
void fc(vector<int>* res) {
	// 指针不能直接调用.push_back() !!!
	res.push_back(1);
	return res;
}
// 虚需要传入参数对象的地址，用取地址符。
vector<int> res;
fc(&res);

3. 声明vector/array

cpp 复制代码

#include <iostream>
#include <stdio.h>
#include <vector>
#include <cstdlib> // rand() % 100

using namespace std;

int main() {
    vector<int> m{1, 2, 3};
    for (int i = 0; i < 3; i ++) {
        printf("%d ", m[i]);
    }
    printf("\n");
    
    int n[3] = {4, 5, 6};
    for (int i = 0; i < 3; i ++) {
        printf("%d ", n[i]);
    }
    printf("\n");
    
    return 0;
}