【C++】类型转换

于 2024-09-27 15:17:44 发布
阅读量621 收藏 17
点赞数 17
文章标签： c++ 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80277275/article/details/142586110
版权

目录

1、内置类型之间

2、内置类型与自定义类型之间

2.1 自定义类型 = 内置类型

2.2 内置类型 = 自定义类型

3、自定义类型与自定义类型之间

4、C++强制类型转换

4.1 static_cast

4.2 reinterpret_cast

4.3 const_cast

4.4 dynamic_cast

在C/C++中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化。注意，类型转换发生也需要两种类型是有一定关联的。类型转换中间都会产生临时变量。

1、内置类型之间

内置类型之间有两种转换方式：
（1）隐式类型转换  整型之间/整型与浮点数之间
（2）显示类型转换  指针与整型/指针之间
隐式类型转换要求两种类型关联性更强，如上面整型的int和char，整型与浮点数等都是表示一个数据的大小，只是有可能会丢失一些精度而已。
显示类型转换要求的关联性就没那么强，但也是必须要有一定关联的。如指针是一个编号，所以整型才可以转。

void Test()
{
	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);
}

2、内置类型与自定义类型之间

2.1 自定义类型 = 内置类型

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(a)
	{}
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}
private:
	int _a1 = 1;
	int _a2 = 2;
};
int main()
{
	A aa1 = 1;
	A aa2 = { 2,2 };
	A& aa3 = { 2,2 }; // 会报错
	return 0;
}

aa1和aa2分别是单参数的隐式类型转换和多参数的隐式类型转换，注意aa2不是initializer_list。

所以，内置类型要转换为自定义类型不是直接转，而是依靠构造函数来转的

若不想一个构造函数参与隐式类型转换，可以在这个构造函数前面加上explicit

class A
{
public:
	explicit A(int a)
		:_a1(a)
		,_a2(a)
	{}
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}
private:
	int _a1 = 1;
	int _a2 = 2;
};

像这样就是禁止了单参数的隐式类型转换，但是仍然是可以强转的

int main()
{
	A aa1 = 1; // 会报错
	A aa4 = (A)1;
	A aa2 = { 2,2 };
	A& aa3 = { 2,2 }; // 会报错
	return 0;
}

2.2 内置类型 = 自定义类型

此时需要重载运算符，()被仿函数占用了，所以不能用

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(a)
	{}
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}
	operator int()
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
int main()
{
	A aa1 = 1;
	A aa2 = { 2,2 };
	int x = aa1;
	int y = aa2;
	int z = aa1.operator int();
	cout << x << endl;
	cout << y << endl;
	cout << z << endl;
	return 0;
}

转换为int需要重载一个operator int

也可以在operator int前面加一个explicit，这样可以防止隐式类型转换，但是还是可以强制类型转换

shared_ptr中就重载了operator bool，用来返回内部指针是否是空指针

3、自定义类型与自定义类型之间

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(a)
	{}
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	B(int b)
		:_b1(b)
	{}
private:
	int _b1 = 1;
};
int main()
{
	A aa1(1);
	B bb1(2);
	bb1 = aa1; // 会报错
	return 0;
}

直接转换是不行的，需要对B实现一个关于A的构造函数

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(a)
	{}
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}
	int get() const
	{
		return _a1 + _a2;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	B(int b)
		:_b1(b)
	{}
	B(const A& aa)
		:_b1(aa.get())
	{}
private:
	int _b1 = 1;
};
int main()
{
	A aa1(1);
	B bb1(2);
	bb1 = aa1; // 会报错
	return 0;
}

实际上，自定义类型与内置类型、自定义类型与自定义类型之间是超过构造函数或运算符重载来建立关联的，因为类型转换前提是要有关联。

