C++基础知识点小结

第一章绪论
- （1）cout 输出流的对象
- （2）cin输入对象
- （3）endl 输出控制符/操控符
- （4）标识符
- （5）命名空间（namespace）
- （6）左值：
- （7）右值
- （8）c++赋值方式（整型和浮点型）
- （9）string字符串：
第二章引用与函数
第三章类的封装
第四章堆空间与深拷贝
第五章静态与友元
第六章继承与多态
第七章运算符重载
第八章模板与STL
第九章异常处理
第十章文件处理

C语言的缺点：
1.C类型检查机制相对较弱，这使得程序中的一些错误不能在编译时发现。
2.C本身几乎没有支持代码重用的语言结构，很难重用。
3.当程序的规模达到一定的程度时，程序员很难控制程序的复杂性。

第一章绪论

C++可以视为c语言的超集
任何合法的c语言程序都是c++程序

最开始c++叫做带类的c语言
C语言面向过程，c++面向对象
与phython相比开发效率低，运行效率高
与C语言相比，运行效率低一点
腾讯框架Tensorflow 物品分类框架Y0L0v4
游戏开发：c++ lua（一门脚本语言）

源文件cpp
头文件 #include 输入输出流
#include //maniplator操控器输入输出控制头文件
Le+06 1*10^6

函数，后面有括号
关键字，会变色

（1）cout 输出流的对象

cout :标准输出对象

1.<< 左移运算符，输出运算符
<< 输出运算符，返回左侧对象

（2）cin输入对象

cin:标准输入对象自动忽略回车和空格

1.>> 右移运算符，输入运算符

输入运算符，返回左侧对象

（3）endl 输出控制符/操控符

作用：（1）换行（2）刷新缓存区

编译 g++ 文件名 gcc
g++ -v

（4）标识符

1.大小写的使用需要规范
2.使用有意义的名字
3.字母、数字、_组成
4.不能是关键字
5.命名规则：
（1）驼峰命名法：firstName
（2）匈牙利命名法：first_name()

（5）命名空间（namespace）

命名空间用于定义对象（全局对象）
目的：解决变量重复定义问题
命名空间可以使用多个命名空间
注意：不同命名空间最好不要定义同名变量
使用多个命名空间时，如果存在同名变量需要用域名限定符::区分。
项目不同文件相同名称的全局变量（1）同一变量（2）不同变量
（1）extern 外部链接属性（2）static内部链接属性
同一文件中，我们需要定义相同名称的不同两个全局变量，怎么办？
C无解 C++命名空间解决

不可以声明两个含有相同变量的命名空间

方法1：命名空间：为了解决函数和变量之间的冲突
关键字 namespace
using namespace name; 将name空间里的所有内容（所有变量和所有函数和所有类/对象）都在当前作用域展开
using 自定义变量名 = 数据类型 //重命名数据类型早期c++版本不支持
方法2：：：:域名限定符调用域限定符左边里的内容
：：:域限定符

using:
（1）using namespace name
将命名空间内的内容在当前作用域展开
（2）重命名数据类型
Using myint_t = int

（6）左值：

左值：拥有内存空间指针不能作为左值
放在等号左边的叫左值
有自己独立内存的量可以放在等号左边（非只读）称为左值（既可以放在等号左边，也可以放在等号右边）

（7）右值

放在等号右边的叫右值
int a = 10;
10 = 20;
func() = 500;

（8）c++赋值方式（整型和浮点型）

1.用括号赋值

2.进制
C++中整型数据，默认十进制
可以用oct dec hex更改输出方式
一次修改会对后面的输出产生影响，所有需要手动更改回默认输出
也可以用setbase函数修改进制输出方式（需要头文件
2.1十进制转化为八进制的方法：
十进制数据除以8一直除到余0为止，把所除的结果正排列
oct 八进制 octal
hex 十六进制 Hexadecimal system
dec 十进制 Decimal system

setbase(); 只支持8，10,16进制转换
加头文件#include cout << setbase(8) << a << endl; 输出八进制
3.C++中浮点型数据，默认保留6位有效数字
（1）整数部分超过6位，自动转换成科学计数法------浮点小数
（2）C语言中的小数是-----定点小数
（3）setprecison() 头文件控制位数
double a = 1.1;
1.保留有效数字：
cout << setprecision(3) << a << endl; 保留3位有效数字
2.保留小数位数：
cout << setprecision(3) << fixed << a << endl;保留3位小数，fixed浮点转定点
还原
cout << setprecision(6) ; 1.控制位数为6；
cout.unsetf(ios::fixed) << a << endl; 2.定点改浮点
4.字符型
（1）c++中，cin输入自动忽略回车和空格
（2）setw()可以设置单个输出的宽度，left可以设置字符的停靠位置
setw(4) 设置宽度为4 头文件 #include

