C++笔记

一、基础知识：

1. • 语言区别：（C/C++）

---

譬如（输入/输出流）：

//  C
#inculde <stdio.h>
int main(){
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d",a+b);
    return 0;
}

//C++
#include <bits/stdc++.h>
using namespace std;
int main(){
    int a,b;
    cin >> a >> b;
    cout << a+b;
    return 0;
}

注释：
<头文件>从stdio.h——>bits/stdc++.h，其中包含(iostream/algorithm/vctor/...)
<命名空间>using namespace std;
<输入输出>利用cin/cout，无需再考虑变量类型。

cin：

• 在默认情况下，运算符>>将跳过空白符，然后读入后面与变量类型相对应的值。因此，给一组变量输入值时可用空格符、回车符、制表符将数据隔开。

• 当输入字符串（sting）时，提取运算符>>的作用是跳过空白字符，读入后面的非空白字符，直到遇到另一个空白字符位置为止，并在末尾放上\0结束。

C++允许代码块任何地方声明变量。
如：for ( int i = 0; i < n; i ++ )

---

强制类型转换：

比如将整型（int）类型的变量转换为双精度（double）类型，可以利用{ (double)i }或者{double(i)}。C++两种方式都支持，推荐使用第二种。

精度损失：高精度向低精度转化时候存在精度损失。

---

引用（reference）

C++对于C的扩充。作为变量的别名。（类型 &引用名 = 已定义变量名）

int a = 1;
int &b = a;

1、引用并不是一种独立的数据类型，它必须与某一种类型的变量相联系。 在声明引用时，必须立即对他进行初始化，不可以声明以后再赋值。
2、为引用提供的初始值，可以是一个变量或者另一个引用。
3、指针是通过地址之间访问某个变量，而 引用是通过别名 直接访问某个变量。

---

范围for循环：

对于有范围集合而言，利用范围for循环。for循环后的括号由冒号”:“分为前后两部分：前面部分是范围内用于迭代的变量，后面部分是表示被迭代的范围。

for循环迭代的范围必须是确定的。数组的范围是第一个元素到最后一个元素。类的范围是begin()到end()。for循环迭代的范围必须保证不会被更改。

string strs[] = {"apple", "banana", "orange" };
for (const auto& e : strs){
    cout << e << " ";
}

---

标准模板库：（Standard Template Library）

STL：C++自带的函数库，包含一些可以直接使用的类或函数。

---

template（模板）

template为自适应类型，用法：template < class 类型名>。//STL中的均是模板

template<class T>
void swap(T &a, T &b){
    T = a;
    a = b;
    b = T;
}//建议使用原本 std::swap

---

iterator（迭代器）

iterator类似于指针，指向容器的一个位置。用法：类::iterator。

vector<int>::iterator it = vec.begin();    //对于容器
cout << *it;

map<int,int>::iterator it = map.begin();    //对于键值对
cout << it -> first << " " << it -> second;

---

sort（排序）

声明：

template< class RandomIt, class Compare >

void sort ( RandomIt first, RandomIt last, Compare comp );

使用：

int a[] = {3,5,6,7,8,4,2,1,9};

sort(a, a+9);    //默认从小到大
sort(a, a+9, less<int>());    //从小到大
sort(a, a+9, greater<int>());    //从大到小

//借助cmp函数
bool cmp(int a, int b){
    return a<b;
}
sort(a, a+9, cmp);    //从小到大

bool cmp(int a, int b){
    return a>b;
}
sort(a, a+9, cmp);    //从大到小

---

string（字符串）

使用：

string str;    //默认为空字符串
string str1 = "hello";    //初始化赋值
//输入
cin >> str;    //读入一个串（空格为间隔符）
getline( cin, str);    //读入一行
//输出
cout << str;     //输出整个string
cout << str[0];    //输出单个位置的字符

运算操作：

• 赋值运算：= 【On】

• 比较运算：== != < > <= >= 按照字典的顺序比较 【On】

• 连接运算：+ += 两个串的拼接 【On】

• s[ index ]：返回字符串s中下标对应的字符 【O1】

• s.substr(p, n)：返回从下标p开始，的n个字符组成的串 【On】

• s.length()：返回字符串的长度 【O1】

• s.empty()：判定是否为空 【O1】

• s.erase( p0, len )：删除从p0开始的len个字符，如果len省略默认后面全部。【On】

• s.erase( s.bgin()+i )：删除前i个字符 【On】

• s.find( s2, pos )：从前往后查找，查找成功返回第一次出现的下标，失败返回string::npos的值-1【On*m】

---

vector（变长数组）——容器

vector是能够存储多个相同类型元素的容器。（类似于没有长度限制的数组）

声明：

template <class T, class Allocator = std::allocator<T>> class vector;

使用：

