C++学习笔记

std就是C++的标准库 就是传说中的STL standard template libary

其中的iostream string vector等都是STL中定义的

标准库中的用<>来include 自己写的用" "引用

.是成员操作符 对象名.类函数名

::是作用域操作符 命名空间::类

想一直让输入值：while(cin>>value)

变量命名习惯：

变量都用小写命名 需要多个单词解释的时候用 _ 或者后面一个词第一个字母大写 textSize或者 text_size

初始化的两种方式

复制初始化：int i=1024;

直接初始化: int i(1024);

内置类型变量是否自动初始化决定于所在的位置：

如果在函数体外定义，默认初始化为0

如果在函数体内定义，不会自动初始化

extern

非const的变量默认都是extern,即可以被外部文件通过extern int i来调用。

而const的常量要在外部调用必须在本文件中显示声明extern const PI;才可以被外部调用

typedef

typedef double price; //就是给double类型起一个别名price

引用&

int x=5;

int &a=x; //引用就是把新的变量指向引用变量，之后对a的所有操作都跟直接对x操作一样

枚举用法

enum direction{north=1,south,east,west};

direction d1=north;

direction d2=2;

类的声明

class Sales_item

{

public:

...

private:

std::string isbn;

unsigned sales;

}; //这里要加分号 ★!!!★

类的数据成员只能通过构造函数进行初始化，不能直接初始化 ★!!!★

定义类在一个头文件中，被需要的文件引用

因为要被多个文件引用，所以注意不应该含有 变量或函数的 定义 可以有声明

头文件保护符避免了头文件在一个文件中多次被引用

#ifndef SALESITEM_H

#define SALESITEM_H

写类定义什么的

#endif

友元类

允许对其非公有成员访问授予给一个函数或者类。

friend开头，只能在类内部声明

friend class Window_mgr;

friend Window_mgr& Window_mgr::relocate(Window_mgr::index.Window_mgr::index,Screen&);

system("pause") 需要引用 cstdlib

引用命名空间时候可以这样using std::string;using std::cout;等

getline来读取一行

string line;

while(getline(cin,line))

string s;

s.zise()返回的是一个string::size_type类型的，不要把size返回值赋给一个int变量

s[i] 定义索引来取的时候i最好也是size_type的类型

头文件引用时候尽量用#include <cmath> 而不是<math.h>

#include <vector>

vector是一个类模板，使用模板可以编写一个类定义或函数定义，而用于多个不同的类型

vector<int> a;vector<myClass> b;

vector不是一个数据类型 vector<int> 是一个数据类型

几种初始化：

vector<Type> v1; //默认v1为空

vector<Type> v2(v1);

vector<Type> v3(n,i); //包含n个值为i的元素

vector<Type> v4(n);

v1.push_back(x);

v1.insert(v1.begin()+2,5);

v1.erase(v1.begin()+1,v1.begin()+3);//删除v1中第2个到第4个元素

v1.clear();//清空

v1.empty();//是不是空的？

v.size();

reverse(v1.begin(),v1.end());

vector操作效率较高的是先定义一个空的vector然后再动态的添加元素

不进行值的初始化 vector会调用默认的构造函数初始化（除非没有默认构造函数，只有自定义的构造函数，此时必须提供元素的个数及初值）

size_type的类型是vector<int> 而不是vector 所以定义时 vector<int>::size_type

C++程序员习惯在写for时用 != 而不是 <

通过下表操作对vector里的元素赋值，不会添加出新的元素（数量不会加）

迭代器对所有容器都支持，但下标操作不是所有容器都支持

各种容器都定义了 各种容器 自己的 iterator类型

vector<int> ivec;

vector<int>::iterator iter=ivec.begin(); //begin()是一个函数,如果容器不为空，返回第一个值

end()也是一个函数，返回最后一个值的下一个，即end()指向一个不存在的元素，如果vector空，end和begin返回的迭代器相同，只是起一个哨兵的作用，代表已经处理完了所有的vector数据

*iter=0; 此时*为解引用操作符 *iter代表里面某个下标的值 *iter++代表往后渐进

vector<int> v1(9,1); //声明一个v1 里面有9个元素 初始都为1

for(vector<int>::iterator iter=v1.begin();iter!=v1.end();iter++) //实现了把每个元素都变成0

