jquery网站右侧悬浮返回顶部带双二维码鼠标经过显示全网整合营销推广系统

简介

C++ 类型转换是开发者必须掌握的重要技能之一, 无论是处理隐式转换还是显式转换, 理解其背后的机制与用法至关重要. 本篇博客旨在从基础到高级全面解析 C++ 的类型转换, 包括实际开发中的应用场景和性能分析.

---

自动转换

隐式类型转换

编译器可以在无需明确指示的情况下, 将一种类型的值自动转换为另一种兼容类型. 例如:

struct Struct {Struct(float f) : m_(f) {}float m_ = 0;
};
float f = -3.1415926;
double d = f;
int i = f;
size_t s = f;
char c = f;
Struct st = f;

赋值语句	值
float f = -3.14;	-3.14159
double d = f;	-3.14159
int i = f;	-3
size_t s = f;	18446744073709551613
char c = f;	乱码
Struct st = f;	{.m_ = -3.14159}

算术类型转换

void drawLine(uint8_t start, uint8_t end);
uint8_t x = 10;
uint8_t width = 50;
// 此处等价于: drawLine(x, static_cast<unsigned char>(static_cast<int>(x) + static_cast<int>(width)));
drawLine(x, x+width);

符号转换

void print(const std::vector<int>& vec) {// 此处等价于: static_cast<unsigned long>(i) < vec.size()for (int i = 0; i < vec.size(); i++) {std::cout << i << ",";}
}

用户转换运算符

class Struct {public:Struct(float f) : m_(f) {}// 重载了转为int类型的操作符operator int() const { return m_; }private:float m_ = 0;
};int main() {Struct si(1);int i = si;
}

显示类型转换

C 风格类型转换

(type)var;

1. 使用 var 创建 <type> 的临时变量
2. <type> 可以是任何带有限定符的有效类型
3. 通过更改变量中位的含义来覆盖类型系统
4. 在某些情况下无法编译(稍后详细介绍)
5. 支持在 constexpr 上下文中使用(稍后详细介绍)
6. 可能导致未定义的行为
7. 参与运算符优先级(级别 3)

struct A {};
struct B {};int main() {float f = 7.406f;int i = (int)f;             // int i = static_cast<int>(f);A* pa = (A*)&f;             // A* pa = reinterpret_cast<A*>(&f);B* pb = (B*)pa;             // B* pb = reinterpret_cast<B*>(pa);double d = *(double*)(pb);  // double d = *reinterpret_cast<double*>((pb));return 0;
}

C 风格和函数式符号转换的问题

1. 单一符号, 多重含义
2. 容易出错
3. 无法 grep
4. 使 C 和 C++ 语法复杂化

C++ 强制转换的目标

1. 不同的符号或不同的任务
2. 易于识别和搜索
3. 执行 C 强制转换可以执行的所有操作
4. 消除意外错误
5. 使强制转换不那么诱人

C++有如下几种类型转换的关键词:

1. static_cast
2. const_cast
3. dynamic_cast
4. reinterpret_cast

static_cast

T1 var;
T2 var2 = static_cast<T>(var)

4. 从 var 类型创建临时变量
5. 尝试通过隐式和用户定义的转换或构造找到从 T1 到 T2 的路径. 无法删除 const 限定.

使用场景:

1. 阐明隐式转换

   int i = 1;
   double d = static_cast<double>(i);
   

2. 指示有意截断

   int a = 1234;
   uint8_t u8 = static_cast<uint8_t>(a);
   

3. 在基类和派生类之间进行强制转换

   struct Base {};
   struct Derived : public Base {};Derived derived;
   Base& rb = derived;
   Derived& rd = static_cast<Derived&>(rb);
   

4. 在 void* 和 T* 之间进行强制转换

   struct MyStruct {};
   void callback(void* handle) {auto p = static_cast<MyStruct*>(handle);//...
   }
   

多重转换

#include <cstdio>struct A {explicit A(int) { puts("A"); }
};
struct E {operator int() {puts("B::operator int");return 0;}
};int main() {E e;A a = static_cast<A>(e);return 0;
}

1. A 有一个接受单个 int 的构造函数
2. E 有一个用户定义的到 int 的转换
3. 所以从e到a的路径为: e -> int -> a

static_cast 与继承

#include <iostream>struct B1 {virtual ~B1() = default;int i;
};struct B2 {virtual ~B2() = default;int j;
};struct Derived : public B1, public B2 {int k;
};void Compare(void* p1, void* p2) {if (p1 == p2) {std::cout << "Same.\n";} else {std::cout << "Different.\n";}
}int main() {Derived d;// pd 指向派生类Derived* pd = &d;// pb1 是指向基类B1的指针B1* pb1 = static_cast<B1*>(&d);Compare(pd, pb1);  // Same.// pb2 是指向基类B1的指针B2* pb2 = static_cast<B2*>(&d);Compare(pd, pb2);  // Different.void* derived_plus_offset = (char*)pd + sizeof(B1);Compare(derived_plus_offset, pb2);  // Same.return 0;
}

为什么会出现这样的情况? 因为Derived的布局为:

+---------+  <--- pd and pb1
|    B1   |
+---------+  <--- pb2
|    B2   |
+---------+
| Derived |
+---------+...

static_cast 并非绝对正确

static_cast 无法防止向下转型为不相关的类型

