• C++之多态以及文件处理

    多态

    1 多态的基本概念

    多态是C++面向对象三大特性之一

    多态分为两类：

    静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名

    动态多态: 派生类和虚函数实现运行时多态

    静态多态和动态多态区别:

    静态多态的函数地址早绑定-编译阶段确定函数地址

    动态多态的函数地址晚绑定-运行阶段确定函数地址

    下面通过案例进行讲解多态

    1，静态多态的函数地址早绑定-编译阶段确定函数地址

    1. #include<iostream>
    2. using namespace std;
    3. //多态
    4.  
    5. //动物类
    6. class Animal
    7. {
    8. public:
    9. 	void speak()
    10. 	{
    11. 		cout << "动物在说话" << endl;
    12. 	}
    13. };
    14.  
    15. class Cat :public Animal
    16. {
    17. public:
    18. 	void speak()
    19. 	{
    20. 		cout << "小猫在说话" << endl;
    21. 	}
    22. };
    23.  
    24. //执行说话的函数
    25. //静态多态的函数地址早绑定-编译阶段确定函数地址
    26. void doWork(Animal& animal)//Animal& animal = cat;
    27. {
    28. 	animal.speak();
    29. }
    30.  
    31. void test()
    32. {
    33. 	Cat cat;
    34. 	doWork(cat);
    35. }
    36.  
    37. int main()
    38. {
    39. 	test();
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    如果想执行让小猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段绑定，地址晚绑定

    1. #include<iostream>
    2. using namespace std;
    3. //多态
    4.  
    5. //动物类
    6. class Animal
    7. {
    8. public:
    9. 	//虚函数  加上virtual变成虚函数，那么编译器在编译的时候就不能缺点函数调用了
    10.     //那么就只能在运行时确认函数地址，则变成晚绑定
    11. 	virtual void speak()
    12. 	{
    13. 		cout << "动物在说话" << endl;
    14. 	}
    15. };
    16.  
    17. //猫类
    18. class Cat :public Animal
    19. {
    20. public:
    21. 	//重写 函数返回值类型 函数名 参数列表 完全相同
    22. 	virtual void speak()
    23. 	{
    24. 		cout << "小猫在说话" << endl;
    25. 	}
    26. };
    27.  
    28. class Dog :public Animal
    29. {
    30. public:
    31. 	void speak()
    32. 	{
    33. 		cout << "小狗在说话" << endl;
    34. 	}
    35. };
    36. //我们希望传入什么对象，那么就调用什么对象的函数
    37. //如果函数地址在编译结点就能缺点，那么静态联编
    38. //如果函数地址在运行时才能缺点，那么就是动态联编
    39.  
    40. void doWork(Animal& animal)//Animal& animal = cat;
    41. {
    42. 	animal.speak();
    43. }
    44. //执行说话的函数
    45. //静态多态的函数地址早绑定-编译阶段确定函数地址
    46. //如果想执行让小猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段绑定，地址晚绑定
    47.  
    48. //动态多态满足条件：
    49. //1，有继承关系
    50. //2，子类出现父类的虚函数
    51.  
    52. //动态多态使用
    53. //父类的指针或者引用 执行子类对象
    54. void test()
    55. {
    56. 	Cat cat;
    57. 	doWork(cat);
    58.  
    59. 	Dog dog;
    60. 	doWork(dog);
    61. }
    62.  
    63. int main()
    64. {
    65. 	test();
    66.  
    67. 	system("pause");
    68.  
    69. 	return 0;
    70. }

     

     总结：多态满足条件
    有继承关系
    子类重写父类中的虚函数
    多态使用条件：
    父类指针或引用指向子类对象
    重写:函数返回值类型 函数名 参数列表 完全一致称为重写

    2，多态案例——计算器类

    案例描述:

    分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

    多态的优点:

    代码组织结构清晰

    可读性强

    利于前期和后期的扩展以及维护

    示例：

    普通实现：

    1. #include<iostream>
    2. using namespace std;
    3. class Calculator
    4. {
    5. public:
    6. 	int getResult(string oper)
    7. 	{
    8. 		if (oper == "+")
    9. 		{
    10. 			return m_Num1 + m_Num2;
    11. 		}
    12. 		else if (oper == "-")
    13. 		{
    14. 			return m_Num1 - m_Num2;
    15. 		}
    16. 	
    17. 		else if (oper == "*")
    18. 		{
    19. 			return m_Num1 * m_Num2;
    20. 		}
    21. 		else 
    22. 		{
    23. 			return m_Num1 / m_Num2;
    24. 		}
    25. 	}
    26. 	int m_Num1;//操作数1
    27. 	int m_Num2;//操作数2
    28. };
    29.  
    30. void test()
    31. {
    32. 	Calculator c;
    33. 	c.m_Num1 = 100;
    34. 	c.m_Num2 = 100;
    35.  
    36. 	cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
    37.  
    38. 	cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
    39.  
    40. 	cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
    41.  
    42. 	cout << c.m_Num1 << "/" << c.m_Num2 << "=" << c.getResult("/") << endl;
    43. }
    44. int main()
    45. {
    46. 	test();
    47.  
    48. 	system("pause");
    49.  
    50. 	return 0;
    51. }

     

    多态实现：

     如果想扩展新的功能，需要修改源码

    在真实开发中，提供 开闭原则

    开闭原则：对扩展进行开发，对修改进行关闭

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. class AbstractCalculator
    6. {
    7. public:
    8. 	virtual int getResult()
    9. 	{
    10. 		return 0;
    11. 	}
    12. 	int m_Num1;//操作数1
    13. 	int m_Num2;//操作数2
    14. };
    15.  
    16. class AddCalculator :public AbstractCalculator
    17. {
    18. 	int getResult()
    19. 	{
    20. 		return m_Num1 + m_Num2;
    21. 	}
    22. };
    23.  
    24. class SubCalculator :public AbstractCalculator
    25. {
    26. 	int getResult()
    27. 	{
    28. 		return m_Num1 - m_Num2;
    29. 	}
    30. };
    31.  
    32. class MulCalculator :public AbstractCalculator
    33. {
    34. 	int getResult()
    35. 	{
    36. 		return m_Num1 * m_Num2;
    37. 	}
    38. };
    39.  
    40. class DivCalculator :public AbstractCalculator
    41. {
    42. 	int getResult()
    43. 	{
    44. 		return m_Num1 / m_Num2;
    45. 	}
    46. };
    47.  
    48. void test()
    49. {
    50. 	//多态使用条件
    51. 	//父类制作或者引用指向子类对象
    52. 	
    53. 	AbstractCalculator* abs = new AddCalculator;
    54. 	abs->m_Num1 = 100;
    55. 	abs->m_Num2 = 100;
    56. 	cout << abs->m_Num1 << "+" << abs->m_Num2 << "=" << abs->getResult() << endl;
    57. 	//用完记得销毁
    58. 	delete abs;
    59.  
    60. 	abs = new SubCalculator;
    61. 	abs->m_Num1 = 100;
    62. 	abs->m_Num2 = 100;
    63. 	cout << abs->m_Num1 << "-" << abs->m_Num2 << "=" << abs->getResult() << endl;
    64. 	//用完记得销毁
    65. 	delete abs;
    66.  
    67. 	abs = new MulCalculator;
    68. 	abs->m_Num1 = 100;
    69. 	abs->m_Num2 = 100;
    70. 	cout << abs->m_Num1 << "*" << abs->m_Num2 << "=" << abs->getResult() << endl;
    71. 	//用完记得销毁
    72. 	delete abs;
    73.  
    74. 	abs = new DivCalculator;
    75. 	abs->m_Num1 = 100;
    76. 	abs->m_Num2 = 100;
    77. 	cout << abs->m_Num1 << "/" << abs->m_Num2 << "=" << abs->getResult() << endl;
    78. 	//用完记得销毁
    79. 	delete abs;
    80. }
    81. int main()
    82. {
    83. 	test();
    84.  
    85. 	system("pause");
    86.  
    87. 	return 0;
    88. }

    利用多态实现计算器//多态好处:
    1、组织结构清晰
    2、可读性强
    3、对于前期和后期扩展以及维护性高 

    C++开发提出利用多态设计程序架构，因为多态优点很多 

    3，纯虚函数和抽象类

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

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

    纯虚函数语法:virtual 返回值类型 函数名(参数列表) = 0;

    当类中有了纯虚函数，这个类也称为抽象类

    抽象类特点:

    无法实例化对象

    子类必须重写抽象类中的纯虚函数，否则也属于抽象类

    1. #include<iostream>
    2. using namespace std;
    3. class Base
    4. {
    5. 	//纯虚函数
    6. 	//只要有一个纯虚函数，这个类就称为抽象类
    7. 	//抽象类特点：
    8. 	//1，无法实例化对象
    9. 	//2,抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
    10. public:
    11. 	virtual void func() = 0;
    12.  
    13. };
    14.  
    15. class Son:public Base 
    16. {
    17. public:
    18. 	virtual void func() 
    19. 	{
    20. 		cout << "func 函数调用" << endl;
    21. 	};
    22.  
    23. };
    24. void test()
    25. {
    26. 	//Base b;//抽象类无法实例化对象
    27. 	//new Base;//抽象类无法实例化对象
    28. 	Son s;//抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
    29.  
    30. 	Base * base = new Son;
    31. 	base->func();
    32. 	delete base;
    33. }
    34. int main()
    35. {
    36. 	test();
    37.  
    38. 	system("pause");
    39.  
    40. 	return 0;
    41. }

     

    4，多态案例二——制作饮品

    案例描述:

    制作饮品的大致流程为:煮水-冲泡-倒入杯中-加入辅料

    利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. class AbstractDrinking
    5. {
    6. public:
    7. 	//煮水
    8. 	virtual void Boil() = 0;
    9.  
    10. 	//冲泡
    11. 	virtual void Brew() = 0;
    12.  
    13. 	//倒入杯中
    14. 	virtual void PourInCup() = 0;
    15.  
    16. 	//加入辅料
    17. 	virtual void PutSomething() = 0;
    18.  
    19. 	void makeDrink()
    20. 	{
    21. 		Boil();
    22. 		Brew();
    23. 		PourInCup();
    24. 		PutSomething();
    25. 	}
    26. };
    27. //制作咖啡
    28. class Coffee :public AbstractDrinking
    29. {
    30. public:
    31. 	//煮水
    32. 	virtual void Boil()
    33. 	{
    34. 		cout << "煮开水" << endl;
    35. 	}
    36.  
    37. 	//冲泡
    38. 	virtual void Brew()
    39. 	{
    40. 		cout << "冲泡咖啡" << endl;
    41. 	}
    42.  
    43. 	//倒入杯中
    44. 	virtual void PourInCup()
    45. 	{
    46. 		cout << "倒入杯中" << endl;
    47. 	}
    48.  
    49. 	//加入辅料
    50. 	virtual void PutSomething()
    51. 	{
    52. 		cout << "加入牛奶和糖" << endl;
    53. 	}
    54. };
    55.  
    56. //制作茶
    57. class Tea :public AbstractDrinking
    58. {
    59. public:
    60. 	//煮水
    61. 	virtual void Boil()
    62. 	{
    63. 		cout << "煮开水" << endl;
    64. 	}
    65.  
    66. 	//冲泡
    67. 	virtual void Brew()
    68. 	{
    69. 		cout << "冲泡茶叶" << endl;
    70. 	}
    71.  
    72. 	//倒入杯中
    73. 	virtual void PourInCup()
    74. 	{
    75. 		cout << "倒入杯中" << endl;
    76. 	}
    77.  
    78. 	//加入辅料
    79. 	virtual void PutSomething()
    80. 	{
    81. 		cout << "加入枸杞" << endl;
    82. 	}
    83. };
    84.  
    85. //制作函数
    86. void doWork(AbstractDrinking* abs)
    87. {
    88. 	abs->makeDrink();
    89. 	delete abs;
    90. }
    91.  
    92. void test()
    93. {
    94. 	//制作咖啡
    95. 	cout << "制作咖啡：" << endl;
    96. 	doWork(new Coffee);
    97.  
    98. 	cout << "---------------------" << endl;
    99. 	cout << "制作茶：" << endl;
    100. 	//制作茶
    101. 	doWork(new Tea);
    102. }
    103. int main()
    104. {
    105. 	test();
    106.  
    107. 	system("pause");
    108.  
    109. 	return 0;
    110. }

     

     

    5，虚构函数和纯虚函数

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

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

    虚析构和纯虚析构共性:

    可以解决父类指针释放子类对象

    都需要有具体的函数实现

    虚析构和纯虚析构区别:

    如果是纯虚析构，该类属于抽象类，无法实例化对象

    虚析构函数的语法：

    virtual ~类名（）{}

    纯虚析构语法：

    virtual ~类名（）=0；

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. //动物类
    6. class Animal
    7. {
    8. public:
    9. 	Animal()
    10. 	{
    11. 		cout << "Animal构造函数调用" << endl;
    12. 	}
    13. 	//利用虚析构函数可以解决 父类指针释放子类对象时不干净的问题
    14. 	//~Animal()
    15. 	//{
    16. 	//	cout << "Animal析构函数调用" << endl;
    17. 	//}
    18. 	 
    19. 	//纯虚析构  需要声明也需要实现
    20. 	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
    21. 	virtual ~Animal() = 0;
    22. 	 
    23. 	//纯虚函数
    24. 	virtual void speak() = 0;
    25. };
    26. Animal:: ~Animal()
    27. {
    28.  
    29. }
    30.  
    31. //猫类
    32. class Cat :public Animal
    33. {
    34. public:
    35. 	Cat(string name)
    36. 	{
    37. 		cout << "Cat构造函数调用" << endl;
    38. 		m_Name = new string(name);
    39. 	}
    40. 	//重写 函数返回值类型 函数名 参数列表 完全相同
    41. 	virtual void speak()
    42. 	{
    43. 		cout << "小猫在说话" << endl;
    44. 	}
    45. 	~Cat()
    46. 	{
    47. 		if (m_Name != NULL)
    48. 		{
    49. 			cout << "Cat析构函数调用" << endl;
    50. 			delete m_Name;
    51. 			m_Name = NULL;
    52. 		}
    53. 	}
    54. 	string *m_Name;
    55. };
    56.  
    57.  
    58. void doWork(Animal& animal)//Animal& animal = cat;
    59. {
    60. 	animal.speak();
    61. }
    62.  
    63. void test()
    64. {
    65. 	Animal* animal = new Cat("Tom");
    66. 	animal->speak();
    67. 	//父类指针在析构时候，不会调用子类中析构函数，
    68. 	// 导致子类如果有堆区属性，出现内存泄露情况
    69. 	delete animal;
    70. }
    71.  
    72. int main()
    73. {
    74. 	test();
    75.  
    76. 	system("pause");
    77.  
    78. 	return 0;
    79. }

     

    总结： 

    1.虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
    2.如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
    3.拥有纯虚析构函数的类也属于抽象类 

    6，多态案例三——电脑组装

    案例描述:

    电脑主要组成部件为CPU(用于计算)，显卡(用于显示)，内存条(用于存储)将每个零件封装出抽象基

    类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商创建电脑类提供让电脑工

    作的函数，并且调用每个零件工作的接口测试时组装三台不同的电脑进行工作

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. class CPU//抽象出每个零件的类
    6. {
    7. public:
    8. 	//抽象计算函数
    9. 	virtual void  calculate() = 0;
    10. };
    11. //抽象的显卡
    12. class VideoCard 
    13. {
    14. public:
    15. 	//抽象显示函数
    16. 	virtual void  display () = 0;
    17. };
    18.  
    19. //抽象类
    20. class Memory
    21. {
    22. public:
    23. 	//抽象存储函数
    24. 	virtual void  storage() = 0;
    25. };
    26.  
    27. //电脑类
    28. class Computer
    29. {
    30. public:
    31. 	Computer(CPU * cpu, VideoCard * vc, Memory * mem)
    32. 	{
    33. 		m_cpu = cpu;
    34. 		m_vc = vc;
    35. 		m_mem = mem;
    36. 	}
    37.  
    38. 	//提供工作函数
    39. 	void work()
    40. 	{
    41. 		//让零件工作起来，调用接口
    42. 		m_cpu->calculate();
    43.  
    44. 		m_vc->display();
    45.  
    46. 		m_mem->storage();
    47. 	}
    48.  
    49. 	//提供析构函数 释放3个电脑零件
    50. 	~Computer()
    51. 	{
    52. 		//释放cpu零件
    53. 		if (m_cpu != NULL)
    54. 		{
    55. 			delete m_cpu;
    56. 			m_cpu = NULL;
    57. 		}
    58.  
    59. 		//释放显卡零件
    60. 		if (m_vc != NULL)
    61. 		{
    62. 			delete m_vc;
    63. 			m_vc = NULL;
    64. 		}
    65.  
    66. 		//释放mem零件
    67. 		if (m_mem != NULL)
    68. 		{
    69. 			delete m_mem;
    70. 			m_mem = NULL;
    71. 		}
    72. 	}
    73.  
    74.  
    75.  
    76. private:
    77. 	//构造函数中传入三个零件指针
    78. 	CPU * m_cpu;//CPU零件指针
    79. 	VideoCard * m_vc;//显卡零件指针
    80. 	Memory * m_mem;//内存条零件指针
    81.  
    82. };
    83.  
    84. //具体厂商
    85. //Inter厂商
    86. class InterCPU :public CPU
    87. {
    88. public:
    89. 	virtual void calculate()
    90. 	{
    91. 		cout << "Inter的COU开始计算！" << endl;
    92. 	}
    93. };
    94.  
    95. class InterCard :public VideoCard
    96. {
    97. public:
    98. 	virtual void display()
    99. 	{
    100. 		cout << "Inter的显卡开始显示！" << endl;
    101. 	}
    102. };
    103.  
    104. class InterMemory :public Memory
    105. {
    106. public:
    107. 	virtual void storage()
    108. 	{
    109. 		cout << "Inter的内存条开始存储！" << endl;
    110. 	}
    111. };
    112.  
    113. //Lenovo厂商
    114. class LenovoCPU :public CPU
    115. {
    116. public:
    117. 	virtual void calculate()
    118. 	{
    119. 		cout << "Lenovo的COU开始计算！" << endl;
    120. 	}
    121. };
    122.  
    123. class LenovoCard :public VideoCard
    124. {
    125. public:
    126. 	virtual void display()
    127. 	{
    128. 		cout << "Lenovo的显卡开始显示！" << endl;
    129. 	}
    130. };
    131.  
    132. class LenovoMemory :public Memory
    133. {
    134. public:
    135. 	virtual void storage()
    136. 	{
    137. 		cout << "Lenovo的内存条开始存储！" << endl;
    138. 	}
    139. };
    140.  
    141. void test01()
    142. {
    143. 	//第一台电脑的零件
    144. 	CPU* interCpu = new InterCPU;
    145. 	VideoCard* interCard = new InterCard;
    146. 	Memory* interMem = new InterMemory;
    147.  
    148. 	//创建第一台电脑
    149. 	cout << "第一台电脑开始工作" << endl;
    150. 	Computer* computer1 = new Computer(interCpu, interCard, interMem);
    151. 	computer1->work();
    152. 	delete computer1;
    153.  
    154. 	//第二台电脑组装
    155. 	cout << "------------------------" << endl;
    156. 	cout << "第二台电脑开始工作" << endl;
    157. 	Computer* computer2 = new Computer(new LenovoCPU, new LenovoCard, new LenovoMemory);
    158. 	computer2->work();
    159. 	delete computer2;
    160.  
    161.  
    162. 	//第三台电脑组装
    163. 	cout << "------------------------" << endl;
    164. 	cout << "第三台电脑开始工作" << endl;
    165. 	Computer* computer3 = new Computer(new LenovoCPU, new InterCard, new LenovoMemory);
    166. 	computer3->work();
    167. 	delete computer3;
    168. }
    169.  
    170. int main()
    171. {
    172. 	test01();
    173.  
    174. 	system("pause");
    175.  
    176. 	return 0;
    177. }

    文件操作

    程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

    通过文件可以将数据持久化

    C++中对文件操作需要包含头文件
    文件类型分为两种:
    1.文本文件 文件以文本的ASCII码形式存储在计算机中
    2.二进制文件- 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

    操作文件的三大类:
    1.ofstream:写操作
    2.ifstream: 读操作
    3.fstream : 读写操作

    1，写文本

    写文件步骤如下
    1.包含头文件
    #indude
    2. 创建流对象
    ofstream ofs;
    3. 打开文件
    ofs.open("文件路径",打开方式);
    4. 写数据
    ofs<<"写入的数据”;
    5.关闭文件
    ofs.close();

    文件打开方式：

    1. 打开方式                 解释
      ios::in为读文件而打开文件
      ios::out为写文件为打开文件
      ios::ate初始位置：文件尾
      ios::app追加方式写文件
      ios::trunc如果文件存在先删除，再船舰
      ios::binary二进制方式

     注意: 文件打开方式可以配合使用，利用 | 操作符
    例如:用二进制方式写文件ios::binary | ios::out

    代码展示：

    1. #include<iostream>
    2. using namespace std;
    3. #include<fstream>//头文件包含
    4.  
    5. void test()
    6. {
    7. 	//1.包含头文件
    8. 	//#indude < fstream>
    9. 	
    10. 	//2. 创建流对象
    11. 	ofstream ofs;
    12.  
    13. 	//3. 指定打开方式
    14. 	ofs.open("text.txt", ios::out);
    15.  
    16. 	//4. 写数据
    17. 	ofs << "姓名：张三"<<endl;
    18. 	ofs << "年龄：18" << endl;
    19. 	ofs << "性别：男" << endl;
    20. 	// 
    21. 	//5.关闭文件
    22. 	ofs.close();
    23. }
    24.  
    25. int main()
    26. {
    27. 	test();
    28.  
    29. 	system("pause");
    30.  
    31. 	return 0;
    32. }

    虽然再运行中未显示 ，但是打开text文件可以看到输入的内容

     

     

     

     

    总结:
    文件操作必须包含头文件 fstream
    读文件可以利用 ofstream，或者fstream类
    打开文件时候需要指定操作文件的路径，以及打开方式
    利用<<可以向文件中写数据
    操作完毕，要关闭文件 

    2，读文件

    读文件与写文件步骤相似，但是读取方式相对于比较多

    读文件步骤如下:
    1.包含头文件
    #include
    2.创建流对象
    ifstream ifs;
    3.打开文件并判断文件是否打开成功
    ifs.open("文件路径",打开方式);
    4. 读数据
    四种方式读取
    5.关闭文件
    ifs.close();

    示例：

    1. #include<iostream>
    2. using namespace std;
    3. #include<fstream>//头文件包含
    4. #include<string>
    5.  
    6. void test()
    7. {
    8. 	//1.包含头文件
    9. 	//#indude < fstream>
    10.  
    11. 	//2. 创建流对象
    12. 	ofstream ofs;//写文件
    13. 	ifstream ifs;//读文件
    14.  
    15. 	//3. 指定打开方式
    16. 	ofs.open("text1.txt", ios::out);
    17. 	//4. 写数据
    18. 	ofs << "姓名：张三" << endl;
    19. 	ofs << "年龄：18" << endl;
    20. 	ofs << "性别：男" << endl;
    21.  
    22. 	ifs.open("text1.txt", ios::in);
    23. 	if (!ifs.is_open())
    24. 	{
    25. 		cout << "文件打开失败" << endl;
    26. 		return;
    27. 	}
    28. 	// 读数据
    29. 	
    30. 	//第一种
    31. 	//char buf[1024] = { 0 };
    32. 	//while (ifs >> buf)
    33. 	//{
    34. 	//	cout << buf << endl;
    35. 	//}
    36.  
    37. 	//第二种
    38. 	char buf[1024] = { 0 };
    39. 	while (ifs.getline(buf,sizeof(buf)))
    40. 	{
    41. 		cout << buf << endl;
    42. 	}
    43.  
    44. 	//第三种
    45. 	//string buf;
    46. 	//while ( getline(ifs, buf) )
    47. 	//{
    48. 	//	cout << buf << endl;
    49. 	//}
    50.  
    51. 	//第四种
    52. 	//char c;
    53. 	//while ((c = ifs.get()) != EOF)//EOF==end of file
    54. 	//{
    55. 	//	cout << c;
    56. 	//}
    57. 	//5.关闭文件
    58. 	ifs.close();
    59. }
    60.  
    61. int main()
    62. {
    63. 	test();
    64.  
    65. 	system("pause");
    66.  
    67. 	return 0;
    68. }

    3， 二进制文件

    3.1写文件

    以二进制的方式对文件进行读写操作
    打开方式要指定为 ios::binany

    二进制方式写文件主要利用流对象调用成员函数write
    函数原型:ostream& write(const char*buffer,int len);
    参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数

    1. #include<iostream>
    2. using namespace std;
    3. #include<fstream>//头文件包含
    4.  
    5. class Person
    6. {
    7. public:
    8. 	char m_Name[64];
    9. 	int m_Age;
    10. };
    11.  
    12. void test()
    13. {
    14. 	//1.包含头文件
    15. 	//#indude < fstream>
    16.  
    17. 	//2. 创建流对象
    18. 	ofstream ofs("person.txt", ios::out | ios::binary);
    19.  
    20. 	//3. 指定打开方式
    21. 	//ofs.open("person.txt", ios::out|ios::binary);
    22.  
    23. 	//4. 写数据
    24. 	Person p = { "张三",18 };
    25. 	ofs.write((const char*)&p, sizeof(p));
    26.  
    27. 	//5.关闭文件
    28. 	ofs.close();
    29. }
    30.  
    31. int main()
    32. {
    33. 	test();
    34.  
    35. 	system("pause");
    36.  
    37. 	return 0;
    38. }

    总结:
    文件输出流对象 可以通过write函数，以二进制方式写数据

    3.2 读文件

    二进制方式读文件主要利用流对象调用成员函数read
    函数原型:istream&read(char *buffer,int len);
    参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数
    示例:

    1. #include<iostream>
    2. using namespace std;
    3. #include<fstream>//头文件包含
    4.  
    5. class Person
    6. {
    7. public:
    8. 	char m_Name[64];
    9. 	int m_Age;
    10. };
    11.  
    12. void test01()
    13. {
    14. 	//1.包含头文件
    15. 	//#indude < fstream>
    16.  
    17. 	//2. 创建流对象
    18. 	ofstream ofs("person.txt", ios::out | ios::binary);
    19.  
    20. 	//3. 指定打开方式
    21. 	//ofs.open("person.txt", ios::out|ios::binary);
    22.  
    23. 	//4. 写数据
    24. 	Person p = { "张三",18 };
    25. 	ofs.write((const char*)&p, sizeof(p));
    26.  
    27. 	//5.关闭文件
    28. 	ofs.close();
    29. }
    30.  
    31. void test02()
    32. {
    33. 	//1.包含头文件
    34. 	//#indude < fstream>
    35.  
    36. 	//2. 创建流对象
    37. 	ifstream ifs;
    38.  
    39. 	//3. 指定打开方式
    40. 	ifs.open("person.txt", ios::out|ios::binary);
    41. 	if (!ifs.is_open())
    42. 	{
    43. 		cout << "文件打开失败" << endl;
    44. 		return;
    45. 	}
    46. 	//4. 读数据
    47. 	Person p;
    48. 	ifs.read((char*)&p, sizeof(p));
    49. 	cout << "姓名：" << p.m_Name << "年龄：" << p.m_Age << endl;
    50. 	//5.关闭文件
    51. 	ifs.close();
    52. }
    53.  
    54. int main()
    55. {
    56. 	test01();
    57.  
    58. 	test02();
    59.  
    60. 	system("pause");
    61.  
    62. 	return 0;
    63. }

  • 相关阅读:
    【java】基础知识（1）
    图解设计模式：身份认证场景的应用
    C++11各种锁的具体使用
    使用kubeseal加密和管理k8s集群的secret
    MySql分区简单说明
    KNN最近邻算法分析及实现(Python实现)
    【操作系统】系统启动流程
    【UE4 反射系统】 UCLAS UFUNCTION UPROPERTY 宏简单解析 持续更新
    spark中结合源码理解reduceByKey、groupByKey、combineByKey等几个ByKey算子的区别
    Win10操作系统安装Python
  • 原文地址：https://blog.csdn.net/bai_lan_ya/article/details/136649093