C++类型转换

转化运算符

static_cast

功能：
- 静态类型转换，用于在编译期确定的转换。
- 能完成 C 语言中大部分的强制类型转换，但不能移除表达式中的 const、volatile 或者 __unaligned 属性。

用途：
- 将 int 转换为 char。
- 数据指针与指针之间的转换，但不能用于两个无关指针类型之间的直接转换，需通过 void* 进行间接转换。
- 父类指针转换为子类指针是安全的，反之则不安全，因为 static_cast 没有动态类型检查。
使用时机：
- 当编译器隐式执行类型转换时，可能会丢失精度并给出警告。这种情况下使用 static_cast 可以明确告知编译器你知道这种转换。

dynamic_cast

功能：
- 仅用于类继承结构中基类和派生类之间的指针或引用的转换。
- 可以进行向上、向下或横向的转换。
- 在运行时进行类型检查。
条件：
- 必须在有继承关系的类之间才能转换。
- 基类中必须有虚函数。
- 特殊情况下，可以把类指针转换成 void* 类型。

const_cast

功能：
- 不能移除变量的常量性。
- 只能用于去除指向常量对象的指针或引用的常量性。
- 去除常量性的对象必须为指针或引用。

reinterpret_cast

功能：
- 进行不同类型指针或引用之间的转换。
- 指针和整数之间的转换。
- 对比特位的简单拷贝并重新解释，不改变数据在内存中的二进制形式。
- 不同基础类型指针类型之间的转换。
注意：
- reinterpret_cast 是 C++ 中最不安全的类型转换方式，应该谨慎使用，尤其是在涉及不同类型的指针之间转换时，以避免未定义行为。

多种类型之间的切换

string与万物互转

string与 const char互转

std::string 是 C++ 标准库提供的字符串类，支持动态大小变化。const char* 是指向 C 风格字符串的指针，字符串以 \0 结束。
从 std::string 到 const char* 的转换，可以通过 c_str() 方法得到。反之，通过 const char* 创建 std::string 对象。

#include <iostream>
#include <string>

int main() {
    // string 转 const char*
    std::string str = "Hello, World!";
    const char* cstr = str.c_str();
    std::cout << "const char*: " << cstr << std::endl;

    // const char* 转 string
    const char* anotherCStr = "Welcome to C++";
    std::string anotherStr(anotherCStr);
    std::cout << "std::string: " << anotherStr << std::endl;

    return 0;
}

string与 char*互转

C++ 不允许直接将 std::string 转换为 char*，因为 string 的数据是常量，不应直接修改。
如果需要 char*，通常使用 std::vector<char> 来保存字符串的可变拷贝。
从 char* 到 string 直接使用构造函数即可。

#include <iostream>
#include <string>
#include <vector>

int main() {
    // string 转 char*
    std::string str = "Hello, World!";
    std::vector<char> vec(str.begin(), str.end());
    vec.push_back('\0');  // 添加空字符终止符
    char* cstr = vec.data();
    std::cout << "char*: " << cstr << std::endl;

    // char* 转 string
    char* anotherCStr = "Welcome to C++";
    std::string anotherStr(anotherCStr);
    std::cout << "std::string: " << anotherStr << std::endl;

    return 0;
}

string与 char[] 互转

char[] 是字符数组，是一种在栈上分配的固定大小的字符串。std::string 可以从 char[] 构造，也可以通过 std::copy 转换为 char[]。

#include <iostream>
#include <string>

int main() {
    // string 转 char[]
    std::string str = "Hello, World!";
    char cstr[50]; // 需要足够大的数组
    std::copy(str.begin(), str.end(), cstr);
    cstr[str.size()] = '\0'; // 手动添加空字符
    std::cout << "char[]: " << cstr << std::endl;

    // char[] 转 string
    char anotherCStr[] = "Welcome to C++";
    std::string anotherStr(anotherCStr);
    std::cout << "std::string: " << anotherStr << std::endl;

    return 0;
}

string与 int, float, double互转

C++ 提供了 std::stoi, std::stof, std::stod 等函数用于从 string 转换为基本数据类型。
反向转换可以使用 std::to_string 函数。

#include <iostream>
#include <string>

