c++笔记


阅读数: 次   
字数统计: 3.5k字   |   阅读时长: 17分

c++部分笔记
主要是一些细碎的知识和stl的简单用法

@TOC

cout的输出设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
1.设置对齐方式 
cout.setf(ios::right)
2.设置宽度
cout.width(8)
3.设置宽度多余部分用某字符填充
cout.fill('0')
4.设置精度，保留有效数字(小数点后的0舍去)
cout.precision(2)
5.保留小数点后的0
cout.setf(ios::showpoint)
6.保留小数点后n位数
cout.flags(ios::fixed)
cout.precision(n)

#include<iomanip>

1
1.setw(width)   用于cout

printf的输出设置

1
2
3
4
5
6
7
#include<cstdio>
1.printf("%.2f",a)  保留2位小数
  printf("%2d",a)   右对齐宽度为2的整形
  printf("%5.2f",a);右对齐宽度为5（包含小数点），保留两位小数的浮点型
  printf("%5f",a);
  其中宽度为最小宽度，如果宽度原本就大于所给宽度，则按原本宽度
  由于如果不设置小数点，浮点数默认为6位小数，所以测试宽度小于时和预测不相符

是否输入_判断

1
2
3
#include<conio.h>
1.kbhit()用来判断用户是否输入
2.getch()得到一个字符

向量_sort

1
2
对向量vector和string类字符串用sort（）函数排序时使用s.begin(),s.end()
//s.begin(),s.end()可以当做位置下标，并且支持+,-运算

系统调用

1
2
3
4
#include<windows.h>
1.system("cmd")
2.system("cls")
3.Sleep(time)

指针

1
2
1.int* p1,p2;     //p1为整形指针变量，而p2只是整形变量
2.*（p1）为p1存储的地址指向的值，&p2为整形变量p2的地址

cin异常处理

1
2
1.cin判断输入失败
cin.fail()
1
2
3
4
5
6
7
8
9
10
//eg:
#include<iostream>
using namespace std;

int a;
cin>>a;
if(cin.fail()){
    cout<<"Error: Not an integer."<<endl;
    return 1;  //也可以利用其跳出循环---break
}
1
2
2.清除失败状态
cin.clear()
1
2
3
4
5
6
7
8
9
10
11
12
13
//eg:
int value;
do{
	cout<<"输入value>=0";
	cin>>value;
	if(cin.fail()){
		cin.clear();
		string item;   //
		cin>>item;     //这两行如果不加会出现错误
		value=-1;
	}
}while(value<0);

1
3.连续输入|输入其他类型结尾|同类型结尾用&&附加条件或在内部用if判断
1
2
3
4
5
6
//输入30 10 5 Q（Q为结尾标志）
int value;
while(cin>>value){
	cout<<value<<" ";
}

1
4.连续输入并去除其他类型数据
1
2
3
4
5
6
7
8
9
10
11
12
13
//输入30 10 5 Q 20 u 8 29 q q q q 29
int value;
while(1){
	cin>>value;
		if(cin.fail()){
		cin.clear();
		string s;
		cin>>s;
	}
	else{
		cout<<value<<" ";
	}
}

c++输入输出重定向

文件流
c++文件操作详解1
c++文件操作详解2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1.使用freopen将cin,cout重定向
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);

2.使用文件输入输出流fstream
#include<fstream>
#include<cstring>
ifstream fin;
fin.open("in.txt");
ofstream fout;
fout.open("out.txt");
string s;
fin>>s;
fout<<s;
fin.close();
fout.close();

2.使用控制台管道符
   cmd_load | 指令 从in.txt输入 输出到out.txt
C:\Users\zdb>demo.exe <in.txt >out.txt

随机数

1
2
3
4
5
6
7
rand()    #include<cstdlib>
time(0)   #include<ctime>
srand(time(0))

随机浮点数
double r=rand()*(1.0)/RAND_MAX;(0~1)
double x=-1+2*r    (-1~1)

typeinfo

1
2
3
4
5
6
7
8
9
10
查看变量类型
#include<typeinfo>
int main(){
	string s;
	cin>>s;
	cout<<typeid(s.length()).name()<<endl;
	printf("%s\n",typeid(s.length()).name());
	printf("%x %x %x",s.begin(),s.end(),&s);
	return 0;
}

向量

