在下面的c+代码中，基于返回类型的运算符重载解析是如何工作的+； 我知道C++中没有基于返回类型的法律过载；即 您不能执行以下操作： int operator ++ getOwner(); char operator ++ getOwner();

然而，我偶然发现了以下几点：

---

我的问题是，在这种配置中，运算符重载是如何工作的。如何在main.cpp中调用此函数以获得这种重载。编译器如何推断，如何调用正确的重载？

上述代码用于

运算符

类型转换，并提供隐式方式将

代理

类型转换为

int

和

char

上述代码用于

运算符

类型转换，并提供隐式方式将

代理

类型转换为

int

和

char

编译器根据转换调用的上下文“知道”，例如：

Proxy p;

// p_int will be set equal to p.my_owner->getInt()
int p_int = p;

// p_char will be set equal to p.my_owner->getChar()
char p_char = p;

编译器根据转换调用的上下文“知道”，例如：

Proxy p;

// p_int will be set equal to p.my_owner->getInt()
int p_int = p;

// p_char will be set equal to p.my_owner->getChar()
char p_char = p;

---

事实上，它是一个代理是无关的；这同样适用于任何类。这些是转换运算符，编译器会根据调用代码中使用的方式选择正确的版本

struct S {
    operator int() const { return 1; }
    operator double() const { return 2.0; }
};

int main() {
    S s;
    int i = s;
    double d = s;
    std::cout << i << ' ' << d << '\n';
    return 0;
}

结构{
运算符int（）常量{return 1；}
运算符double（）常量{return 2.0；}
};
int main（）{
S S；
int i=s；
双d=s；
std:：cout它是一个代理的事实是不相关的；同样的事情适用于任何类。这些是转换运算符，编译器根据调用代码中如何使用它来选择正确的版本

struct S {
    operator int() const { return 1; }
    operator double() const { return 2.0; }
};

int main() {
    S s;
    int i = s;
    double d = s;
    std::cout << i << ' ' << d << '\n';
    return 0;
}

结构{
运算符int（）常量{return 1；}
运算符double（）常量{return 2.0；}
};
int main（）{
S S；
int i=s；
双d=s；
标准：：cout
我的问题是，在这种配置中，运算符重载是如何工作的

这些运算符提供隐式转换。这意味着该类可以在许多需要
int
或
char
的上下文中使用，并将使用这些运算符提供期望值

如何在main.cpp中调用此函数以获得这种重载

以下是一些隐式转换的示例：

Proxy p = whatever();
int i = p;   // convert to int
char c = p;  // convert to char
long l = p;  // ERROR: ambiguous

void f(int);
f(p);        // convert to int

void g(int);
void g(char);
g(p);        // ERROR: ambiguous

您还可以使用常用的强制转换符号请求显式转换：

long l = static_cast<int>(p);  // convert to int, then to long
g((char)p);                    // convert to char

long l=static_cast（p）；//转换为int，然后转换为long
g（（char）p）；//转换为char

编译器如何推断，如何调用正确的重载

每当出现类型不匹配时，编译器都会查找转换序列。规则相当复杂，但基本上该序列最多可以包含一个用户定义的转换（使用这样的运算符或转换结构），以及标准转换，如
int
到
long

我的问题是，在这种配置中，运算符重载是如何工作的

这些运算符提供隐式转换。这意味着该类可以在许多需要
int
或
char
的上下文中使用，并将使用这些运算符提供期望值

如何在main.cpp中调用此函数以获得这种重载

以下是一些隐式转换的示例：

Proxy p = whatever();
int i = p;   // convert to int
char c = p;  // convert to char
long l = p;  // ERROR: ambiguous

void f(int);
f(p);        // convert to int

void g(int);
void g(char);
g(p);        // ERROR: ambiguous

您还可以使用常用的强制转换符号请求显式转换：

long l = static_cast<int>(p);  // convert to int, then to long
g((char)p);                    // convert to char

long l=static_cast（p）；//转换为int，然后转换为long
g（（char）p）；//转换为char

编译器如何推断，如何调用正确的重载

每当类型不匹配时，编译器都会查找转换序列。规则相当复杂，但基本上该序列最多可以包含一个用户定义的转换（使用这样的运算符或转换构造），以及标准转换，如
int
到
long
这有时称为或“返回时重载类型”。要调用的转换运算符是根据需要隐式转换的使用上下文选择的（例如，基于要初始化或分配到的对象的类型）。例如：

#include <stdio.h>

class RtR {
public:
    operator int() const
    {
        puts("operator int()");
        return 42;
    }
    operator double() const
    {
        puts("operator double()");
        return 3.14;
    }
};

void f(int) {}

int main()
{
    RtR x;
    int i = x; // or int i = RtR();
    double d = x;
    f(x);
}

.
这有时称为或“返回类型重载”。要调用的转换运算符是根据需要隐式转换的使用上下文选择的（例如，基于要初始化或分配到的对象的类型）。例如：

#include <stdio.h>

class RtR {
public:
    operator int() const
    {
        puts("operator int()");
        return 42;
    }
    operator double() const
    {
        puts("operator double()");
        return 3.14;
    }
};

void f(int) {}

int main()
{
    RtR x;
    int i = x; // or int i = RtR();
    double d = x;
    f(x);
}

.
在13.1可重载声明中：

仅在返回类型上不同的函数声明不能被删除
重载。[注意：…它不适用于函数集
由于名称查找（例如，由于使用指令）或重载解析（例如。，
对于操作员功能）…]

因此，这是有效的：

struct X {
    // Conversion function:
    operator int () { return 1; }
    operator double () { return 2; }
};

此外（与问题无关）：

struct Y
{
//操作员（功能调用）：
int运算符（）（int）{return 1；}
双运算符（）（double）{return 2；}
//操作员（订阅）：
int运算符[]（int）{return 1；}
双运算符[]（双）{return 2；}
//操作员（轮班）：
13.1可重载声明中的int运算符：

仅在返回类型上不同的函数声明不能被删除
重载。[注意：…它不适用于函数集
由于名称查找（例如，由于使用指令）或重载解析（例如。，
对于操作员功能）…]

因此，这是有效的：

struct X {
    // Conversion function:
    operator int () { return 1; }
    operator double () { return 2; }
};

此外（与问题无关）：

struct Y
{
//操作员（功能调用）：
int运算符（）（int）{return 1；}
双运算符（）（double）{return 2；}
//操作员（订阅）：
int运算符[]（int）{return 1；}
双运算符[]（双）{return 2；}
//操作员（轮班）：
int运算符我不明白为什么显示
operator（）（int）
/
operator（）（double）
（对于
operator[]）也是如此