C++知识点总结,c语言考试重点知识点总结
一、重点C考知识点的汇总数据类型。获取PDF版本和详细的C关键知识点教程。可以关闭微信公众号：“C和C plus plus”回复：“C KS”
1.整数函数：整数变量表示整数类型的数据。
Int-4字节
unsigned int-无符号整数，占4个字节
2.sizeof关键字的作用：sizeof关键字可以用来统计数据类型的内存大小。
3.浮点函数：用来表示小数。
浮点变量有两种类型：
单精度浮点型占用4个字节，并提供一个6位有效数组。
双精度Double占用8个字节，提供15个有效数字。
4.数字常数4.1数字常数整数常数可以用三种不同的方式表示：
十进制整数。如1357，-432，0等。
八进制整数。在一个常数的开头加一个数0意味着它是一个用八进制数表示的常数。
十六进制整数。在常数的开头加上一个数字0和一个英文字母X(或X)意味着它是一个十六进制形式的常数。
4.2浮点数的表示浮点数可以用两种不同的方式表示：
十进制形式。如21.456，-7.98等。
指数形式(即浮点形式)
5.字符常量功能：字符变量用于显示单个字符。
语法：char ch= a
1:显示字符变量时，将字符括在单引号中，而不是双引号中。
注意：单引号只能包含一个字符，不能包含字符串。
而C和C中的字符变量只占1个字节。
字符常量只包含一个字符是非法的，例如“AB”
字符区分大小写，比如 A 和 A 是两个不同的字符常量。
类型变量不将字符本身存储在内存中，而是将相应的ASCII代码放在存储单元中。
6.字符串常量函数：用来表示一串字符。
两种风格
c风格字符串：char变量名[]=字符串值 char str 1[]= hello world ；注意：C风格的字符串应该用双引号括起来。
C style string: string变量名=字符串值 string str= hello world注意：C风格的字符串，需要添加头文件==#include string==
字符串常量是双引号。
Chang:字符串“abc”在内存中占多少字节？
回答：占用4个字节而不是3个字节。编译系统会自动在字符串末尾加一个 \ 0 作为字符串的结尾。但是 \ 0 不是字符串的一部分，它只是作为字符串的结束标记。
字符串常量“ABC \ n”包含多少个字符？
答：不是5个字符而是4个字符，其中“\ n”是转义字符，但是占用内存5个字节。
7.布尔类型的布尔函数：布尔数据类型代表真或假值。
bool类型只有两个值：
True—true(本质是1)
False—False(本质上是0)
Bool类型占用1个字节的大小。
8.数据输入输出关键词：cin，cout
语法：cin变量1变量2.变量n，cout表达式1表达式2.表情
cout a，b，c；//错误，不能一次插入多个项目。
cout a b c；//正确，这是一个表达式，作为项
cin公元前200年至公元200年；9.变量命名规则C规定标识符只能由字母、数字和下划线组成，第一个字符必须是字母或下划线。
不能是关键字
区分大小写
10.局部变量在函数内部定义的变量就是局部变量，它们只在这个函数的范围内有效，也就是说，只能在这个函数内部使用，不能在这个函数外部使用。
参数也是一个局部变量。
1.全局变量。定义在函数外部的变量是外部变量，称为全局变量。
二、C重点考试知识总结运算符1、算术运算符
注意：
两个整数相除的结果还是一个整数(这里不进行四舍五入，小数点后的数字直接掉)。如果C中的两位小数中有一位可以是除运算数据，那么运算的结果就是double，因为在运算过程中C中的所有浮点数据都被当作double数据处理。只有整数变量可以取模，两位小数不能取模。在除法运算中，当除数不能以0为模时，除数不能为0。
后置运算符单独使用没有什么区别。
在计算表达式之前递增变量。
增量后，首先计算表达式，然后处理变量。
请详细阅读下面的代码并理解它。
//增量
int main() {
//后增量
int a=10
a；//相当于a=a 1
cout a endl//11
//提前增量
int b=10
b；
cout b endl//11
//差异
//首先预递增变量，然后计算表达式。
int a2=10
int b2=a2 * 10
cout b2 endl//110
//Post-increment首先计算表达式，然后执行变量。
int a3=10
int b3=a3 * 10
cout b3 endl//100
系统(“暂停”)；
返回0；
}2.赋值运算符的作用：用于将表达式的值赋给变量。
请仔细看表格。
3.比较运算符：用于比较表达式并返回真值或假值。
4.逻辑运算符的作用：用于根据表达式的值返回真值或假值。
！操作员是三者中最高的。
三。C重点考试知识点的总结过程结构1。选择结构1.1。if语句if语句比较简单，经常和else一起使用，可以嵌套。
1.2.三元算子的作用：简单的判断是通过三元算子实现的。
语法：表达式1？表情2:表情3
如果表达式1的值为真，执行表达式2，返回表达式2的结果；
如果表达式1的值为false，则执行表达式3并返回表达式3的结果。
这里经常出程序阅读题！
1.3.switch语句的作用：执行多条件分支语句。
语法：
开关(表达式)
{
案例一：执行语句；打破；
案例二：执行语句；打破；
.
默认值：执行语句；打破；
}switch语句中的表达式类型只能是整数或字符。
如果案例中没有断点，程序将一直向下执行。
2.圆形结构2.1。while函数：满足循环条件时，执行循环语句。
语法：while(循环条件){loop语句}
说明：只要循环条件的结果为真，就会执行循环语句。
2.2.do…while函数：满足循环条件并执行循环语句。
语法：do{ loop statement} while(循环条件)；
注意：与while的区别在于do…while会先执行一个循环语句，然后判断循环条件(这里经常测试这两个区域)
不要，记住不管怎样，do…while必然会执行一个循环语句)
2.3.forfor循环中的表达式应该用分号分隔。
int main() {
for(int I=0；i 10我)
{
cout i endl
}
系统(“暂停”)；
返回0；
}3.跳转语句3.1。break函数：用于跳出选择结构或循环结构。
3.2.continue的作用：在循环语句中，跳过这个循环中剩余未执行的语句，继续执行下一个循环。
注意：continue不会结束整个循环，break会跳出循环。
四、C重点考试知识总结数组数组：所谓数组就是存储同一类型数据元素的集合。
数组中的每个数据元素都是相同的数据类型。
数组由连续的内存位置组成。
1.一维数组。定义一维数组的三种方法：
键入数据数组名称[数组长度]；(常用，只知道另外两个)
类型数据数组名称[数组长度]={值1，值2.};
类型数据数组名称[]={值1，值2.};
int评分[10]；
int score2[10]={ 100，90，80，70，60，50，40，30，20，10 }；
int score3[]={ 100，90，80，70，60，50，40，30，20，10 }；数组中的下标是从0开始的索引。
当所有数组元素都被赋予初始值时，数组长度可以不指定。
直接打印数组名，可以查看数组占用内存的第一个地址。
数组名的Sizeof可以得到整个数组的内存空间。
以上三种方法不要求知道全部，但都需要看到，防止程序纠错过程中的无序。
一维数组初始化
定义数组时，会给数组的元素赋予初始值。例如
int a[10]={0，1，2，3，4，5，6，7，8，9 }；您只能为某些元素赋值。例如
int a[10]={0，1，2，3，4 }；如果希望数组中的所有元素的值都为1，可以编写
int a[10]={1，1，1，1，1，1，1，1，1，1，1 }；
int a[10]={ 1 * 10 }；//写错了。你不能给整个数组赋值初始值。当给所有数组元素赋值初始值时，不能指定数组长度。
int a[5]={1，2，3，4，5 }；
//可以写成
int a[]={1，2，3，4，5 }；2.二维数组。定义二维数组的四种方法：
类型数据数组名称[行数][列数]；类型数据数组名称[行数][列数]={ {数据1，数据2}，{数据3，数据4 } }；类型数据数组名称[行数][列数]={数据1，数据2，数据3，数据4 }；类型数据数组名称[][列数]={数据1，数据2，数据3，数据4 }；int arr[2][3]；
int arr2[2][3]=
{
{1,2,3},
{4,5,6}
};
int arr3[2][3]={ 1，2，3，4，5，6 }；
int arr4[][3]={ 1，2，3，4，5，6 }；在以上四个定义中，第二个更直观，提高了代码的可读性。如果所有元素都给了初始值，定义数组时可以省略第一维的长度，但是第二维的长度不能省略。
3.字符数组用来存储字符数据的数组是一个字符数组，字符数组中的一个元素存储一个字符。
定义：
char c[10]={“I”，“a”，“m”，“h”，“a”，“p”，“p”，“y”}；任务：
只能用赋值语句给字符数组的元素赋值，而不能给整个数组赋值。
char c[5]；
C={“C”，“h”，“I”，“n”，“a”}；//错误，不能一次赋值整个数组。
C[0]=C；c[1]=h；c[2]=I；c[3]=n；c[4]=a；//给数组元素赋值，正确
int a[5]，b[5]={1，2，3，4，5 }；
a=b；//错误，不能给整个数组赋值。
a[0]=b[0]；//正确，引用数组元素4、字符串函数字符串连接函数strcat字符串复制函数strcpy字符串比较函数strcmp字符串长度函数strlen V、C重点考试知识总结函数函数作用：封装一段常用代码，减少重复代码。
1、函数定义函数定义一般有五个主要步骤：
返回值类型函数名称参数列表列函数体语句返回表达式返回值类型函数名称(参数列表)
{
函数体语句
返回表达式
}返回值类型：函数可以返回值。在函数定义中
函数名：给函数命名。
参数列表：使用该函数时传入的数据。
函数语句：花括号中的代码，函数中要执行的语句。
返回表达式：链接到返回值类型，函数执行后返回相应的数据。
示例：定义一个加法函数将两个数相加。
//函数定义
int add(整数1，整数2)
{
int sum=num1 num2
返回总和；
} 2.函数调用函数：使用已定义的函数。
语法：函数名(参数)
int result=add(10，20)；函数定义中的括号称为形参，调用函数时传入的参数称为实参。
比如这里的num1和num2是形式参数，10和20是实际参数。
函数不能嵌套在定义中，但可以嵌套在调用中(通用测试)
3.函数声明函数可以声明多次，但函数的定义只能一次。
//可以多次声明，只能定义一次。
//声明
int max(int a，int b)；
int max(int a，int b)；
//定义
int max(int a，int b)
{
回个b？甲：乙；
}
int main() {
int a=100
int b=200
cout max(a，b)endl；
系统(“暂停”)；
返回0；
} 4.值传递所谓值传递，即单向传递，是指函数被调用时，实参将值传递给形参，但不能由形参传回实参。
当值被传递时，如果参数改变，不会影响实际参数(当值被传递时，参数不能修改实际参数)。请务必
而且记住，因为篇幅原因，我在这里就不解释了！
5.函数的默认参数在C中，函数的参数列表中的参数可以有默认值。
语法：返回值类型函数名(参数=默认值){}
int func(int a，int b=10，int c=10) {
返回一个b c；
}
//1.如果一个位置参数有一个默认值，那么从这个位置，从左到右，必须有一个默认值。
//2.如果函数被声明为具有默认值，则该函数在实现时不能有默认参数。
int func2(int a=10，int b=10)；
int func2(int a，int b) {
返回a b；
}
int main() {
cout ret= func(20，20)endl；
cout ret= func(100)endl；
系统(“暂停”)；
返回0；
}如果一个位置参数有默认值，它必须从这个位置从左到右有一个默认值。
如果一个函数被声明为具有默认值，那么它在实现时就不能有默认参数。
6.函数占位符参数C在函数的参数列表中可以有占位符参数，可以作为占位符使用。调用函数时必须填充这个位置。
语法：返回值类型函数名(数据类型){}
//函数占位符参数，也可以有默认参数。
void func(int a，int) {
cout 这是func endl
}
int main() {
func(10，10)；//必须填充占位符参数。
系统(“暂停”)；
返回0；
} 7.函数重载：函数名可以相同，这提高了可重用性。
函数重载满足条件：
函数名称相同，函数参数的类型、数量或顺序不同。注意：函数的返回值不能作为重载函数的条件。
8.重载运算符规则C有以下五个不能重载的运算符
重载运算符规则：
重载不能改变运算符的操作数(即操作数)的个数。重载不能改变运算符的优先级。重载不能改变运算符的组合。重载函数可以是类的成员函数，类的友元函数，或者既不是类的成员函数也不是友元函数的普通函数。什么时候应该使用成员函数和好友函数？两者有什么区别？()
一般单目算子重载为成员函数，双目算子(二元算子)重载为友元函数。
运算符函数是重载类的成员函数，它有一个参数。
operator函数是重载类的友元函数，它有两个参数。
只有重载" "(流插入运算符)和" "(流提取运算符)的函数可以重载为友元函数或普通函数，但不能定义为成员函数，因为参数是两种类型的转换运算符，只能重载为成员函数。
一元运算符：只有一个操作数，如！-(减号)，*，双目操作者：*，/，%，-，==，=,=, 9.inline function指定内置函数的方法很简单，只需要在函数第一行的左端加一个关键字inline即可。
inline int max(int a，int b)；使用内置函数可以节省运行时间。
只有那些小而频繁调用的简单函数才适合被声明为内联函数。
10.函数模板的语法：
模板类型名T
函数声明或定义的解释：
模板-声明创建模板。
Typename表面后面的符号是一种数据类型，可以用class替换。
t—通用数据类型，名称可以替换，通常用大写字母。
只适用于函数体相同、参数个数相同、函数类型不同的情况。如果参数数量不同，则不能使用函数模板。
不及物动词c重点考试知识点总结指针的作用：可以通过指针间接访问内存。
1.指针变量指针变量定义语法：数据类型*变量名；
请参见下面的代码示例，了解指针变量的定义和用法。一般期末不会有很难的指针题，但是基本用法一定要！
int main() {
//1，指针的定义
int a=10//定义整数变量a。
//指针定义语法：数据类型*变量名；
int * p；
//指针变量赋值
p=a；//指针指向变量a的地址。
cout a endl//打印数据a的地址。
cout p endl//打印指针变量p
//0073F8BC
//0073F8BC
//2、指针的使用
//通过*操作指针变量指向的内存
cout * p= * p endl
//*p=10
系统(“暂停”)；
返回0；
}指针变量和普通变量的区别
普通变量存储数据，指针变量存储地址指针变量通过 * 运算符可以指向的内存空间。这个过程叫做解引用总结1:我们可以通过符号得到变量的地址。
2.指针可以用来记录地址。
总结：指针变量可以解引用，指针指向的内存可以操作。
总结：32位操作系统下所有指针类型都是4字节(懂)
2.const修改指针有三种情况。
Const修改指针-const指针const修改常量-指针常量const修改指针和常量int main() {
int a=10
int b=10
//const修改指针，指针指向可以改变，指针指向的值不能改变。
const int * P1=a；
P1=b；//正确
//* P1=100；错误报告
//const修改常量，指针指针不能改变，指针所指的值可以改变。
int * const p2=a；
//p2=//错误
* p2=100//正确
//const修改指针和常量
const int * const P3=a；
//p3=//错误
//* P3=100；//错误
系统(“暂停”)；
返回0；
}提示：看指针或常量是否跟在const的右边，是指针还是const指针，是常量还是指针常量。
3.指针和数组的作用：用指针访问数组中的元素。
c，数组名是数组的起始地址
数组的指针是数组的起始地址。
数组名可以作为函数的实参和形参，传递数组的地址。
int main() {
int arr[]={ 1，2，3，4，5，6，7，8，9，10 }；
int * p=arr//指向数组的指针
“Cout”的第一个元素：“arr[0]endl；//1
“Cout”指针访问第一个元素：“* p endl//1
for(int I=0；i 10我)
{
//用指针遍历数组
cout * p endl
p；
}
系统(“暂停”)；
返回0；
}4.指针和函数的作用：使用指针作为函数参数，可以修改自变量的值(地址传递)。
//值传递
void swap1(int a，int b)
{
int temp=a；
a=b；
b=温度；
}
//地址传递
void swap2(int * p1，int *p2)
{
int temp=* p1
* p1=* p2
*p2=温度；
}
int main() {
int a=10
int b=20
swap1(a，b)；//值传递不会更改参数
swap2( a，b)；//地址传递会改变参数
cout a= a endl
cout b= b endl
系统(“暂停”)；
返回0；
}
int a[10]；
int * p=a[0]；//相当于int * p=a；
* p=1；//相当于a[0]=1；
*(P1)=2；//相当于a[1]=2；
//So *(p 1)=a[1]；*(p2)=a[2]；指向数组的下一个元素
void main()
{
int array[10]；
//使用数组名作为参数。因为地址是接收的，所以不能指定具体的元素个数。
f(数组，10)；
}
//形状参数组
f(int arr[]，int n)
{
.
}
void main()
{
int a[10]；
//参数数组
f(a，10)；
}
//参数指针
f(int *x，int n)
{
.
}总结：如果不想修改参数，就按值传递；如果要修改参数，请通过地址传递它们。
4.返回指针值的函数返回指针值的函数简称指针函数。
定义指针函数的一般形式是：
//类型名*函数名(参数列表)
int * a(int x，int y)；七。引用函数：别名变量。
语法：数据类型别名=原始名称
int main() {
int a=10
int b=a；
cout a= a endl
cout b= b endl
//10
//10
b=100
cout a= a endl
cout b= b endl
//100
//100
系统(“暂停”)；
返回0；
}1.应该初始化引用。
int c；//错误，必须初始化引用。声明引用后，它不能用作对另一个变量的引用。
2.引用作为函数参数的作用：当函数作为参数传递时，参数可以通过引用技术进行修改。
优点：可以简化指针修改参数。
引用参数与通过地址传递具有相同的效果。参考语法更加清晰和简单。
//1.价值传递
void mySwap01(int a，int b) {
int temp=a；
a=b；
b=温度；
}
//2.地址传递
void mySwap02(int* a，int* b) {
int temp=* a；
* a=* b；
*b=温度；
}
//参数：传入地址，用指针接收。
//3.参考传递
void mySwap03(int a，int b) {
int temp=a；
a=b；
b=温度；
}
//参数：alias，后面的A是上面A的别名，用别名操作修改也是一样的。
int main() {
int a=10
int b=20
//值被传递，形参不会修改实参。
mySwap01(a，b)；
cout a: a b: b endl；
//a:10 b:20
//地址转移，正式参与修改参数。
mySwap02( a，b)；
cout a: a b: b endl；
//a:20 b:10
//按引用传递，正式参与会修改实际实参。
mySwap03(a，b)；
cout a: a b: b endl；
//a:20 b:10
系统(“暂停”)；
返回0；
}3.引用作为函数返回值：引用可以作为函数返回值存在。
//之后添加数据类型，相当于引用返回。
int test02() {
//必须使用静态变量，并且要添加static关键字。
静态int a=20
返回a；
}
int main(){
int re F2=test 02()；
系统(“暂停”)；
返回0；
}八。c重点考试知识点汇总类和对象1。结构和类的区别C #中结构和类的唯一区别是默认访问权限不同。
差异：
struct的默认权限是public class，默认权限是private 2，构造函数和析构函数。构造函数主要用于在创建对象时给对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
析构函数(Destructor):主要作用是系统在对象被销毁之前自动调用它来执行一些清理工作。
构造函数的语法：class name () {}(构造和销毁很容易做选择题，记住特性)
构造函数，没有返回值，也没有写void。构造函数的名称必须与类名相同。构造函数可以有参数，所以可以发生重载的程序在调用对象时会自动调用构造函数，不需要手动调用，而且只会调用一次(构造函数不需要用户调用，也不能被用户调用)。析构函数语法：~类名(){}
析构函数，没有返回值，没有写void。函数名和类名一样，名字前加个符号~析构函数不能有参数，所以不能重载。程序会在对象销毁前自动调用destructor，所以不需要手动调用，只会调用一次类Person。
{
公共：
//构造函数
人()
{
“cout”Person的构造函数调用“endl
}
//析构函数
~人()
{
“cout”Person的析构函数调用“endl
}
};
void test01()
{
人p；//执行完堆栈上的数据，test01()后，释放这个对象。
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}3.构造函数和调用构造函数的分类按参数分为：参数化构造和无参数构造。
调用方法：括号法
类别人员{
公共：
//无参数(默认)构造函数
Person() {
Cout 无参数构造函数！endl
}
//参数构造函数
人员(内部){
年龄=a；
“Cout”有一个参数构造函数！”endl
}
//析构函数
~Person() {
Cout 析构函数！endl
}
公共：
int age
};
//2、构造函数的调用
//调用无参数构造函数
void test01() {
人p；//调用无参数构造函数
}
//用参数调用构造函数
void test02() {
//括号法，常用
人P1(10)；
}虽然一个类可以包含多个构造函数，但是对于每个对象来说，创建对象时只执行其中一个构造函数，并不是所有的构造函数都执行。
4.初始化列表C提供初始化属性的初始化列表语法。
语法：Constructor():属性1(值1)，属性2(值2).{}
类别人员{
公共：
传统初始化
//Person(int a，int b，int c) {
//m _ A=A；
//m _ B=B；
//m _ C=C；
//}
//初始化列表模式。
Person(int a，int b，int c) :m_A(a)，m_B(b)，m_C(c) {}
void PrintPerson() {
cout mA: m _ A endl；
cout mB: m _ B endl；
cout mC: m _ C endl；
}
私人：
int m _ A；
int m _ B；
int m _ C；
};
int main() {
人p(1，2，3)；
页（page的缩写）print person()；
系统(“暂停”)；
返回0；
}5.类对象是一个类成员。C类中的成员可以是另一个类的对象。我们称这个成员为对象成员。
例如：
A级{}
B类
{
A a
} B类有对象A作为成员，A是对象成员。
那么在创建一个B对象的时候，A和B的构造和销毁顺序是哪个呢？
先调用对象成员的构造，再调用这个类的构造(在上面的例子中，先调用A的构造函数)
解构的顺序与建构相反。
6.静态成员通过在成员变量和成员函数前添加关键字static，静态成员被称为静态成员。
静态成员分为：
静态成员变量所有对象共享相同的数据。
在编译时分配内存。
类内声明，类外初始化
静态成员函数所有对象共享同一个函数。
静态成员函数只能访问静态成员变量。
* *示例1 **:静态成员变量
阶级人士
{
公共：
静态int m _ A；//静态成员变量
//静态成员变量的特征：
//1在编译阶段分配内存
//2类内声明和类外初始化
//3所有对象共享相同的数据
私人：
静态int m _ B；//静态成员变量也是可访问的。
};
int Person:m _ A=10；
int Person:m _ B=10；
void test01()
{
//访问静态成员变量的两种方法
//1，通过对象
人P1；
p1.m _ A=100
cout P1 . m _ A= P1 . m _ A endl；
人p2；
p2.m _ A=200
cout P1 . m _ A= P1 . m _ A endl；//共享相同的数据
cout p2 . m _ A= p2 . m _ A endl；
//2，按类名
cout m _ A= Person:m _ A endl；
//cout m _ B= Person:m _ B endl；//私有权限不能访问它
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}示例2:静态成员函数
阶级人士
{
公共：
//静态成员函数的特性：
//1个程序共享一个函数
//2静态成员函数只能访问静态成员变量。
静态void函数()
{
Cout func calls endl
m _ A=100
//m _ B=100；//错误，无法访问非静态成员变量。
}
静态int m _ A；//静态成员变量
int m _ B；//
私人：
//静态成员函数也有访问权限
静态void函数2()
{
Cout func2调用 endl
}
};
int Person:m _ A=10；
void test01()
{
//访问静态成员变量的两种方法
//1，通过对象
人P1；
P1 . func()；
//2，按类名
person:func()；
//Person:func 2()；//私有权限不能访问它
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}7.const修改成员函数常量函数：
将const加到一个函数后，我们称这个函数为常数函数。在常量函数中，不能修改成员的属性。常量对象：
在对象声明前添加const，以调用它为常量对象。常量对象只能调用常量函数8，常量数据汇总。
九。继承的好处：可以减少重复代码。
继承的语法：类子类：继承模式父类
甲类：公乙；
一个类被称为子类或派生类。
b类称为父类或基类。
1.有三种继承方式：
公共继承保护继承私人继承
简单来说：
公共继承：基类的公共和受保护成员在派生类中保留它们原来的访问属性，它们的私有成员仍然是基类的私有成员。私有继承：基类的公共和受保护成员成为派生类中的私有成员。它的私有成员仍然是基类的私有保护继承：基类的公共成员和受保护成员成为派生类中的受保护成员，它们的私有成员仍然是基类的私有成员。2.构造函数和析构函数的主要作用是初始化数据成员。
派生类不能继承基类的析构函数，也需要通过派生类的析构函数调用基类的析构函数。
在继承中，先调用父类的构造函数，再调用子类的构造函数，析构顺序与构造相反。
3.不能从C继承也不能被派生类继承的是：构造函数。
4.继承以单一继承为特征：派生类只从基类派生。
多重继承：具有两个或更多基类的派生类称为多重继承。
X.多态性(Polymorphism)多态性是指不同功能的函数可以使用同一个函数名，这样就可以用一个函数名调用不同内容的函数。
多态性分为两类
静态多态：函数重载和运算符重载属于静态多态，函数名是重用的。
动态多态性：派生类和虚函数实现运行时多态性。
1.虚函数什么是虚函数？
在基类中，成员函数由。
虚函数的功能：
虚函数的作用是允许在派生类中重新定义与基类同名的函数，通过基类的指针或引用可以访问基类和派生类同名的函数。
如何使用虚函数：
基类将成员函数声明为带有。这样就可以在派生类中重新定义这个函数，赋予新的函数，方便调用。
当虚函数在类外定义时，没有必要添加虚函数。
在派生类中重新定义这个函数，要求函数名、函数类型、函数参数的个数和类型都与基类的虚函数相同，函数体要根据派生类的需要重新定义。
c规定，当一个成员函数被声明为虚函数时，其派生类中所有同名的函数都会自动成为虚函数。因此，当派生类重新声明虚函数时，它可能会也可能不会添加虚函数。但是习惯上在每一层声明函数的时候都加上虚，这样程序更清晰。
动物类
{
公共：
//Speak函数是虚函数。
//函数前面加了virtual关键字，变成了虚函数，所以编译时编译器无法确定函数调用。
虚虚言()
{
Cout“动物在说话”endl
}
};
类别猫：公共动物
{
公共：
void speak()
{
小猫在说话。
}
};
班级狗：公共动物
{
公共：
void speak()
{
Cout“小狗说话”endl
}
};
//调用我们想要传入的任何对象的函数。
//如果函数地址可以在编译阶段确定，那么静态绑定
//如果函数地址只能在运行时确定，则为动态绑定。
void DoSpeak(动物动物)
{
animal . speak()；
}
//
//多态性满足条件：
//1.有继承关系
//2.子类覆盖父类中的虚函数。
//多态使用：
//父类指针或引用指向子类对象
void test01()
{
猫猫；
DoSpeak(猫)；
狗狗狗狗；
DoSpeak(狗)；
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}多态性符合条件
继承的子类覆盖父类中的虚函数，纯虚函数。
纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式是
虚函数类型函数名(参数表列)=0；纯虚函数没有函数体。
last=0并不意味着函数的返回值为0，它只是告诉编译系统“老子是纯虚函数”
纯虚函数只有函数名而没有函数，所以不能调用。
抽象类
所有包含纯虚函数的类都是抽象的。
如果一个基类包含一个或多个纯虚函数，那么它就是抽象的。抽象基类不能也不需要定义对象，
XI。C重点考试知识点总结文件操作C需要包含头文件fstream进行文件操作。
有两种类型的文件：
文本文件以ASCII文本形式存储在计算机中。二进制文件-文件以文本的二进制形式存储在计算机中。一般来说，用户不能直接读取他们的三类操作文件：
Ofstream:写操作ifstream:读操作fstream:读写操作1，文本文件1)写文件
文件写入步骤如下：
包含头文件# includesfstream
创建流的流对象；
打开文件ofs.open("文件路径"，打开方法)；
“写入数据”的写入数据；
关闭文件ofs . close()；
打开文件的位置：
注意：文件打开方法可以一起使用，使用操作符。
* *例如：* *以二进制模式写入文件ios:binary ios: out
示例：
#包括fstream
void test01()
{
ofstream ofs
ofs.open(test.txt ，IOs:out)；
姓名：张三；
的“性别：男性”endl
年龄：18岁结束；
ofs . close()；
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}摘要：
该操作必须包含头文件fstream。可以使用ofstream读取文件，或者在fstream类打开文件时，需要指定操作文件的路径以及打开方式。您可以将数据写入文件。操作完成后，您应该关闭该文件。2)读取文件。
读取文件类似于写入文件，但是有多种读取方式。
文件读取步骤如下：
包含头文件# includesfstream
创建一个流对象ifstream ifs
打开文件，判断文件是否打开成功。ifs.open("文件路径"，打开方法)；
以四种方式读取数据。
关闭文件ifs . close()；
示例：
#包括fstream
#包含字符串
void test01()
{
ifstream ifs
ifs.open(test.txt ，IOs:in)；
如果(！ifs.is_open())
{
Cout“文件打开失败”endl
返回；
}
//第一种方式
//char buf[1024]={ 0 }；
//while (ifs buf)
//{
//cout buf endl；
//}
//第二种
//char buf[1024]={ 0 }；
//while (ifs.getline(buf，sizeof(buf)))
//{
//cout buf endl；
//}
//第三种
//string buf；
//while (getline(ifs，buf))
//{
//cout buf endl；
//}
char c；
while ((c=ifs.get())！=EOF)
{
cout c；
}
ifs . close()；
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}摘要：
可以使用ifstream或fstream类来读取文件。
Is_open函数可以用来判断文件是否被成功打开。
关闭文件
2.二进制文件以二进制模式读写文件。
打开模式应该指定为ios:binary。
1)二进制模式写文件：写文件主要是用stream对象调用成员函数write。
原型：ostreamwrite (constchar * buffer，int len)；
参数解释：字符指针缓冲区指向内存中的一个存储空间。Len是读写的字节数。
示例：
#包括fstream
#包含字符串
阶级人士
{
公共：
char m _ Name[64]；
int m _ Age
};
//二进制文件写文件
void test01()
{
//1，包括头文件
//2.创建输出流对象。
ofstream ofs(person.txt ，IOs:out IOs:binary)；
//3.打开文件。
//ofs.open(person.txt ，IOs:out IOs:binary)；
Person p={ 张三，18 }；
//4、写文件
ofs.write((const char *) p，sizeof(p))；
//5.关闭文件。
ofs . close()；
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}摘要：
Fileoutputstream可以通过write函数以二进制模式写入数据。
2)二进制模式读取文件读取文件主要是利用流对象调用成员函数read。
原型：istream read(char *buffer，int len)；
参数解释：字符指针缓冲区指向内存中的一个存储空间。Len是读写的字节数。
示例：
#包括fstream
#包含字符串
阶级人士
{
公共：
char m _ Name[64]；
int m _ Age
};
void test01()
{
ifstream ifs(person.txt ，IOs:in IOs:binary)；
如果(！ifs.is_open())
{
Cout“文件打开失败”endl
}
人p；
ifs.read((char *) p，sizeof(p))；
cout Name: p . m _ Name Age: p . m _ ageendl；
}
int main() {
test 01()；
系统(“暂停”)；
返回0；
}文件输入流对象可以通过read函数以二进制方式读取数据。
十二。C考试重点知识点总结iostream标准输出流：cout，cerr，clog
Cerr和clog stream对象是标准的错误流，它们都在终端显示器上显示错误信息。
标准输入流：cin、get、getline
get函数读取一个字符，getline读取一行字符。
Eof函数：文件结尾
Peek函数：peek函数用于观察下一个字符。
Putback函数：它的作用是将之前用get或getline函数从输入流中读取的字符ch返回到输入流中，并插入到当前指针位置，供以后读取。
Ignore函数：函数跳过输入流中的N个字符，或者在遇到指定的结束字符时提前结束。
十三。破例领取PDF版本和详细的C关键知识教程。可以关注微信微信官方账号：“C和C plus plus”回复：“C KS”
C异常处理的机制由三部分组成，即check (try)、throw (throw)和catch (catch)。
命名空间的作用是建立一些分离的作用域，分离一些全局实体，避免名称冲突。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。