投稿
  1. 首页
  2. 随笔

C++ 核心编程

推女郎 • 2022-12-15 • 随笔 • 阅读 15

C++ 核心编程,第1张

C++ 核心编程

##0.前言
最近在做算法移植的时候，发现自己对c++的知识忘得很多，于是就计划重新捡起来。
纸上得来终觉浅，绝知此事要躬行
一直都是我学习和工作的原则，我比较喜欢动手。
于是我把c++的基础知识一行行代码敲了一遍！

1.内存分区模型

c++内存分为4个区域：

  • 代码区：存放函数体的二进制代码，由 *** 作系统进行管理。

  • 全局区：存放全局变量、静态变量、常量

  • 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。

  • 堆区：由程序员分配和释放，若程序员不释放，程序结束时由 *** 作系统回收

内存分区的意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。

1.1 程序运行前

在程序编译后，生产了exe可执行程序，未执行该程序前分为
代码区：

存放cpu执行的机器指令
1.共享：目的是对于频繁被执行的程序，只需内存中由一份代码即可。
2.只读：防止程序被随意修改指令

全局区：

全局变量包含常量区：字符串常量和其他常量
程序结束后，系统自己释放全局区的数据
const修饰的局部变量(局部常量),不放在全局区，而是放在栈区
int fun() {
 const int a =10;//局部常量
}

总结：

  • c++在exe程序运行前分为全局区和代码区
  • 代码区的特点是只读和共享
  • 全局区中存放全局变量 静态变量 常量
  • 常量区中存放const修饰的全局变量(即全局常量) 和 字符串常量
1.2 程序运行后

栈区
由编译器自动分配和释放，函数的参数，局部变量等
注意事项：不与返回局部变量的地址，栈区开辟的数据在函数结束后，编译器会自动释放

堆区
由程序员分别和释放，若程序员不释放，程序结束后，系统会自己释放，如果程序不结束，系统就永远不释放。

c++中主要用new在堆区申请内存

1.3 new的用法

new申请，务必使用delete释放

int *a = new int(10);
delete a;

int *b = new int [8];
delete [] b;//数组释放要加[]
2.引用 2.1 引用的基本使用

**作用：**给变量起别名
**语法：**数据类型 &别名 = 原名

int a =10;
int &b = a;
(本质上：int *const b = &a)
2.2 引用的注意事项
  • 1.引用必须要初始化
    int &b;//错误
  • 2.引用在初始化后，不可以改变
int a =10;
int &b = a;

int c =20;

b = c;//赋值 *** 作，而不是更改引用
2.3 引用做函数参数

**作用:**函数传参时，可以利用引用的技术，让形参修饰实参
**优点：**可以简化指针修改实参

void swap(int &a,int &b) {
	int temp = a;
	a = b;
	b = temp;
}
2.4 引用做函数返回值

作用：引用可以作为函数的返回值

注意：不要返回局部变量的引用

用法：函数调用作为左值

int& fun()
{
  static int a =10;
  return a;
}

int &ref = fun();

fun()= 100;//函数调用可以作为左值 被赋值
2.5 引用的本质

本质：引用的本质在c++内部实现是一个指针常量（指向不变，里面的值可变）

//编译器发现这里是引用，转换位int * const ref = &a;
void func(int & ref) {
  ref = 100;//ref是引用，转换位*ref = 100
}

int main(){
  int a=10;

  int& ref = a;
  //自动转换为 int* const ref = &a;
  //指针常量是指向不可更改，值可改，也说明为什么引用不可更改

  ref = 20;//发现是引用，自动转换成 *ref =20
}

结论：c++途径用引用计数，因为语法方便，引用的本质是指针常量，但是所有指针的 *** 作，编译器都帮我们做了

常量引用

**作用：**常量引用主要用来修饰形参，防止误 *** 作
const int & a;

int &ref =10;//这是错误的，引用必须引用一块合法的内存,10在常量区，访问时必须加const

