允许从类类型到其他类型的隐式转换或显式转换。

语法

转换函数的声明类似于非静态成员函数或函数模板，但没有参数或显式返回类型，并拥有下列形式的名字：

1) 声明用户定义的转换函数，它参与所有隐式和显式转换。

2) 声明用户定义的转换函数，它仅参与直接初始化和显式转换。

3) 声明用户定义的转换函数，它为条件性 explicit 。

转换类型标识是一个类型标识，但其声明器中不允许出现函数与数组运算符 [] 或 ()（因此，转换到诸如数组的指针的类型要求使用类型别名、typedef 或标识模板：见下文）。无论是否使用 typedef，转换类型标识都不能代表数组或函数类型。

尽管用户定义转换函数的声明中不允许出现返回类型，声明的文法中的 声明说明符序列可以存在并可包含除了 类型说明符 或关键词 static 之外的任何说明符。尤其是，其不仅允许 explicit，亦允许说明符 inline、virtual、constexpr (C++11 起)、consteval (C++20 起) 及 friend（注意 friend 要求有限定名：friend A::operator B();）。

如果在类 X 中声明这种成员函数，则它进行从 X 到 转换类型标识 的转换：

struct X {
    // 隐式转换
    operator int() const { return 7; }
 
    // 显式转换
    explicit operator int*() const { return nullptr; }
 
//   错误：转换类型标识中不允许出现数组运算符
//   operator int(*)[3]() const { return nullptr; }
    using arr_t = int[3];
    operator arr_t*() const { return nullptr; } // 若通过 typedef 进行则 OK
//  operator arr_t () const; // 错误：不允许任何情况下转换到数组
};
 
int main()
{
    X x;
 
    int n = static_cast<int>(x);   // OK：设 n 为 7
    int m = x;                     // OK：设 m 为 7
 
    int* p = static_cast<int*>(x);  // OK：设 p 为 null
//  int* q = x; // 错误：无隐式转换
 
    int (*pa)[3] = x;  // OK
}

解释

用户定义的转换函数在隐式转换的第二阶段被调用，第二阶段由零或一个转换构造函数或零或一个用户定义转换函数构成。

若转换函数和转换构造函数都能用于进行某个用户定义转换，则复制初始化和引用初始化语境中的重载决议同时考虑转换函数和转换构造函数，但在直接初始化语境中只考虑转换构造函数。

struct To {
    To() = default;
    To(const struct From&) {} // 转换构造函数
};
 
struct From {
    operator To() const {return To();} // 转换函数
};
 
int main()
{
    From f;
    To t1(f); // 直接初始化：调用构造函数
// （注意，若转换构造函数不可用，则选择隐式复制构造函数，且调用转换函数以准备其参数）
    To t2 = f; // 复制初始化：歧义
// （注意，若转换函数来自非 const 类型，例如 From::operator To(); 
//  则它在此情况中替代构造函数被选中）
    To t3 = static_cast<To>(f); // 直接初始化：调用构造函数
    const To& r = f; // 引用初始化：歧义
}

可以定义转换到其自身（可有 cv 限定）类（或其引用），转换到其自身类的基类（或其引用），和转换到类型 void 的转换函数，但它无法作为转换序列的一部分执行，除非在某些情况下通过虚派发来执行：

struct D;
struct B {
    virtual operator D() = 0;
};
struct D : B
{
    operator D() override { return D(); }
};
 
int main()
{
    D obj;
    D obj2 = obj; // 不调用 D::operator D()
    B& br = obj;
    D obj3 = br; // 通过虚派发调用 D::operator D() 
}

它亦可用成员函数调用语法调用：

struct B {};
struct X : B {
    operator B&() { return *this; };
};
 
int main()
{
    X x;
    B& b1 = x;                  // 不调用 X::operatorB&()
    B& b2 = static_cast<B&>(x); // 不调用 X::operatorB&
    B& b3 = x.operator B&();    // 调用 X::operatorB&
}

显式调用转换函数时，类型标识 是贪心的：它是可作为合法 类型标识 的最长可能的记号序列（包括属性，若存在）：

& x.operator int * a; // 分析为 & (x.operator int*) a
                      // 而非 & (x.operator int) * a

struct X {
    operator int(); // OK
    operator auto() -> short;  // 错误：尾随返回类型不是语法的一部分
    operator auto() const { return 10; } // OK：推导的返回类型
};

转换函数可以继承而且可以为虚函数，但不能为静态函数。派生类中的转换函数不会隐藏基类中的转换函数，除非它们转换到同一类型。

转换函数可以为模板成员函数，例如 std::auto_ptr<T>::operator auto_ptr<Y>。其适用的特殊规则参阅成员模板和模板实参推导。