template<class T>
struct __List_node//创建一个T类型的链表结点
{
	__List_node(const T& data = T())//构造函数
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr)
	{}
 
	__List_node<T>* _next;
	__List_node<T>* _prev;
	T _data;
};
template<class T, class Ref, class Ptr>
struct __List_iterator//封装链表的迭代器
{
	typedef __List_node<T> Node;
	typedef __List_iterator<T, Ref, Ptr> Self;
	Node* _node;//成员变量
	__List_iterator(Node* node)//构造函数。将迭代器中的结点初始化成传过来的结点
		:_node(node)
	{}
	// *it
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	// ++it
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	// it++
	Self operator++(int)
	{
		Self tmp(*this);//调用默认的拷贝构造，因为是指针类型所以直接用默认的
		//_node = _node->_next;
		++(*this);
		return tmp;
	}
	// --it
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	// it--
	Self operator--(int)
	{
		Self tmp(*this);
		//_node = _node->_prev;
		--(*this);
		return tmp;
	}
	// it != end()
	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
};
template<class T>
class List//真正的链表
{
public:
	typedef __List_node<T> Node;//将链表结点的名称重命名为Node
	typedef __List_iterator<T, T&, T*> iterator;
	typedef __List_iterator<T, const T&, const T*> const_iterator;
	//带头双向循环链表
	List()
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
    List(std::initializer_list<T> il)
    {
	    _head = new Node;
	    _head->_next = _head;
	    _head->_prev = _head;
	    for (auto e : il)
		    push_back(e);
    }
	~List()
	{
		clear();
		delete _head;
		_head = nullptr;
	}
	List(const List<T>& lt)
	{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
		//const_iterator it = lt.begin();//这里迭代器不需要指定是那个类域，因为就是在这个类中使用
		//while (it != lt.end())
		//{
		//	push_back(*it);
		//	++it;
		//}
		for (const auto& e : lt)//这里与上面用迭代器一样，因为最终也会被替换成迭代器
			push_back(e);
	}
	/*List<T>& operator=(const List<T>& lt)
	{
		if (this != &lt)
		{
			clear();
			for (const auto& e : lt)
				push_back(e);
		}
		return *this;
	}*/
	List<T>& operator=(List<T> lt)
	{
		swap(_head, lt._head);//原来的空间给这个临时变量，因为这个临时变量是自定义类型，出了作用域后会自动调用析构函数
		return *this;
	}
	void clear()//clear是清除除了头节点意外的所以结点
	{
		iterator it = begin();
		while (it != end())
		{
			erase(it++);
		}
	}
	void push_back(const T& x)//一定要用引用，因为T不一定是内置类型
	{
		Node* tail = _head->_prev;
		Node* newnode = new Node(x);
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
		/*insert(end(),x);*/
	}
	void pop_back()
	{
		Node* tail = _head->_prev;
		Node* prev = tail->_prev;
		delete tail;
		_head->_prev = prev;
		prev->_next = _head;
		//erase(--end());
	}
	void push_front(const T& x)
	{
		Node* first = _head->_next;
		Node* newnode = new Node(x);
		_head->_next = newnode;
		newnode->_prev = _head;
		newnode->_next = first;
		first->_prev = newnode;
		//insert(begin(), x);
	}
	void pop_front()
	{
		Node* first = _head->_next;
		Node* second = first->_next;
		delete first;
		_head->_next = second;
		second->_prev = _head;
		//erase(begin());
	}
	void insert(iterator pos, const T& x)
	{
		Node* newnode = new Node(x);
		Node* cur = pos._node;
		Node* prev = cur->_prev;
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = cur;
		cur->_prev = newnode;
	}
	void erase(iterator pos)
	{
		assert(pos != end());//不能删除头节点
		Node* cur = pos._node;
		Node* prev = cur->_prev;
		Node* next = cur->_next;
		prev->_next = next;
		next->_prev = prev;
		delete cur;
		cur = nullptr;
	}
	iterator begin()
	{
		return iterator(_head->_next);//使用这个结点去构造一个迭代器，并将这个迭代器返回
	}
	iterator end()
	{
		return iterator(_head);
	}
	const_iterator begin() const
	{
		return const_iterator(_head->_next);//使用这个结点去构造一个迭代器，并将这个迭代器返回
	}
	const_iterator end() const
	{
		return const_iterator(_head);
	}
private:
	Node* _head;
};

在外面前面自己实现的链表中，是没有办法用普通迭代器来构造一个const迭代器的，这两个是自定义类型之间的转换，我们没有实现对应的构造函数，所以不行。现在，我们来实现一个用普通迭代器构造const迭代器的构造函数

int main()
{
	List<int> lt = { 1,2,3,4 };
	List<int>::const_iterator cit = lt.begin();
	return 0;
}

这样会报错，因为lt不是const的，调用begin后返回的是一个普通迭代器，赋值给const迭代器就会报错