int &ref =10;//这是错误的，引用必须引用一块合法的内存


const int &ref =10；//合法
//加上const之后，编译器把代码修改成


//常量引用使用场景：通常用来修饰形参，防止函数改值
void printValue(const int&a){
  //a=20；报错
  print("a=%d",a);
}
3.函数提高
3.1 函数的默认参数

在c++中，函数的形参是可以有默认值的。

语法： 返回值 函数名 (参数 = 默认值) { }

int func(int a,int b=1, int c =2) {

}

  • 如果形参中某个位置有了默认参数，从这个位置往后，从左往右都必须有默认参数

  • 如果函数声明有默认参数，函数实现就不能有默认参数，否则会报错：重定义默认参数

int fun2(int a =10);//声明
int func2(int a =10){//实现
}
这样会报错
3.2 函数占位参数

c++中的函数的形参是可以有占位参数的，用来做占位，调用函数时必须填补该位置。

语法： 返回值 函数名 （数据类型）{ }

//占位参数-第二个参数
void func(int a,int) {

}
//占位参数 还可以有默认参数
void func2(int = 10){

}

int main(){
 func(10,10);
}
3.3 函数重载 3.3.1 函数重载概述

**作用：**函数名可以相同，提高复用性

函数重载满足条件

  • 同一个作用域下
  • 函数名相同
  • 函数参数 类型不同 或者 个数不同 或者 顺序不同

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

void fun();
void fun (int a,float b)
void fun (float b,int a)
//int  fun (float b,int a) 这个会报错，二义性
3.3.2 函数重载注意事项
  • 引用作为重载条件
//1.引用作为重载条件
void func(int &a){ //int& a =10 ；不合法

}

void func(const int &a){const int &a = 10 合法

}
这两个是函数重载 int 和 const int算不同类型

int main(){
int a =10;
func(a);//此时调用第1个void func(int &a)，
//如果void func(int &a)没定义，就调用第2个
func(10);//此时调用第2个void func(const int &a)
}
  • 函数重载碰到默认参数
void func(int a){ //int& a =10 ；不合法

}
void func(int a,int b =10){
}

fun(10);//这里编译器不知道调用哪个了
这里函数会出现二义性，会报错，
一般写函数重载时，就别写默认参数了 4.类和对象

万事万物皆为对象，包含属性和行为
c++面向对象的三大特性：封装、继承、多态

4.1 封装 4.4.1 封装的意义

封装是c++面向对象的三大特性之一
意义：

  • 将属性和行为作为一个整体，表现生活中的事物
  • 将属性和行为加以权限控制f

封装的意义1：
在设计类的时候，属性和行为写一起，表现事物

**语法：**class 类名{访问权限： 属性/行为}；

设计一个圆类

//圆周率
const double PI = 3.14；

class Circle
{
//访问权限
public:

//属性
int r;//半径

//行为
double calZC(){
  return 2*PI*r;
}


Circle c ;//对象
c.r = 10;
c.calZC（）；

}

封装的意义2：
将属性和行为加以权限控制

访问权限有3种
1.public：公共权限
成员 类内可以访问，类外可以
2.protected：保护权限
成员 类内可以访问，类外不可以
3.private：私有权限
成员 类内可以访问，类外不可以

4.1.2 struct 和 class区别

在c++中，struct和class的唯一区别：
默认访问权限不同

  • struct 默认权限 公共
  • class 默认权限 私有
class C1
{
  int a;//私有
}；

struct C2 {
int  a ;//公共
}
4.1.3 成员属性设置为 私有
  • 优点1：：将所有的属性设置成私有，可以自己控制读写权限
  • **优点2：**对于写权限，可以检测数据的有效性
4.2 对象的初始化和释放 4.2.1 构造函数和析构函数

对象的初始化和释放是2个非常重要的安全问题。