1
2
3
4
5
6
7
8
9
#include<vector>
一维向量
vector<type> a;
a.size()
a.push_back(key)
二维向量
vector<vector<int>> b;
b.size()
b[0].size()

基于区间的循环

1
2
3
4
vector<int> value={0,1,2,3,4,5,6};
for(int v:value){
	cout<<v<<" ";
}

文件流

1
2
3
4
#include<fstream>
ifstream fin;
fin>>a>>b>>c;
fin.close;

加速

1
2
3
4
5
6
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
//一个细节:前置++的速度比后置++快
++i;
i++;

const

1
2
不可变量 即 可读不可写
并且相关量不能赋值给指针

万能头文件

1
#include<bits/stdc++.h>

构造函数

1
2
int a(2);
cout<<a<<endl;

class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Point{
	public:
		Point(int ,int);
		void show();
}

Point::Point(int x1,int y1):x(1),y(3){
	x=x1;
	y=y1;
}
Point::Point():x(1),y(3){
	//x=x1;
	//y=y1;
}
Point::Point():Point(0,0){}

Point 
void Point::show(){
	
}

Zeller’s coniogruence公式计算星期

1
2
3
w=(d+5+(26*(mm+1)/10)+5*(year%100)/4+21*(year/100)/4)%7
mm=修改后的月份（3-三月，12-十二月，13-一月，14-二月）
w=星期几（0-一，6-日）

c++继承

C++中的继承
c++继承中的内存布局

1
2
3
4
5
6
7
8
public：内部外部均可访问，继承可访问
protected：外部不可访问，内部，继承可访问
private：外部不可访问，内部可访问，继承不可访问
内部访问直接用函数调用变量名x；外部访问用.x;继承同内部

继承后属性低于继承属性

友元函数可访问所以成员

c++函数重载与运算符重载

