一 STL
STL说明:
定义集合类型（STL中不同数据结构）变量，数据元素类型在尖括号内说明，通过变量名.成员函数去执行具体功能。
一.栈(stack)
1.栈是一种先进后出的数据结构，只能操作最顶端的元素
2.头文件#include<stack>
格式 stack<int>(尖括号内是堆栈内元素的类型，可以是结构体等其他类型）s
3.操作: s.empty()------返回bool型，表示栈内是否为空
s.size()------返回栈内元素个数
s.top()-----返回栈顶元素值
s.pop()------移除栈顶元素值
s.push(a)------向栈顶压入一个元素a
二.动态数组(vector)
1.操作: v.empty()------返回bool型，表示动态数组是否为空
v.size()------返回vector中元素个数
v.push_ back(a)------将元素a插入最尾端
v.pop_back------将最尾端元素删除
v[i]---------和数组作用相同
三.map
1.map是一个关联容器，是一种映射.
2.map结构:map<key_type,value_type>map_show
map<string,int>mp默认按string由小到大排序
mp.begin()返回一个双向迭代器，指向第一个元素
mp.end()返回一个双向迭代器，指向最后一个元素的下一个位置
3.添加数据:
map<string,int>mp;
mp.insert(pair<string,int>(“achieve”,12);
4. 查找:
map<int ,string> ::iterator it;
it = mp.find(112);
if(it == mp.end())
cout<<“we do not find 112”<<endl;
else cout<<“we find 112”<<endl;
map<string,int>mp;
cout<<“mp->first(键值)”<<“mp->second(实值)”
四.set
1.迭代器举例（遍历）
set<int>::iterator pos;
for(pos=s.begin();s!=s.end();pos++)
s.size()-----返回容器中的元素个数
s.empty()-----返回bool类型
五.队列(queue)
1.定义：#include<queue>
2.格式：#include<int>q
3. q.front()---------队头
q.back()---------队尾
q.pop()----------在队头删元素 而stack的s.pop()则是在栈顶删元素
查找
upper_bound和lower_bound
upper_bound(begin,end,zhi)----返回大于zhi元素的第一个位置
lower_bound(begin,end,zhi)-----返回大于等于zhi元素的第一个位置
例如：
num[]={1,2,2,3,4,5};
lower_bound(num,num+6,2)为num+1
upper_bound(num,num+6,2)为num+3
sort排序
格式：sort(begin,end) //默认按从小到大排序
sort(begin,end,cmp)
例如：int num[]={1,5,6,2,9}
bool cmp(int a,int b)
{
return a>b;
}
sort(num,num+5,cmp); //num[]={9,6,5,2,1}
给STL排序
sort(b.begin(),b.end,cmp)
万能头文件
#include<bits/stdc++.h>
优先队列（priority_queue)用法总结
一.头文件#include<queue>
二.优先队列（priority_queue)和队列（queue）的区别
队列是按进入的次序排序，而优先队列则是可以自定义其中数据的优先级，让优先级高的排在队列的前面
三.定义：例如自定义的数据类型
priority_queue<int,vector<int>,great<int> >q //升序队列
priority_queue<int,vector<int>,less<int> >q //降序队列
注：在less<int> 后和 >q之间要有空格，否则会造成表意不明
四.应用
#include<iostream>
#include<queue>
using namespace std;
int main()
{
priority_queue<int>a; //默认是大顶堆，相当于降序队列
priority_queue<int,vector<int>,great<int> >c;
priority_queue<string>b;
for(int i=0;i<5;i++)
{
a.push(i);
c.push(i);
}
while（！a.empty())
{
cout<<c.top()<<‘ ’；
c.pop();
}
cout<<endl;
b.push("abc");
b.push("abcd");
b.push("cbd");
while(!b.empty())
{
cout<<b.top()<<' ';
b.pop();
}
cout<<endl;
return 0;
}
输出：
4 3 2 1 0
0 1 2 3 4
cbd abcd abc
vector的find用法
一.
find函数存在于算法中
其头文件为#include<algorithm>
二.
代码示例：
#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
vector<int>L;
L.push back(1)；
L.push back(2);
L.push back(3);
vector<int>::iterator it=find(L.begin(),L.end(),3);
if(it==L.end())
cout<<"NO"<<endl;
else
cout<<"YES"<<endl;
}
二.函数
参数传递
定义：参数传递是指用函数调用的实参来初始化函数形参存储区的过程。
1.函数的形参是局部对象，仅在函数的作用域内可见
2.每次调用函数时，会创建形参变量，并用传入的实参初始化形参
3.如果形参是引用类型，形参将绑定到对应的实参上，否则，将实参的值复制后赋给形参
4.参数传递方式
I.传值，按值传递参数。当实参的值被复制给形参时，形参和实参是两个独立的对象，实参被称为按值传递，或传值调用函数
II.传指针：使用指针参数是传地址值。
void pswap(int *pv1, int *pv2){
int t;
t = *pv1; *pv1 = *pv2; *pv2 = t; //间接访问
}
int main(){
int ival1 = 10, ival2 = 20;
int *p1 = &ival1;
int *p2 = &ival2;
cout << ival1 << " " << ival2 <<endl;
pswap(p1,p2);
cout << ival1 << " " << ival2 <<endl;
}
III.传引用，按引用传递参数。此时，引用形参绑定到实参，是实参对象的别名。
函数操纵的形参是实参的别名，因而可以改变实参的值.
传递引用参数，交换两个变量的值.
void swap(int& rv1, int& rv2){
int t;
t = rv1;
rv1 = rv2;
rv2 = t;
}
int main(){
int ival1 = 10;
int ival2 = 20;
cout << ival1 << " " << ival2 <<endl;
swap(ival1,ival2);
cout << ival1 << " " << ival2 <<endl;
}
使用引用参数传递大对象,使用const限定可以避免实参被修改
5.参数传递方式的选择
数组和函数作参数时必须传指针
拷贝构造函数的参数必须传引用
数组作参数时，将传递数组第一个元素的地址
将形参数组声明为const表明不希望改变数组元素
6 参数类型检查
void func(int* pi){...}
int a = 10;
const int b = 5;
func(&a); //正确：形参int*类型，实参int*类型，类型匹配
func(&b); //错误：实参const int*类型，不能转换为int*类型
void goo(const int* cp){...}
goo(&a); //正确：实参int*类型可以转换为形参const int*类型
goo(&b); //正确：实参const int*类型，匹配
7 函数声明
I. 函数在使用之前必须声明
II. 一个函数可以在程序中多次声明
III. 函数定义也可以被用作声明，但是函数在程序中只能定义一次
8 返回引用
将函数声明为返回引用，则不需要对return语句中的表达式进行复制，而是返回对象本身，函数返回的引用仅是它所指向对象的一个别名。
//找出s1和s2中比较短的一个并返回其引用
const string& shorter(const string& s1, const string& s2)
{
return (s1.size() <= s2.size()) ? s1 : s2;
}
//函数返回结果时不会真正复制对象，返回的就是s1或s2本身
例：代码
#include <iostream>
#include <string>
using namespace std;
string& longerString(string &sa, string &sb){
return sa.size() > sb.size() ? sa : sb;
//返回对象本身，不进行复制
}
int main(){
string s1 = "cat",s2 = "at";
longerString(s1 , s2)[0] = 'h';
//相当于s1[0] = 'h';
cout << s1 << endl;
}
#include <iostream>
using namespace std;
int& searchElement(int array[],int index){
return array[index];
//返回的不是array[index]的副本，而是array[index]本身
}
int main(){
int arr[5] = {0,1,2,3,4};
searchElement(arr , 2)=5;
cout<<"arr[2]:"<<arr[2]<<endl;
}
9 局部static对象
I. 声明为static的局部对象是静态存储的
II. static对象在控制流程第一次到达其定义点时被初始化，如果没有提供初始值，就被自动初始化为0值
III. 在函数的后续调用中，初始化语句被跳过
IV. 静态对象的值在函数的多次调用之间保持有效，生存期会延续到整个程序结束，但它的作用域仍然是局部的,因此，需要在同一函数的两次调用之间保留某些数据时可以使用局部static对象
V. 比自动对象生存期长，比全局变量作用域小更安全
#include <iostream>
using namespace std;
void fun(){
static int sval = 5; //第一次调用函数时初始化
int ival = 5;
sval++;
ival++;
cout<<"sval="<<sval<<" ival="<<ival<<endl;
}
int main(){
for (int i =0 ; i < 3; i ++) fun();
}
Output
sval=6 ival=6
sval=7 ival=6
sval=8 ival=6
三.auto类型说明符
1.用auto声明变量的类型，由编译器去自动分析表达式的类型，推断出变量的实际类型
定义auto变量必须有初始值
四.指针和引用
1.空指针
指针值为0时是一个空指针，即不指向任何对象的指针.
生成空指针的3种方法
I. int *p1 = nullptr;
II. int *p2 = 0;
III. int *p3 = NULL;
2.const限定指针
指向const对象的指针（非const ）
const type cp; 或者type const cp;
cp是指向常量的指针，它所指向的内存中的内容不可以改变，即cp的值不能改变
指向非const对象的const指针
type const cp = initAddressValue;
cp是常量指针，初始化后值不能改变，指向固定的单元
指向const对象的const指针
const type* const cp = initAddressValue;
const int ival = 5;
const int* const pi = &ival;
//pi是一个指向const对象的const指针
第一个const限定int，表示指针指向的单元是常量；
第二个const限定pi，表示指针的值也是一个常量
因此，指针pi所在内存的值不允许改变，它所指向内存的值也不能改变
五.结构体
1.结构体的成员不能独立使用，必须由结构体类型的变量通过成员选择运算符“.”来选择，或者由结构体类型的指针通过“->”运算符选择。
2.数组上的指针运算
I. 指针加或减一个整数n，结果仍是指针
II. 两个指针相减的结果是它们之间的距离,参与运算的两个指针必须指向同一个数组中的元素
六.标准库string类
1.
2.比较string对象
可以用关系运算符比较两个字符串对象
两个string相等意味着它们的长度相同，并且所包含的字符也完全相同
字符串的大小关系依照字典顺序定义且区分大小写字母
string s1 = "hello";
string s2 = "hello world"; // s2 > s1
string s3 = "Hello"; // s3 < s1, s3 < s2
3.string对象的赋值和连接
I. 两个字符串可以直接用运算符“+”连接，结果得到一个新的string对象
II. "+"运算符要求至少有一个运算对象是string
4.头文件中的标准库函数
七.字符串流
1.
istringstream：从string对象中读取数据
ostringstream：向string对象写入格式化的内容
stringstream：从字符串读取数据，将数据写入字符串
2.
I. 使用时包含标准库头文件
II. 在定义时直接用string对象初始化
III. strm.str(s)，将字符串s复制到字符串流strm中，返回void
IV. strm.str()，返回字符串流strm中保存的字符串的副本
3.字符串流的用途
从输入流一次性读取一大块数据，以字符串形式保存在istringstream对象中，再用适当的输入操作逐项从istringstream对象中提取各个数据项
扫一扫
717
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
