C++期末复习超详细总结知识点(期末冲刺)

您所在的位置:网站首页 期末考试c语言题及答案大全 C++期末复习超详细总结知识点(期末冲刺)

C++期末复习超详细总结知识点(期末冲刺)

#C++期末复习超详细总结知识点(期末冲刺)| 来源: 网络整理| 查看: 265

0、c++期末总结 更新时间:2022年8月21日 pdf版下面评论置顶有链接 重点已经用黑体和高亮表示,属于记忆理解部分,可收藏使用 后面考完找时间分享下c++面向对象程序设计课后习题答案(谭浩强版)与C++题库刷题部分! 题库与答案链接:题库与答案链接(已失效,置顶评论有习题),设置为0积分下载,如果还不可下载请下方留邮箱,虽然各个学校情况各异,但是知识点是一样的,而且基本高校内C++考的也基本都是这些,大差不差吧~ 更新一下:习题和笔记pdf版均在置顶评论,自取

学校考试一般比较简单,更多在于概念和语法的考察,包括一些细节知识点在选择判断等。

是根据老师的PPT与自己所学进行总结的,基本不涉及偏难怪知识点,重点是为了期末考试。

全文长10400多字,基本可以囊括90%的考试知识点

个人感觉知识掌握了就是多做做习题,毕竟考试偏应试,想提高分请一定多做题!!!!

考试加油!!!!

只是知识点总结,请一定要理解记忆,由于博主这学期也要考,时间有限,难免有不全有误之处,望谅解。

10.时间充足者可以按如下顺序学习,更有利于掌握。

《黑马程序员》C++基础入门(一)《黑马程序员》通讯录管理系统实战《黑马程序员》通讯录管理系统源码《黑马程序员》C++核心编程(二)《黑马程序员》职工管理系统实战《黑马程序员》职工管理系统源码《黑马程序员》C++提高编程(三)《黑马程序员》演讲比赛管理系统实战《黑马程序员》演讲比赛管理系统源码《黑马程序员》演讲比赛管理系统成品 0.1、程序的构成 一个C++程序可以由一个程序单位或多个程序单位构成。每一个程序单位作为一个文件。在程序编译时,编译系统分别对各个文件进行编译,因此,一个文件是一个编译单元。 0.2、程序的编写与实践 用高级语言编写的程序称为“源程序”,C++的源程序是以.cpp作为后缀的对源程序(.cpp)进行编译 ➡ 目标程序(.obj) ➡ 二进制文件(.exe)编写C++程序一般需要经过的几个步骤是:编辑➡编译➡连接➡调试 1、数据类型 1.1、整型

作用:整型变量表示的是整数类型的数据

int - 占4个字节unsigned int - 无符号整型,占4个字节 1.2、sizeof关键字

作用:利用sizeof关键字可以统计数据类型所占内存大小

1.3、浮点型

作用:用于表示小数

浮点型变量分为两种:

单精度float ➡占4个字节,提供6位有效数组双精度double ➡占8个字节,提供15位有效数字 1.4、数值型常量 1.4.1数值常量

一个整型常量可以用3种不同的方式表示:

十进制整数。如1357,-432,0等八进制整数。在常数的开头加一个数字0,就表示这是以八进制数形式表示的常数。十六进制整数。在常数的开头加一个数字0和一个英文字母X(或x),就表示这是以十六进制数形式表示的常数 1.4.2浮点数的表示方法

一个浮点数可以用两种不同的方式表示:

十进制小数形式。如21.456,-7.98等。指数形式(即浮点形式) 1.5、字符型常量

作用:字符型变量用于显示单个字符

语法:char ch = 'a';

注意1:在显示字符型变量时,用单引号将字符括起来,不要用双引号

注意2:单引号内只能有一个字符,不可以是字符串

C和C++中字符型变量只占用1个字节。

字符常量只能包括一个字符,如′AB′ 是不合法的

字符常量区分大小写字母,如′A′和′a′是两个不同的字符常量

字符型变量并不是把字符本身放到内存中存储,而是将对应的ASCII编码放入到存储单元

1.6、字符串型常量

作用:用于表示一串字符

两种风格

C风格字符串: char 变量名[] = "字符串值" char str1[] = "hello world";

注意:C风格的字符串要用双引号括起来

C++风格字符串: string 变量名 = "字符串值" string str = "hello world";

注意:C++风格字符串,需要加入头文件==#include==

字符串常量为双引号

常考:字符串 "abc" 在内存中占几个字节?