#include <iostream>
#include <type_traits>struct Base {virtual void f() { std::cout << "base\n"; }virtual ~Base() = default;
};
struct Derived : public Base {void f() override { std::cout << "Derived\n"; }
};struct Other : public Base {void f() override { std::cout << "Other\n"; }
};int main() {Derived d;Base& b = d;  // OKd.f();  // Derivedb.f();  // DerivedOther& a = static_cast<Other&>(b);  // 危险, 转换到了其他类型a.f();                              // Derivedstatic_assert(std::is_same<decltype(a), Other&>::value, "not the same");return 0;
}

---

const_cast

1. 从变量中删除或添加 const 或 volatile 限定符, 不能更改类型
2. 不会更改原始变量的 CV 限定符

#include <iostream>void use_pointer(int* p) { std::cout << "*p = " << *p << std::endl; }
void modify_pointer(int* p) {*p = 42;std::cout << "\tmodify_pointer *p <- 42\n"<< "\tmodify_pointer *p = " << *p << std::endl;
}int main() {const int i = 7;use_pointer(const_cast<int*>(&i));modify_pointer(const_cast<int*>(&i));std::cout << "i = " << i << std::endl;  // i = 7int j = 4;const int* cj = &j;modify_pointer(const_cast<int*>(cj));std::cout << "i = " << i << std::endl;  // i = 7return 0;
}

输出

*p = 7modify_pointer *p <- 42modify_pointer *p = 42
i = 7modify_pointer *p <- 42modify_pointer *p = 42
i = 7

可以看到虽然在函数modify_pointer里面指针指向的值发生了变化, 但是在外面的值却不受影响.

const_cast example: member overload

#include <stddef.h>class my_array {public:char& operator[](size_t offset) {// 此处调用const版本的实现, 避免重写一遍逻辑.return const_cast<char&>(const_cast<const my_array&>(*this)[offset]);}const char& operator[](size_t offset) const { return buffer[offset]; }private:char buffer[10];
};
int main() {const my_array a{};const auto& c = a[4];my_array mod_a;mod_a[4] = 7;return 0;
}

用于防止成员函数的代码重复.

运行时类型信息 (RTTI)

1. 为实现定义的结构中的每个多态类型存储额外信息
2. 允许在运行时查询类型信息
3. 可以禁用以节省空间(gcc/clang: –fno-rtti, msvc: /GR-)

dynamic_cast

1. 查看 To 是否与 From 位于同一公共继承树中
2. 只能是引用或指针
3. 不能删除 CV
4. From 必须是多态的
5. 需要 RTTI
6. 如果类型不相关, 则对指针返回 nullptr, 对引用抛出 std::bad_cast

#include <cstdio>
#include <vector>struct A {virtual ~A() = default;
};
struct B : public A {};
struct C : public A {};
int main() {C c;B b;std::vector<A*> a_list = {&c, &b};for (size_t i = 0; i < a_list.size(); ++i) {A* pa = a_list[i];if (dynamic_cast<B*>(pa)) {printf("a_list[%lu] was a B\r\n", i);}if (dynamic_cast<C*>(pa)) {printf("a_list[%lu] was a C\r\n", i);}}return 0;
}

dynamic_cast 用例: UI 框架

struct Widget {};
struct Label : public Widget {};
struct Button : public Widget { void DoClick(); };

dynamic_cast can be expensive

from gcc’s rtti.c

reinterpret_cast

#include <cstdint>struct A {};
struct B {int i;int j;
};int main() {int i = 0;int* pi = &i;uintptr_t uipt = reinterpret_cast<uintptr_t>(pi);float& f = reinterpret_cast<float&>(i);A a;B* pb = reinterpret_cast<B*>(&a);char buff[10];B* b_buff = reinterpret_cast<B*>(buff);return 0;
}

1. 可以将任何指针或引用类型更改为任何其他指针或引用类型
2. 也称为类型双关
3. 不能在 constexpr 上下文中使用
4. 不能删除 CV 限定
5. 不确保 To 和 From 的大小相同
6. 适用于内存映射功能

reinterpret_cast 访问私有继承的基类

struct B {void m() { puts("private to D"); }
};
struct D : private B {};
int main() {D d;B& b = reinterpret_cast<B&>(d);b.m();return 0;
}

Type Aliasing

当两种类型的内存布局兼容时, 将一种类型的内存当作另一种类型的内存来使用的行为.

compatible types

struct Point {int x;int y;
};
struct Location {int x;int y;
};
Point p{1, 2};
auto* loc = reinterpret_cast<Location*>(&p);

incompatible types

float f = 1.0f;
int* i = reinterpret_cast<int*>(&f);

C 风格类型转换在 C++ 中是如何实际执行的

对与一个类型转换

T conv = (T)val;

C++会依次尝试:

1. T conv = const_cast<T>(val);
2. T conv = static_cast<T>(val);
3. T conv = const_cast<T>(static_cast<const T>(val));
4. T conv = reinterpret_cast<T>(val);
5. T conv = const_cast<T>(reinterpret_cast<const T>(val));

如果找到匹配则会选择并执行编译, 否则会报错.

总结

C++ 提供了更安全, 更明确的类型转换工具, 开发者应根据场景选择合适的转换方式. 通过熟练掌握这些工具, 您可以编写更健壮, 更易维护的代码. 希望本博客能帮助您更深入地理解 C++ 类型转换的精髓!

参考资源

• Back to Basics: Casting - Brian Ruth - CppCon 2021