lesson8: C++的类型转换 和 IO流

已于 2023-07-28 17:52:49 修改
阅读量573 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2022-12-06 10:51:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyc_462857656/article/details/128154068
版权

1. C语言的类型转换

#include <iostream>
#include <string>
using namespace std;

void Insert(size_t pos, char ch)
{
	size_t _size = 5;
	//....
	int end = _size - 1;
	// size_t end = _size - 1;
	while (end >= pos) // end隐式类型转换
	{
		//_str[end + 1] = _str[end];
		--end;
	}
}

void Test1()
{
	int i = 1;
	// 隐式类型转换(意义相近的类型)
	double d = i;
	printf("%d, %.2f\n", i, d);

	int* p = &i;
	// 显示的强制类型转换(意义不相近的类型，值转换后有意义)
	int address = (int)p;

	printf("%x, %d\n", p, address);

	Insert(3, 'a');
	Insert(0, 'a');// 触发死循环
}

int main()
{
	Test1();

	return 0;
}
  • 隐式类型转换(意义相近的类型)
  • 显示的强制类型转换(意义不相近的类型，值转换后有意义)

2. C语言类型转换的缺陷

  1.  隐式类型转化有些情况下可能会出现问题: 比如数据精度丢失
  2. 显示类型转换将所有情况混合在一起,代码不够清晰

3. C++强制类型转换

标准C++为了加强类型转换的可视性,引入了四种命名的强制类型转换操作符

3.1 static_cast关键字 -> 隐式类型转换

#include <iostream>
#include <string>
using namespace std;

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;

	int* p = &a;
	
	//int address = static_cast<int>(p);// 不支持的
	return 0;
}
  • static_cast用于非多态类型的转换(静态转换),编译器隐式执行的任何类型转换都可用static_cast就像C语言的隐式类型转换,常用于意义相近的类型
  • 但是它不能用于两个不相关的类型进行转换

 3.2 reinterpret_cast关键字 -> 强制类型转换

#include <iostream>
#include <string>
using namespace std;

int main()
{
	int a = 100;
	int* p = &a;
	int address = reinterpret_cast<int>(p);

	return 0;
}
  • reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型,
  • reinterpret_cast就像 C语言的强制类型转换
  • 常用于两个类型不相关的

 3.3 const_cast关键字->取消变量的const属性

  •  const_cast最常用的用途就是删除变量的const属性，方便赋值
  • volatile关键字取消编译器的优化

3.4 dynamic_cast->父类指针 转换 子类指针

dynamic_cast 用于将一个 父类 对象的指针/引用转换为 子类 对象的指针或引用(动态转换)  
向上转型： 子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)->切片
向下转型： 父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

 3.4.1案例一

#include <iostream>
using namespace std;

class A
{
public:
	virtual void f(){}
public:
	int _a = 0;
};

class B : public A
{
public:
	int _b = 1;
};