答:占4个字节,而不是3个字节,编译系统会在字符串最后自动加一个′\0′作为字符串结束标志。但′\0′并不是字符串的一部分,它只作为字符串的结束标志

常考: 字符串常量″abc\n″包含几个字符?

答:不是5个而是4个字符,其中“\n”是一个转义字符,但它在内存中占5个字节

1.7、布尔类型bool

作用:布尔数据类型代表真或假的值

bool类型只有两个值:

true — 真(本质是1)false — 假(本质是0)

bool类型占1个字节大小

1.8、数据的输入输出

关键字:cin、cout

语法: cin >> 变量1>>变量2>>....>>变量n 、cout case 结果1:执行语句;break; case 结果2:执行语句;break; ... default:执行语句;break; } switch语句中表达式类型只能是整型或者字符型case里如果没有break,那么程序会一直向下执行 3.2、循环结构 3.2.1、while

作用:满足循环条件,执行循环语句

语法: while(循环条件){ 循环语句 }

解释:只要循环条件的结果为真,就执行循环语句

3.2.2、do…while

作用: 满足循环条件,执行循环语句

语法: do{ 循环语句 } while(循环条件);

注意:与while的区别在于do…while会先执行一次循环语句,再判断循环条件(这里常考两者区别,记住无论怎样,do…while都会必然执行一次循环语句)

3.2.3、for for循环中的表达式,要用分号进行分隔 int main() { for (int i = 0; i 100, 90,80,70,60,50,40,30,20,10 }; int score3[] = { 100,90,80,70,60,50,40,30,20,10 }; 数组中下标是从0开始索引在对全部数组元素赋初值时,可以不指定数组长度直接打印数组名,可以查看数组所占内存的首地址对数组名进行sizeof,可以获取整个数组占内存空间的大小以上三种方式并不要求都会,但是需要都见过,防止在程序改错中乱改 4.1.1、一维数组初始化 在定义数组时分别对数组元素赋予初值。例如 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}; int a[10]={1*10}; // 错误写法,不能给数组整体赋初值 在对全部数组元素赋初值时,可以不指定数组长度 int a[5]={1,2,3,4,5}; // 可以写成 int a[]={1,2,3,4,5}; 4.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 }; 以上4种定义方式,利用第二种更加直观,提高代码的可读性如果对全部元素赋初值,定义数组时对第一维的长度可以不指定,但是第二维的长度不能省略 4.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.4、字符串函数

字符串连接函数 strcat

字符串复制函数 strcpy

字符串比较函数 strcmp

字符串长度函数 strlen

5、函数

作用:将一段经常使用的代码封装起来,减少重复代码

5.1、函数定义

函数的定义一般主要有5个步骤:

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法:

返回值类型 函数名 (参数列表) { 函数体语句 return表达式 } 返回值类型 :一个函数可以返回一个值。在函数定义中函数名:给函数起个名称参数列表:使用该函数时,传入的数据函数体语句:花括号内的代码,函数内需要执行的语句return表达式: 和返回值类型挂钩,函数执行完后,返回相应的数据

示例:定义一个加法函数,实现两个数相加

//函数定义 int add(int num1, int num2) { int sum = num1 + num2; return sum; } 5.2、函数调用

功能:使用定义好的函数

语法: 函数名(参数)

int result = add(10,20);

函数定义里小括号内称为形参,函数调用时传入的参数称为实参

例如此处的num1,num2 为形参,10,20为实参

函数不能嵌套定义但是可以嵌套调用(常考)

5.3、函数声明 函数的声明可以多次,但是函数的定义只能有一次 //声明可以多次,定义只能一次 //声明 int max(int a, int b); int max(int a, int b); //定义 int max(int a, int b) { return a > b ? a : b; } int main() { int a = 100; int b = 200; cout return a + b; } int main() { cout func(10,10); //占位参数必须填补 system("pause"); return 0; } 5.7、函数重载

作用:函数名可以相同,提高复用性

函数重载满足条件:

函数名称相同函数参数类型不同 或者 个数不同 或者 顺序不同

注意: 函数的返回值不可以作为函数重载的条件

//函数重载需要函数都在同一个作用域下 void func() { cout cout cout func(); func(10); func(3.14); func(10,3.14); func(3.14 , 10); system("pause"); return 0; } 5.8、重载运算符规则

C++中有以下五个运算符不能重载

成员访问运算符成员指针访问运算符域运算符长度运算符条件运算符..*::sizeof?:

重载运算符规则:

重载不能改变运算符运算对象(即操作数)的个数重载不能改变运算符的优先级别重载不能改变运算符的结合性运算符重载函数可以是类的成员函数,也可以是类的友元函数,还可以是既非类的成员函数也不是友元函数的普通函数