对象没用初始状态，其后果是未知的
使用完对象没释放，也会造成安全难问题

  • 构造函数：创建对象时，初始化属性
  • 析构函数：销毁对象时，释放资源
    2个函数都是系统自动调用！

**构造函数语法：**类名(){ }
1.构造函数没有返回值，也不写void
2.函数名和类名相同
3.构造函数有参数，可以函数重载
4.创建对象时，自动调用一次构造函数

析构函数语法：
1.析构函数没有返回值，也不写void
2.析构函数与类名相同，在名称前加上~
3.析构函数没用参数，无法重载
4.对象销毁前会自动调用一次析构函数

Class p{
 //构造函数
 p(){ }
  //析构函数
~p(){
}
};
4.2.3构造函数的分类和调用

两种分类方式：
按照参数：有参构造和无参构造
按照类型：普通构造和拷贝构造

三种调用方式：
括号法
显示法
隐式转换法

class Person {
public:
  Person(){//无参构造
  }
  Person(int a){//有参构造
    age = a；
  }
//以上都是普通构造

  Person(const  Person &p){//拷贝构造
    age = p.age;
  }

private：
int age；
}


1.括号法
Person p1;
Person p2(10);
Person p3(p2);

2.显示法
Person p1;
Person p2  = Person(10);
Person p3 = Person(p2);

Person(6);//单独拿出来是 匿名对象
 特点：当前行执行结束后，系统会立即回收匿名对象

注意事项：
不要利用拷贝构造函数，初始化匿名对象
Person(p3);
编译器会认为Person(p3) == Person p3;



3.隐式转换法
Person p4 = 10;//相当于 Person p4 = Person(10);
Person p5 = p4;//相当于 Person p5 = Person(p4);
4.2.3 拷贝构造函数的调用时机 
class Person{
public:
  Person(){
    无参构造
  }

  Person(int a ){
    有参构造
    age =a;
  }

  Person(const Person & p){
    拷贝构造
    age = p.age;
  }

  ~Person(){
    析构函数
  }

private:
int age;
}

三种情况：

  • 使用一个已经创建完的对象来初始化一个新对象
void test(){
  Person p1(20);
  Person p2(p1);
}
  • 值传递的方式给函数参数传值
