C++类型转换 #

// 整型提升
short s = 10;
int i = s;      // short → int

// 浮点提升
float f = 3.14f;
double d = f;   // float → double

// 混合运算时的转换
int a = 10;
double b = 3.14;
auto result = a + b;  // int → double，result是double

// 转换方向：小类型 → 大类型
// char → short → int → long → long long → float → double → long double

// 混合运算示例
char c = 'A';
short s = 100;
int i = 1000;
long l = 10000;
float f = 3.14f;
double d = 3.14159;

auto r1 = c + s;    // int
auto r2 = i + l;    // long
auto r3 = f + d;    // double
auto r4 = i + f;    // float

int i = 10;
double d = i;     // int → double（安全）

double d2 = 3.14;
int i2 = d2;      // double → int（可能丢失精度，i2 = 3）

// 无符号转换
int neg = -1;
unsigned int pos = neg;  // 很大的正数（回绕）

// 非零值为true，零为false
int x = 10;
bool b1 = x;      // true

int y = 0;
bool b2 = y;      // false

double d = 3.14;
bool b3 = d;      // true

// 指针转布尔
int* ptr = nullptr;
bool b4 = ptr;    // false

int value = 10;
int* ptr2 = &value;
bool b5 = ptr2;   // true

double d = 3.14;

// C风格转换
int i1 = (int)d;        // 3
int i2 = int(d);        // 3

// 问题：不安全，不推荐使用

const int x = 10;
int* p = (int*)&x;  // 移除const，危险！

class Base {};
class Derived : public Base {};
class Other {};

Base* base = new Derived;
Other* other = (Other*)base;  // 完全不相关的类型转换，危险！

// 基本类型转换
double d = 3.14;
int i = static_cast<int>(d);  // 3

// 指针转换（相关类型）
void* ptr = &i;
int* p = static_cast<int*>(ptr);

// 类层次结构中的转换（编译时检查）
class Base { virtual void foo() {} };
class Derived : public Base {};

Base* base = new Derived;
Derived* derived = static_cast<Derived*>(base);  // 向下转型

// 不相关类型会编译错误
// int* p1 = static_cast<int*>(&d);  // 错误

class Base { 
public:
    virtual ~Base() {} 
};

class Derived : public Base {
public:
    void derivedMethod() { std::cout << "Derived method" << std::endl; }
};

int main() {
    Base* base = new Derived;
    
    // 安全的向下转型
    Derived* derived = dynamic_cast<Derived*>(base);
    if (derived) {
        derived->derivedMethod();
    }
    
    // 引用转型失败会抛出std::bad_cast异常
    try {
        Derived& ref = dynamic_cast<Derived&>(*base);
    } catch (const std::bad_cast& e) {
        std::cout << "Cast failed: " << e.what() << std::endl;
    }
    
    delete base;
    return 0;
}

const int x = 10;

// 移除const
int* p = const_cast<int*>(&x);
*p = 20;  // 未定义行为！不要修改原本的const变量

// 合法用途：调用非const版本的函数
void printString(const char* str) {
    // 某些旧API可能需要非const参数
    char* mutableStr = const_cast<char*>(str);
    // 使用mutableStr...
}

// 添加const
int y = 10;
const int* cp = const_cast<const int*>(&y);

// 指针与整数之间的转换
int x = 10;
long addr = reinterpret_cast<long>(&x);

// 不同指针类型之间的转换
int* pInt = &x;
char* pChar = reinterpret_cast<char*>(pInt);

// 函数指针转换
void (*func1)() = []() {};
int (*func2)() = reinterpret_cast<int(*)()>(func1);  // 危险！

// 注意：reinterpret_cast是危险的，慎用

// 1. 基本类型转换 → static_cast
double d = 3.14;
int i = static_cast<int>(d);

// 2. 多态向下转型 → dynamic_cast
Base* base = new Derived;
Derived* derived = dynamic_cast<Derived*>(base);

// 3. 移除const → const_cast（谨慎使用）
const int* cp = &x;
int* p = const_cast<int*>(cp);

// 4. 底层位转换 → reinterpret_cast（尽量避免）
int* pInt = reinterpret_cast<int*>(&d);

#include <string>

// 数值转字符串
std::string s1 = std::to_string(123);
std::string s2 = std::to_string(3.14);

// 字符串转数值
int i = std::stoi("123");
long l = std::stol("123456");
double d = std::stod("3.14");
float f = std::stof("3.14f");

class Fraction {
private:
    int numerator;
    int denominator;
    
public:
    Fraction(int n, int d) : numerator(n), denominator(d) {}
    
    // 转换为double
    operator double() const {
        return static_cast<double>(numerator) / denominator;
    }
    
    // 显式转换函数（C++11）
    explicit operator std::string() const {
        return std::to_string(numerator) + "/" + std::to_string(denominator);
    }
};

int main() {
    Fraction f(1, 2);
    
    double d = f;  // 隐式转换：0.5
    // std::string s = f;  // 错误：显式转换函数不能隐式调用
    std::string s = static_cast<std::string>(f);  // 正确
    
    return 0;
}

// 窄化转换：大类型 → 小类型，可能丢失数据
double d = 3.14;
int i = d;  // 窄化转换，i = 3

long l = 2147483648L;
int i2 = l;  // 窄化转换，可能溢出

double d = 3.14;

// 普通初始化允许窄化转换
int i1 = d;  // 警告或无警告

// 列表初始化禁止窄化转换
int i2{d};   // 编译错误！
int i3 = {d}; // 编译错误！

// 正确做法
int i4 = static_cast<int>(d);
int i5{static_cast<int>(d)};

int x = 10;

// auto会丢弃引用和顶层const
const int& ref = x;
auto a = ref;        // int（丢弃const和引用）
const auto b = ref;  // const int

// auto不会丢弃底层const
const int* ptr = &x;
auto p = ptr;        // const int*

const int x = 10;

// decltype保留所有类型信息
decltype(x) a = 20;  // const int

int& ref = x;
decltype(ref) b = x; // int&

// 不推荐
int i = (int)3.14;
int* p = (int*)malloc(100);

// 推荐
int i = static_cast<int>(3.14);
int* p = static_cast<int*>(malloc(100));
// 或更好的方式
int* p = new int[25];

class Base { virtual ~Base() {} };
class Derived : public Base {};

Base* base = new Derived;

// 不推荐：不安全的向下转型
Derived* d1 = static_cast<Derived*>(base);

// 推荐：安全的向下转型
Derived* d2 = dynamic_cast<Derived*>(base);
if (d2) {
    // 安全使用
}

// 推荐：使用列表初始化防止窄化转换
int x{10};
double d{3.14};

// 需要转换时显式指定
int y{static_cast<int>(d)};

// 类型转换可能表明设计问题
// 尽量使用多态、模板等替代

// 不好的设计
void process(void* data, int type) {
    if (type == 1) {
        int* p = static_cast<int*>(data);
        // ...
    } else if (type == 2) {
        double* p = static_cast<double*>(data);
        // ...
    }
}

// 好的设计：使用多态
class Data { virtual void process() = 0; };
class IntData : public Data { void process() override; };
class DoubleData : public Data { void process() override; };