重载菜鸟教程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//函数重载解决函数功能相同但参数不同的问题
//函数重载有参数选择函数问题
#include<iostream>
#include<cctype>
using namespace std;
int f(float a,int b,int c){
	cout<<"a"<<endl;
	return a*b*c;
}
float f(int a,float b,float c){
	cout<<"b"<<endl;
	return a*b*c;
}
float f(int a,int b,int c){
	cout<<"c"<<endl;
	return a*b*c;
}
int main(){
	double dou=1.3;
	float flo=2.6;
	int in=3.333;
	cout<<"1:"<<f(in,in,dou)<<endl;
	cout<<"2:"<<f(dou,flo,flo)<<endl;
	cout<<"3:"<<f(flo,flo,flo)<<endl;
	cout<<"4:"<<f(dou,dou,dou)<<endl;
	cout<<"5:"<<f(dou,flo,in)<<endl;
	cout<<"6:"<<f(dou,in,in)<<endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
输出结果：（注释掉3，4，5，6）
c
1:9
b
2:6.76

//3，4，5，6方式均报错
/*
归纳以参数选择哪一个函数的规律：
1.选择参数完全匹配的
2.若不完全匹配
	1）a所含匹配参数包含b所含匹配参数，并且a有其他匹配参数，选a，不匹配参数强制转化为匹配参数。
	2）a所含匹配参数包含b所含匹配参数，但a,b均无其他匹配参数，报错
	3）a所含匹配参数不包含b所含匹配参数，报错
3.若完全不匹配，报错
*/

STL基础

迭代器iterator

迭代器1
迭代器2

1
2
3
4
正向迭代器支持：it++,++it,*it,=,==,!=
双向迭代器支持：相比正向多了it--,--it
随机访问迭代器：it+=i,it-=i,it+i,it-i,it[i],
此外，随机访问迭代器还支持>,<,>=,<=,it2-it1
容器 迭代器功能
vector 随机访问
deque 随机访问
list 双向
set/multiset 双向
map/multimap 双向
stack 不支持迭代器
queue 不支持迭代器
priority_queue 不支持迭代器 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//以set为例
#include<set>
set<int> myset;
//
//正向迭代器
//常量正向迭代器
//
set<int>::iterator iter;
set<int>::const_iterator iter;
//
//反向迭代器
//常量反向迭代器
//
set<int>::reverse_iterator itter;
set<int>::const_reverse_iterator iter;
//
//迭代器++ 指向容器中的下一个元素 与指针类似，不过是通过类型更改指向的位置，且不能+n
1
2
3
4
5
//迭代器相关函数
#include<algorithm>
advance(it,n);      -->it+=n;
distance(it1,it2);  -->return it2-it1; 注意it2必须大于it1,否则死循环
iter_swap(it1,it2); -->交换it1,it2的值

顺序容器

vector

vector相关资料
关于capacity()与size()
关于reserve()和resize()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//
//vector容器的构造
//
#include<vector>
1.vector<int> v1;      //创造一个空vector
2.vector<int> v2(v1);  //复制v1到v2
3.vector<int> v3(n);   //创造一个初始空间为n的vector
4.vector<int> v4(n,x); //创造一个有n个x的vector
5.vector<int> v5(v4.begin(),v4.end()); //复制范围为[begin,end)的v4到v5中
6.int a[]={1,2,3,4};
  vector<int> v6(a+1,a+2);  //v6中有2;
7.v6.~vector<int>();   //清除数据，释放内存
//
//基本函数使用
//
1.v.assign(n,x);//同构造中的4
2.v.assign(v1.begin(),v2.end()); //同构造5
3.int a[] = {1,2,3,4};
  v.assign(a,a+4);
4.v.clear();
5.v.empty();
6.v.capacity();//容量大小  !=size()
7.v.size();    //实际元素数
8.v.at(idx);
9.v.resize(n,x);//改变size和capacity   size变小则截断，变大填充x（默认为空字符）
10.v.reserve(n);//只改变capacity
11.v.max_size();
12.v.begin(); v.end(); v.rbegin(); v.rend(); 
13.v.push_back(n); v.pop_back();
14.v.front(); v.back();  //front,back传回的是引用，而begin,end传回的是迭代器（位置）
15.v.swap(v1);
//
//插入与删除
//
1.v.insert(position,element);
2.v.insert(position,n,element);
3.v.insert(position,v1.begin(),v2.end());
4.v.erase(position);
5.v.erase(v1.begin(),v2.end());

deque

1
2
3
4
5
//容器的操作大同小异
#include<deque>
deque<int> deq;
deq.push_front(n);
deq.pop_front();

list

1
2
3
4
5
6
merge();//合并list
splice();//合并list
remove();//删除元素
remove_if();//指定条件删除
sort();//排序
unique();//去重

关联容器

set

set基础操作
set自定义结构体和排序
反向遍历
equal_range的理解
insert(otherset.begin(),otherset.end())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include<set>
set<int> s;
//
//set关联容器的遍历
//insert(n) 返回值为pair<iterater,bool> 
//iterator指向添加元素的位置，bool为元素是否添加成功
//insert(otherset.begin(),otd());
//还可以直接插入区域，不过otherset与原set数据类型要保持一致
//
//set<int,cmp>  cmp()重载运算符
// struct cmp  
// {  
//     bool operator()(const your_type &a,const your_type &b)  
//     {  
//         return a.data-b.data>0;  
//     }  
// } 
//或者可以直接写在结构体内部
// struct Info  
// {  
//     string name;  
//     float score;  
//     //重载“<”操作符，自定义排序规则  
//     bool operator < (const Info &a) const  
//     {  
//         //按score从大到小排列  
//         return a.score<score;  
//     }  
// } 
//
set<int>::iterater it;
int n;
cin>>n;
for(int i=0;i<n;i++){
	int x;
	cin>>x;
	s.insert(x);   
}
//
//其他赋值方法
// int myints[] = {75,23,65,42,13};
// std::set<int> myset (myints, myints+5);
//
for(int it=s.begin();it!=s.end();it++){
	cout<<*it<<endl;
}
cout<<*s.begin()<<endl;
cout<<*s.lower_bound(n); //n的下限（即大于等于的最小值）
cout<<*s.upper_bound(n); //大于n的第一个数
cout<<*s.find(n);
cout<<s.size();
//
//equal_range(x)函数寻找x的边界线
//
int x;
auto iter=s.equal_range(x);
//pair<set<int>::const_iterator,set<int>::const_iterator> it;
cout<<"lower bound of x is:"<<*iter.first<<endl;
cout<<"upper bound of x is:"<<*iter.second<<endl;
//
//erase()函数删除元素
//##注意：删除操作不进行错误检查，如定位器是否合法
//
int first,second,key;
s.erase(it);             //erase it-->value;
s.erase(first,second);   //erase first to second;
s.erase(key);            //erase key;
//
//find()函数寻找是否存在该元素，找到返回位置
//##注意如果没找到返回值为最后一个元素之后的位置即 s.end()
//
set<int>::iterater itter;
itter=s.find(n);
if(itter!=s.end()){
	cout<<"存在"<<*itter<<endl;
}else{
	cout<<"不存在"<<n<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//
//auto* p=s.get_allocator().allocate(n);
//申请空间 以下标访问元素
//
#include <iostream>
#include <set>
int main () {
   std::set<int> myset;
   int * p;
   unsigned int i;
   p = myset.get_allocator().allocate(5);
   for (i = 0; i < 5; i++) p[i]=(i+1)*10;
   std::cout << "The allocated array contains:";
   for (i = 0; i < 5; i++) std::cout << ' ' << p[i];
   std::cout << '\n';
   myset.get_allocator().deallocate(p,5);
   return 0;
}
//
//s1.swap(s2);
//直接交换两集合的所有元素
//
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
其他基础操作
begin()     　,返回set容器的第一个元素
end() 　　　　 ,返回set容器的最后一个元素

clear()   　　 ,删除set容器中的所有的元素
empty() 　　　,判断set容器是否为空

max_size() 　 ,返回set容器可能包含的元素最大个数

find(n)
count(n)      ,返回值为n的个数
size() 　　　　 ,返回当前set容器中的元素个数

rbegin()　　　　 ,返回的值和end()相同 （反向迭代）
rend()　　　　 ,返回的值和rbegin()相同

multiset

map

map的插入与取值操作
map用法总结

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include<map>
//
//声明
//
1.map<int,string> id_name;
2.map<int,string> id_name={
	{0001,"zdb"};
	{0002,"aaa"};
	{0003,"bbb"}
}//c++11以后可以用
//
//插入操作
//注意insert操作只能插入不能覆盖，而用[]可以覆盖原数据,但[]无安全检查
//insert()返回值为iterator和bool
//
1.id_name[0004]="ccc";//插入
2.id_name[0003]="ddd";//覆盖
3.id_name.insert(pair<int,string>(0005,"eee"));
4.id_name.insert(map<int,string>::value_type(0006,"fff"));

pair<map<int,string>::iterator,bool> ret;
ret=id_name.insert(pair<int,string>(0005,"eee");

//利用iterator指定位置插入
map<int,string>::iterator iter;
id_name.insert(iter,pair<int,string>(0005,"eee"));

//范围插入
map<int,string> id_name_2;
id_name_2.insert(id_name.begin(),id_name.end());
id_name_2.insert(id_name.begin(),id_name.find(0003));

//列表插入
id_name.insert({{0006,"zzz"}，{0007,"xxx"}});

//
//取值操作
//
1.cout<<id_name[0003].c_str()<<endl;
2.cout<<id_name.at(0003)<<endl;
//
//容量查询
//
bool empty();
size_t size();
size_t max_size();
size_t count(const Key& key) const;
//
//顺序比较
//
key_compare key_comp() const;
value_compare value_comp() const;
//
//删除操作，交换，查找等其他操作都与set类似
//

multimap

容器适配器

stack

queue

priority_queue

sort对部分容器排序

不同容器的比较

字符串与字符数组

#include<cstdlib>

atoi函数

1
2
3
4
5
6
7
int y=atoi("2020");

char year[]="2020";
int y=atoi(year);

string s="2020";
int yy=atoi(s.c_str());

c字符串函数

1
2
3
4
5
6
7
8
9
10
11
strlen(s)
strcpy(t,s)    s-->t
strncpy(t,s,n) s-->t len_max=n
strcat(t,s)    t+=s
strncat(t,s,n) t+=s  len_max=n
strcmp(s,t)    if(s==t)return 0;else if(s<t) return -(int);else return (int);

char a[],b[];
char* ret;
ret=strstr(a,b);//返回在a中第一次出现b字符串的位置，如果未找到则返回 null
printf("子字符串是： %s\n", ret);

string

1
2
string s;
s.substr(i,len);

#include<cctype>

1
2
toupper()  小写字母转大写
tolower()  大写字母转小写

c++动态内存分配

1
2
3
4
5
6
7
//new
int n;
double* account_p=new double;
double* account_array=new double[n];
//delete
delete account_p;
delete[] account_array;


-------------本文结束感谢您的阅读-------------



赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

朱登榜，来自河南郑州，河南大学学生，倘若文章有错误，望提醒修正，感谢！<br>qq:879322660<br>微信:z15981855791