*iter=0;

for(vector<int>::const_iterator iter=v1.begin();iter!=v1.end();iter++)//const_iterator类型不会改变值，只能读取

cout<<*iter<<endl;

iter +n -n会产生新的游标

两个游标相减会产生一个difference_type类型的值（这个也是vector里定义的，类似于size_type类型）

vector<int>::iterator mid=v1.begin()+v1.size()/2;

任何改变vector长度的操作都会使已存在的迭代器失效，如push_back之后就不能信赖vector迭代器的值了

bitset类来简化类集的处理

#include <bitset>

using std::bitset;

初始化

bitset<32> bit1; //32个位的bitset对象 记住 灵活定义的初始化只能通过str实现，不能直接=

比如

bitset<16> bit2(0xffff);

string str("1100");

bitset<32> bit3(str); //此时的bit3为 28个0 后面是1100

bitset中的位处理

b.any();//是否存在为1的二进制

b.none();//不存在为1的位？

b.count();//为1的位的个数

b.size();//

b[pos];//

b.test(pos);//为1么？

b.set();//都设置成1

b.set(pos);//某个位置设置成1

b.reset();//都设置成0

b.reset(pos);//某位置成0

b.flip();//反转

b.flip(pos);//某位置反转

b.to_ulong();//转化成一个十进制整数

os<<b;//流入某个输出流

对string对象中字符的处理 #include <cctype>

isalnum(c)//是否为字母或数字

isalpha(c)// 是否为字母

isdigit(c)//是否为数字

islower(c)//是否为小写

isupper(c)

tolower(c)

toupper(c)

string s1;

s1.insert(s1.begin(),'p');

s1.erase(s1.begin(),s1.end());

s1.length();

s1.empty();

s1.replace(2,4,"mygod");//从第二个字符开始（包括），再加上后面4个字符替换为"mygod"

s1.find("ahaha");//在s1中查找ahaha，找到返回第一次出现的下标

reverse(s1.begin(),s1.end());//需要#include <algorithm>

string对象与字符数组互操作

string s;

char ss[100];

scanf("&s",&ss);//string可以直接用字符数组赋值

s=ss;

printf(s.c_str());//用string.c_str()转化为字符数组

按格式分解字符串

string s1,s2,s3;

char sa[100],sb[100],sc[100];

sscanf("abc 123 pc","%s %s %s",sa,sb,sc);

s1=sa;s2=sb;s3=sc;//这样就把一个字符串按格式分解开来

int a,b,c;

sscanf("1 2 3","%d %d %d",&a,&b,&c);//此时是数字格式，要传递指针地址来改变变量的值

int x,y,z;

sscanf("4,5&^1","%d,%d&^%d",&x,&y,&z);//按照字符串的格式来分解

通过字符流转化

把数值转化为string

string convertToString(double x)

{

ostringstream o;

if(o<<x)

return o.str();

return "conversion error";

}

把string转化为数值

double convertFromString(const string &s)

{

istringstream i(s);

double x;

if(i>>x)

return x;

return 0.0;

}

关联容器set

s.insert(5);

s.erase(5);

s.size();

s.find(5);//返回迭代器的位置

#include <set>

int main()

{

set<int> s;//定义一个set

s.insert(8);//插入一个元素

s.insert(1);

s.insert(12);

s.insert(8);//重复插入不生效

set<int> iterator it;

//set<int> reverse_interator rit//反向迭代器

//for(rit=s.rbegin();it!=s.rend();rit++)

for(it=s.begin();it!=s.end();it++)

{

cout<<*it<<" ";

}

cout<<endl;

//s.erase(6);//删除键值为6的元素

return 0;

}

自定义myComp

struct myComp //从大到小

{

myComp()(const int &a,const int &b)

{

if(a!=b)

return a>b;

else

return a>b;

}

};

set<int,myComp>::iterator it;

multiset允许插入重复键值的点

也有erase find方法

map容器的数据元素由一个键值和一个映照数据组成

#include <map>

map<string,float> m;

插入元素

m["JACK"]=90.3;

m["Bomi"]=43.2;

m["Kate"]=23.3;

m.insert(pair<string,float>("Zoe",76.3))

map<string,float>::iterator it;

for(it=m.begin();it!=m.end();it++)

