【无标题】7 c++基础自用
目录
一
1始
1）编程序：
2）注释
3）变量
4）常量
5）关键字
6）标识符命名规则
2数据类型
1）
2）整型
3）sizeof关键字
4）实型（浮点型）
5）字符型
6）转义字符
7）字符串型
8）布尔类型bool
9）数据输入
3运算符
1）作用：运算
4程序流程结构
1）选择结构（if 、三目、switch）
2）循环结构（while、do...while、for）
3）跳转语句（break、continue、goto）
5数组
6函数
7指针
8 结构体
其他
二
1始
1）c++程序执行时，将内存大方向分为4个区域
2new关键字
3引用
4函数+
5类、对象
5.1）封装
5.2）对象的初始化和清理
5.3）c++对象模型、this指针
5.4）友元friend
5.5）运算符重载operator
5.6）继承
5.7)多态
6文件操作
6.1）
6.2）文本文件：
6.3）二进制文件
一
1始
1）编程序：
- 创建项目--创建文件--编写代码--运行
2）注释
- 作用：说明解释
- 单行注释//和多行注释/**/
3）变量
- 作用：空间起名，不同于地址，更方便
- 格式：数据类型 变量名 = 初始值；
4）常量
- 作用：记录不可更改的数据
- 定义：
| #define 宏常量 | #define 常量名 常量值 |
| const修饰的变量 | const 数据类型 常量名 = 常量值 |
5）关键字
- 作用：具有功能...
- 定义常量，变量不可以关键字
6）标识符命名规则
- 作用：规则
- ①不能是关键字②字母数字下划线组成③第一个字符为字母、下划线④区分大小写
2数据类型
1）
- 规定：创建变量或常量时，必须指出相应数据类型。区别所占领空间的大小
2）整型
| 数据类型 | 占用字节 |
| short短整型 | 2 |
| int | 4 |
| long | 4、8 |
| long long | 8 |
3）sizeof关键字
- 作用：统计数据类型所占空间的大小
- 格式：sizeof（数据类型/变量）
4）实型（浮点型）
- 作用：表示小数
| 数据类型 | 占用空间 | 有效数字范围 |
| float | 4 | 7 |
| double | 8 | 15-16 |
ti：float f1=3.14f
5）字符型
- 作用：显示单个字符
- 一个字节
- 单引号括
- 以对应ascll编码放入存储单元
- ascll=>0-31非打印的控制字符。和32-126能打印的能在键盘上找到的字符
6）转义字符
- 作用：表示一些不能显示的ascll字符
- 例：\n 换行。\\ 代表反斜线字符 。\t 水平制表（tab键）
7）字符串型
- 作用：一串字符
- 格式：
| c | char 变量名[] ="字符串值" |
| c++ | string 变量名 = "字符串值" |
- 双引号
- c++要包括的头文件：#include
8）布尔类型bool
- 作用：真假
- true真、false假
- 一个字节
9）数据输入
- 作用：
- 关键字：cin
- 格式：cin>>变量
3运算符
1）作用：运算
| 运算符类型 | 作用 | 符号 |
| 算术运算符 | 四则运算 | + - * / % ++ -- |
| 赋值运算符 | 表达式赋值给变量 | = += -= *= /= %= |
| 比较运算符 | 比较返回真假 | == != < > <= >= |
| 逻辑运算符 | 根据表达式值返回真值、假值 | ! && || |
- 求余%需整型
4程序流程结构
1）选择结构（if 、三目、switch）
1.1if
- 作用：判断
| 单行格式 |
if(条件){条件满足执行的语句}; |
| 多行格式 |
if(条件){条件满足执行的语句}else{条件不满足执行的语句}; |
| 多条件格式 |
if(){}else if(){}...else{}; |
- 格式
- 可以嵌套
1.2三目运算符
- 作用：判断
- 格式：表达式1?表达式2：表达式3
- 说明：1真执行2，返回2的值。1假执行3，返回3的值
1.3switch语句
- 作用：多条件分支
- 格式：switch(){case结果1:执行语句;break;case结果2:执行语句;break;...default:执行语句;break}
2）循环结构（while、do...while、for）
2.1while
- 作用：
- 格式：while(条件){循环语句}
2.2do...while
- 作用：
- 格式：do{循环语句 }while(条件);
- 先执行一次
2.3for
- 作用
- 格式：for(起始表达式;条件表达式;改循环状态表达式){循环语句;}
2.4嵌套
3）跳转语句（break、continue、goto）
3.1break
- 作用：跳出选择或者循环
- 时机：
| switch中 | ，终止case并跳出switch |
| 循环 | 跳出当前循环循环语句 |
| 嵌套 | 跳当前循环 |
3.2continue
- 作用：循环中，跳本次循环，执行下一次
3.3goto
- 作用：无条件跳转
- 格式：goto 标记；
5数组
1）
- 一个集合，存放了相同的元素
- 特点：数组中每个元素都是相同的\由连续的内存位置组成的
2）一维数组
- 定义：
| 数据类型 数组名[数组长度]; |
| 数据类型 数组名[数组长度] = {值}; |
| 数据类型 数组名 [] = {值}; |
- 数组名：统计长度、获取数组在内存的首地址
3）二维数组
- 定义：利用第二种更为直观
| 数组类型 数组名[行号][列号]; |
| 数组类型 数组名[行号][列号] = {{值},{值}}； |
| 数组类型 数组名[行号][列号] = {值}; |
| 数组类型 数组名[ ][列号] = {值}; |
- 数组名：查看所占内存空间、获取二维数组首地址
6函数
1）
- 作用：将一段经常使用的代码（功能）封装
2）定义
- 5步骤：返回值类型、函数名、参数列表、函数体语句、return 表达式
- 格式：返回值类型 函数名（参数列表）{函数体语句；return表达式；}
3）调用
- 格式：函数名（函数）
4）值传递
- 即实参只是将数值传入形参中。形参发生变化，并不影响实参。
5）函数的常见样式
- 无参无返、有参无返、无参有返、有参有返
6）函数声明
- 作用：告诉编译器函数名称以及如何调用函数。后汉书的实际主体可以单独定义
- 函数声明可以多次，函数定义只有一次
7）函数分文件编写
- 创建后缀 为.h的头文件==写声明、后缀为.cpp的源文件==写定义、
7指针
1）
- 通过指针间接访问内存。
- 内存编号从0开始记录，十六进制数字表示
- 可以利用指针变量保存地址
2）定义与使用
- 格式：数据类型 * 变量名;
//定义
int a = 10;
int * p ;
p = &a;
//使用
//解引用
cout<<"*p = "<<*p<3）所占空间
- 4或8字节，看多少位机
4）空指针或野指针
- 空指针：指向编号为0的空间。其用途：初始化指针。不可访问
- 野指针：指向非法的内存空间。（一个没有对象的野指针）。不可访问
5）const修饰指针
- 3情况：在int a=10;下
| 修饰指针--常量指针 | const int * p1=&a; | 指针指向可以变，指向的值不可变 |
| 修饰常量--指针常量 | int * const p2=&a; | 指针指向不可变，指向的值可变 |
| 都修饰 | const int* const p3=&a; | 都不能变 |
6）指针与数组
- 利用指针访问数组元素
- 注意符号->
7）指针与函数
- 值传递与地址传递
8）指针、数组、函数结合
8 结构体
1）
- 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
2 ）定义与使用
- 格式：struct 结构体名 {结构体成员列表}；
- 创建变量的三种方式：
| struct 结构体名 变量名 |
| struct 结构体名 变量名 = {成员}； |
| 定义结构体时顺便创建 |
void text() {
struct Student {
string name;
int age;
int score;
}stu2;//创建方法2
stu2.name = "李四";
struct Student stu1;//创建方法1
stu1.age = 18;
stu1.score = 99;
stu1.name = "张三";
cout << stu1.name<<"\t" << stu1.age << "岁\t" << "语文成绩:"<3）结构体数组
- 将定义的结构体放入到数组中==方便
- 格式：struct 结构体名 数组名[元素个数] = {{}，{}，...};
4）结构体指针
- 作用：通过指针访问结构体中成员
- 操作符：->。访问结构体属性
5）结构体嵌套结构体
- 作用：结构体中成员可以是另一个结构体
6）结构体做函数参数
- 作用：将结构体作为参数向函数传递
- 传递方式：值、址（推荐）
- ===》函数名（&结构体变量名）
- 定义（例）：void text(struct student * p){}
7）结构体中const的使用
- 与之前差不多（在前值不可变，在后指向不可变）
其他
二
对面向对象的进一步学习
1始
1）c++程序执行时，将内存大方向分为4个区域
| 代码区 |
存放函数体的二进制代码，由操作系统进行管理 | 共享，只读。程序运行前 |
| 全局区 | 存放全局变量，静态变量，常量 | 操作系统释放。程序运行前 |
| 栈区 | 编译器自动分配释放，存放函数参数、局部变量等 | 不要返回局部变量地址。程序运行后 |
| 堆区 | 程序员分配释放，未释放则在程序结束由操作系统释放 | 利用new开辟。程序运行后 |
意义：灵活编程
2new关键字
堆区开辟空间，程序员手动开辟释放，释放：delete
格式：new 数据类型
new返回的是这个数据类型的指针
#include
using namespace std;
int* func() {
int* a = new int(10);
return a;
}
int main() {
int* p = func();
cout << *p << endl;//*解引用，表示的是值
delete p;//释放堆区数据
system("pause");
} 3引用
作用：给变量起别名
格式：数据类型 &别名=原名
注意：引用必须初始化，一旦初始化便不能更改
int a = 10;
int b = 20;
//int &c ;//未初始化
int &c = a;//初始化后不能更改
c = b;//赋值操作，不是更改
3.1）引用做函数参数
作用：让形参修饰实参
优点：简化指针修改实参
void myswap1(int a,int b) {//值传递
int temp = a;
a = b;
b = temp;
}
void myswap2(int* a, int* b) {//地址传递
int temp = *a;
*a = *b;
*b = temp;
}
void myswap3(int &a, int &b) {//引用传递
int temp = a;
a = b;
b = temp;
}
//int a = 10;
//int b = 20;
//myswap1(a,b);//值传递，不改变实参
//myswap2(&a,&b);//地址传递，改变实参
//myswap3(a,b);//引用传递，改变实参3.2)引用做函数返回值
作用：引用做函数返回值
注意：不要返回局部变量引用
用法：函数调用作为左值
int& text01() {
int a = 10;//局部变量
return a;
}
int& text02() {
static int a = 10;//全局变量
return a;
}
int &c = text01();
cout << c << endl;//第一次结果正确，编译器保留
cout << c;//第二次结果错误，a的内存已经释放3.3）引用的本质
在c++内部实现一个指针常量
void text02(int& re) {//引用自动转换：int* const re = &a;
re = 100;//转换：*re = 100;
}
void text01() {
int a = 10;
int& tep = a;//引用自动转换：int* const tep = &a;指针常量是指针指向不可更改
tep = 20;//转换：*tep = 100;
cout << a << endl;
cout << tep << endl;
text02(a);
cout << a << endl;
cout << tep << endl;
}
//结果10 10 100 1003.4）常量引用
作用：防止误操作
格式：const 数据类型& 形参名
4函数+
4.1）函数默认参数
格式：返回值类型 函数名 （参数 = 默认值）{}
注意：①某位置有默认参数，该位置往后必须有默认参数②函数声明有默认参数，函数实现（定义）不能有默认函数
4.2）函数占位参数
形参表里可以有占位参数，用来占位，调用函数时必须填补
格式： 返回值类型 函数名 (数据类型) {}
4.3）函数重载
作用：函数名可以相同，提高复用性
条件：①同一个作用域下②函数名相同③函数参数类型不同或个数不同或顺序不同
注意：函数返回值不可以作为函数重载的条件
注意事项：①引用作为重载条件√②碰到默认参数×会出错
5类、对象
面向对象三大特征：封装、继承、多态
万物皆可为对象
5.1）封装
5.1.1）
意义1：
| 将属性和行为作为一个整体，表型生活中的事物 |
| 将属性和行为加以控制 |
格式：class 类名{ 访问权限 ：属性/行为 }；
实例：学生类
class student {//定义学生类
public:
string m_name;
int m_age;
public:
void setstu(string name,int age) {//赋信息的方法
m_name = name;
m_age = age;
}
void showstu() {//显示信息的方法
cout << "姓名：" << m_name << "\t年龄：" << m_age << endl;
}
};
void text() {
student st1;
st1.setstu("张三",18);
st1.showstu();
}意义2：访问权限
| public | 公共权限 | 类内可以访问，类外可以访问 |
| protected | 保护权限 | 类内可以访问，类外不可以访问，儿子可以访问父亲保护的内容 |
| private | 私有权限 | 类内可以访问，类外不可以访问，儿子不可以访问父亲保护的内容 |
成员属性设置为私有的优点：
- 可以自己控制读写权限
- 对于写权限，可以检测数据的有效性
5.1.2）struct与class的区别
默认的访问权限不同：
- struct默认权限为公共
- class默认权限为私有
5.2）对象的初始化和清理
出厂设置...删除数据
5.2.1）构造函数与析构函数
对象或变量未初始化，对其使用后果未知
使用完的对象和变量未及时清理，有安全问题
构造函数与析构函数解决上述。编译器自动调用，我们不提供，系统自动提供空实现
| 构造函数 | 创建对象时为对象的成员属性赋值 |
| 析构函数 | 在对象清理前自动调用，执行清理工作 |
构造函数语法：类名（）{}
- 没有返回值也不写void
- 函数名与类名相同
- 可以有参数，因此可以发生重载
- 自动调用，执行一次
析构函数语法：~类名（）{}
- 没有返回值也不写void
- 函数名与类名相同，在类名前加~
- 不可以有参数，因此不可以发生重载
- 自动调用，执行一次
如上述例子的学生类中：student st1;//为栈上数据，在执行完text（）后，释放这个对象
5.2.2）构造函数的分类与调用
两种分类方式：
- 按参数分类：有/无
- 按类型分类：普通/拷贝构造
Person(const Person &p){//拷贝构造 //将传入的人身上的所以属性，拷贝到我的身上 m_age = p.age; }
三种调用方式：
- 括号法；
Person p1;//默认构造函数，不要写（），否则会认为是一个声明 Person p2(10);//有参构造 Person p3(p2);//拷贝构造 - 显示法；
Person p1; Person p2 = Person(10); Person p3 = Person(p2); Person(10);//匿名构造，特点：当前行执行完，系统会立即回收匿名函数,即马上析构 //不要用拷贝构造初始化匿名对象，如：Person(p3); - 隐私转换法；
Person p4 = 10;//相当于Person p4 = Person(10); Person p5 = p4;
5.2.3）拷贝函数的调用时机
3情况：
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
-
void dowor(Person p){//第二种 } void text02(){ Person p2; dowor(p2); } //第三种 Person dowoo(){ Person p3; //cout<<(int*)&p3<
5.2.4)构造函数的调用规则
默认，c++编译器至少给一个类添加3个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性值拷贝
构造函数调用规则如下：
- 用户定义有参构造，c++不提供默认构造函数，但提供默认拷贝构造
- 用户定义拷贝构造，c++不提供其他
5.2.5）深拷贝，浅拷贝
| 浅拷贝 | 简单拷贝 | （自己理解）如果开辟了空间，拷贝仍然指向同一个堆中区域、空间的值，在某一方释放该空间时会让另一方出错（重复释放） |
| 深拷贝 | 在堆区重新申请空间，进行拷贝（new） | 再开辟空间（重构拷贝用深拷贝解决浅拷贝问题） |
析构代码：将堆区开辟的数据做释放操作
m_heig = new int(heih);//再开辟
~Person(){
if(m_heig != NULL){
delete m_heig;
m_heig = NULL;
}
}例子：
class person {
public:
person(){
cout << "无参构造" << endl;
mage = 0;
mhhhe = 0;
}
person(int age, int hhhe) {
cout << "有参构造" << endl;
mage = age;
mhhhe = new int(hhhe);
}
person(const person& p) {
cout << "拷贝构造" << endl;
mage = p.mage;
//mhhhe = p.mhhhe;//浅拷贝，默认拷贝
mhhhe = new int(*p.mhhhe);//深拷贝，重构拷贝
}
~person() {
if (mhhhe != NULL) {
delete mhhhe;
mhhhe = NULL;
}
cout << "析构函数" << endl;
}
public:
int mage;
int *mhhhe;
};
void text() {
person p1(10,20);
cout << p1.mage << endl;
cout << *p1.mhhhe << endl;
person p2(p1);
cout << p2.mage << endl;
cout << *p2.mhhhe << endl;
}浅拷贝（默认拷贝会发生问题）
5.2.6）初始化列表
作用：初始化属性
格式：构造函数()：属性(值1),属性(值2)...{}
Person(int a,int b):ma(a),mb(b)//初始化列表
{}//初始化列表
int ma;
int mb;
};//上面是在类内
Person p(10,20);//调用5.2.7）类对象做类成员
例：
class A{}
class B{
A a;
}
//我拿我的手机
//a构造--b构造--b析构--a析构5.2.8）静态成员
静态成员就是在成员变量或成员函数前加关键字static
| 静态成员变量 | 所有对象共用一份数据 在编译阶段分配数据 类内声明，类外初始化 |
| 静态成员函数 | 所有对象共用一个函数 静态成员函数只能访问静态成员变量 |
class person {
public:
static int ma;//类内声明
};
int person::ma = 100;//类外定义（初始化）静态成员的访问2种方式
void text() {
//1，创建对象
person p1;
cout << p1.ma << endl;
//2，通过类名
cout << person::ma << endl;
}静态成员也有访问权限，不同权限下，访问结果不同；
5.3）c++对象模型、this指针
5.3.1）成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上，占对象空间。静态成员变量，成员函数（一个函数实例）都不占
c++会为每个空对象分配一个空间
5.3.2）this指针概念
解决5.3.1中代码如何区分一个函数实例问题，（如何知道是自己的函数）
this指针指向被调动的成员函数所属的对象。（谁调用指谁）
this指针是隐含在每一个非静态成员函数内的一种指针
不需要定义，直接使用
用途：
当形参和成员变量同名时，可以用this区分
在类的非静态成员函数中返回对象本身，可以用return *this
5.3.3）空指针访问成员函数
空指针也可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断代码健全性
if (this == NULL) {
return;
}
5.3.4）const修饰成员函数
| 常函数 | 成员函数加上const后称为常函数 常函数不可修改成员属性 成员属性声明时加关键字mutable后，在常函数中依旧可以修改 |
| 常对象 | 声明（实例）对象前加const称为常对象 常对象只能调用常函数 |
5.4）友元friend
有些私属性，可让类外特殊的一些函数或类访问
让一个函数或类访问另一个类中私有成员
友元关键字：friend
友元的三种实现
| 全局函数做友元 |
| 类做友元 |
| 成员函数做友元 |
5.5）运算符重载operator
对已有的运算符重新定义，赋予其另一种功能，以适应不同的数据类型（自定义类型）
关键字：operator
//例 加法
class jia1 {
public:
int a ;
//通过成员函数重载
jia1 operator+ (jia1 jiaa) {//对应j5
jia1 temp;
temp.a = jiaa.a + this->a;
return temp;
}
};
jia1 jiafacongzai(jia1 jiaa, jia1 jiaaa) {//以函数方式，对应j4
jia1 temp;
temp.a = jiaa.a + jiaaa.a;
return temp;
}
//通过全局函数重载
//jia1 operator+(jia1 jiaa, jia1 jiaaa) {//关键字operator可简化函数名不写，对应j5
// jia1 temp;
// temp.a = jiaa.a + jiaaa.a;
// return temp;
//}
void jia() {
jia1 j1;
j1.a = 10;
jia1 j2;
j2.a = 20;
jia1 j3;
j3.a = j1.a + j2.a;//普通加法
cout << j3.a << endl;
jia1 j4;
j4 = jiafacongzai(j1, j2);
cout << j4.a << endl;
jia1 j5 = j1 + j2;
}另：c++编译器给一个类添加4个函数
默认构造函数，无参，函数体为空
默认析构函数，无参，函数体为空
默认拷贝函数，无参，对属性进行值拷贝
赋值运算符operator=，对属性进行值拷贝
5.6）继承
面向对象的三大特性之一
5.6.1）
优点：减少重复代码
格式：class 子类：继承方式 父类
子类又名派生类，父类又名基类
子类成员：
- 一是继承过来的（表现共性），二是自己增添的（表现个性）
继承方式：
|
|
|
|
|
|
|
|
|
父类中继承过来的属性：
|
|
|
|
|
|
继承的构造和析构顺序：
- 父类构造--子类构造--子类析构--父类析构
继承同名处理方式：（通过子类访问时）
子类出现父类同名的成员函数，会隐藏父类的
- 访问子类同名成员：直接访问
- 访问父类同名成员：通过作用域访问（base::）
多继承：
- 格式：class 子类：继承方式 父类1，继承方式 父类2
- 同名加作用域区分
菱形继承：
两个派生类b'c继承同一个基类a，又有某个类c同时继承两个派生类
菱形继承问题：基类a中的某份数据会重复继承
解决方法，虚继承：在继承之前加上关键字virtual
class A{};
class B:virtual public A{};
class c:virtual public A{};
//5.7)多态
面向对象的三大特性之一
分为两类 ：
| 静态多态 | 函数重载和运算符重载属于静态多态，复用函数名 | 的函数地址早绑定：编译阶段确定函数地址 |
| 动态多态 | 派生类和虚函数运行时多态 | 的函数地址晚绑定：运行阶段确定函数地址 |
动态多态满足条件：
- 有继承关系
- 子类重写父类的虚函数
动态多态的使用：
- 父类的指针或引用，执行子类对象
多态优点：
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展和维护
例
class Animal {
public:
virtual void move() {//缺少virtual的时候，结果都为“动物在走”
cout << "动物在走" << endl;
}
};
class cat :public Animal {
public:
void move() {
cout << "猫在走猫步" << endl;
}
};
class big :public Animal {
public:
void move() {
cout << "猪在跳舞" << endl;
}
};
void moveaaa(Animal& animal) {
animal.move();
}
void text() {
cout << "zhixin " << endl;
cat cat1;
moveaaa(cat1);
big big1;
moveaaa(big1);
}纯虚函数/抽象类：
- 多态中父类的虚函数实现是无意义的，可转换为纯虚函数
- 格式：virtual 返回值类型 函数名 （参数列表） = 0；
- 当类中有纯虚函数，这个类称为抽象类
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也是抽象类
-
virtual void move() = 0;
虚析构和纯虚析构：
多态使用时，如果子类中有属性开辟到堆区，那么父类在释放时无法调用到子类的析构代码
Animal * animal = new Cat("tom");//这种情况下解决方法：将父类中的析构函数改为虚析构或纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚函数，该类属于抽象类，无法实例化对象
虚析构格式：
- virtual ~类名(){}
纯虚析构格式：
- virtual ~类名() = 0;
- 类名::~类名(){}
6文件操作
程序运行产生的数据属于临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化
6.1）
C++中对文件操作需要包含头文件
文件类型分两类：
| 文本文件 | 文件以文本的ASCLL码的形式存储在计算机内 |
| 二进制文件 | 文件以文本的二进制的形式存储在计算机内，用户一般不能读懂 |
操作文件的三大类：
| ofstream | 写操作 |
| ifstream | 读文件 |
| fstream | 读写操作 |
6.2）文本文件：
6.2.1）写文件：
- ①包含头文件：#include
- ②创建流对象：ofstream ofs;
- ③打开文件：ofs.open("文本路径",打开方式);
- ④写数据：ofs<<"写入的数据";
- ⑤关闭文件：ofs.close();
文件打开方式：
| 打开方式 | |
| ios::in | 为读而打开文件， |
| ios::out | 为写而打开文件，会删除原来的内容 |
| ios::ate | 初始位置：文件尾，会删除原来的内容 |
| ios::app | 追加方式写文件 |
| ios::trunc | 如果文件存在先删除，再创建 |
| ios::binary | 二进制方式 |
注意：文件打开方式可以配合使用，利用|操作符
例：用二进制方式写文件ios::binary| ios::out
6.2.2）读文件：
- ①包含头文件：#include
- ②创建流对象：ifstream ifs;
- ③打开文件：ifs.open("文本路径",打开方式);
-
//打开文件判断是否成功 //ifs.open(...); if(!ifs.is_open()) { cout<<"文本打开失败"< - ④写数据：四种方式读取
- ⑤关闭文件：ofs.close();
有4种读数据方式：
①
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 << endl;
}6.3）二进制文件
以二进制的方式对文本进行 读写操作
打开方式要指定为ios::binary
6.3.1）写文件
主要利用流对象调用成员函数write
函数原型：ostre write (const char* buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数。
//片段
Person p={"张三",18};
ofs.write((const char*)&P,sizeof(Person));6.3.2)读文件
主要利用流对象调用成员函数read
函数原型：istream& write (const char* buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数。
//片段
Person P;
ifs.read((char *)&P, sizeof(Person));