关于C++的知识点总结的太棒了

• static 成员变量属于类，不属于某个具体的对象
  
• 静态成员函数只能访问类中静态数据成员
  静态数据成员
  
  

• 友元函数不是类的成员函数，所以没有this指针，必须通过参数传递对象。
  
• 友元函数中不能直接引用对象成员的名字，只能通过形参传递进来的对象或对象指针来引用该对象的成员。
  
  

• 类之间的友元关系不能传递
  
• 类之间的友元关系是单向的
  
• 友元关系不能被继承
  
  

• 引入C语言的结构体，是为了保证和c程序的兼容性。
  
• c语言中的结构体不允许定义函数成员，且没有访问控制权限的属性。
  
• c++为结构体引入了成员函数，访问控制权限，继承，多态等面向对象特性。
  
• c语言中，空结构体的大小为0，而C++中空结构体大小为1。
  
• class中成员默认是private,struct中的成员默认是public。
  
• class继承默认是private继承，而struct继承默认是public继承。
  
• class可以使用模版，而struct不能。
  举个例子：
  
  

• 一个基类可以派生出多个派生类，一个派生类可以继承多个基类
  派生类的声明：
  
  

• public-基类的public成员和protected成员的访问属性保持不变，私有成员不可见。
  
• private-基类的public成员和protected成员成为private成员,只能被派生类的成员函数直接访问，私有成员不可见。
  
• protected-基类的public成员和protected成员成为protected成员,只能被派生类的成员函数直接访问，私有成员不可见。
  
  

• 利用using关键字可以改变基类成员再派生类中的访问权限；using只能修改基类中public和protected成员的访问权限。
  
  

• 先执行基类的构造函数，随后执行派生类的构造函数
  
• 先执行派生类的析构函数，再执行基类的析构函数。
  
• 派生类的构造函数：派生类名(总参数列表)：基类名(基类参数列表),子对象名1(参数列表){构造函数体;}
  
  

  多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。

• 1.类名::同名成员名;
  
• 2.派生类定义同名成员，访问的就是派生类同名成员。
  
  

• 虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class）。
  
• 派生类的 同名成员 比虚基类的 优先级更高
  虚基类的声明：class 派生类名:virtual 继承方式 基类名
  
  

• 如果 B 或 C 其中的一个类定义了a，也不会有二义性，派生类的a 比虚基类的a 优先级更高。
  
• 如果 B 和 C 中都定义了 a，那么D直接访问a 将产生二义性问题。
  应用：c++中的iostream ， istream ， ostream，base_io
  
  

• 只能将将派生类赋值给基类（C++中称为向上转型）： 派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用
  
• 派生类对象赋值给基类对象，舍弃派生类新增的成员；派生类指针赋值给基类指针，没有拷贝对象的成员，也没有修改对象本身的数据，仅仅是改变了指针的指向；派生类引用赋值给基类引用，和指针的一样。、
  
  

• 静态多态性-在程序编译时系统就决定调用哪个函数，比如函数重载和静态多态性
  
• 动态多态性-在程序运行过程中动态确定调用那个函数，通过虚函数实现的。
  
  

• 将基类中的函数声明为虚函数，派生类中的同名函数自动为虚函数。
  
• 声明形式：virtual 函数类型 函数名 (参数列表);
  
• 构造函数不能声明为虚函数，析构函数可以声明为虚函数。
  
  

• 运算符重载是通过函数实现的，它本质上是函数重载。
  
  

• 不允许重载的运算符
  
  

• 不可以自己定义新的运算符，只能对已有的C++运算符重载。
  
• 不能改变运算符运算对象的个数。
  
• 不能改变运算符的优先级和结合性
  
• 应与标准类型运算功能相似，避免影响可读性。
  一般格式：
  
  

• 双目运算符作为友元函数时需要制定两个参数。
  
• 运算符重载函数作为类成员函数可以显式调用。
  
  

>( istream  &input, Vector3 &v )      {          input >> v.m_x>> v.m_y>>v.m_z;         return input;                  } 16.4 实现类型转换

• 不指定函数类型和参数，返回值的类型由类型名来确定。
  
• 类型转换函数只能作为成员函数，不能作为友元函数。
  类型转换函数的一般形式：
  
  