int main() {
    // string 转 int
    std::string intStr = "12345";
    int num = std::stoi(intStr);
    std::cout << "int: " << num << std::endl;

    // string 转 float
    std::string floatStr = "123.45";
    float fnum = std::stof(floatStr);
    std::cout << "float: " << fnum << std::endl;

    // int 转 string
    int anotherNum = 67890;
    std::string anotherIntStr = std::to_string(anotherNum);
    std::cout << "std::string: " << anotherIntStr << std::endl;

    // float 转 string
    float anotherFNum = 678.90f;
    std::string anotherFloatStr = std::to_string(anotherFNum);
    std::cout << "std::string: " << anotherFloatStr << std::endl;

    return 0;
}

const char* 与万物互转

const char* 与 char* 互转

const char* 到 char* 的转换涉及去掉 const 限制。这通常是危险的，因为可能导致未定义行为。因此，一般通过 strcpy 等函数拷贝到新分配的 char* 中。
char* 到 const char* 是安全的，直接赋值即可。

#include <iostream>
#include <cstring>

int main() {
    // const char* 转 char*
    const char* cstr = "Hello, World!";
    char buffer[50];
    std::strcpy(buffer, cstr); // 复制到可变的 char* 中
    std::cout << "char*: " << buffer << std::endl;

    // char* 转 const char*
    char* mutableCStr = buffer;
    const char* constCStr = mutableCStr; // 安全转换
    std::cout << "const char*: " << constCStr << std::endl;

    return 0;
}

const char*与 char[] 互转

const char* 可以通过 strcpy 等方法拷贝到 char[] 中。
char[] 直接赋值给 const char* 即可。

#include <iostream>
#include <cstring>

int main() {
    // const char* 转 char[]
    const char* cstr = "Hello, World!";
    char buffer[50];
    std::strcpy(buffer, cstr);
    std::cout << "char[]: " << buffer << std::endl;

    // char[] 转 const char*
    char anotherBuffer[] = "Welcome to C++";
    const char* anotherCStr = anotherBuffer;
    std::cout << "const char*: " << anotherCStr << std::endl;

    return 0;
}

const char*与 int, float, double互转

const char* 到数字类型的转换可以通过 atoi, atof 等函数实现。
反向转换可以使用 sprintf 或者 C++11 以后的 std::to_string 再转换成 const char*。

#include <iostream>
#include <cstdlib>   // for atoi, atof
#include <cstdio>    // for sprintf

int main() {
    // const char* 转 int
    const char* intCStr = "12345";
    int num = std::atoi(intCStr);
    std::cout << "int: " << num << std::endl;

    // const char* 转 float
    const char* floatCStr = "123.45";
    float fnum = std::atof(floatCStr);
    std::cout << "float: " << fnum << std::endl;

    // int 转 const char*
    int anotherNum = 67890;
    char buffer[50];
    std::sprintf(buffer, "%d", anotherNum);
    const char* intToStr = buffer;
    std::cout << "const char*: " << intToStr << std::endl;

    // float 转 const char*
    float anotherFNum = 678.90f;
    std::sprintf(buffer, "%.2f", anotherFNum);
    const char* floatToStr = buffer;
    std::cout << "const char*: " << floatToStr << std::endl;

    return 0;
}

总结

string 与 const char\* 互转： 使用 c_str() 方法和 std::string 的构造函数。
string 与 char\* 互转： 需要创建一个可变的字符数组 (std::vector<char>)，通过 data() 获取指针；char* 转换为 string 直接使用构造函数。
string 与 char[] 互转： 使用 std::copy 将 string 转换为 char[]；通过 string 的构造函数从 char[] 创建。
string 与基本类型 (int, float, double) 互转： 使用 std::stoi、std::stof、std::stod 转换为数字类型，使用 std::to_string 转换为 string。
const char\* 与 char\* 互转： 通过 strcpy 等拷贝方法将 const char* 复制到 char*；char* 转换为 const char* 直接赋值即可。
const char\* 与 char[] 互转： 类似于上面，使用 strcpy 等拷贝方法将 const char* 复制到 char[]。
const char\* 与基本类型 (int, float, double) 互转： 使用 atoi, atof 等 C 标准库函数从 const char* 转换为数字类型，使用 sprintf 或 C++11 以后的 std::to_string 再转换为 const char*。