第三节 · 换一种交流的方式 · 成员访问运算符定义

类型转换运算符允许对象隐式或显式地转换为其他类型，就像内置类型之间的转换一样。

---

基本语法

class Integer
{
private:
    int value;
    
public:
    Integer(int v = 0) : value(v) {}
    
    // 类型转换运算符
    operator int() const
    {
        return value;
    }
};

int main()
{
    Integer a(42);
    
    int n = a;           // 隐式转换
    int m = (int)a;      // C 风格显式转换
    int k = static_cast<int>(a);  // C++ 风格
    
    cout << n + 10 << endl;  // 52
    
    return 0;
}

---

隐式转换的危险

class String
{
    char* data;
public:
    String(const char* s);
    operator const char*() const { return data; }
};

void print(const char* s) { cout << s << endl; }
void print(const String& s) { cout << "String: " << s << endl; }

int main()
{
    String s = "hello";
    
    // 这里会调用哪个 print？
    // 可能引起歧义或意外的隐式转换
    print(s);
    
    // 更糟糕的是...
    if (s) { }  // 可以编译！因为转换为 const char*，然后转 bool
    
    return 0;
}

---

explicit 类型转换

C++11 引入 explicit 来防止隐式转换。

class Integer
{
private:
    int value;
    
public:
    Integer(int v = 0) : value(v) {}
    
    // 显式转换运算符
    explicit operator int() const
    {
        return value;
    }
    
    explicit operator bool() const
    {
        return value != 0;
    }
};

int main()
{
    Integer a(42);
    
    // int n = a;  // 错误：不能隐式转换
    int n = static_cast<int>(a);  // OK
    int m = (int)a;               // OK
    
    // bool 在条件语句中例外，可以隐式转换
    if (a) { cout << "non-zero" << endl; }
    
    // 但不能用于其他隐式转换
    // bool b = a;  // 错误
    bool b = static_cast<bool>(a);  // OK
    
    return 0;
}

---

智能指针的 bool 转换

#include <memory>

int main()
{
    unique_ptr<int> p1;
    unique_ptr<int> p2 = make_unique<int>(42);
    
    // explicit operator bool() 允许在条件中使用
    if (p1) cout << "p1 valid" << endl;
    if (p2) cout << "p2 valid" << endl;  // 输出
    
    // 但不能这样
    // bool b = p2;  // 错误
    
    return 0;
}

---

转换为指针类型

template<typename T>
class SmartPtr
{
private:
    T* ptr;
    
public:
    SmartPtr(T* p = nullptr) : ptr(p) {}
    ~SmartPtr() { delete ptr; }
    
    // 转换为原始指针
    explicit operator T*() const { return ptr; }
    
    // 转换为 bool
    explicit operator bool() const { return ptr != nullptr; }
    
    T* get() const { return ptr; }  // 通常更推荐用命名函数
};

void useRawPointer(int* p)
{
    if (p) cout << *p << endl;
}

int main()
{
    SmartPtr<int> sp(new int(42));
    
    // useRawPointer(sp);  // 错误：explicit
    useRawPointer(static_cast<int*>(sp));  // OK
    useRawPointer(sp.get());  // 更清晰
    
    return 0;
}

---

多重转换

class Celsius
{
    double temp;
public:
    Celsius(double t) : temp(t) {}
    double getValue() const { return temp; }
};

class Fahrenheit
{
    double temp;
public:
    Fahrenheit(double t) : temp(t) {}
    
    // 转换为摄氏度
    operator Celsius() const
    {
        return Celsius((temp - 32) * 5 / 9);
    }
};

void displayCelsius(Celsius c)
{
    cout << c.getValue() << "°C" << endl;
}

int main()
{
    Fahrenheit f(98.6);
    displayCelsius(f);  // 隐式转换为 Celsius
    
    return 0;
}

---

转换构造函数 vs 转换运算符

class A
{
public:
    int value;
    A(int v) : value(v) {}  // 转换构造函数：int -> A
};

class B
{
public:
    int value;
    B(int v) : value(v) {}
    operator A() const { return A(value); }  // 转换运算符：B -> A
};

int main()
{
    A a1 = 42;   // 转换构造函数
    B b(100);
    A a2 = b;    // 转换运算符
    
    return 0;
}

选择原则：

• 如果目标类型是你的类，用转换构造函数

• 如果源类型是你的类，用转换运算符

---

字符串转换

class Person
{
    string name;
    int age;
    
public:
    Person(string n, int a) : name(n), age(a) {}
    
    // 转换为字符串
    explicit operator string() const
    {
        return name + " (" + to_string(age) + ")";
    }
    
    // 更推荐的方式：命名函数
    string toString() const
    {
        return name + " (" + to_string(age) + ")";
    }
};

int main()
{
    Person p("Alice", 25);
    
    string s1 = static_cast<string>(p);
    string s2 = p.toString();  // 更清晰
    
    cout << s1 << endl;  // Alice (25)
    
    return 0;
}

---

避免歧义

class Integer
{
    int value;
public:
    Integer(int v) : value(v) {}
    operator int() const { return value; }
};

void print(int x) { cout << "int: " << x << endl; }
void print(Integer x) { cout << "Integer: " << (int)x << endl; }

int main()
{
    Integer a(42);
    
    // print(a);  // 歧义：两个 print 都可以匹配
    print(static_cast<int>(a));  // 明确
    
    return 0;
}

---

习题

• 解释 explicit operator bool() 的特殊规则。

• 设计一个 Ratio 类，支持转换为 double。

• 什么时候应该用转换运算符，什么时候用命名函数？