// A*指针pa有可能指向父类，有可能指向子类
void fun(A* pa)
{
	// 如果pa是指向子类，那么可以转换，转换表达式返回正确的地址
	// 如果pa是指向父类，那么不能转换，转换表达式返回nullptr
	B* pb = dynamic_cast<B*>(pa); // 安全的
	//B* pb = (B*)pa;             // 不安全
	if (pb)
	{
		cout << "转换成功" << endl;
		pb->_a++;
		pb->_b++;
		cout << pb->_a << ":" << pb->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	A aa;
		// 父类对象无论如何都是不允许转换成子类对象的
		//B bb = dynamic_cast<B>(aa);// error
		//B bb = (B)aa;// error
	B bb;

	fun(&aa);
	fun(&bb);
	fun(nullptr);

	return 0;
}
  • dynamic_cast只能用于 父类含有虚函数的类
  • dynamic_cast会 先检查是否能转换成功 ，能成功则转换，不能则返回0

 3.4.2案例一 

#include <iostream>
using namespace std;
class A1
{
public:
	virtual void f(){}
public:
	int _a1 = 0;
};

class A2
{
public:
	virtual void f(){}
public:
	int _a2 = 0;
};

class B : public A1, public A2
{
public:
	int _b = 1;
};

int main()
{
	B bb;
	A1* ptr1 = &bb;
	A2* ptr2 = &bb;
	cout << ptr1 << endl;
	cout << ptr2 << endl << endl;

	B* pb1 = (B*)ptr1;
	B* pb2 = (B*)ptr2;
	cout << pb1 << endl;
	cout << pb2 << endl << endl;

	B* pb3 = dynamic_cast<B*>(ptr1);
	B* pb4 = dynamic_cast<B*>(ptr2);
	cout << pb3 << endl;
	cout << pb4 << endl << endl;

	return 0;
}

 

3.5 类型转换的实质 

类型转换是通过临时对象来实现的,且临时对象具有常性,

  • 但是尽量不要使用强制类型转换

3.6 常见面试题

  1. C++中的4种类型转换分别是：____ 、____ 、____ 、____。
    1. 分别是static_cast、reinterpret_cast、const_cast和dynamic_cast。
  2. 说说4种类型转换的应用场景。
    1. static_cast用于相近类型的类型之间的转换，编译器隐式执行的任何类型转换都可用
    2. reinterpret_cast用于两个不相关类型之间的转换。
    3. const_cast用于删除变量的const属性，方便赋值。
    4. dynamic_cast用于安全的将父类的指针（或引用）转换成子类的指针（或引用）

4. RTTI->运行时类型识别

RTTI：Run-time Type identifification的简称，即：运行时类型识别 

C++通过以下方式来支持RTTI:

  1. typeid运算符(获取对象类型字符串)
  2. dynamic_cast运算符(父类的指针指向父类对象或者子类对象)
  3. decltype(推导一个对象类型,这个类型可以用来定义另一个对象)

5. C语言的输入与输出

printf/scanf

fprintf/fscanf

sprintf/sscanf

#include <iostream>
using namespace std;
class A
{
public:
    // explicit A(int a)
	A(int a)
		:_a(a)
	{}

	operator int()
	{
		return _a;
	}

private:
	int _a;
};

int main()
{
	// 内置类型 转换成自定义类型
	A aa1 = 1; // 隐式类型转换 用1构造A临时对象，再拷贝构造aa1，优化后直接1构造aa1

	// 自定义类型 转换成内置类型
	int i = aa1;

	return 0;
}

  •  int i = aa1;能将自定义类型转换成内置类型,主要因为operator int()

  • explicit关键字: 不允许隐式类型的转换

5.1 多组输入

#include <iostream>
using namespace std;
class Date
{
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator >> (istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	operator bool()
	{
		// 这里是随意写的，假设输入_year为0，则结束
		if (_year == 0)
			return false;
		else
			return true;
	}
private:
	int _year;
	int _month;
	int _day;
};

istream& operator >> (istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

ostream& operator << (ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}

// C++ IO流，使用面向对象+运算符重载的方式
// 能更好的兼容自定义类型，流插入和流提取
int main()
{
	// 自动识别类型的本质--函数重载
	// 内置类型可以直接使用--因为库里面ostream类型已经实现了
	int i = 1;
	double j = 2.2;
	cout << i << endl;
	cout << j << endl;

	// 自定义类型则需要我们自己重载<< 和 >>
	Date d(2022, 4, 10);
	cout << d;
	while (d)
	{
		cin >> d;
		cout << d;
	}

	return 0;
}

 

  •  while(cin >> d){}遇到文件退出符才结束,因为库里面实现了operator bool()

5.2 fstream文件流 

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
	ifstream ifs("Test.cpp");
	char ch = ifs.get();
	while (ifs)
	{
		cout << ch;
		ch = ifs.get();
	}

	return 0;
}

 

  •  C++中也有对文件进行操作的流fstream
  • 它的使用就可以不用打开文件,和关闭文件
  • 库里面写的是一个类它会自己调构造,调析构

5.3 C++ 文件操作 

#include <iostream>
#include <fstream>
using namespace std;
class Date
{
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator >> (istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	operator bool()
	{
		// 这里是随意写的，假设输入_year为0，则结束
		if (_year == 0)
			return false;
		else
			return true;
	}
private:
	int _year;
	int _month;
	int _day;
};

istream& operator >> (istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

ostream& operator << (ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}

int main()
{
	ifstream ifs("test.txt");// 默认以读的方式打开
	//fscanf("%d%s%f", )
	int i;
	string s;
	double d;
	Date de;
	ifs >> i >> s >> d >> de;
	cout << i << s << d << de;
	return 0;
}

5.4 二进制文件的读写 && 文本文件的读写

#include <iostream>
#include <fstream>
using namespace std;
struct ServerInfo
{
	char _address[32];
	//string _address;
	int _port;  // 100

	// Date _date;
};

struct ConfigManager
{
public:
	ConfigManager(const char* filename = "server.config")
		:_filename(filename)
	{}

	// 二进制文件的写
	void WriteBin(const ServerInfo& info)
	{
		ofstream ofs(_filename, ios_base::out | ios_base::binary);
		ofs.write((char*)&info, sizeof(info));
	}

	// 二进制文件的写
	void ReadBin(ServerInfo& info)
	{
		ifstream ifs(_filename, ios_base::in | ios_base::binary);
		ifs.read((char*)&info, sizeof(info));
	}

	// 文本文件的写
	void WriteText(const ServerInfo& info)
	{
		ofstream ofs(_filename, ios_base::out);
		ofs << info._address << info._port;
	}

	// 文本文件的读
	void ReadText(ServerInfo& info)
	{
		ifstream ifs(_filename, ios_base::in | ios_base::binary);
		ifs >> info._address >> info._port;
	}

private:
	string _filename; // 配置文件
};
int main()
{
	// 二进制的写
	ServerInfo winfo = { "127.0.0.1", 888 };
	ConfigManager cm;
	cm.WriteBin(winfo);
	// cm.WriteText(winfo);// 文本的写

	// 二进制的读
	ServerInfo rinfo;
	ConfigManager rm;
	rm.ReadBin(rinfo);
	// rm.ReadText(rinfo);// 文本的读
	cout << rinfo._address << endl;
	cout << rinfo._port << endl;
	
	return 0;
}

  • 二进制读写：在内存如何存储，就如何写到磁盘文件 

    • 优点：快

    • 缺点：写出去内容看不见

  • 文本读写：对象数据序列化字符串写出来，读回来也是字符串，反序列化转成对象数据 

    • 优点：可以看见写出去是什么

    • 缺点：存在一个转换过程，要慢一些

 5.5 字符串流-- stringstream

#include <iostream>
#include <fstream>
#include<sstream>

using namespace std;
struct ChatInfo
{
	string _name; // 名字
	int _id;      // id
	string _msg;  // 聊天信息
};

int main()
{
	// 序列化
	ChatInfo winfo = { "张三", 135246, "晚上一起看电影吧" };
	//ostringstream oss;
	stringstream oss;
	oss << winfo._name << endl;
	oss << winfo._id << endl;
	oss << winfo._msg << endl;

	string str = oss.str();
	cout << str << endl;

	// 网络传输str，另一端接收到了字符串串信息数据

	// 反序列化
	ChatInfo rInfo;
	//istringstream iss(str);
	stringstream iss(str);
	iss >> rInfo._name;
	iss >> rInfo._id;
	iss >> rInfo._msg;

	cout << "----------------------------------" << endl;
	cout << rInfo._name << "[" << rInfo._id << "]:>" << rInfo._msg << endl;
	cout << "----------------------------------" << endl;

	return 0;
}

 

旧链爱学习
关注
专栏目录
perez_zaelynn_lesson8：一个MakeCode项目
02-09
在打开此页面 用作扩展 该存储库可以作为扩展添加到MakeCode中。 打开 ...搜索并导入 编辑这个专案 在MakeCode中编辑此存储库。... 单击导入，然后单击导入URL ...此图显示了master中最后一次提交的块代码。...
unsigned char 与string之间的转换
neuzhangno的博客
06-28 5945
这种方法适用于将无符号字符数组转换为字符串，使用std::stringstream对象将每个无符号字符逐个写入，然后从std::stringstream对象中提取字符串。这种方法适用于将单个无符号字符转换为字符串，使用std::to_string()函数将无符号字符转换为对应的ASCII码数字的字符串形式。这种方法适用于将无符号字符数组转换为字符串，使用字符数组存储数据，然后使用字符数组构造字符串。方法一：使用std::to_string()函数。方法三：使用字符数组和std::copy()
【C++】类型转换和IO流
最新发布
Sxy_wspsby的博客
07-01 715
首先我们看看C语言中的类型转换：在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化C隐式类型转换和显式类型转换。1.隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败2.显式类型转化：需要用户自己处理int main()int i = 1;// 隐式类型转换// 显示的强制类型转换对于上面这种C语言的类型转换其实是有一些缺陷的，
c++ string
xiaoma_bk的博客
12-08 3023
文章目录文件读写读写基本属性构造赋值连接string对象的比较求 string 对象的子串交换两个string对象的内容查找子串和字符替换子串删除子串插入字符串将 string 对象作为流处理用 STL 算法操作 string 对象常见用法string转char*`char*`、`char[]`转换为`string`int string互转 文件读写 fstream提供了三个类，用来实现c++对文件的操作。（文件的创建、读、写）。 ifstream ：从已有的文件读入 ofstream ： 向文件写内容
学习-＞C++篇十七：C++的类型转换和IO流
u014801954的博客
12-15 388
目录 一.类型转换 1.C语言中的类型转换 2.C++中的类型转换 二.IO流 1. C语言的输入与输出 2. 流是什么 3. stringstream
lesson8.github.io
03-14
标题“lesson8.github.io”和描述的简洁性表明这是一个与GitHub Pages相关的项目，可能是第八课的教学资源或示例。GitHub Pages是一个服务，允许用户通过GitHub托管静态网站，通常用于个人简历、项目展示或教程等。...
OOP3200-lesson1:测试Github
03-19
OOP3200-lesson1:测试Github
Lesson01：课程概述与如何学好FPGA
06-30
Lesson01：课程概述与如何学好FPGA
iOS-Obj-C-Lesson4:使用地图和定位
04-06
在本课程“iOS-Obj-C-Lesson4:使用地图和定位”中，我们将深入探讨如何在iOS应用中集成地图服务和实现地理位置跟踪功能。这个课题是iOS开发中的关键部分，特别是对于那些需要提供基于位置服务的应用，如导航、生活...
[C++] IO流，文件输入输出，string流，类型转换运算符
CegghnnoR的博客
10-12 866
C++不直接处理输入输出，而是通过一族定义在标准库中的类型来处理IO，这些类型支持从设备读取数据，向设备写入数据的IO操作，设备可以是文件，控制台窗口等。还有一些类型允许内存IO，即，从 string 读取数据，向 string 写入数据。
中级C++：类型转换，IO流操作
kimsaul的白给岁月
07-11 621
前言 类型转换 IO流 内置类型的IO 自定义类型的IO 文件流IO stringstream
C++:__int8、__int16、__int32、__int64
it_cplusplus
06-24 3808
C++:__int8、__int16、__int32、__int64Microsoft 专用示例 Microsoft 专用 Microsoft C/C++ 功能支持固定大小整数类型。 您可以使用类型说明符声明8位、16位、32或64位整数变量 __intN ，其中 * N _ 为8、16、32或64。 以下示例为这些类型的固定大小整数声明了一个变量： __int8 nSmall; // Declares 8-bit integer __int16 nMedium; // Declares 1
C++数据类型转换
weixin_62258981的博客
06-22 1999
1、static_cast（静态类型转换）：用于基本数据类型（char、int、double等）之间、对象之间、继承关系类对象指针之间、继承类指针之间的转换；不能用于基本数据类型指针之间的转换（char* 、int*、double*等）。 2、dynamic_cast（动态类型转换） ：用于函数父类与子类之间的指针或引用的转换；使用的前提是必须要有虚函数；不能用于基本不能用于基本数据类型指针之间的转换（char* 、int*、double*等）。...
[C++]C++中string、char *、char[]的转换
刘好念的博客
09-03 718
一、摘要 二、string、char和char[] 之间的转换 三、参考
【C++深度解析】29、int 与类类型之间的转换，类类型之间转换（转换构造函数，类型转换函数）
桑凯旋的博客
02-10 1684
文章目录1 基本类型之间的转换2 普通类型与类类型之间的转换2.1 转换构造函数2.2 explicit 关键字3 小结 1 基本类型之间的转换 标准数据类型之间存在隐式的类型安全转换，在【C语言进阶剖析】4、类型转换中我们已经讲解了 C 语言中的强制类型转换和隐式类型转换。 安全的隐式类型转换如下所示： 我们通过一个案例回顾一下隐式类型转换 // 29-1.cpp #include<io...
C++之数据类型转换（全）
热门推荐
suren_jun的博客
09-12 3万+
当我们用C++编写代码时，经常会遇到数据类型的转换，如string，char*，char[],const char*、Qstring以及int，float等各种类型之间的转换。而且有些转换的函数在低版本的C++中是不支持的，所幸这里我们对C++中常用的数据类型转换进行记录。在数据转换中，尤其是字符串转换是最常用的，所以我们以字符串来作为整个数据类型转换的核心。
【C++基础】文件流读写操作
XBlog
10-31 713
向文本文件写入数据 int arr[] = {1,2,3,4,5}; //定义文件流对象 ofstream ofile; //打开文件 ofile.open("test.txt", ios::out); if(!ofile) { cerr << "open file fail" << endl; exit(1); } //把内容写入文件 for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++) { ofile
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值