【知识总结】C++编程易忘的使用方法

函数

传参

1. 分清修改的是参数对象本身，还是参数对象指向的对象。

例如下面代码中，从fun中出来以后的指针对象n还是原来的值。

要想改变指针对象，得传进node**。要想改变指针对象指向的对象，在fun里修改时要用*n = ...。

void fun(node* n){
    node* m;
    ...
    n = m;
    return;
}
void main(){
    node* n;
    fun(n);
}

2. 数组

数组传参的时候本来传的就是地址，不用再写成&了。此时在函数体内对数组修改，会影响函数外。

 

类

一个坑：

.size()函数的返回值是size_type类型，实际上是一个unsigned类型，如果把它和负的int比较，int会先转换成unsigned int再比较，会出错。示例：

int a = -1, b = -5;
vector<int> vec = {1,2,3};
cout<< (a > vec.size()) <<endl;    // 结果是1.
cout<< (b > vec.size()) <<endl;    // 结果是1.
cout<< (unsigned int)a <<endl;    // 结果是4294967295.
cout<< (unsigned int)b <<endl;    // 结果是4294967291.

 

定义

成员变量和函数参数同名的赋值：

this->val = val;

 

数据类型

数组

1.初始化

不初始化，int数组里元素就是随机值：

int a[3];    // 结果：0 -272632272 32766 
bool a[3];    // 结果：false,true,false

以下代码只能初始化第一个元素，后面未初始化的元素就是0：

int a[3] = {3};    // 结果：3，0，0
bool a[3] = {false};    // 结果：true,false,false

2. memset

以下代码并不能完成对数组所有元素初始化为1：

int a[5];
memset(a, 1, sizeof(a));  //结果： 16843009 16843009 16843009 16843009 16843009 

原因：不管数组是什么类型的，memset都是按位赋值。

对于int数组，一个int有4位，用memset时也是每一位都赋值位1，因此会出错。int数组只有在赋0或-1是才有正常效果。

对于char数组，一个char有1位，因此可以赋任意char型的值。

3.拷贝

int a[3] = {1,2,3};
int b[3];
memcpy(b, a, 3*sizeof(int));

 

string

！string用双引号""，char用单引号' '。

头文件：<string>

用下标s[0]取出来的结果类型为char。

判空方法

1、string类的成员函数empty，返回true为空。

string str;
if(str.empty())    //成立则为空
...

2、判断字符串长度。如果长度为0，则为空。

string str;
if(str.size()==0)    //成立则为空
...

3、与空串比较，如果相等则为空。

string str;
if(str=="")    //成立则为空
...

子串

参考：https://www.cnblogs.com/catgatp/p/6407788.html

！注意：c++的string没有split函数

取子串：s.substr(开始位置，取的长度)

替换子串：s.replace(开始位置，替换长度，新子串)

类型转换

1.string与int

string to int：atoi(s.c_str)

int to string：to_string(int n)

参考这篇博客：https://blog.csdn.net/xiong452980729/article/details/61677701

2.char与int

char to int：

char c = '1';
int n = c - '0';

int to char：

int n = 1;
char c = c + '0';

vector

参考：https://www.runoob.com/w3cnote/cpp-vector-container-analysis.html

！一个坑：同样是记录2个int，vector使用空间大于pair，递归次数很大时，vector可能导致stack_overflow。所以能用pair就pair。

1.声明

vector<int> v;

2.添加元素

加到尾部：puch_back(值)

加到其他位置：insert(位置，值)。

res.insert(res.begin(), 2)

加一段vector：insert(位置，起始位置，结束位置)

3.初始化

vector<int> v(长度，初始值)    

vector<int> v(10, 0);

4.查找

vector中没有定义find函数，需要借助algorithm库里的find来实现。

find(vec.begin(), vec.end(), 6);

5.取末尾元素值

vec.back();

pair

头文件：<iostream>

参考：https://blog.csdn.net/sinat_35121480/article/details/54728594

！一个坑：同样是记录2个int，vector使用空间大于pair，递归次数很大时，vector可能导致stack_overflow。所以能用pair就pair。

1.声明

pair<数据类型,数据类型> p    例如pair<int,int> p

2.访问

第一个值：p.first

第二个值：p.second

 

priority_queue

默认是降序排列，定义的是<。

改为升序则需要传入3个参数：

priority_queue<int, vector<int>, greater<int>> pq;

第二个参数是数据存储方式，第三个参数是代表升序。less<int>在pq中是降序。

1. 自定义比较方式

参考：https://blog.csdn.net/AAMahone/article/details/82787184

struct node{
    int x, y;
    node(int x, int y):x(x),y(y){}
};

struct cmp{
    bool operator()(node a, node b){
        if(a.x == b.x)  return a.y >= b.y;
        else return a.x > b.x;
    }
};

priority_queue<node, vector<node>, cmp> qp;

 

map

默认是升序，less<int>，定义<。

参考资料：https://riptutorial.com/zh-CN/cplusplus/example/13316/%E7%94%A8std----map%E6%8E%92%E5%BA%8F-%E5%8D%87%E5%BA%8F%E5%92%8C%E9%99%8D%E5%BA%8F-

1.初始化直接赋值：用列表形式

unordered_map<string, vector<char>> letter = {
        {"2",{'a','b','c'}},
        {"3",{'d','e','f'}},
        {"4",{'g','h','i'}},
        {"5",{'j','k','l'}},
        {"6",{'m','n','o'}},
        {"7",{'p','q','r','s'}},
        {"8",{'t','u','v'}},
        {"9",{'w','s','y','z'}}
    };

 

2.自定义比较函数 & 按value排序

参考资料：https://blog.csdn.net/Shrimp_millet/article/details/93885695

一些库函数

错误提示

assert(表达式)：当表达式为false时，想stderr打印错误信息，调用abort终止程序。

参考：https://blog.csdn.net/yunzhongguwu005/article/details/9178911

数字处理

ceil(n)：大于等于n的最小整数

floor(n)：小于等于n的最大整数

初始化

memset(容器指针, 初始化值, 容器长度) 

eg. memset(arr, 0, sizeof(int)*10)

排序

1.sort(开始位置，结束位置（不参加排序），比较方法)：从小到大排序

eg. sort(vec.begin(), vec.end())，从大到小排序的话改传反向指针，就能反向排序，sort(vec.rbegin(), vec.rend())

2. 自定义排序方法

例子：按字符串长度排序

vector<string> words = {"abc","dweg","en","al"};
sort(words.begin(),words.end(),[](string &a, string &b){ return a.size()>b.size(); });    
// {"dweg","abc","en","al"}

求和

accmulate(开始位置，结束位置（不参加求和），求和起始值)：计算从开始位置到结束位置的和

头文件：<numeric>

数组iterator

begin(数组）：数组第一个元素的指针。

end(数组)：数组最后一个元素后面的指针。

int a[] = {1,2,3};
auto iter = begin(a);    // *iter = 1;

参考：http://www.cplusplus.com/reference/iterator/

反转

reverse(开始位置，结束位置（不参与））：将容器中 [开始位置，结束位置) 的元素顺序反转。

可用于vector，数组，string中。示例：

vector<int> vec = {1,2,3};
int arr[] = {1,2,3};
string s = "123";
reverse( vec.begin(), vec.end());    // {3,2,1}
reverse( begin(arr), end(arr));      // {3,2,1}
reverse( s.begin(), s.end());        // "321"

头文件： <algorithm>

参考：https://zh.cppreference.com/w/cpp/algorithm/reverse