什么时候应该用成员函数方式,什么时候应该用友元函数方式?二者有何区别呢?()

一般将单目运算符重载为成员函数,将双目运算符(二元运算符)重载为友元函数 重载为类的成员函数 - operator 函数有一个参数重载为类的友元函数 - operator 函数有两个参数只能将重载 “>>” (流插入运算符)和“ int a = 10; int b = 10; //const修饰的是指针,指针指向可以改,指针指向的值不可以更改 const int * p1 = &a; p1 = &b; //正确 //*p1 = 100; 报错 //const修饰的是常量,指针指向不可以改,指针指向的值可以更改 int * const p2 = &a; //p2 = &b; //错误 *p2 = 100; //正确 //const既修饰指针又修饰常量 const int * const p3 = &a; //p3 = &b; //错误 //*p3 = 100; //错误 system("pause"); return 0; }

技巧:看const右侧紧跟着的是指针还是常量, 是指针就是常量指针,是常量就是指针常量

6.3、指针和数组

作用:利用指针访问数组中元素

C++规定,数组名就是数组的起始地址数组的指针就是数组的起始地址数组名可以作函数的实参和形参,传递的是数组的地址 int main() { int arr[] = { 1,2,3,4,5,6,7,8,9,10 }; int * p = arr; //指向数组的指针 cout int temp = a; a = b; b = temp; } //地址传递 void swap2(int * p1, int *p2) { int temp = *p1; *p1 = *p2; *p2 = temp; } int main() { int a = 10; int b = 20; swap1(a, b); // 值传递不会改变实参 swap2(&a, &b); //地址传递会改变实参 cout .... } void main() { int a[10]; // 实参数组 f(a,10); } // 形参指针 f(int *x,int n) { ... }

总结:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递

6.4、返回指针值的函数 返回指针值的函数简称指针函数。定义指针函数的一般形式为: // 类型名 * 函数名(参数列表) int * a(int x,int y); 7、引用

作用: 给变量起别名

语法: 数据类型 &别名 = 原名

int main() { int a = 10; int &b = a; cout int temp = *a; *a = *b; *b = temp; } //参数:把地址传进去,用指针接收 //3. 引用传递 void mySwap03(int& a, int& b) { int temp = a; a = b; b = temp; } //参数:别名,下面的a是上面的a的别名,用别名操作修改可原名操作修改是一样的 int main() { int a = 10; int b = 20; // 值传递,形参不会修饰实参 mySwap01(a, b); cout public: //构造函数 Person() { cout Person p; //在栈上的数据,test01()执行完毕后,释放这个对象 } int main() { test01(); system("pause"); return 0; } 8.3、构造函数分类与调用

构造函数按参数分为: 有参构造和无参构造

调用方式:括号法

class Person { public: //无参(默认)构造函数 Person() { cout cout // 括号法,常用 Person p1(10); } 尽管在一个类中可以包含多个构造函数,但是对于每一个对象来说,建立对象时只执行其中一个构造函数,并非每个构造函数都被执行 8.4、初始化列表 C++提供了初始化列表语法,用来初始化属性

语法:构造函数():属性1(值1),属性2(值2)... {}

class Person { public: 传统方式初始化 //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 } class B { A a; } B类中有对象A作为成员,A为对象成员那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后? 先调用对象成员的构造,再调用本类构造(如上例中,先调用A的构造函数)析构顺序与构造相反 8.6、静态成员

静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员

静态成员分为:

静态成员变量 所有对象共享同一份数据在编译阶段分配内存类内声明,类外初始化 静态成员函数 所有对象共享同一个函数静态成员函数只能访问静态成员变量 **示例1 **:静态成员变量 class Person { public: static int m_A; //静态成员变量 //静态成员变量特点: //1 在编译阶段分配内存 //2 类内声明,类外初始化 //3 所有对象共享同一份数据 private: static int m_B; //静态成员变量也是有访问权限的 }; int Person::m_A = 10; int Person::m_B = 10; void test01() { //静态成员变量两种访问方式 //1、通过对象 Person p1; p1.m_A = 100; cout public: //静态成员函数特点: //1 程序共享一个函数 //2 静态成员函数只能访问静态成员变量 static void func() { cout //静态成员变量两种访问方式 //1、通过对象 Person p1; p1.func(); //2、通过类名 Person::func(); //Person::func2(); //私有权限访问不到 } int main() { test01(); system("pause"); return 0; } 8.7、const修饰成员函数

常函数:

成员函数后加const后我们称为这个函数为常函数常函数内不可以修改成员属性

常对象:

声明对象前加const称该对象为常对象常对象只能调用常函数 8.8、const型数据小结 形式含义Time const t1t1 是常对象,其值在任何情况下都不能改变void Time::fun() constfun 是 Time类中的常成员函数,可以引用,但不能修改本类中的数据成员Time * const pp 是指向Time对象的常指针,P的值不能改变const Time *pp是指向 Time 类常对象的指针,其指向的类对象的值不能通过指针来改变Time &t1 = t;t1是Time类对象t的引用,二者指向同一段内存空间 9、继承

继承的好处:可以减少重复的代码

继承的语法:class 子类 : 继承方式 父类

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

9.1、继承方式

继承方式一共有三种:

公共继承保护继承私有继承

在这里插入图片描述

简单的说:

公共继承:基类的公用成员和保护成员在派生类中保持原有访问属性,其私有成员仍为基类私有。私有继承:基类的公用成员和保护成员在派生类中成了私有成员。其私有成员仍为基类私有保护继承:基类的公用成员和保护成员在派生类中成了保护成员,其私有成员仍为基类私有。 9.2、构造和析构函数

构造函数的主要作用是对数据成员初始化

派生类是不能继承基类的析构函数,也需要通过派生类的析构函数去调用基类的析构函数

继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反

9.3、不能继承 C++中,不能被派生类继承的是:构造函数 9.4、继承特点

单继承:一个派生类只从一个基类派生

多继承:一个派生类有两个或多个基类的称为多重继承

10、多态

多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容的函数

多态分为两类

静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名动态多态: 派生类和虚函数(virtual function)实现运行时多态 10.1、虚函数

什么是虚函数?

在基类用 virtual 声明成员函数为虚函数

虚函数的作用:

虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数

虚函数的使用方法:

在基类用 virtual 声明成员函数为虚函数。这样就可以在派生类中重新定义此函数,为它赋予新的功能,并能方便地被调用 在类外定义虚函数时,不必再加virtual 在派生类中重新定义此函数,要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同,并根据派生类的需要重新定义函数体

C++规定,当一个成员函数被声明为虚函数后,其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时,可以加virtual,也可以不加,但习惯上一般在每一层声明该函数时都加virtual,使程序更加清晰

class Animal { public: //Speak函数就是虚函数 //函数前面加上virtual关键字,变成虚函数,那么编译器在编译的时候就不能确定函数调用了。 virtual void speak() { cout cout cout Cat cat; DoSpeak(cat); Dog dog; DoSpeak(dog); } int main() { test01(); system("pause"); return 0; }

多态满足条件

有继承关系子类重写父类中的虚函数 纯虚函数

纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式是

virtual 函数类型 函数名 (参数表列) =0;

纯虚函数没有函数体

最后面的 =0 ,并不表示函数返回值为0,它只告诉编译系统“老子是纯虚函数”

纯虚函数只有函数的名字而不具备函数的功能,不能被调用

抽象类

凡是包含纯虚函数的类都是抽象类

一个基类如果包含一个或一个以上纯虚函数,就是抽象基类。抽象基类不能也不必要定义对象、

11、文件操作

C++中对文件操作需要包含头文件 < fstream >

文件类型分为两种:

文本文件 - 文件以文本的ASCII码形式存储在计算机中二进制文件 - 文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们

操作文件的三大类:

ofstream:写操作ifstream: 读操作fstream : 读写操作 11.1、文本文件 5.1.1写文件

写文件步骤如下:

包含头文件

#include

创建流对象

ofstream ofs;

打开文件

ofs.open(“文件路径”,打开方式);

写数据

ofs test01(); system("pause"); return 0; }

总结:

文件操作必须包含头文件 fstream读文件可以利用 ofstream ,或者fstream类打开文件时候需要指定操作文件的路径,以及打开方式利用 cout // cout cout public: 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() { test01(); system("pause"); return 0; }

总结:

文件输出流对象 可以通过write函数,以二进制方式写数据 5.2.2 读文件

二进制方式读文件主要利用流对象调用成员函数read

函数原型:istream& read(char *buffer,int len);

参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数

示例:

#include #include class Person { public: char m_Name[64]; int m_Age; }; void test01() { ifstream ifs("person.txt", ios::in | ios::binary); if (!ifs.is_open()) { cout


【本文地址】


今日新闻


推荐新闻


CopyRight 2018-2019 办公设备维修网 版权所有 豫ICP备15022753号-3