a b 相隔6个字符
5.布尔类型
程序默认以0和1的方式输出布尔类型数据
boolalpha 以布尔类型方式输出布尔类型数据
noboolalpha 取消布尔形式输出

布尔类型可以参与计算，但结果只是数值，不是布尔类型

ture false 0 1 0

（9）string字符串：

C语言中有字符串类型的常量，却没有字符串类型的变量
c风格字符串

指针一定要指向一个合法的空间才能使用。
以下有警告，因为指针（可变）指向了常量（不可变）。

加上const 变为只读后，警告消除

1.c++风格字符串 string
（1）c++中有直接使用的字符串类型string
（2）string 不是关键字，不是基本数据类型
（3）string是自定义出来的类-----什么是类？
string:c++风格的字符串
是一个类，通过类可以申请一个对象（数据类型和变量之间的关系）
类只是一个类型，string申请的对象才是一个变量
2.赋值方法

S5(4,’x’); 打印出来4个x xxxx
S6(4,65); 打印出来4个A AAAA
S7 （s1,3）,从第3个后面开始打印 adsafad
S8（s1,3,4） ,从第3个后面开始打印4个； adsa
S9（s1.c_str()+3,s1.c_str()+8） ,从第3个打印到第8个(前闭后开区间） adsa
String （自定义的类）和Qstring 可以通过C语言（基本数据类型char）交换

s = ss;
只读字符串 const char p = s.c_str();
C语言中可以char p = “abcd”;
C++中不可以char* p = “abcd”
;
sizeof()无法用于计算string类型数据中字符个数
需要求取字符串字符个数
3.求取字符串字符个数

3.1.字符串元素表示方法：
（1）下标： str[] : 不检查越界问题
（2）at函数： str.at() : 会检查越界问题
下标和at函数都可以访问某一个位置的元素。
3.2.字符串大小比较
字符串可以直接进行大小比较

3.3重设字符串长度
str.resize(2); 重设字符串长度，超出部分直接舍弃 He
3.4遍历字符串字符的方法：
逐个遍历字符串内字符

4.字符串拼接
+=拼接
append拼接

插入insert()

抹除erase()
string::erase
string& erase (size_t pos = 0,size_t n = npos);
iterator erase (iterator position);
iterator erase(iterator first,iterator last);

拷贝copy

面向对象oop
堆空间的管理：

C++机器视觉
（8）arry
一维数组的容器

二维数组的容器

第二章引用与函数

1.核心语言：代码块，分支，循环，函数
2.C++标准库：包含C语言标准库（printf函数、scanf函数等）
3.STL标准模板库：
（1）数据结构
（2）算法
（3）迭代器

C++经常更新，添加内容先学一个基础部分，往一个方向发展（工作过程中学习），不要精通
1.数据类型：
（1）字符型：char
（2）整型： int
（3）浮点型： float 1符号位 8位指数 23小数
（4）双浮点型：double 1符号位 11位指数 52位小数
（5）空类型：void
（6）宽字符型：wchar_t
（7）布尔型：bool

2.类型修饰符：
（1）signed
（2）unsignes
（3）short
（4）long
3.枚举类型：（都是全局变量）
enum
{

}

3.引用reference 初级c++面试必问
（1）引用：别名（给一个对象取别名）
引用是一个别名，引用内部是一个优化了的 *const类型的指针
与const接近的是谁，const修饰的是谁 const修饰左边值

固定格式：类型名 &别名 = 同类型变量
引用符： &
引用：优先左匹配（数据类型）
指针和引用的区别：
（1）指针可以为空，引用不能
（2）指针可以指向其它地址，引用在初始化后就会进行绑定
（3）指针可以不被初始化，引用必须被初始化
（4）函数返回的指针不能作为左值，但函数返回的引用可以作为左值

引用的底层实现是通过const指针的方式实现的
（2） p是a的别名，修改p的值直接影响a的值（效果上与指针相同）
Int*p =a; 即p是a,a是p 给p赋值，即给a赋值
引用直接使用变量的地址

（3）引用必须被同类型变量初始化
类型名 &别名 = 同类型变量中的 = 同类型变量不能缺少
如： int &c; 是错的
Int &c = 10; 是对的
（4）指针与引用的区别
1.指针可以改变指向，引用不能
2.指针可以直接定义不初始化，引用不能
（5）一个引用有8个字节
通过间接方式，得出一个引用占据8字节空间
指针也是8字节空间
Struct A
{
Int a;
Char a;
}
Cout << sizeof(A) << endl; 8
（6）引用直接使用变量地址，不需要自行开辟空间
（7）总结
1.引用可以当作弱化版本的指针使用
面试题
（8）const只读（只能看不能改）
（1）c++中的const是具有强制性的

const int a = 10;（只读不能改）
int *p = &a;
*p =100;
以上三行代码
（1）在C语言中用指针后可以改（但有警告）
（2）在c++中直接不可运行
结论：c++中const只读，不能以任何形式修改（想想都不行）
？？？？？

1.数组的引用

（2）c++中的常量化
返回的是a的值
int func() const //const修饰返回值
{
static int a = 10;
return a; //返回的是a 的值
}
返回的是a的引用
int& func() const //const修饰返回值
{
static int a = 10;
return a; //返回的是a的引用
}

mutable 把一个被const修饰的变量重新变为变量
（9）作业
2.函数的引用

3.指针的引用

4.没有引用的引用
5….指针是拥有引用的
引用没有指针 c++不提供访问引用自己本身地址的方式，引用取地址得到的是原本被别名的变量的地址
引用没有引用

int main()
{
int a = 10;
int& p = a;
printf(“a:%p,p:%p\n”,&a,&p);
}

C语言中传值传地址不一定改变变量的值？？
（10）传引用，执行速度更快
传引用，参数位置不需要创建栈空间对象，不需要传参，执行速度更快，同时可以获取参数在程序中的计算结果反馈

（11）返回值与引用
返回值类型是整型那么返回的是a 的值，没有独立内存，不能被赋值
返回值类型是整型引用，那么返回的是a 本身，a在主函数中的内存一直存在，可以被赋值
不要试图返回一个栈空间局部变量的地址或者引用

结论：有自己独立内存的量可以放在等号左边（非只读）称为左值（既可以放在等号左边，也可以放在等号右边）
没有自己独立内存的量右值
正常

有警告（两个实质一样）

正常

=100 不行
去掉时 a 10 b 10

正常 a 100 b 100

（12）C语言和c++三目运算符的区别
C语言中不可运行，c++中可以

4.内联函数（记住，不怎么用得到）
inline:
定义：将内联函数本身在调用的位置展开（替换）
目的：为了提高程序运行效率
内联函数不存在函数调用，不应该存在递归
内联函数和普通函数的调用不一样，内联函数是在调用的位置进行替换（内联函数会将函数体直接替换到函数调用位置）
内联函数的函数体限制
（1）内联函数内的代码一般少于5行
（2）内联函数内的代码逻辑不能太复杂，不能有循环分支等复杂结构
（3）不能有递归
（4）能否通过inline申请取决于编译器
内联函数效果上和宏定义类似，但是做入参检查
内联函数运行上比函数调用快
缺点：内联函数结构过于简单
类当中的函数默认是inline关键字申请的
C语言的内联：（C语言用宏函数define实现内联） C++的内联

宏定义只做简单替换，也可以带参，不做入参检查函数做入参检查

练习：写一个内联函数，实现大小写转换

inline: 没有强制性规定，如果代码不符合inline的规定，通常会将其转换为普通函数
内联函数效率比较高
在类内部实现的方法一般都是内联函数，就算没有显示的声明inline（头文件只能放声明）
面试题
将以下代码改为C语言代码，要求在.c文件中能编译通过（要提交.c文件）
inline float max (float c1,float c2)
{
return c1>c2?c1:c2;
}
void main()
{
cout <<”请输入2个浮点数：”;
float c1,float c2;
cin >> c1 >> c2;
cout << max(c1,c2) << endl;
}

5.重载函数
函数重载是在汇编中体现出来的 g++ -S HANSHU.cpp –o 1.s 汇编文件
函数重载：写重载函数的过程
重载函数：函数名相同，参数列表不一致的一系列函数
C++函数名可以重复
C++中支持多个相同名字的函数

C语言中通过函数名判断是否是同一个函数
C++中在函数名一致的情况下通过判断参数的数量、类型、顺序来判断是否是同一个函数
函数调用时会优先调用最匹配的函数
Double类型数据，在传参时可以内部自动转换成整型或字符串型
当同时存在整型和浮点型参数的函数重载的时候，调用会出现二异性
所以，程序员最好是将需要的函数重载实现出来
重载函数中：
同名函数根据
（1）形参类型不一样
（2）形参个数不一样
（3）形参顺序不一样
返回值类型与重载无关
不能根据返回值类型进行重载，不能根据形参名
与返回值、形参名无关

（1）实参的匹配，实参首先进行数据类型完全对应的匹配
（2）转换之后的匹配，在没有完全匹配的情况下，会进行类型自动转换后的匹配
可以重载的原因：因为在编译阶段对不同形参的函数进行了重命名
例子
1.是重载函数，通过编译，但调用fun(a)有问题，调用fun(10)无问题

2.是重载函数，通过编译，调用fun(a)无问题，fun(10)无问题
const int &x=10;
cout << &x << endl;当且仅当引用前面有const修饰时，(引用可以用常量初始化)引用可以指向常量；
此时，引用恢复指针特性，拥有自己的指针空间
常量没有地址

3.三个是重载函数，编译可以通过 fun(a)

Fun(a) int a= 10; 1和2 有问题

2和3有问题 const int b = 20; fun(b);

1和3有问题 fun(1)

Void fun(int &a) {}
Const int b= 20; 不可以

Void fun(const int &a){} 比较好
6.默认参数函数
parameter参数传参时从左往右，依次赋值

默认参数函数效果上等同于多个同名函数的重载，需要注意有无相应的函数重载，以免调用出现二异性
在有默认参数的情况下可以不用写函数重载
C++入参检查更加严格
默认参数函数：在形参的位置给形参进行初始化
默认参数在函数声明时声明
默认参数函数，声明的时候加默认值，实现不加默认值
如果声明时不加默认值，实现时默认值无效，必须传参调用
如果声明实现都有默认值，会导致编译器与程序员信任关系破裂，不能通过编译
实参与形参，实参是从左往右进行匹配
定义默认参数函数，默认参数需要从右往左进行匹配（函数声明时初始化），中间不能跳过

需要避免默认参数函数与函数重载之间的二义性

第三章类的封装

1.C语言中struct与c++中类的比较
C语言中的结构体 c++中的结构体

1.C++对结构体的优化：
1.定义对象可以省略关键字struct
2.结构体内可以放函数
2.定义对象和对象调用方法

(1)结构体
struct Score
{
public:

 private:

}

(2)类
class Score
{
public:

 private:

}
(3)结构体和类的区别：
1.1 关键字不同
定义时关键字：struct class
1.2 默认权限不同
struct默认是public class默认是private
1.2.1struct默认是public，public可以省略

1.2.2class默认是private，public不可以省略

2.类的权限
struct：默认公共不符合面向对象思想
class：默认私有符合面向对象思想
（1）私有
不可通过外部访问
（2）公共
可以通过外部访问

Struct C语言中必须写struct，c++中可以写，不写。

结构体也可写数据处理（算法、函数）
s1为对象
member variable 成员变量
member function 成员函数
1.1member function类中成员函数的调用：
具体对象指针引用
定义对象数组
（1）通过对象调用

（2）通过指针调用成员函数：

（3）通过引用和对象数组调用

1.2定义成员函数
1.2.1类的内部定义成员函数
例如：set_score函数

（1）只读函数
凡是不对类内数据作修改的成员函数，都可以设置成只读函数，增加代码重用性
凡是函数内不对参数作修改的，参数位置可以设置成只读引用，增加代码重用性
函数+const 意为对函数内容不可修改

Int const 和const int 没有区别 const void show()；和void const show();写法都不对
（2）this指针
this指针指向类本身，可以访问类内数据

1.2.2类的外部定义成员函数
类名+：：+函数名

1.2.3类的定义放在 .h文件中
.c文件

函数的返回值是：const const int fun();
成员函数是const 表示这个成员函数不会改变数据成员的值
对象有const类型的，表示对象的数据成员的值不会改变
通过对象的成员函数可能改变对象的值，所以成员函数也有const类型的

Class A
{
Public:
Void fun() const
{

}
}
const类型的对象只能调用const类型的成员函数
非const类型的对象可以调用const类型的成员函数，也可以调用非const类型的成员函数

c:对数据进行打包
程序：（数据结构）+（算法）

c++:对数据与算法进行打包
程序：（数据结构+算法）

程序就是许多对象在计算机中相继表现自己对象又是一个个程序实体
：：使用域限定符访问指定的作用域

3.类的初始化
类（对象）的初始化：
使用构造进行初始化：在对象实例化时会显调用构造函数
构造函数函数名与类名相同，并且没有返回值类型
如果没有显式的声明构造函数，c++会自己给类添加无参构造函数
如果有显式声明有参构造函数，c++不会自己添加无参构造函数
对象初始化：const必须初始化
1.构造函数：在对象实例化前进行调用初始化构造器：主要使用与引用与const变量的初始化
2．析构函数：在对象销毁前调用
1.构造函数（类、数据的初始化）
（1）构造函数
只读对象必须被初始化-----类需要有初始化的方式
类定义对象：对象有数据成员private
构造函数：函数名 = 类名没有返回值，会在类对象定义时自动调用，用于数据初始化可以被重载
自动调用一个函数public 自动将数据成员初始化（构造函数）
（2）类外构造函数的写法

（3）初始化构造器：
定义：用于对成员函数进行初始化
使用初始化构造器的原因：
（1）因为c++引用与const变量必须被初始化，所有需要使用到初始化构造器
（2）区别：初始化构造器的效率比较高

类内引用在初始化构造器中的初始化

函数+const 意为对函数内容不可修改
（4）临时对象
直接通过构造函数创建的对象是临时对象，生命周期只有一行代码，到分号结束，可以正常调用函数

2.析构函数
析构函数：函数名 = ~类名

释放对象：自动调用一个函数public 自动释放数据成员初始化时申请的空间（析构函数）
（1）析构函数（类里面默认有的）
在对象被释放时调用
对象生存周期最后一个调用的函数

使用堆空间

（2）类外析构函数的写法：

3.构造与析构顺序

4.面向对象（OOP）包含：（面试必问题）
1.类的封装：（面试时候写封装string）
封装：把属性和方法，放在同一个结构体中，并且合理的设置权限------整个过程叫封装
（1）将不同类型的数据以及这些数据的算法组成一个集合。

  （2）将一些数据或算法定义成private，而一些数据或算法定义成public，对外提供接口。

对内部数据进一步封装:
通过公有函数对私有数据进行赋值

（1）封装：对数据进行保护
权限：
private:不能通过外部进行访问（点的方式），通常提供接口方法（函数）间接的改变
public:公共权限，可以通过外部直接进行访问

struct默认public权限
class默认private权限
2.继承
3.多态
4.抽象 ADT

构造函数：类里拥有的一个与自己名字相同的函数，没有返回值类型，用于初始化对象
构造函数汇中对象实例化前调用
对象实例化：通过类申请一个对象

5.类中成员变量命名规则
m----member
n----int
double ------d
string -----str
如：m_strName

第四章堆空间与深拷贝

（1）C:malloc
malloc申请堆空间堆区域映射（map）区库函数
-> 128k -> 链接空间 free() malloc free
加头文件 #include <mallo.h> 不会调用构造函数和析构函数
（Student *）强制转换

（2）C++：关键字new
new申请堆空间，自动调用构造函数 delete释放堆空间，自动调用析构函数
new堆区域、映射区、静态数据段
当希望自己控制生存周期时，需要使用堆空间
空间大小有运行时需要改变的需求时，使用堆空间
※1.new
（1）new申请的堆空间大小根据类型判断
（2）new申请出来的指针有类型
（3）new申请堆空间的过程会调用构造函数。
（4）new可以连续申请多个空间 p = new A[5];，也可以连续释放整个数组空间 delete [] p;

1.申请一个普通变量 int *p = new int; 释放空间：delete p;

2.申请数组 int *p = new int[10]; 释放空间：delete []p;
3.申请结构体 CStudent p = new CStudent; 释放空间：delete p;
结构体中数组赋值用strcpy, strcpy(p->sName,”aaa”);
p->nNum = 1000;
4.申请结构体数组 CStudent p = new CStudent[10]; 释放空间：delete []p;
结构体数组中数组赋值用strcpy, strcpy(p[0].sName,”aaa”);
P[0].nNum = 1000;
5.申请指针数组 CStudent ps = new CStudent[100]; 释放空间：delete []ps;
注意：new的错误写法：int p1 = new int(5); 意为初始化堆空间语句，申请一个int,并用5初始化申请的这个int

（3）区别
（1）malloc不会调用构造函数，new会调用构造函数
（2）malloc是库函数，new是关键字
（1）free不会调用析构函数，delete会调用构造函数
（2）free是库函数，delete是关键字

练习：
写一个函数申请一块堆空间，再写一个函数添加数据到堆空间中，再写一个函数打印出来，再写一个释放堆空间
在main()中调用上面四个函数

6．拷贝
系统默认提供的拷贝构造是浅拷贝----最简单的值与值的赋值
当类内存在指针的时候，需要给指针单独开辟堆空间----必须手动写深拷贝
1111111构造 22222拷贝 333析构

用g++ 文件名 –fno-elide-constructors 多了两次拷贝和两次析构，未看到的对象为匿名对象

（1）调用拷贝构造的三种情况：
（1）定义对象时，使用对象进行初始化另外一个对象
（2）实参拷贝给形参时，除了引用（传递一个对象到子函数中）
以下例子调用了两次拷贝构造函数， s3=s2; fun(s2) 分别调用一次

（3）返回值返回时（返回一个静态对象时，创建临时对象，也调用拷贝构造函数）

两个不同类型的拷贝构造函数

Const类型的拷贝构造函数既可以调用const类型的对象，又可以调用非const类型的对象，所以使用const类型的拷贝构造函数

赋值，拷贝行为

（2）C++
1.浅拷贝：默认的拷贝方式
拷贝构造没有申请新的堆空间
使用拷贝构造函数的原因：
默认拷贝构造函数功能：一个对象的所有数据成员赋值给另外一个对象的数据成员
2.深拷贝：拷贝构造申请新的堆空间
使用条件：成员变量有指针，会使用到堆空间

第五章静态与友元

1.类中静态成员 static
Static：使变量不再与对象进行绑定
static成员变量：是共有的，所有对象共有的，相当于类中的全局变量，必须在类外进行初始化
static成员函数：使方法不再与对象进行绑定，属于类方法
限制:static方法不能访问对象成员变量，可以访问static变量

（1）类外初始化方式
1.静态成员属性
类的静态成员初始化（多用于计数，也可以辅助编号增长）

C++将静态存储区的初始化和未初始化区域整合在一起
类的静态成员属性不能在类内完成初始化

2.静态成员函数（在类内书写）
静态成员函数----属于整个类而不属于某个对象

（2）构造函数

（3）对象之间的共享
实例化对象 book b1

（4）通过类调用，访问对象

（5）使用析构函数

（6）添加一个函数

（7）static方法通过对象和类调用

1.1C语言中static作用
（1）static修饰局部变量：变量将申请到静态数据段
（2）static修饰全局变量：不能被外部文件访问
（3）static修饰函数：不能被外部文件访问
1.2c++中static作用
（1）static修饰类成员变量：使成员变量与对象脱离绑定，与类进行绑定，必须在类外进行初始化
（2）static修饰类成员函数：使成员函数与对象脱离绑定，与类进行绑定，只能访问static成员变量
1.3类中的static成员变量：
（1）在类外进行初始化，初始化时才会申请空间
1.4类中的static成员函数：
（1）不能使用类中的普通成员变量，能够使用static成员变量
8.友元函数
关键字：friend
friend用于修饰函数，修饰的函数是全局函数，但是可以视为类内部函数

1.类调用全局函数的方法----友元函数

保护参数位置数据，加const

3.定义类外的友元函数的方法

（1）单一职责原则 SRP:

第六章继承与多态

1.继承
B继承于A
A –> B
A:父类，基类
B：子类，派生类
（1）普通的继承方式
•class New:public Old
class 子类：继承权限父类名{}；
子类中会包含父类中所有的变量与方法
父类中private对子类不可见

1.1.1子类构造函数初始化父类数据的方法
子类构造函数位置，在使用初始化构造器的时候，不能直接对父类的数据赋值（初始化），但是可以通过调用父类的构造函数完成父类数据初始化。

1.1.2类的分解
当两个或两个以上类，有一部分共有属性，并且这些类有符合逻辑的关系，可以把共有属性提取出来，放置新的类中，由其继承
以上过程称为类的分解。

（2）权限
private：私有的
不可被外部访问，也不可被直接子类直接访问
protected：受保护的
不可被外部访问，但可以让自己的子类进行内部调用（对子类可见）
public：公共的
既可以被外部访问，也可以让自己子类进行内部访问

父类 private protected public
继承权限private protected public
子类 private（private） private（private） private（private）
private（protected） protected（protected） protected（protected）
private（public） protected（public） public（public）

Public继承

Protected继承
Protected数据，类外不能用，子类可以用

（3）菱形继承
在菱形关系继承中，两个父类继承自同一个父类（爷爷类），会同时继承到父类（爷爷类），导致最终的子类多出一份父类（爷爷类）的数据
使用虚继承，两个父类，会多出一个虚类表，和一个虚类指针，共计8字节
最终的子类，则只包含一份父类（爷爷类），以及两个父类的虚类表和虚类指针，只会比开始的父类多16个字节

B,C -> D D继承于B,C

（4）虚函数：解决菱形继承
virtual：
作用：
（1）声明在函数前，使函数变为虚函数
纯虚函数：没有实现
抽象类：包含纯虚函数的类，不能被实例化
1.1虚函数和纯虚函数的区别
虚函数：类可以实例化对象，虚函数可以在子类中被覆盖，有函数实现
（在父类中有实现，但会被在子类中覆盖，父类可以实例化）
纯虚函数：类不可以被实例化对象，纯虚函数必须在子类中覆盖，没有函数实现， = 0；
（在父类中没有实现，必须在子类中被覆盖，父类不可实例化（抽象类））
（5）单继承：
单继承：先构造基类，再构造派生类，先析构派生类，再析构基类
（6）多继承
多继承：在继承表中从左往右构造，再从右往左析构
C++ 支持多继承
class类名：继承权限类名，继承权限类名
（7）虚继承：（笔试题中常见）
虚继承先构造
防止继承同一个东西
A->B：实例化B，AB的构造、析构分别是什么顺序
A->C：实例化C，ABC的构造、析构分别是什么顺序
B->C：

A->C：实例化C，ABC的构造、析构分别是什么顺序
虚B->C：
使用虚继承，目的：省内存以及，避免函数调用的二异性

（8）里氏替换LSP原则：
LSP:子类应当实现父类中的所有方法，在父类被正常调用的地方，如果被替换为子类，也需要能够正常运行
如果出现了子类没有办法完全实现父类的情况，就需要考虑断开继承关系
多态：
（9）赋值兼容规则：
派生类的对象可以赋值给基类对象。
派生类的对象可以初始化基类的引用。
派生类对象的地址可以赋值给指向基类的指针
类与类之间的关系：类内嵌套继承虚继承
2.多态
1.定义
一个对象，用其它类的方式表示

2.三种赋值规则
（1）父类对象，可以用子类对象初始化

（2）增加虚函数概念，解决同名函数中指针问题

为了达到上述效果，增加了虚函数概念
会在B类中增加一张虚函数表，用于存放两个同名函数地址，调用时，虚函数指针，自己判断，发送偏移，调用B类中的函数

（3）父类引用，可以用子类对象初始化
引用也是引用的B类对象中A类的部分数据
K是b的别名，应当调用b的函数，也需要virtual 关键字，使得函数调用时发生偏移，调用B类函数

3.纯虚函数
在多态思想中，想要调用子类的某个函数，父类又不需要具体实现，可以设置为纯虚函数
一旦类中，出现纯虚函数，这个类称为抽象类，不能定义对象

4.多态两种用法
（1）有继承关系的所有类对象，可以统一管理
（2）可以给一个函数接口提供多种调用方式

多态：使用父类指针指向不同的子类，使用这个指针可以实现调用不同的函数
使用内容：赋值兼容规则，虚函数

Hello world hello
A类中fun前加virtual 关键字时，p->fun(); world(打印出来的是B类中的函数)
继承中出现同名函数

5.练习
题目：
公司中有：经理销售销售经理技术员
1.经理：固定薪资 8000
2.销售：提成 5% 150000
3.技术员：50/h 一个月工作100小时
4.销售经理：底薪2500 提成1.5% 管8个销售员
设计类：
计算每类人薪资并显示
要求：工号自增；职位不一；一个数组存储；

第七章运算符重载

1.+、-、+=、*

6.前置-- 和后置—

3.输出运算符的重载

4.输入运算符的重载

练习

5.String封装（面试题）
构造函数，拷贝构造函数， = 手写

第八章模板与STL

6.模板函数
泛型编程
（1）模板函数的表示方式
模板函数：把只是数据类型不同的不同函数合成一个函数。
标志：(T只是名字，可以自定义，通常使用T)
template 定义了一个模板类型
void Swap(T& a, T& b)
{
T temp;
temp = a;
a= b;
b = temp;
}
从汇编代码的角度看，函数模板在没有调用的时候，没有实现，有调用产生时，会衍生出对应的函数实现
函数模板，一次编译，多次实现
优先调用最匹配的函数，接着会去判断有无对应参数数量的函数模板。如果函数模板不匹配，再去自动转换类型
1.1单个模板函数
函数重载方式：模板函数方式：

1.2多个模板函数方式：

1.3 模板函数与类
类内加模板函数：类外加模板函数：

1.4类模板
类模板要衍生出模板类的时候，需要优先通过<类型>的方式，实例化模板类型

类外

写模板不用友元，因为这种情况下友元只能写在类内

（2）STL标准模板库
Standard Template Library,STL 是惠普实验室开发的一系列软件
容器：vector
迭代器：本身就是指针
算法：
容器
1.1容器vector
多用于学生管理系统，不需删除

下标访问不检查越界
v.at[10]=100;检查越界

1.2迭代器
在实际使用中，迭代器相当于指针，但迭代器不是指针
打印begin 位置的地址

迭代器遍历

1.2.1使用迭代器抹除

1.2.2使用迭代器排序
#include 算法头文件 sort(开始位置，结束位置，排序规则)

Vector容器没有自己的排序方式，只能通过调用算法库的排序算法辅助排序

Vector内部是一个长度可变的数组
数组删除元素的方法：
1.伪删
2.真删

1.2.3vector删除

1.2.4Vector内放指针
hello

1.2.5容器内存放什么

1.3 map映射
Map：映射，键值对
（1）映射关系容器------内部实现是二叉树会自动从小到大排序
（2）Map容器的所有便利，是建立在有对应key值的情况
（3）多用于人口普查，图书馆数据量大的（上百万的）
元素小于7：链表 n
大于7：红黑树 logn

1.遍历排序
会自动从小到大排序

2.删除
（1）可以直接通过key值删除元素
Key-----value

（2）也可以通过迭代器位置删除
It = m.find(1067); 可以通过find函数找到迭代器位置
m.erase(it);

3.插入元素
Map容器插入数据，如果通过的insert函数插入，需要注意：
（1）如果只插入数据，可以通过返回值判断，是否成功插入
（2）如果，有迭代器位置作为参数参与插入，那么，无法直接判断是否插入成功-----原有Key对应的value不覆盖
（3）如果直接通过下标插入，那么，原有key对应的value会被覆盖
It = m.begin();
m.insert(it,pair<int,string> (1007，“马坝”));

1.4 list容器
内部实现是双向链表
头文件#include
多用于高铁
1.赋值方式
不能通过下标访问元素-----内部实现不是数组，空间不连续

2.内部自带排序算法

3.删除

第九章异常处理

异常
提出问题把问题解决（出现问题以至于系统不会直接崩溃）
丢出去throw和接收catch到的不是同一个，是拷贝
throw可以结束当前函数，直接跳转到catch位置

throw可以结束当前函数，直接跳转到catch位置
throw抛出异常
catch捕获异常

其它异常

抛出异常后，函数调用过程中出现的栈空间对象会依次释放…… 栈解旋

第十章文件处理

7.c++文件输入输出

学生管理系统菜单
Menu.h

Menu.cpp
功能、代码、界面

C++基础知识点小结相关推荐

python基础知识点小结(2021/2/9)
python基础知识点小结(2021/2/9)持续更新中~~ 入门小知识 cmd 在cmd上进行python,直接输入 python\quad pythonpython 退出cmd输入 exit()\ ...
python语言基础知识点总结_Python语言的12个基础知识点小结
Python语言的12个基础知识点小结 python编程中常用的12种基础知识总结:正则表达式替换,遍历目录方法,列表按列排序.去重,字典排序,字典.列表.字符串互转,时间对象操作,命令行参数解析(g ...
读书笔记 --- [基础知识点] 小结2
1. TCP和UDP的区别 \ TCP UDP 是否连接面向连接无连接是否可靠可靠不可靠连接对象个数 1对1 1对1 或1 对多传输方式面向字节面向报文首部开销 20字节 8字节 ...
读书笔记 --- [基础知识点] 小结3
1. cookie与session的区别参考 cookie机制 Cookie是服务器在本地机器上存储的小段文本,并随每一次发送至同一个服务器.网络服务器用HTTP头向客户端发送cookies,在客户 ...
计算机知识必备,小结||计算机基础知识点十（必备）
原标题:小结||计算机基础知识点十(必备) 451.数据库管理系统主要功能: (1)数据定义功能 (2)数据操纵功能 (3)数据库的运行管理 (4)数据库的建立和维护功能 452.数据库不仅要反映数据 ...
好程序员分享24个canvas基础知识小结
好程序员分享24个canvas基础知识小结,非常全面详尽,推荐给大家. 现把canvas的知识点总结如下,以便随时查阅. 1.填充矩形 fillRect(x,y,width,height); 2.绘制 ...
Android技能树 — 树基础知识小结(一)
前言: 现在安卓面试,对于数据结构的问题也越来越多了,也经常看到别人发的面试题都是问什么红黑树,二叉树查找等,所以我们虽然不会马上就会各种难的面试题,但起码树的基础知识还是要会的,这样才能去进一步学. ...
jdbctemplate 开启事务_SpringBoot 系列教程之事务隔离级别知识点小结
上一篇博文介绍了声明式事务@Transactional的简单使用姿势,最文章的最后给出了这个注解的多个属性,本文将着重放在事务隔离级别的知识点上,并通过实例演示不同的事务隔离级别下,脏读.不可重复读. ...
好程序员分享24个canvas基础知识小结 1
好程序员分享24个canvas基础知识小结,非常全面详尽,推荐给大家. 现把canvas的知识点总结如下,以便随时查阅. 1.填充矩形 fillRect(x,y,width,height); 2.绘制 ...

C++基础知识点小结

C++基础知识点小结

第一章绪论

（1）cout 输出流的对象

（2）cin输入对象

（3）endl 输出控制符/操控符

（4）标识符

（5）命名空间（namespace）

（6）左值：

（7）右值

（8）c++赋值方式（整型和浮点型）

（9）string字符串：

第二章引用与函数

第三章类的封装

第四章堆空间与深拷贝

第五章静态与友元

第六章继承与多态

第七章运算符重载

第八章模板与STL

第九章异常处理

第十章文件处理

C++基础知识点小结相关推荐

最新文章

热门文章

C++基础知识点小结

C++基础知识点小结

第一章 绪论

（1）cout 输出流的对象

（2）cin输入对象

（3）endl 输出控制符/操控符

（4）标识符

（5）命名空间（namespace）

（6）左值：

（7）右值

（8）c++赋值方式（整型和浮点型）

（9）string字符串：

第二章 引用与函数

第三章 类的封装

第四章 堆空间与深拷贝

第五章 静态与友元

第六章 继承与多态

第七章 运算符重载

第八章 模板与STL

第九章 异常处理

第十章 文件处理

C++基础知识点小结相关推荐

最新文章

热门文章

第一章绪论

第二章引用与函数

第三章类的封装

第四章堆空间与深拷贝

第五章静态与友元

第六章继承与多态

第七章运算符重载

第八章模板与STL

第九章异常处理

第十章文件处理