cout<<(*it).first<<":"<<(*it).second;//使用first,second

也可以用rbegin rend来反转

m<string,float>::iterator it=m.find(90.3);//返回指针位置

deque双端队列

#include <deque>

deque<int> d;

d.push_back(5);//从队列后插入，使队列元素值增加

d.push_front(3);//从队列前插入，替代队列前端的树

d.insert(d.begin()+1,7);//在某个位置插入，代替所在元素

deque<int>::iterator it;

deque<int>::reverse_iterator rit;

pop_front();//从头部删除元素

pop_back();//从尾部删除元素

d.erase(d.begin()+1);//删除某个元素

list双向链表

只能对迭代器使用++ --来移动，不能直接+n -n来移动

#include <list>

list<int> l;

l.push_back(5);

l.push_front(6);//都会增加长度

list<int>::iterator it;

it++;

l.insert(it,20);

l.remove(20);//这里是remove

l.erase(it);//删除迭代器上的值

l.pop_front();

l.pop_back();

it=l.find(l.begin(),l.end(),5);//需要声明#include <algorithm>

l.sort();

stack堆栈

#include <stack>

stack<int> s;

s.push(5);

s.pop();

s.top();

s.empty();

s.size();

queue队列

#include <queue>

queue<int> q;

q.push();

q.pop();

q.front();

q.back();

priority_queue最大的元素在最前，也可重载<运算符

pop每次pop最前端，也即是最大的元素

一般只转换bitset的某一个段

string str("1111111000000011001101");

bitset<32> bit4(str,5,4); //这里从str[5] 注意 不是第5个字符开始，往后找4位，即1100

bitset<32> bit5(str,str.size()-4);意味着从开始处取到最后，此处为后四位数1101

对bitset对象的操作

b.any() b中存在置为1的位？存在返回TRUE 不存在返回FALSE

b.none() b中不存在为1的位？不存在返回TRUE 存在返回FALSE

b.count() b中为1的位数

b.size() b的位数

这两个函数返回值的类型是size_t类型，定义在cstddef头文件中，是一个与机器相关的unsigned类型

b[pos] b中的二进制位

b.test(pos) b中pos处的二进制位是否为1

b.set() 全置1 b.set(pos) pos设1

b.reset() 全置0 b.reset(pos) pos设0

b.flip() 全取反 b.flip(pos) pos取反

unsigned long ulong=bit1.to_ulong(); //把位所表示的值转化为 平时见的 值 比如“1111”为15

直接对bitset对象进行cout 得到的是其一位位的1010的排序值

数组 长度是固定的，没有获取其长度的size操作，也不提供push_back操作

只有当性能测试表明使用vector无法达到必要的速度要求时，才使用数组

字符数组

char a[]={'c','+','+'};

char b[]="c++";

char c[]={'c','+','+','\0'};//和上式等价

指针，保存的是一个对象的地址

用*把一个标识符声明为指针

要么修改指针指向的对象，要么修改指针中存储的地址

即 通过指针进行赋值 和 给指针赋值

比如有

string s1("i am a string"); string *sp1=&s1;

如果*sp1="a new string"; 实际上改变了(sp1所指向的对象)s1的值

如果sp1=sp2; 实际上改变了这个指针所引用的对象

指针和引用的区别：

引用&一经初始化就不能改变 int &a=x; 看到a就跟看到x一样

指针string *a=" " a只是后面的一个代理，之后也可以转去代理别的值

若指针直接指向一个数组，则其实是指向了数组的第一个元素 int *ip=array; //int *ip=&array[0];

int *p=&ia[2];

int j=*(p+1) 后者 int j=p[1] 都是代表访问p所在下一个位置的数据

用指针遍历数组

const size_t arr_az=5;

int a[arr_az]={2,3,1,9,5};

for(int *abegin=a,int *aend=abegin+arr_az;abegin!=aend;aend++)

//定义指针指向数组开始第一个元素，再定义一个指针指向最后一个元素后一个位置

*abegin=0;

const double *d; //自以为指向const的指针，不能通过他来改变指向的值

int *const d; //不能指向别的对象的指针

const double *const d; //既不能修改指向对象的值，也不能修改指的方向

#include <string> 跟 #include <cstring> 不是一回事

C风格的字符串使用strlen strcmp strcat等函数进行操作