operator 类型名(){        转换语句;}class Vector3{public:        Vector3();        Vector3(double x,double y,double z);public:        Vector3 operator+(const Vector3 &A)const;        Vector3 operator++();        friend Vector3 operator-(const Vector3 &v1, const Vector3 &v2);        friend Vector3 operator--(Vector3 &v,int);        operator double()        {                return m_x + m_y + m_z;        }        void display()const;private:        double m_x;        double m_y;        double m_z;};int main(){        Vector3 v1(1, 2, 3);        double d = v1;        cout << d << endl;//6        return 0;} 17 IO流

流-一连串连续不断的数据集合。
17.1 流类和对象

• 输入流-从输入设备流向内存的流。
  
• 输出流-从内存流出设备的流。
  
• 内存缓冲区-用来存放流中的数据。
  
  

输入输出流程：键盘输入=》键盘缓冲区=(回车触发)》程序的输入缓冲区=》‘>>’提取数据
                        输出缓冲区=(缓冲满或endl)》‘<<’送到 显示器显示
输入/输出流类：
iostream：ios ,istream,ostream,iostream
fstream：ifstream,ofstream,fstream
strstream：istrstream,ostrstream,strstream

• istream 是用于输入的流类，cin 就是该类的对象。
  
• ostream 是用于输出的流类，cout 就是该类的对象。
  
• ifstream 是用于从文件读取数据的类。
  
• ofstream 是用于向文件写入数据的类。
  
• iostream 是既能用于输入，又能用于输出的类。
  
• fstream 是既能从文件读取数据，又能向文件写入数据的类。
  
• istrstream 输入字符串类
  
• ostrstream 输出字符串类
  
• strstream 输入输出字符串流类
  
  
  
  
  
  

17.2 标准输入输出流

C++的输入/输出流库(iostream)中定义了4个标准流对象：cin(标准输入流-键盘)，cout(标准输出流-屏幕)，cerr(标准错误流-屏幕)，clog(标准错误流-屏幕)

• cerr 不使用缓冲区，直接向显示器输出信息；而输出到 clog 中的信息会先被存放到缓冲区，缓冲区满或者刷新时才输出到屏幕。
  
• cout 是 ostream 类的对象，ostream 类的无参构造函数和复制构造函数都是私有的，所以无法定义 ostream 类的对象。
  
• 使用>>提取数据时，系统会跳过空格，制表符，换行符等空白字符。所以一组变量输入值时，可用这些隔开。
  
• 输入字符串，也是跳过空白字符，会在串尾加上字符串结束标志。
  
  

int  x;double y;cin>>x>>y;//输入 22 66.0  两个数之间可以用空格、制表符和回车分隔数据char str[10];cin>>str;//hei ren  字符串中只有hei 输入流中的成员函数

• get函数：cin.get()，cin.get(ch)（成功返回非0值，否则返回0），cin.get(字符数组(或字符指针)，字符个数n,终止字符)
  
  

char c = cin.get();//获取一个字符while ((c = cin.get()) != EOF)//循环读取，直到换行{        cout << c;}char ch;cin.get(ch);while (cin.get(ch))//读取成功循环{        cout << ch;}char arr[5];cin.get(arr, 5, 'n');//输入 heiren  结果 heir

• getline函数：cin.getline(字符数组(或字符指针),字符个数n,终止标志字符)
  读取字符知道终止字符或者读取n-1个字符，赋值给指定字符数组（或字符指针）
  
  

char arr0[30],arr1[30],arr2[40];cin>>arr0;//遇到空格、制表符或回车结束  "Heiren"cin.getline(arr1,30);//字符数最多为29个，遇到回车结束 " Hello World"cin.getline(arr2,40,'*');//最多为39个，遇到*结束 "yar"//输入 Heiren Hello World//yar*123

• cin.peek() 不会跳过输入流中的空格、回车符。在输入流已经结束的情况下，cin.peek() 返回 EOF。
  
• ignore(int n =1, int delim = EOF)
  
  

int n; cin.ignore(5, 'Y');//跳过前5个字符或Y之前的字符，‘Y’优先 cin >> n; //输入1234567  ->  67    1234567Y345->345//输入2020.2.23int year,month,day;cin >> year ;cin.ignore() >> month ; //用ignore跳过 '.' cin.ignore() >> day;cin.ignore();   //跳过行末 'n' cout<< setfill('0') << setw(2) << month ;//设置填充字符''，输出宽度2 cout << "-" << setw(2) << day << "-" << setw(4) << year << endl;

• putback(char c)，可以将一个字符插入输入流的最前面。
  
  

输出流对象

• 插入endl-输出所有数据，插入换行符，清空缓冲区
  
• n-输出换行，不清空缓冲区
  
• cout.put(参数) 输出单个字符（可以时字符也可以是ASII码）
  
  

格式化输出
iomanip 中定义的流操作算子：

• *不是算子的一部分，星号表示在没有使用任何算子的情况下，就等效于使用了该算子，例如，在默认情况下，整数是用十进制形式输出的，等效于使用了 dec 算子
  
  

[tr]流操纵算子作 用[/tr]

*dec	以十进制形式输出整数 常用
hex	以十六进制形式输出整数
oct	以八进制形式输出整数
fixed	以普通小数形式输出浮点数
scientific	以科学计数法形式输出浮点数
left	左对齐，即在宽度不足时将填充字符添加到右边
*right	右对齐，即在宽度不足时将填充字符添加到左边
setbase(b)	设置输出整数时的进制，b=8、10 或 16
setw(w)	指定输出宽度为 w 个字符，或输人字符串时读入 w 个字符
setfill©	在指定输出宽度的情况下，输出的宽度不足时用字符 c 填充（默认情况是用空格填充）
setprecision(n)	设置输出浮点数的精度为 n。在使用非 fixed 且非 scientific 方式输出的情况下，n 即为有效数字最多的位数，如果有效数字位数超过 n，则小数部分四舍五人，或自动变为科学计 数法输出并保留一共 n 位有效数字。在使用 fixed 方式和 scientific 方式输出的情况下，n 是小数点后面应保留的位数。
setiosflags(flag)	将某个输出格式标志置为 1
resetiosflags(flag)	将某个输出格式标志置为 0
boolapha	把 true 和 false 输出为字符串 不常用
*noboolalpha	把 true 和 false 输出为 0、1
showbase	输出表示数值的进制的前缀
*noshowbase	不输出表示数值的进制.的前缀
showpoint	总是输出小数点
*noshowpoint	只有当小数部分存在时才显示小数点
showpos	在非负数值中显示 +
*noshowpos	在非负数值中不显示 +
*skipws	输入时跳过空白字符
noskipws	输入时不跳过空白字符
uppercase	十六进制数中使用 A~E。若输出前缀，则前缀输出 0X，科学计数法中输出 E
*nouppercase	十六进制数中使用 a~e。若输出前缀，则前缀输出 0x，科学计数法中输出 e。
internal	数值的符号（正负号）在指定宽度内左对齐，数值右对 齐，中间由填充字符填充。

• 流操作算子使用方法：cout << hex << 12 << "," << 24;//c,18
  
  

setiosflags() 算子
setiosflags() 算子实际上是一个库函数，它以一些标志作为参数，这些标志可以是在 iostream 头文件中定义的以下几种取值，它们的含义和同名算子一样。
[tr]标 志作 用[/tr]

ios::left	输出数据在本域宽范围内向左对齐
ios::right	输出数据在本域宽范围内向右对齐
ios::internal	数值的符号位在域宽内左对齐，数值右对齐，中间由填充字符填充
ios::dec	设置整数的基数为 10
ios::oct	设置整数的基数为 8
ios::hex	设置整数的基数为 16
ios::showbase	强制输出整数的基数（八进制数以 0 开头，十六进制数以 0x 打头）
ios::showpoint	强制输出浮点数的小点和尾数 0
ios::uppercase	在以科学记数法格式 E 和以十六进制输出字母时以大写表示
ios::showpos	对正数显示“+”号
ios::scientific	浮点数以科学记数法格式输出
ios::fixed	浮点数以定点格式（小数形式）输出
ios::unitbuf	每次输出之后刷新所有的流
ios::stdio	每次输出之后清除 stdout, stderr

• 多个标志可以用|运算符连接，表示同时设置。例如：
  
  

cout << setiosflags(ios::scientific|ios::showpos) << 12.34;//+1.234000e+001

• 如果两个相互矛盾的标志同时被设置,结果可能就是两个标志都不起作用,应该用 resetiosflags 清除原先的标志
  
  

cout << setiosflags(ios::fixed) << 12.34 << endl;cout << resetiosflags(ios::fixed) << setiosflags(ios::scientific | ios::showpos) << 12.34 << endl; ostream 类中的成员函数：
[tr]成员函数作用相同的流操纵算子说明[/tr]

precision(n)	setprecision(n)	设置输出浮点数的精度为 n。
width(w)	setw(w)	指定输出宽度为 w 个字符。
fill©	setfill ©	在指定输出宽度的情况下，输出的宽度不足时用字符 c 填充（默认情况是用空格填充）。
setf(flag)	setiosflags(flag)	将某个输出格式标志置为 1。
unsetf(flag)	resetiosflags(flag)	将某个输出格式标志置为 0。

• setf 和 unsetf 函数用到的flag，与 setiosflags 和 resetiosflags 用到的完全相同。
  
  

cout.setf(ios::scientific);cout.precision(8);cout << 12.23 << endl;//1.22300000e+001 18 文件操作

文件-指存储在外部介质上的数据集合，文件按照数据的组织形式不一样，分为两种：ASCII文件(文本/字符)，二进制文件(内部格式/字节)

• ASCII文件输出还是二进制文件，数据形式一样，对于数值数据，输出不同
  
  

18.1 文件类和对象

C++ 标准类库中有三个类可以用于文件操作，它们统称为文件流类。这三个类是：

• ifstream：输入流类，用于从文件中读取数据。
  
• ofstream：输出流类，用于向文件中写人数据。
  
• fstream：输入/输出流类，既可用于从文件中读取数据，又可用于 向文件中写人数据。
  文件流对象定义：
  
  

#include ifstream in;ofstream out;fstream inout; 18.2 打开文件

• 打开文件的目的：建立对象与文件的关联，指明文件使用方式
  
• 打开文件的两种方式：open函数和构造函数
  
  

open函数：void open(const char* szFileName, int mode);
[tr]模式标记适用对象作用[/tr]

ios::in	ifstream fstream	打开文件用于读取数据。如果文件不存在，则打开出错。
ios::out	ofstream fstream	打开文件用于写入数据。如果文件不存在，则新建该文件；如 果文件原来就存在，则打开时清除原来的内容。
ios::app	ofstream fstream	打开文件，用于在其尾部添加数据。如果文件不存在，则新建该文件。
ios::ate	ifstream	打开一个已有的文件，并将文件读指针指向文件末尾（读写指 的概念后面解释）。如果文件不存在，则打开出错。
ios:: trunc	ofstream	单独使用时与 ios:: out 相同。
ios::binary	ifstream ofstream fstream	以二进制方式打开文件。若不指定此模式，则以文本模式打开。
ios::in | ios::out	fstream	打开已存在的文件，既可读取其内容，也可向其写入数据。文件刚打开时，原有内容保持不变。如果文件不存在，则打开出错。
ios::in | ios::out	ofstream	打开已存在的文件，可以向其写入数据。文件刚打开时，原有内容保持不变。如果文件不存在，则打开出错。
ios::in | ios::out | ios::trunc	fstream	打开文件，既可读取其内容，也可向其写入数据。如果文件本来就存在，则打开时清除原来的内容；如果文件不存在，则新建该文件。

ios::binary 可以和其他模式标记组合使用，例如：

• ios::in | ios::binary表示用二进制模式，以读取的方式打开文件。
  
• ios::out | ios::binary表示用二进制模式，以写入的方式打开文件。
  
  

流类的构造函数
eg:ifstream::ifstream (const char* szFileName, int mode = ios::in, int);
#include #include using namespace std;int main(){    ifstream inFile("c:\tmp\test.txt", ios::in);    if (inFile)        inFile.close();    else        cout << "test.txt doesn't exist" << endl;    ofstream oFile("test1.txt", ios::out);    if (!oFile)        cout << "error 1";    else        oFile.close();    fstream oFile2("tmp\test2.txt", ios::out | ios::in);    if (!oFile2)        cout << "error 2";    else        oFile.close();    return 0;} 18.3 文本文件的读写

对于文本文件，可以使用 cin、cout 读写。
eg：编写一个程序，将文件 i.txt 中的整数倒序输出到 o.txt。（12 34 56 78 90 -> 90 78 56 34 12）
#include #include using namespace std;int arr[100];int main(){        int num = 0;        ifstream inFile("i.txt", ios::in);//文本模式打开        if (!inFile)                return 0;//打开失败        ofstream outFile("o.txt",ios::out);        if (!outFile)        {                outFile.close();                return 0;        }        int x;        while (inFile >> x)                arr[num++] = x;        for (int i = num - 1; i >= 0; i--)                outFile << arr << " ";        inFile.close();        outFile.close();        return 0;} 18.4 二进制文件的读写

• 用文本方式存储信息不但浪费空间，而且不便于检索。
  
• 二进制文件中，信息都占用 sizeof(对象名) 个字节；文本文件中类的成员数据所占用的字节数不同，占用空间一般比二进制的大。
  
  

ostream::write 成员函数：ostream & write(char* buffer, int count);
class Person{public:        char m_name[20];        int m_age;};int main(){        Person p;        ofstream outFile("o.bin", ios::out | ios::binary);        while (cin >> p.m_name >> p.m_age)                outFile.write((char*)&p, sizeof(p));//强制类型转换        outFile.close();        //heiren 烫烫烫烫烫烫啼          return 0;} istream::read 成员函数：istream & read(char* buffer, int count);
Person p;ifstream inFile("o.bin", ios::in | ios::binary); //二进制读方式打开if (!inFile)        return 0;//打开文件失败while (inFile.read((char *)&p, sizeof(p)))        cout << p.m_name << " " << p.m_age << endl;inFile.close(); 文件流类的 put 和 get 成员函数
#include #include using namespace std;int main(){        ifstream inFile("a.txt", ios::binary | ios::in);     if (!inFile)        return 0;    ofstream outFile("b.txt", ios::binary | ios::out);    if (!outFile)     {        inFile.close();        return 0;    }    char c;    while (inFile.get(c))  //每读一个字符        outFile.put(c);  //写一个字符    outFile.close();    inFile.close();    return 0;} 一个字节一个字节地读写，不如一次读写一片内存区域快。每次读写的字节数最好是 512 的整数倍
18.5 移动和获取文件读写指针

• ifstream 类和 fstream 类有 seekg 成员函数，可以设置文件读指针的位置；
  
• ofstream 类和 fstream 类有 seekp 成员函数，可以设置文件写指针的位置。
  
• ifstream 类和 fstream 类还有 tellg 成员函数，能够返回文件读指针的位置；
  
• ofstream 类和 fstream 类还有 tellp 成员函数，能够返回文件写指针的位置。
  
  

函数原型
ostream & seekp (int offset, int mode);istream & seekg (int offset, int mode);//mode有三种：ios::beg-开头往后offset(>=0)字节 ios::cur-当前往前(<=0)/后(>=0)offset字节 ios::end-末尾往前(<=0)offect字节int tellg();int tellp();//seekg 函数将文件读指针定位到文件尾部，再用 tellg 函数获取文件读指针的位置，此位置即为文件长度 举个栗子：折半查找文件，name等于“Heiren”
#include #include //#include //#includeusing namespace std;class Person{public:        char m_name[20];        int m_age;};int main(){        Person p;        ifstream ioFile("p.bin", ios::in | ios::out);//用既读又写的方式打开        if (!ioFile)                 return 0;        ioFile.seekg(0, ios::end); //定位读指针到文件尾部，以便用以后tellg 获取文件长度        int L = 0, R; // L是折半查找范围内第一个记录的序号                                  // R是折半查找范围内最后一个记录的序号        R = ioFile.tellg() / sizeof(Person) - 1;        do {                int mid = (L + R) / 2;                 ioFile.seekg(mid *sizeof(Person), ios::beg);                 ioFile.read((char *)&p, sizeof(p));                int tmp = strcmp(p.m_name, "Heiren");                if (tmp == 0)                {                         cout << p.m_name << " " << p.m_age;                        break;                }                else if (tmp > 0)                         R = mid - 1;                else                          L = mid + 1;        } while (L <= R);        ioFile.close();        system("pause");        return 0;} 18.6 文本文件和二进制文件打开方式的区别

• UNIX/Linux 平台中，用文本方式或二进制方式打开文件没有任何区别。
  
• 在 UNIX/Linux 平台中，文本文件以n（ASCII 码为 0x0a）作为换行符号；而在 Windows 平台中，文本文件以连在一起的rn（r的 ASCII 码是 0x0d）作为换行符号。
  
• 在 Windows 平台中，如果以文本方式打开文件，当读取文件时，系统会将文件中所有的rn转换成一个字符n，如果文件中有连续的两个字节是 0x0d0a，则系统会丢弃前面的 0x0d 这个字节，只读入 0x0a。当写入文件时，系统会将n转换成rn写入。
  
  

用二进制方式打开文件总是最保险的。
19 泛型和模板

• 泛型程序设计在实现时不指定具体要操作的数据的类型的程序设计方法的一种算法，指的是算法只要实现一遍，就能适用于多种数据类型，优势在于代码复用，减少重复代码的编写。
  
• 模板是泛型的基础，是创建泛型类或函数的蓝图或公式。
  
  

19.1 函数模板

函数模板的一般形式：
template或template函数类型 函数名(参数列表){        函数体;}template//class可以换成typename函数类型 函数名(参数列表){        函数体;}//举个栗子template T max(T a, T b){        return a > b ? a : b;}int main(){        cout <<"max value is "<< max(12,34) << endl;//34        cout << "max value is " << max(12.4, 13.6) << endl;//13.6        cout << "max value is " << max(12.4, 13) << endl;//error 没有与参数列表匹配的 函数模板 "max" 实例参数类型为:(double, int)        return 0;} 19.2 类模板

• 声明了类模板，就可以将类型参数用于类的成员函数和成员变量了。换句话说，原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。
  类模板的一般形式：
  
  

template//class可以换成typename 模板头class 类名{        函数定义;};//多个类型参数和函数模板类似，逗号隔开 当类中的成员函数在类的声明之外定义时，它必须定义为函数模板，带上模板头，定义形式如下：
template//class可以换成typename函数类型 类名::函数名(形参列表){        函数体;} 举个栗子：
template  // 模板头  没有分号class Point {public:        Point(T1 x, T2 y) : x(x), y(y) { }public:        T1 getX() const;  //成员函数后加const，声明该函数内部不会改变成员变量的值        void setX(T1 x);          T2 getY() const;          void setY(T2 y);  private:        T1 x;          T2 y;  };template  //模板头T1 Point::getX() const  {        return x;}templatevoid Point::setX(T1 x) {        x = x;}templateT2 Point::getY() const {        return y;}templatevoid Point::setY(T2 y) {        y = y;}int main(){        Point p1(66, 20.5);        Point p2(10, "东经33度");        Point *p3 = new Point("西经12度", "北纬66度");        cout << ", y=" << p1.getY() << endl;        cout << ", y=" << p2.getY() << endl;        cout << ", y=" << p3->getY() << endl;        return 0;} 19.3 typename 和 class 的区别

      在模板引入 c++ 后，采用class来定义模板参数类型，后来为了避免 class 在声明类和模板的使用可能给人带来混淆，所以引入了 typename 这个关键字。

• 模板定义语法中关键字 class 与 typename 的作用完全一样。
  
• 不同的是typename 还有另外一个作用为：使用嵌套依赖类型(nested depended name)
  
  

class MyClass{public:                typedef int LengthType;                LengthType getLength() const                {                        return this->length;                }                void setLength(LengthType length)                {                        this->length = length;                }                private:        LengthType length;};templatevoid MyMethod(T myclass){        //告诉 c++ 编译器，typename 后面的字符串为一个类型名称，而不是成员函数或者成员变量        typedef typename T::LengthType LengthType; //        LengthType length = myclass.getLength();        cout << "length = " <19.4 强弱类型语言和c++模板的那点猫腻

计算机编程语言可以根据在 "定义变量时是否要显式地指明数据类型"可以分为强类型语言和弱类型语言。

• 强类型语言-在定义变量时需要显式地指明数据类型，为变量指明某种数据类型后就不能赋予其他类型的数据了，除非经过强制类型转换或隐式类型转换。典型的强类型语言有 C/C++、Java、C# 等。
  
  

int a = 123;  //不转换a = 12.89;  //隐式转换 12（舍去小数部分）a = (int)"heiren,HelloWorld";  //强制转换（得到字符串的地址） 不同类型之间转换需要强制 //Java 对类型转换的要求比 C/C++ 更为严格，隐式转换只允许由低向高转，由高向低转必须强制转换。int a = 100;  //不转换a = (int)12.34;  //强制转换（直接舍去小数部分，得到12）

• 弱类型语言-在定义变量时不需要显式地指明数据类型，编译器（解释器）会根据赋给变量的数据自动推导出类型，并且可以赋给变量不同类型的数据。典型的弱类型语言有 JavaScript、Python、PHP、Ruby、Shell、Perl 等。
  
  

var a = 100;  //赋给整数a = 12.34;  //赋给小数a = "heiren,HelloWorld";  //赋给字符串a = new Array("JavaScript","React","JSON");  //赋给数组       强类型语言在编译期间就能检测某个变量的操作是否正确，因为变量的类型始终哦都市确定的，加快了程序的运行；对于弱类型的语言，变量的类型可以随时改变，编译器在编译期间能确定变量的类型，只有等到程序运行后、赋值后才能确定变量当前是什么类型，所以传统的编译对弱类型语言意义不大。

• 解释型语言-弱类型往往是解释型语言，边执行边编译
  
• 编译型语言-先编译后执行。
  
        强类型语言较为严谨，在编译时就能发现很多错误，适合开发大型的、系统级的、工业级的项目；而弱类型语言较为灵活，编码效率高，部署容易，学习成本低，在 Web 开发中大显身手。另外，强类型语言的 IDE 一般都比较强大，代码感知能力好，提示信息丰富；而弱类型语言一般都是在编辑器中直接书写代码。
  
        C++模板退出的动力来源是对数据结构的封装：数据结构关注的是数据的存储以及对其的增删改查操作，C++开发者们想封装这些结构，但是这些结构中数据成分的类型无法提前预测，于是模板诞生了。
  
  

  STL(Standard Template Library，标准模板库)就是c++对数据结构封装后的称呼。

20 命名空间和异常处理

20.1 命名空间

    命名空间实际上是由用户自己命名的一块内存区域，用户可以根据需要指定一个有名字的空间区域，每个命名空间都有一个作用域，将一些全局实体放在该命名空间中，就与其他全局实体分割开来。
命名空间定义的一般形式：
namespace [命名空间名]//名省略时，表示无名的命名空间{        命名空间成员;} 命名空间成员的引用：命名空间名::命名空间成员名
使用命名空间别名：namespace 别名 = 命名空间名
使用using声明命名空间成员的格式：using 命名空间名::命名空间成员名;
使用using声明命名空间的全部成员：using namespace 命名空间名;

• using声明后，在using语句所在的作用域中使用该命名空间成员时，不必再用命名空间名加以限定。
  
• 标准C++库的所有标识符（包括函数、类、对象和类模板）都是在一个名为std的命名空间中定义的。
  
• 无名的命名空间,只在本文件的作用域内有效。
  
  

20.2 异常处理

    异常就是程序在执行过程中，由于使用环境变化和用户操作等原因产生的错误，从而影响程序的运行。

• 程序中常见的错误：语法错误，运行错误
  
• 异常处理机制的组成：检查异常（try）、抛出异常（throw）、捕获并处理异常（catch）
  
  

异常处理语句：

• 被检查的语句必须放在try后面的{}中，否则不起作用，{}不能省略。
  
• 进行异常处理的语句必须放在catch后面的{}中，catch后()中的异常信息类型不能省略，变量名可以省略。
  
• catch语句块不能单独使用，必须和try语句块作为整体出现。
  
• 在try-catch结构中，只能有一个try，但可以有多个catch.
  
• catch(…)通常放在最后，可以捕获任何类型的异常信息。
  
  

try{        被检查的语句（可以有多个throw语句）;}catch(异常信息类型 [变量名]){ } throw语句：thow 变量或表达式;

• throw放在try中，也可以单独使用，向上一层函数寻找try-catch，没有找到系统就会调用系统函数terminate，使程序终止运行。
  
  

try{        throw 123;}catch (int a){        cout << a << endl;//123} c++中没有finally
类的异常处理，当在try中定义了类对象，在try中抛出异常前创建的对象将被自动释放。
异常规范-描述了一个函数允许抛出那些异常类型。

• 异常规范应同时出现在函数声明和函数定义中。
  
• 如果没有异常规范，可以抛出任何类型的异常。
  异常规范的一般形式：函数类型 函数名(参数类型)throw ([异常类型1，异常类型2，...])
  
  

float fun(float float)throw(int,float,double); C++标准异常





[tr]异常描述[/tr]

std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过 new 抛出。
std::bad_cast	该异常可以通过 dynamic_cast 抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过 typeid 抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

21 STL

C++标准模板库（Standard Template Library,STL）是泛型程序设计最成功的实例。STL是一些常用数据结构和算法的模板的集合，由Alex Stepanov主持开发，于1998年被加入C++标准。

• C++ 标准模板库的核心包括三大组件：容器，算法，迭代器
  
  

21.1 容器

顺序容器：可变长动态数组Vector、双端队列deque、双向链表list
关联容器：set、multliset、map、multimap

• 关联容器内的元素是排序的,所以查找时具有非常好的性能。
  容器适配起：栈stack、队列queu、优先队列priority_queue
  所有容器具有的函数：
  
  

int size();bool empty(); 顺序容器和关联容器函数：
begin()end()rbegin()erase(...)clear() 顺序容器独有的函数：
front()back()push_back();pop_back();insert(...); 21.2 迭代器

迭代器是一种检查容器内元素并遍历元素的数据类型。C++更趋向于使用迭代器而不是下标操作，因为标准库为每一种标准容器（如vector）定义了一种迭代器类型，而只用少数容器（如vector）支持下标操作访问容器元素。按照定义方式分为以下四种。
1.正向迭代器：容器类名::iterator 迭代器名;
2.常量正向迭代器：容器类名::const_iterator 迭代器名;
3.反向迭代器：容器类名::reverse_iterator 迭代器名;
4.常量反向迭代器：容器类名::const_reverse_iterator 迭代器名
21.3 算法

    STL 提供能在各种容器中通用的算法（大约有70种），如插入、删除、查找、排序等。算法就是函数模板。算法通过迭代器来操纵容器中的元素。
    STL 中的大部分常用算法都在头文件 algorithm 中定义。此外，头文件 numeric 中也有一些算法。
    许多算法操作的是容器上的一个区间（也可以是整个容器），因此需要两个参数，一个是区间起点元素的迭代器，另一个是区间终点元素的后面一个元素的迭代器。
会改变其所作用的容器。例如：

• copy：将一个容器的内容复制到另一个容器。
  
• remove：在容器中删除一个元素。
  
• random_shuffle：随机打乱容器中的元素。
  
• fill：用某个值填充容器。
  
  

不会改变其所作用的容器。例如：

• find：在容器中查找元素。
  
• count_if：统计容器中符合某种条件的元素的个数。
  
  

#include #include #include using namespace std;int main()  {   vector v;        v.push_back(1);        v.push_back(2);        v.push_back(3);        v.push_back(4); //1,2,3,4        vector::iterator p;        p = find(v.begin(), v.end(), 3); //在v中查找3 若找不到,find返回 v.end()        if (p != v.end())                cout << "1) " << *p << endl; //找到了        p = find(v.begin(), v.end(), 9);        if (p == v.end())                cout << "not found " << endl; //没找到        p = find(v.begin() + 1, v.end() - 1, 4); //在2,3 这两个元素中查找4        cout << "2) " << *p << endl; //没找到，指向下一个元素4        int arr[10] = { 10,20,30,40 };        int * pp = find(arr, arr + 4, 20);        if (pp == arr + 4)                cout << "not found" << endl;        else                cout << "3) " << *pp << endl;        return 0;} 22 总结

    终于写完了，因为新冠疫情，在家隔离了一个多月，闲来无事，写写博客来总结一下自己之前学的知识；零零散散大约花了一周左右的时间，该篇文章面向C++的基础知识，有许多详细，深层的没有写进去。后面有时间会写模板，STL，C++11新特性，Boost库等的文章，刚开始写博客，文章中有错误或有遗漏的知识点，请大佬们指出。