void doWork(Person p){//这里相当于Person p = my_p
  
}
void test2(){
    Person my_p;
    doWork(my_p);
}
* 以值的方式返回局部对象
```c
Person doWork3(){
  Person p;
  return p;//这里执行完后会释放p，系统会拷贝一个临时p返回
}
void test(){
  Person p = doWrok3();
}
4.2.4 构造函数调用规则

默认情况下，c++编辑器会给一个类添加3个函数

1.默认构造函数(无参 函数体为空)
2.默认析构函数(无参 函数体为空)
3.默认拷贝构造函数(对所有属性进行值拷贝)

构造函数规则：

  • 如果用户定义了有参构造，c++编辑器不在提共默认无参构造，但是会提供默认拷贝构造
  • 如果用户定义拷贝构造函数，c++不会提供其他构造函数
  Person(const Person & p){
    拷贝构造
    age = p.age;
  }
4.2.5 深拷贝和浅拷贝
  • 浅拷贝：值拷贝
  • 深拷贝: 在堆区重新申请一块内存空间，进行拷贝 *** 作
#include 
using namespace std;

class Person
{
public:
	Person()
	{
		cout<<"Person 默认构造函数"< 

总结：如果成员变量有在堆区开辟内存的，一点要自己提供拷贝构造函数，防止浅拷贝代理的堆内存重复释放问题
 
4.2.6 初始化列表 

作用
 c++提供初始化列表的语法，用来初始化属性
 

**语法：**构造函数():属性1(值1)，属性2(值2)···{}
 

#include 
using namespace std;

class Person
{
public:
	Person():m_a(10),m_b(20)
	{
		
	}
	
	Person(int a,int b):m_a(a),m_b(b)
	{
		
	}	
	int m_a;
	int m_b;
};

int main(int argc, char** argv) {
	Person p;
	cout< 
4.2.7 类对象作为类的成员 

构造时：当其他类对象作为本类成员时，构造时先构造出其他类的对象，在构造自身
 析构时：先析构自己，再析构其他类。(因为加载函数是栈的形式 后进先出)
 

class Phone
{
public:
	Phone(string name):name(name)
	{
		cout<<"Phone 有参构造函数调用"< 
4.2.8 静态成员 

在成员函数和成员变量前面加上static关键字，成为静态成员。
 

静态成员分为：
 

  • 静态成员变量 
  
    • 所有对象共享一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
     
 

class A
{
public:
  static int m_a;//类内声明
}
int A::m_a = 100;//类外初始化 要去掉static

 

  • 静态成员函数 
  
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量
    • 类外无法访问私有的成员函数或者变量
     
 

class Person
{
public:
	static void fun()
	{
		cout<<"静态成员函数"< 
4.3 C++的对象模型和this指针 
4.3.1 成员变量和成员函数分开存储 

在c++中，类内的成员变量和成员函数是分开存储的，
 只有非静态成员变量才属于类的对象上
 

  • 空对象占用内存为1个字节
     c++编译器会给每个空对象分配一个字节空间，是为了区分空对象占用内存的位置。
 

class Person
{
	
} ;

void test()
{
	Person p;//空对象
	cout< 

  • 只有非静态成员变量才属于类的对象上
 

class Person
{
	int a;//非静态成员变量 属于类的对象 此时p的内存为4 个字节
	
	static int b;//静态成员变量 不属于类对象上
	
	void fun();//非静态成员函数 不属于类对象上
	
	static void fun2();//静态成员函数 不属于类对象上 
	
} ;

void test()
{
	Person p;
	cout< 
4.3.2 this指针的概念 

this指针指向被调用的成员函数所属的对象
 谁调用this，this就指向哪个对象
 

this是隐含在非静态成员函数内的一种指针
 

this指针的用途：
 

  • 当形参和成员变量同名时，可以用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可以用return *this
 

class Person
{
public:
	Person(int age)
	{
		this->age = age;
	}
	
//这里要返回Person&，如果返回Person，系统会创建一个临时变量返回
	Person& addAge(Person &p)
	{
		this->age += p.age;
         //this指向的是p2的指针，而*this指向的是p2对象本身
		return *this;
	}
	int age;
		
} ;

 

this指向的是p2的指针，而*this指向的是p2对象本身
 
4.3.3 空指针访问成员函数 

c++中空指针也是可以调用成员函数的，
 如果要用到this指针，要加以判断，保证代码的健壮性
 

class Person
{
public:
	void showName()
	{
		cout<<"this is Person class"< 

  • 类做友元
 

class Home
{
public:
	friend class GoodGay;
	Home():m_livingRoom("客厅"), m_bedRoom("卧室")
	{
		
	}
public:
	string m_livingRoom;
private:
	string m_bedRoom;
};

class GoodGay
{
public:
	GoodGay()
	{
		h = new Home;
	}
	void visit()
	{
		cout<<"好基友正在访问:"<< h->m_livingRoom<m_bedRoom< 

  • 成员函数做友元
 

class GoodGay;

class Home
{
//成员函数做友元
	friend void GoodGay::visit(); 
public:
	Home():m_livingRoom("客厅"), m_bedRoom("卧室")
	{
		
	}
public:
	string m_livingRoom;
private:
	string m_bedRoom;
};

class GoodGay
{
public:
	GoodGay()
	{
		h = new Home;
	}
	void visit()
	{
		cout<<"好基友正在访问:"<< h->m_livingRoom<m_bedRoom< 
4.5 重载 

ps:运算符重载跳过
 
4.6 继承 

继承的好处
 减少重复的代码
 
4.6.1 继承的基本语法 

语法：
 class 子类：继承方式 父类
 子类也称为派生类
 父类也成为基类
 

class BaspePage
{
public:
	void header()
	{
		cout<<"首页 公开课 登录 注册"< 
4.6.2 继承的方式 

继承的方式一共有三种：
 

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

 

class Father
{
public:
	Father():a(1),b(1),c(1)
	{
		
	} 
public:
	int a;
protected:
	int b;
private:
	int c;	
};

class Son1:public Father
{
public:
	void fun()
	{
		a= 10; 
		b= 20;
		//c= 30;
	} 
};
void test01()
{
	Son1 s;
	s.a = 100;
	//s.b = 50; 保护权限类外无法访问 
}

 
4.6.3 继承中的对象模型 

问题：从父类继承过来的成员，哪些属于子类对象中？
 私有成员也会被子类继承，只是被编译器隐藏了，无法访问
 

class base
{
public:
	int a;
protected:
	int b;
private:
	int c;//私有成员也会被子类继承，只是被编译器隐藏了，无法访问 
};
class Son:private base
{
public:
	int d;
};


int main(int argc, char** argv) {
	Son s;
	cout< 
4.6.4 继承中构造和析构的顺序 

子类继承父类后，当创建子类对象时，也会调用父类的构造。
 

先构造父类，在构造子类，析构相反：先析构子类，再析构父类
 

class base
{
public:
	base()
	{
		std::cout<<"base 的默认构造函数"< 
4.6.5 继承中同名成员的处理方式 

问题：当子类与父类出现同名成员，如何通过子类对象，访问子类或者父类的同名数据呢？
 

  • 访问子类 同名成员，直接访问即可
  • 访问父类 同名成员，需要加作用域
 

总结：
 

  • 1.子类对象可以直接访问到子类中的同名成员
  • 2.子类对象加作用域可以访问到父类同名成员
  • 3.当子类和父类拥有同名的成员函数时，子类会隐藏父类中所有的同名函数，需要加作用域才可以访问父类的同名函数
 

class base
{
public:
	base()
	{
		m_a = 100;
	}	
	
	void fun()
	{
		cout<<"base - fun()"< 
4.6.8 菱形继承 

概念：
 2个子类继承同一个父类
 又有某个类统计继承2个子类
 这种继承被称为菱形继承，或者钻石继承
 

class Animal
{
public:
	int m_Age;
};
//继承前面加virtual关键字，变为虚继承
//此时公共父类Animal称为虚基类 
class Sheep : virtual public Animal{};//羊
class Camel : virtual public Animal{};//骆驼
class Alpaca : public Sheep , public Camel{};//羊驼 
int main() {
	Alpaca a;
	a.Sheep::m_Age = 100;
	a.Camel::m_Age = 200;
	cout<<"a.Sheep::m_Age ="< 

总结：
 

  • 菱形继承带来主要问题是 子类继承多份相同的数据，导致资源浪费。
  • 利用 虚继承 解决菱形继承问题
  • 虚继承的本质是继承指针，通过指针去访问同一份数据(m_Age)
 
4.7 多态 

多态是C++面向对象的三大特性之一
 
4.7.1 多态的基本概念 

多态分为2类：
 

  • 静态多态：函数重载和运算符重载 属于静态多态，复用函数名
  • 动态多态：派生类和虚函数实现运行时多态
 

静态多态和动态多态的区别：
 

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
 

静态多态
 

class Animal
{
public:
	void speak()
	{
		cout<<"动物在说话"< 

动态多态
 

class Animal
{
public:
    //加上virtual，变成虚函数，就可以晚绑定 ，子类的函数可加virtual 或者不加
	virtual void speak()
	{
		cout<<"动物在说话"< 

重写： 函数返回值 参数列表完全相同
 重载：函数参数列表不同，返回值相同
 

总结：
 动态多态的满足条件
 

  • 1.有继承关系
  • 2.子类重写父类的虚函数
 

动态多态的使用
 父类的指针或者引用，执行子类对象
 

class A
{
public:
   int fun(){}
}
这里 sizeof(A)= 1 
class A
{
public:
   virtual int fun(){}
}
这里 sizeof(A)= 4,因为加上 virtual ，fun就变成了一个指针(指针都是4个字节)vfptr:虚函数指针

 
4.7.2 多态案例-计算器 

普通代码实现计算器
 

//普通代码实现计算器
class NomalCal
{
public:
	int getResutl(int oper)
	{
		switch(oper)
		{
			case '+' :
				return m_a + m_b;
				break;
			case '-' :
				return m_a - m_b;
				break;
			case '*' :
				return m_a * m_b;
				break;
			//如果想扩展功能：除法，需要修改源码
			//开发中提倡开闭原则：对扩展进行开放，对修改进行关闭 
			default:
				return 0;			
		}	
	}	
	int m_a;
	int m_b;
} ;

void test1()
{
	NomalCal nc;
	nc.m_a = 10;
	nc.m_b = 10;
	cout<m_b<<" = "<getResult()< 

多态的优点：
 

  • 代码结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护，符合开闭原则
 
4.7.3 纯虚函数和抽象类 

在多态中，通常父类中的虚函数是毫无意义的，主要调用子类的重写的函数。
 

因此可以把虚函数改为纯虚函数
 

语法：virtual 返回值类型 函数名(参数列表) = 0
 

当类中只要有1个纯虚函数，也把类称为抽象类
 

抽象类的特点：
 

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
 

class base//抽象类：类中只要有一个纯虚函数 
{
public:
	//纯虚函数 
	virtual void fun() = 0;	
} ;
class Son : public base
{
public:
	virtual void fun(){}
};

 
4.7.4 多态案例2-制作饮品 

1.茶的抽象类
 

class AbsDrinKing
{
public:
	//1.煮水 
	virtual void boil() = 0;
	//2.冲泡
	virtual void brew() = 0;
	//3.倒入杯中
	virtual void pourInCup() = 0; 
	//4.加入辅料
	virtual void putSomething() = 0;
	
	void makeDrink()
	{
		boil();
		brew();
		pourInCup();
		putSomething();
	} 
};

 

2.做咖啡
 

class CofferDrink : public AbsDrinKing
{
	//1.煮水 
	virtual void boil()
	{
		cout<<"煮咖啡"< 

3.做奶茶同理
 省略···
 4.制作函数
 

void doWork(AbsDringKing *abs)
{
  abs->makeDrink();
}

 
4.7.5 虚析构和纯虚析构 

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
 

解决方式：将父类的析构函数改为虚析构或者纯虚析构
 

虚析构和纯虚析构共性：
 

  • 可以解决父类指针释放子类对象的问题
  • 都需要有具体的函数实现
 

虚析构和纯虚析构的区别：
 

  • 如果是纯虚析构，则该类属于抽象类，无法实例化对象，而虚析构可以！
 

虚析构语法：
 virtual 类名(){ }
 

纯虚析构语法:
 virtual 类名() = 0;
 类外还要写实现
 类名：：~类名(){ }
 

可能出现内存泄漏
 
 

解决办法：
 1.父类析构函数加上virtual，变成虚析构
 

class Animal
{
public:
	Animal(){cout<<"Animal 构造函数调用"< 

2.纯虚析构
 

class Animal
{
public:
	Animal(){cout<<"Animal 构造函数调用"< 

总结：
 

  • 1.虚析构和纯虚析构是用来解决 通过父类指针 释放子类对象的情况
  • 2.如果子类中没有堆区数据，可以不写虚析构或者纯虚析构
  • 3.拥有纯虚函数的类也属于抽象类
 
4.7.6 多态案例3-电脑组装 

//抽象零件
//1.抽象CPU
class CPU
{
public: 
	virtual void cal() = 0;
};
//2.抽象显卡
class VideoCard
{
public: 
	virtual void display() = 0;
};
//3.抽象内存
class Memory
{
public: 
	virtual void storage() = 0;	
} ;

//电脑类
class Computer
{
public:
	Computer(CPU *cpu,VideoCard *vc,Memory * mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
		cout<<"Computer 构造函数"<cal();
		m_vc->display();
		m_mem->storage();
	}
private:
	CPU *m_cpu;
	VideoCard *m_vc;
	Memory *m_mem;
};

//intel 电脑 
class IntelCPU : public CPU
{
public:
	void cal(){cout<<"Intel cpu 工作了"<doWork();
	delete com1; 
} 

int main(int argc, char** argv) {
	test();
	return 0;
}

 

 
5.文件 *** 作 

文件类型分为2类：
 **1.文本文件：**文本以ASCII码形式存储在计算机中
 **2.二进制文件：**文本以二进制形式存储在计算机中
 

头文件：
 

 *** 作文件的三大类：
 1.ofstream：写 *** 作
 2.ifstream：读 *** 作
 3.fstream：读写 *** 作
 
5.1文本文件 
5.1.1 写文件 

写文件步骤：
 1.包含头文件
 #include 
 2.创建流对象
 ofstream ofs;
 3.打开文件
 ofs.open(“文件路径”，打开方式)
 4.写数据
 ofs<<“数据”；
 5.关闭文件
 ofs.close();
 

文件的打开方式：
 
打开方式解释ios::in读ios::out写ios::ate初始位置：文件尾ios::app追加方式写文件ios::trunc如果文件存在，先删除 再创建ios::binary二进制形式

//文本文件 写文件
void test()
{
	ofstream ofs;
	ofs.open("test.txt",ios::out);
	ofs<<"张三 18";
	ofs.close(); 
} 

 
5.1.2 读文件 

读文件步骤：
 1.包含头文件
 #include 
 2.创建流对象
 ifstream ifs;
 3.打开文件
 ifs.open(“文件路径”，打开方式)
 4.写数据
 四种方式读取；
 5.关闭文件
 ifs.close();
 

void test()
{
	ifstream ifs;
	ifs.open("test.txt",ios::in);
	if(!ifs.is_open())
	{
		cout<<"文件打开失败"<> buf) 
//	{
//		cout< 
5.2 二进制文件 

以二进制的方式对文件进行读写 *** 作，
 打开方式要指定为ios::binary
 
5.2.1 二进制方式写文件 

class Person
{
public:
	char m_Name[64];
	int m_age;	
} ;

void test()
{
	//1.引入头文件 #include 
	
	//2.创建流对象
	ofstream ofs;//或者ofs("person.txt",ios::out|ios::binary); 
	//3.打开文件
	ofs.open("person.txt",ios::out|ios::binary);
	//4.写文件 
	Person p = {"张三",18};
	ofs.write((const char*)&p,sizeof(Person));
	//5.关闭文件
	ofs.close(); 
}

 
5.2.2 二进制方式读文件 

二进制方式读文件主要利用流对象的成员函数read
 函数原型：istream& read(char *buffer,int len);
 

class Person
{
public:
	char m_Name[64];
	int m_age;	
} ;

void test()
{
	//1.引入头文件
	
	//2.创建流对象
	ifstream ifs;
	//3.打开文件
	ifs.open("person.txt",ios::in);
	if(!ifs.is_open())
	{
		cout<<"文件打开失败！"< 

继续当一名咸鱼(￣︶￣)!
 
Stay hungry，Stay foolish！					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/5592965.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
推女郎 推女郎 一级用户组
0 0
上一篇 2022-12-15
下一篇 2022-12-15

发表评论

登录后才能评论

评论列表（0条）

保存