C++重点考试知识点总结
一、C++重点考试知识点总结数据类型
1、整型
作用:整型变量表示的是整数类型的数据
int - 占4个字节
unsigned int - 无符号整型,占4个字节
2、sizeof关键字
作用:利用sizeof关键字可以统计数据类型所占内存大小
3、浮点型
作用:用于表示小数
浮点型变量分为两种:
单精度float ➡占4个字节,提供6位有效数组
双精度double ➡占8个字节,提供15位有效数字
4、数值型常量
4.1数值常量
一个整型常量可以用3种不同的方式表示:
十进制整数。如1357,-432,0等
八进制整数。在常数的开头加一个数字0,就表示这是以八进制数形式表示的常数。
十六进制整数。在常数的开头加一个数字0和一个英文字母X(或x),就表示这是以十六进制数形式表示的常数
4.2浮点数的表示方法
一个浮点数可以用两种不同的方式表示:
十进制小数形式。如21.456,-7.98等。
指数形式(即浮点形式)
5、字符型常量
作用:字符型变量用于显示单个字符
语法:char ch = 'a';
注意1:在显示字符型变量时,用单引号将字符括起来,不要用双引号
注意2:单引号内只能有一个字符,不可以是字符串
C和C++中字符型变量只占用1个字节。
字符常量只能包括一个字符,如′AB′ 是不合法的
字符常量区分大小写字母,如′A′和′a′是两个不同的字符常量
字符型变量并不是把字符本身放到内存中存储,而是将对应的ASCII编码放入到存储单元
6、字符串型常量
作用:用于表示一串字符
两种风格
- C风格字符串: char 变量名[] = "字符串值"
注意:C风格的字符串要用双引号括起来
- C++风格字符串: string 变量名 = "字符串值"
注意:C++风格字符串,需要加入头文件==#include<string>==
字符串常量为双引号
常考:字符串 "abc" 在内存中占几个字节?
答:占4个字节,而不是3个字节,编译系统会在字符串最后自动加一个′\0′作为字符串结束标志。但′\0′并不是字符串的一部分,它只作为字符串的结束标志
常考: 字符串常量″abc\n″包含几个字符?
答:不是5个而是4个字符,其中“\n”是一个转义字符,但它在内存中占5个字节
7、布尔类型bool
作用:布尔数据类型代表真或假的值
bool类型只有两个值:
true — 真(本质是1)
false — 假(本质是0)
bool类型占1个字节大小
8、数据的输入输出
关键字:cin、cout
语法: cin >> 变量1>>变量2>>....>>变量n、cout<<表达式1<<表达式2<<...<<表达式n
9、变量命名规则
C++规定标识符只能由字母、数字和下划线3种字符组成,且第一个字符必须为字母或下划线
不能是关键字
区分大小写
10、局部变量
在一个函数内部定义的变量是局部变量,它只在本函数范围内有效,也就是说只有在本函数内才能使用它们,在此函数以外是不能使用这些变量的
形参也是局部变量
11、全局变量
在函数之外定义的变量是外部变量,称为全局变量
二、C++重点考试知识点总结运算符
1、算数运算符
注意:
- 两个整数相除结果依然是整数(这里不进行四舍五入,直接舍去小数点后面数字)
- C++中两个小数可以相除
- 运算的两个数中有一个数为float型数据,则运算的结果是double型,因为C++在运算时对所有float型数据都按double型数据处理
- 只有整型变量可以进行取模运算,两个小数不可以取模
- 在除法运算中,除数不能为0
- 取模运算时,除数也不能为0
常考:
前置后置运算符单独使用没有什么区别
前置递增先对变量进行++,再计算表达式
后置递增先计算表达式,后对变量进行++
请详细看下方代码并理解
2、赋值运算符
作用:用于将表达式的值赋给变量
请详细看表格即可
3、比较运算符
作用:用于表达式的比较,并返回一个真值或假值
4、逻辑运算符
作用:用于根据表达式的值返回真值或假值
!
非为三者中运算符最高的
三、流程结构
1、选择结构
1.1、if语句
if语句较为简单,常常搭配else使用,且可以嵌套使用
1.2、三目运算符
作用: 通过三目运算符实现简单的判断
语法:表达式1 ? 表达式2 :表达式3
如果表达式1的值为真,执行表达式2,并返回表达式2的结果;
如果表达式1的值为假,执行表达式3,并返回表达式3的结果。
此处常出程序阅读题!!!!
1.3、switch语句
作用:执行多条件分支语句
语法:
case里如果没有break,那么程序会一直向下执行
2、循环结构
2.1、while
作用:满足循环条件,执行循环语句
语法:while(循环条件){ 循环语句 }
解释:只要循环条件的结果为真,就执行循环语句
2.2、do…while
作用: 满足循环条件,执行循环语句
语法: do{ 循环语句 } while(循环条件);
注意:与while的区别在于do…while会先执行一次循环语句,再判断循环条件(这里常考两者区
别,记住无论怎样,do…while都会必然执行一次循环语句)
2.3、for
for循环中的表达式,要用分号进行分隔
3、跳转语句
3.1、break
作用: 用于跳出选择结构或者循环结构
3.2、continue
作用:在循环语句中,跳过本次循环中余下尚未执行的语句,继续执行下一次循环
注意:continue并没有使整个循环终止,而break会跳出循环
四、C++重点考试知识点总结数组
数组:所谓数组,就是一个集合,存放相同类型的数据元素
数组中的每个数据元素都是相同的数据类型
数组是由连续的内存位置组成的
1、一维数组
一维数组定义的三种方式:
数据类型 数组名[ 数组长度 ];(常用,了解其余两种即可)
数据类型 数组名[ 数组长度 ] = { 值1,值2 ...};
数据类型 数组名[ ] = { 值1,值2 ...};
数组中下标是从0开始索引
在对全部数组元素赋初值时,可以不指定数组长度
直接打印数组名,可以查看数组所占内存的首地址
对数组名进行sizeof,可以获取整个数组占内存空间的大小
以上三种方式并不要求都会,但是需要都见过,防止在程序改错中乱改
一维数组初始化
在定义数组时分别对数组元素赋予初值。例如
可以只给一部分元素赋值。例如
如果想使一个数组中全部元素值为1,可以写成
在对全部数组元素赋初值时,可以不指定数组长度
2、二维数组
二维数组定义的四种方式:
- 数据类型 数组名[ 行数 ][ 列数 ];
- 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1,数据2 } ,{数据3,数据4 } };
- 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1,数据2,数据3,数据4};
- 数据类型 数组名[ ][ 列数 ] = { 数据1,数据2,数据3,数据4};
以上4种定义方式,利用第二种更加直观,提高代码的可读性如果对全部元素赋初值,定义数组时对第一维的长度可以不指定,但是第二维的长度不能省略
3、字符数组
用来存放字符数据的数组是字符数组,字符数组中的一个元素存放一个字符
定义:
赋值:
只能对字符数组的元素赋值,而不能用赋值语句对整个数组赋值
4、字符串函数
- 字符串连接函数 strcat
- 字符串复制函数 strcpy
- 字符串比较函数 strcmp
- 字符串长度函数 strlen
五、函数
作用:将一段经常使用的代码封装起来,减少重复代码
1、函数定义
函数的定义一般主要有5个步骤:
- 返回值类型
- 函数名
- 参数表列
- 函数体语句
- return 表达式
返回值类型 :一个函数可以返回一个值。在函数定义中
函数名:给函数起个名称
参数列表:使用该函数时,传入的数据
函数体语句:花括号内的代码,函数内需要执行的语句
return表达式: 和返回值类型挂钩,函数执行完后,返回相应的数据
示例:定义一个加法函数,实现两个数相加
2、函数调用
功能:使用定义好的函数
语法:函数名(参数)
函数定义里小括号内称为形参,函数调用时传入的参数称为实参
例如此处的num1,num2 为形参,10,20为实参
函数不能嵌套定义但是可以嵌套调用(常考)
3、函数声明
函数的声明可以多次,但是函数的定义只能有一次
所谓值传递,即单向传递,就是函数调用时实参将数值传入给形参,而不能由形参传回来给实参
值传递时,如果形参发生改变,并不会影响实参(值传递时,形参是修饰不了实参的),请务必
解并记住,此处因篇幅就不进行讲解了!
5、函数默认参数
在C++中,函数的形参列表中的形参是可以有默认值的。
语法:返回值类型 函数名 (参数= 默认值){}
如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值
如果函数声明有默认值,函数实现的时候就不能有默认参数
6、函数占位参数
C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置
语法: 返回值类型 函数名 (数据类型){}
//函数占位参数 ,占位参数也可以有默认参数 void func(int a, int) { cout << "this is func" << endl; } int main() { func(10,10); //占位参数必须填补 system("pause"); return 0; }
7、函数重载
作用:函数名可以相同,提高复用性
函数重载满足条件:
- 函数名称相同
- 函数参数类型不同 或者 个数不同 或者 顺序不同
注意: 函数的返回值不可以作为函数重载的条件
8、重载运算符规则
C++中有以下五个运算符不能重载
- 重载不能改变运算符运算对象(即操作数)的个数
- 重载不能改变运算符的优先级别
- 重载不能改变运算符的结合性
- 运算符重载函数可以是类的成员函数,也可以是类的友元函数,还可以是既非类的成员函数也不是友元函数的普通函数
什么时候应该用成员函数方式,什么时候应该用友元函数方式?二者有何区别呢?()
一般将单目运算符重载为成员函数,将双目运算符(二元运算符)重载为友元函数
重载为类的成员函数 - operator 函数有一个参数
重载为类的友元函数 - operator 函数有两个参数
只能将重载 “>>” (流插入运算符)和“<<” (流提取运算符)的函数作为友元函数或者普通函数重载,而不能将它们定义为成员函数,因为参数为两个类型转换运算符只能作为成员函数重载
- 单目运算符:只有一个操作数,如 !,-(负号),&,*,++,–
- 双目运算符:*,/,%,+,-,==,!=,<,>,<=,>=,&&,||
9、内联函数
指定内置函数的方法很简单,只需在函数首行的左端加一个关键字inline即可。
使用内置函数可以节省运行时间
只有那些规模较小而又被频繁调用的简单函数,才适合于声明为inline函数。
10、函数模板
语法:
解释:
template — 声明创建模板
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 system("pause"); return 0; }
- 普通变量存放的是数据,指针变量存放的是地址
- 指针变量可以通过" * "操作符,操作指针变量指向的内存空间,这个过程称为解引用
总结1: 我们可以通过 & 符号 获取变量的地址
总结2:利用指针可以记录地址
总结3:对指针变量解引用,可以操作指针指向的内存
总结4:所有指针类型在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 = &b; //错误 *p2 = 100; //正确 //const既修饰指针又修饰常量 const int * const p3 = &a; //p3 = &b; //错误 //*p3 = 100; //错误 system("pause"); return 0; }
技巧:看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; i++) { //利用指针遍历数组 cout << *p << endl; p++; } system("pause"); return 0; }
4、指针和函数
作用:利用指针作函数参数,可以修改实参的值(地址传递)
//值传递 void swap1(int a ,int b) { 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 << "a = " << a << endl; cout << "b = " << b << endl; system("pause"); return 0; }
int a[10]; int *p = &a[0]; // 等价于 int *p = a; *p = 1; // 等价于 a[0] = 1; *(p+1) = 2; // 等价于 a[1] = 2; // 所以 *(p+1) = a[1]; *(p+2) = a[2];
C++规定, p+1 指向数组的 下一个元素
void main() { int array[10]; // 用数组名作形参,因为接收的是地址,所以可以不指定具体的元素个数 f(array,10); } // 形参数组 f(int arr[],int n) { .... } 点击并拖拽以移动 void main() { int a[10]; // 实参数组 f(a,10); } // 形参指针 f(int *x,int n) { ... }
![点击并拖拽以移动](https://img2022.cnblogs.com/blog/2149097/202204/2149097-20220425110256910-579755952.gif)
总结:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递
4、返回指针值的函数
返回指针值的函数简称指针函数。
定义指针函数的一般形式为:
七、C++重点考试知识点总结引用
作用: 给变量起别名
语法: 数据类型 &别名 = 原名
1、引用注意事项
引用必须初始化
在声明一个引用后,不能再使之作为另一变量的引用
2、引用做函数参数
作用:函数传参时,可以利用引用的技术让形参修饰实参
优点:可以简化指针修改实参
通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单
//1. 值传递 void mySwap01(int a, int b) { int temp = a; a = b; b = temp; } //2. 地址传递 void mySwap02(int* a, int* b) { 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 << "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 system("pause"); return 0; }
3、引用做函数返回值
作用:引用是可以作为函数的返回值存在的
八、类和对象
1、struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别:
- struct 默认权限为公共
- class 默认权限为私有
2、构造函数和析构函数
构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。
构造函数语法:类名(){}(构造和析构很容易出选择题,特点要记住)
- 构造函数,没有返回值也不写void
- 构造函数的名字必须与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象时候会自动调用构造函数,无须手动调用,而且只会调用一次(构造函数不需用户调用,也不能被用户调用)
析构函数语法: ~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称与类名相同,在名称前加上符号~
- 析构函数不可以有参数,因此不可以发生重载
- 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
class Person { public: //构造函数 Person() { cout << "Person的构造函数调用" << endl; } //析构函数 ~Person() { cout << "Person的析构函数调用" << endl; } }; void test01() { Person p; //在栈上的数据,test01()执行完毕后,释放这个对象 } int main() { test01(); system("pause"); return 0; }
3、构造函数分类与调用
构造函数按参数分为: 有参构造和无参构造
调用方式:括号法
class Person { public: //无参(默认)构造函数 Person() { cout << "无参构造函数!" << endl; } //有参构造函数 Person(int a) { age = a; cout << "有参构造函数!" << endl; } //析构函数 ~Person() { cout << "析构函数!" << endl; } public: int age; }; //2、构造函数的调用 //调用无参构造函数 void test01() { Person p; //调用无参构造函数 } //调用有参的构造函数 void test02() { // 括号法,常用 Person p1(10); }
尽管在一个类中可以包含多个构造函数,但是对于每一个对象来说,建立对象时只执行其中一个构造函数,并非每个构造函数都被执行
4、初始化列表
C++提供了初始化列表语法,用来初始化属性
语法:构造函数():属性1(值1),属性2(值2)... {}
5、类对象作为类成员
C++类中的成员可以是另一个类的对象,我们称该成员为 对象成员
例如:
B类中有对象A作为成员,A为对象成员
那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?
先调用对象成员的构造,再调用本类构造(如上例中,先调用A的构造函数)
析构顺序与构造相反
6、静态成员
静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员
静态成员分为:
- 静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明,类外初始化
- 静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
**示例1 **:静态成员变量
7、const修饰成员函数
常函数:
- 成员函数后加const后我们称为这个函数为常函数
- 常函数内不可以修改成员属性
常对象:
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
8、const型数据小结
九、C++重点考试知识点总结继承
继承的好处:可以减少重复的代码
继承的语法:class 子类 : 继承方式 父类
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
1、继承方式
继承方式一共有三种:
- 公共继承
- 保护继承
- 私有继承
简单的说:
- 公共继承:基类的公用成员和保护成员在派生类中保持原有访问属性,其私有成员仍为基类私有。
- 私有继承:基类的公用成员和保护成员在派生类中成了私有成员。其私有成员仍为基类私有
- 保护继承:基类的公用成员和保护成员在派生类中成了保护成员,其私有成员仍为基类私有。
2、构造和析构函数
构造函数的主要作用是对数据成员初始化
派生类是不能继承基类的析构函数,也需要通过派生类的析构函数去调用基类的析构函数
继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反
3、不能继承
C++中,不能被派生类继承的是:构造函数
4、继承特点
单继承:一个派生类只从一个基类派生
多继承:一个派生类有两个或多个基类的称为多重继承
十、C++重点考试知识点总结多态
多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容的函数
多态分为两类
静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名
动态多态: 派生类和虚函数(virtual function)实现运行时多态
1、虚函数
什么是虚函数?
在基类用 virtual 声明成员函数为虚函数
虚函数的作用:
虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数
虚函数的使用方法:
在基类用 virtual 声明成员函数为虚函数。这样就可以在派生类中重新定义此函数,为它赋予新的功能,并能方便地被调用
在类外定义虚函数时,不必再加virtual
在派生类中重新定义此函数,要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同,并根据派生类的需要重新定义函数体
C++规定,当一个成员函数被声明为虚函数后,其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时,可以加virtual,也可以不加,但习惯上一般在每一层声明该函数时都加virtual,使程序更加清晰
class Animal { public: //Speak函数就是虚函数 //函数前面加上virtual关键字,变成虚函数,那么编译器在编译的时候就不能确定函数调用了。 virtual void speak() { cout << "动物在说话" << endl; } }; class Cat :public Animal { public: void speak() { cout << "小猫在说话" << endl; } }; class Dog :public Animal { public: void speak() { cout << "小狗在说话" << endl; } }; //我们希望传入什么对象,那么就调用什么对象的函数 //如果函数地址在编译阶段就能确定,那么静态联编 //如果函数地址在运行阶段才能确定,就是动态联编 void DoSpeak(Animal & animal) { animal.speak(); } // //多态满足条件: //1、有继承关系 //2、子类重写父类中的虚函数 //多态使用: //父类指针或引用指向子类对象 void test01() { Cat cat; DoSpeak(cat); Dog dog; DoSpeak(dog); } int main() { test01(); system("pause"); return 0; }
多态满足条件
- 有继承关系
- 子类重写父类中的虚函数
纯虚函数
纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式是
纯虚函数没有函数体
最后面的 =0 ,并不表示函数返回值为0,它只告诉编译系统“老子是纯虚函数”
纯虚函数只有函数的名字而不具备函数的功能,不能被调用
抽象类
凡是包含纯虚函数的类都是抽象类
一个基类如果包含一个或一个以上纯虚函数,就是抽象基类。抽象基类不能也不必要定义对象、
十一、文件操作
C++中对文件操作需要包含头文件 < fstream >
文件类型分为两种:
- 文本文件 - 文件以文本的ASCII码形式存储在计算机中
- 二进制文件 - 文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们
操作文件的三大类:
- ofstream:写操作
- ifstream: 读操作
- fstream : 读写操作
1、文本文件
1)写文件
写文件步骤如下:
- 包含头文件
#include <fstream>
- 创建流对象
ofstream ofs;
- 打开文件
ofs.open(“文件路径”,打开方式);
- 写数据
ofs << “写入的数据”;
- 关闭文件
ofs.close();
文件打开方式:
注意: 文件打开方式可以配合使用,利用|操作符
**例如:**用二进制方式写文件 ios::binary | ios:: out
示例:
总结:
- 文件操作必须包含头文件 fstream
- 读文件可以利用 ofstream ,或者fstream类
- 打开文件时候需要指定操作文件的路径,以及打开方式
- 利用<<可以向文件中写数据
- 操作完毕,要关闭文件
2)读文件
读文件与写文件步骤相似,但是读取方式相对于比较多
读文件步骤如下:
- 包含头文件
#include <fstream>
- 创建流对象
ifstream ifs;
- 打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);
- 读数据
四种方式读取
- 关闭文件
ifs.close();
示例:
#include <fstream> #include <string> void test01() { ifstream ifs; ifs.open("test.txt", ios::in); if (!ifs.is_open()) { cout << "文件打开失败" << endl; return; } //第一种方式 //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() { test01(); system("pause"); return 0; }
读文件可以利用 ifstream ,或者fstream类
利用is_open函数可以判断文件是否打开成功
close 关闭文件
2、二进制文件
以二进制的方式对文件进行读写操作
打开方式要指定为 ios::binary
1)写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型 :ostream& write(const char * buffer,int len);
参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例:
#include <fstream> #include <string> class Person { 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函数,以二进制方式写数据
2)读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型:istream& read(char *buffer,int len);
参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例:
#include <fstream> #include <string> 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 << "文件打开失败" << endl; } Person p; ifs.read((char *)&p, sizeof(p)); cout << "姓名: " << p.m_Name << " 年龄: " << p.m_Age << endl; } int main() { test01(); system("pause"); return 0; }
文件输入流对象 可以通过read函数,以二进制方式读数据
十二、C++重点考试知识点总结输入输出流
标准输出流:cout 、cerr、clog
cerr、clog流对象都是标准错误流,都是在终端显示器上显示出错信息
标准输入流:cin、get、getline
get函数读入一个字符,getline读入一行字符
eof函数:文件结束
peek函数:peek函数的作用是观测下一个字符。
putback函数:其作用是将前面用get或getline函数从输入流中读取的字符ch返回到输入流,插入到当前指针位置,以供后面读取
ignore函数:函数作用是跳过输入流中n个字符,或在遇到指定的终止字符时提前结束
十三、C++重点考试知识点总结异常
C++处理异常的机制是由3个部分组成的,即检查(try)、抛出(throw)和捕捉(catch)。
命名空间的作用是建立一些互相分隔的作用域,把一些全局实体分隔开来,以免产生名字冲突
十四、C++重点知识点总结和C++入门基础知识 PDF版 获 取 方 法
复制如 下 链 接 再打开
https://docs.qq.com/doc/DV3ZkQ3FvRlpwZkxj