emplate<class T, class Ref, class Ptr>
struct __List_iterator//封装链表的迭代器
{
	typedef __List_node<T> Node;
	typedef __List_iterator<T, Ref, Ptr> Self;
	Node* _node;//成员变量
	__List_iterator(Node* node)//构造函数。将迭代器中的结点初始化成传过来的结点
		:_node(node)
	{}
	__List_iterator(const __List_iterator<T, T&, T*>& it)
		:_node(it._node)
	{}
	// *it
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	// ++it
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	// it++
	Self operator++(int)
	{
		Self tmp(*this);//调用默认的拷贝构造，因为是指针类型所以直接用默认的
		//_node = _node->_next;
		++(*this);
		return tmp;
	}
	// --it
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	// it--
	Self operator--(int)
	{
		Self tmp(*this);
		//_node = _node->_prev;
		--(*this);
		return tmp;
	}
	// it != end()
	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
};

加入了用普通迭代器构造迭代器的构造函数后就可行了

4、C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast

4.1 static_cast

static_cast就是隐式类型转换 -- 数据的意义没有发生变化，只是丢了精度或增加了精度

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	int b = d; // a和b是相同的
	cout << a << endl;
	cout << b << endl;
	// 下面这样是不行的，不能隐式类型转换的也不能用static_cast
	int* p = static_cast<int*>(a);
	return 0;
}

4.2 reinterpret_cast

reinterpret_cast就是强制类型转换 -- 数据的意义已经发生变化

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	int b = d; // a和b是相同的
	cout << a << endl;
	cout << b << endl;
	// 下面这样是不行的，不能隐式类型转换的也不能用static_cast
	//int* p = static_cast<int*>(a);
	int* p1 = reinterpret_cast<int*>(a);
	int* p2 = (int*)(a); // p1和p2是相同的
	int c = reinterpret_cast<int>(d); // 这样不行
	return 0;
}

4.3 const_cast

const_cast也是强制类型转换，用const_cast是为了提示是存在风险的去掉const属性

int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << *p << endl;
	cout << a << endl;
	return 0;
}

结果是

为什么已经将*p = 3了，a的值依旧没有变化呢？

是因为编译器的优化，编译器面对const变量，有些会将其放到寄存器中，有些地方会直接在打印时将a的值替换成2，内存中的a确实变成了3(通过监视窗口也可以看见)，只是打印时被替换成了2

此时可以在const前面添加一个volatile

int main()
{
	volatile const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << *p << endl;
	cout << a << endl;
	return 0;
}

结果是

此时就不是直接打印2了，而是先将a放入寄存器，再从寄存器中取值

4.4 dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意：
1. dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

class A
{
public:
	virtual void f() {}
	int _a = 1;
};
class B : public A
{
public:
	int _b = 2;
};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb1 = static_cast<B*>(pa);
	cout << "pb1:" << pb1 << endl;
	cout << pb1->_b << endl;
    pb1->_b++;
    cout << pb1->_b << endl; // 这一句会报错
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

父类转为子类可以通过构造函数来完成
父类转为子类默认是不完全的，因为子类多出的成员变量是随机值，若对其就行写操作，则会报错
所以，父类转子类需要使用dynamic_cast，dynamic_cast会检查是否安全，能成功则转换，不能成功则返回空

class A
{
public:
	virtual void f() {}
	int _a = 1;
};
class B : public A
{
public:
	int _b = 2;
};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb1 = dynamic_cast<B*>(pa);
	cout << "pb1:" << pb1 << endl;
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

结果是，父类转成子类不行，子类转成子类可以，若像父类转成子类，需要在子类实现一个关于父类的构造函数

需要父类包含虚函数，因为本质是通过在虚表中加入一些标识来完成的。在父类中加一个标识，在子类中加一个标识，调用dynamic_cast时，通过标识看是指向子类还是父类，然后返回相应的值