vector<int> vec;//一个存储int类型变量的容器，默认size为0
vector<int> vec(n);//一个存储int类型变量的容器，size为n
//输入
//size为0
int tmp;
cin >> tmp;//读入
vec.push_back(tmp);//将tmp推入vec末尾
//size为n
cin >> vec[i];//写入vec第i个元素（）从0开始

//输出
for(int i = 0; i < vec.size(); i++)    cout << vec[i];//vec.size()是元素的个数，而非下标
for(auto it : vec)    cout << it;//range_based loop

运算操作：

• v[i]：返回下标为i的元素 【O1】

• v.push_back( var )：向v后面添加一个元素var 【O1】

• v.pop_back( )：删除最后一个元素 【O1】

• v.size()：获取元素的个数，返回size_t类型变量 【O1】

• v.resize( int n )：容器个数改为n个元素 【On】

• v.empty()：判断是否为空 【O1】

• v.clear()：清空 【Osize】

• v.insert( it ,x )：向迭代器it指向的元素前面增加一个元素x 【On】

• v.erase( it )：删除向量中迭代器指向元素 【On】

• v.front()：返回首元素的引用 【O1】

• v.back()：返回尾元素的引用 【O1】

• v.begin()：返回指向第一个元素的迭代器 【O1】

• v.end()：返回指向最后一个元素下一个位置的迭代器 【O1】

---

list（双向链表）

list是由双向链表实现的存储容器。

声明：

template < class T, class Allocator = std::allocator<T>> class list;

使用：

list<int> lis;//一个存储int类型变量的list，默认为空。
//插入
list.push_front(item);//从list前端进行插入
list.push_back(item);//从list后端插入
//从中间插入
auto it = find(lis.begin(), lis.end(), val);//定位某个val的位置
if(it != lis.end())    lis.insert(it, item);//找到list中第一个值为val的元素，插入到前方

//输出
for(auto it = lis.begin(); it != lis.end(); it++ )    cout << *it;
for(auto it : lis)    cout << it;//range-based loop

运算操作：

• list.push_front(var)：向lis前面添加一个元素var 【O1】

• lis.push_back(var)：向lis后面添加一个元素var 【O1】

• lis.pop_front()：删除lis第一个元素 【O1】

• lis.pop_back()：删除lis最后一个元素 【O1】

• lis.size()：获取元素的个数，返回size_t类型变量 【O1】

• lis.resize(int n)：把容量改成n个元素 【On】

• lis.empty()：判定是否为空 【O1】

• lis.clear()：清空 【Osize】

• lis.insert(it, x)：向迭代器it指向元素前增加一个元素x 【O1】

• lis.erase(it)：删除向量中迭代器指向的元素 【O1】

• lis.front()：返回首元素的引用 【O1】

• lis.back()：返回尾元素的引用 【O1】

• lis.begin()：返回指向第一个元素的迭代器 【O1】

• lis.end()：返回指向最后一个元素的下一个位置迭代器 【O1】

---

map（K-V存储）：

声明：

template<

class Key,

class T,

class Compare = std::less<Key>,

class Allocator = std::allocator<std::pair<const Key, T>>

>class map;

//创建
map<int,int> mp;//key和value值
//使用
mp[0]=1;//key为0时，value为1.
//输出
for(auto it::mp) cout<<it.first<<it.second;//first为key,second为value
for(auto it = mp.begin();it!=mp.end();it++)
    cout<< it->first << it ->second ;

运算操作：

• mp.size():获取mp中元素的个数O1

• mp.empty():判断是否为空O1

• mp.clear():清空mpO1

• mp.begin():返回mp中最小的key的迭代器O1

• mp.end():返回mp中最大的迭代器的后一个迭代器O1

• mp.find(key):查找key并返回iterator，没找到返回mp.end()Ologn

• mp.count(key):在mp中返回key数量（因为key唯一）所以只返回0或1Ologn

• mp.erase(key)：删除key所在的项Ologn

• mp.lower_bound(item):返回第一个大于等于item的迭代器，找不到返回mp.end()Ologn

• mp[key]:返回对应的value值。若不存在，返回value类型的默认构造的值，并将该对插入mp中

• mp[key] = value:改变key对应的值。如不存在新添加到mp中。

注：map中迭代器无法直接和数加减，只可以++或--；自带排序。

---

pair（能够存储两个相同或不同类型的元素）

声明：

template<

class T1,

class T2

>struct pair;

//使用
pair<int,int> p;
pair = make_pair(1,1);

使用方法：

make_pair(item1,item2):创建一个存储两元素的pair

p.first：获取p中前一个元素

p.second：获取p中后一个元素

---

set（所有元素唯一，自动排序）

声明:

template<

class Key,

class Compare = std::less<key>

class Allocator = std::allocator<key>

>class set;

//创建
set<int> s;
//插入
s.insert(item);
//输出
for(auto it:s) cout<<it<<" ";