不要忘记最后必须有一个null,但是strlen返回是不带最后null的数

程序员必须自己保证目标字符串足够大

尽量使用string 避免使用cstring

创建动态的数组

string *psa=new string
; //不声明名字，指针*psa指向数组第一个元素的位置

用法：

for(int *q=psa;q!=psa+n;q++)

{ ...... }

用完以后释放掉

delete [] *psa; //注意要加[]

用数组来初始化一个vector

需要两边两个指针

const size_t arr_size=6;

int arr[arr_size]={1,4,5,2,3,2};

vector<int> ivec(arr,arr+arr_size); //两端的指针，其中后一个是指被复制的最后一个元素后的地址空间

多维数组

int ia[3][4];

int (*ip)[4]=ia; //这个指针的类型为 维数为4的int数组

ip=ia[2]; //把指针指向ia[2]

用typedef简化

typedef int int_array[4];

int_array *ip=ia;

for(int_array *p=ia;p!=ia+3;++p)

for(int *q=*p;q!=*p+4;q++)

cout<<*q<<endl;

++i的效率比i++要高

箭头操作符：

MyItem a;

MyItem *sp=&a;

则要获取a中的成员时 用a.foo 或者用指针形式 sp->foo; ★!!!★

sizeof() 可以知道一个类型或者对象所占的长度 单位为字节

在循环语句中创建的变量每一次都要经历创建啊和撤销的过程

标准库定义的异常类,在stdexcept头文件中

exception 常见的问题

runtiem_error 运行时错误，仅在运行时才能检测到的错误

range_error 运行时错误，结果超出了有意义的值域

try

{

....

throw runtime_error("Data illegal!!!");

}

catch(runtime_errr)

{

cout<<err.what();

...

}

一些常量

__FILE__ __LINE__ __TIME__ __DATE__

文件的读写

#include <iofstream>

ofstream a("a.txt");//把a绑定为向a.txt文件的输出流

ifstream b("a.txt");//把b绑定为输入a.txt文件的输入流

a<<something; //把something写入a

b>>something; //把b中的值写入something

switch(a)

{

case 1:

case 2:

do something;

break;

case 3:

lalala;

break;

defalt:

blabla;

break;

}

如果只是单纯的为了避免使用复制引用(比如只是为了引用而不需要修改引用参数)，把引用参数为const

bool aa(const string &s1,const string &s2)

函数的参数 如果不是&引用 只是对实参的一个副本引用，任何赋值操作不会改变原实参

如果使用指针作为参数，可以改变指针所指向的变量的值

引用形式参数 void swap(&s1,&s2);

//如果数组作为非引用参数，实际上是以指向数组第一个元素的指针为参数

//作为引用，则传递整个数组

static int i;无论在哪里声明 都是全局变量

(inline) //这样可以内联函数

const string &shorterString(....) //解析：返回的类型是一个对string的引用 这个引用指向是不变的，所以有const

this是一个指针 用的时候this->isbn; 但一般不些this也默认是隐士定义

类的构造函数

名字与类名相同，没有返回值

构造函数的初始化列表,函数名冒号后面是对类的一个或多个数据成员指定初值

Sales_item():units_sold(0),revenue(1,5)

{

}

▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲第9章顺序容器▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲第10章关联容器▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲第11章泛型算法▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

类中的成员函数声明

double avg_price() const;//后面的const代表这个函数不改变成员函数

友元 以关键字friend开始，只能在类中出现，友元类可以访问本类的私有成员

▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲第13章复制控制▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲第14章重载运算符与转换▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

重载运算符

在类中定义

bool operator==(const Date&a,const Date&b)

{

return a.year()==b.year()&&aa.month()==b.month()&&a.day()==b.day();

}

使用 string名.c_str()转化为c风格字符串

cin除了普通的用法外还可以cin.getline(ch,26)一行获得 cin.get(ch)一个一个获得 其中char ch[256];

'\0'表示字符串的结束符

char(65)可以输出字母

printf("%d%c",amount,str[i]);

scanf();

strcmp(show1,show2) 要求两个参数都为const

show1.compare(show2);不需要为const

控制小数精度

cout.preision(2);

printf("%.2f\n",i);

二维数组int p[10][10]

字符串的长度用length()

vector长度用size()

reverse(xx.begin(),xx.end())