while(77)
关注
C++类型转换
09-08
STR 32-bit指针，指向一个字符串 LPCTSTR 32-bit指针，指向一个常数字符串，此字符串可移植到Unicode和DBCS(双字节字集) LPTSTR 32-bit指针，指向一个字符串，此字符串可移植到Unicode和DBCS(双字节字集) ...
C++类型转换归纳总结
09-04
C++类型转换是编程中必不可少的操作，它涉及到变量在不同数据类型间的转换，这对于理解和编写高效、安全的C++代码至关重要。C++继承了C语言的两种类型转换方式：隐式转换和显式转换。 1. 隐式转换： 隐式转换是由...
C++类型转换运算符介绍
疯狂挖掘机的博客
03-30 2196
C++中的新式类型转换介绍
C++ 类型转换
shuzfan的专栏
08-17 1万+
隐式类型转换 1 数值类型转换 2 指针类型转换 显式类型转换 1 explicit关键字 1 强制类型转换 11 static_cast 12 dynamic_cast 13 const_cast 14 reinterpret_cast 参考资料 C++类型转换大体上包括隐式类型转换和显式类型转换。1. 隐式类型转换隐式类型转换是自动执行的，无需显式的操作符。 隐式类型转换发生在很多地方，比如函数
C/C++ 类型转换
cpp_learner的博客
06-14 3001
C语言的强制类型转换与C++的四种转换类型的方式。
c++类型转换
热门推荐
一条二哈
05-29 2万+
类型转换有 c 风格的,当然还有 c++风格的。c 风格的转换的格式很简单(TYPE) EXPRESSION,但是 c 风格的类型转换有不少的缺点,有的时候用 c 风格的转换是不合 适的,因为它可以在任意类型之间转换,比如你可以把一个指向 const 对象的指针转换 成指向非 const 对象的指针,把一个指向基类对象的指针转换成指向一个派生类对象的 指针,这两种转换之间的差别...
C++类型转换规则
kangjielearning的博客
08-10 1195
自动转换规则： 1、若参与运算量的类型不同，则先转换成同一类型，然后进行运算。 2、转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。 a、若两种类型的字节数不同，转换成字节数高的类型 b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型 3、所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。 4、char型和short型参与运算时，必须先转换
C++的类型转换
rayn的专栏
01-03 2980
c++类型转换
掌握C++类型转换：static_cast、const_cast、dynamic_cast 和 reinterpret_cast
Lion_Long的博客
04-20 5468
静态类型转换静态类型转换是最常用的类型转换方式，它可以将一种类型的数据强制转换为另一种类型，但需要注意的是，这种转换可能会损失一些信息，因此在进行此类转换时应当谨慎。int a = 10;动态类型转换动态类型转换主要用于多态类型之间的转换，它可以将基类指针或引用转换为派生类指针或引用。如果进行非法的类型转换，动态类型转换会返回一个空指针。重新解释类型转换。
类型转换（C++）
Man9o
03-09 3182
或者编译器会对常量进行优化，直接用它的值替换所有的引用，那么你修改的只是一个临时变量，而不是原来的常量。在main函数中，创建了一个B类的对象b，并将其地址分别赋给了指向A1和A2类型的指针ptr1和ptr2。reinterpret_cast可以将任何指针类型转换为任何其他指针类型，但是这种转换是不安全的，因为它不检查转换前后的指针是否兼容。这些输出的地址表明，指向A1类型的指针ptr1和指向A2类型的指针ptr2分别指向了B类对象b中不同的内存地址。每个包含虚函数的类或者虚继承的子类，都有一个虚函数表。
c++ 4种类型转换
zxf347085420的博客
01-24 1670
其中， reinterpret_cast后的尖括号中的type-id类型必须是一个指针、引用、算术类型、函数指针或者成员指针。完成，适用于具有继承关系的类或指针类型之间的转换。动态转换会进行类型检查，如果类型无法转换，则返回空指针(对于指针类型)或抛出bad_cast异常(对于引用类型)。向上转型是指：子类对象指针/引用 -> 父类指针/引用(不需要转换，赋值兼容规则)，适用于具有继承关系的类或者指针类型之间的转换。父类对象指针/引用 ->子类指针/引用(用dynamic_cast转型是安全的)
C++class_convert.rar_c++类型转换_类型转换
09-20
在C++编程语言中，类型转换是至关重要的概念，它允许程序员在不同数据类型之间进行操作。本资源包，"C++class_convert.rar"，主要关注C++中的类型转换，包括隐式转换和显式转换，这对于理解和编写高效、安全的代码至...
vc.zip_c++类型转换_数据类型转换
09-14
本资源“vc.zip”包含了一份关于C++类型转换的详细文档“vc.doc”，涵盖了从基本数据类型到复杂类型的转换方法。下面，我们将深入探讨C++中的类型转换及其重要性。 1. **静态类型转换**： - **C-style类型转换**：...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 991
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1006
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 397
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
最新发布
csdn_aspnet的专栏
09-26 1074
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值