将枚举传递给整体类型的论点

Question

考虑以下代码：

enum ABC : char
{
    a, b, c
};

void ff(char c)
{
    cout << "char\n";
}

void ff(int i)
{
    cout << "int\n";
}

int main()
{
    ff(a);  // char
}

我可以问为什么要匹配 ff（char）而不是 ff（int）？

---

当我阅读 c ++底漆（第5版）时，我提出了这个问题。在第835页上，作家说：

...我们可以将未枚举的对象或枚举者传递给积分类型的参数。当我们这样做时， enum 值将促进 int 或更大的积分类型...无论其基础类型，对象和枚举者... int 。

我对上述报价的理解是，当传递给期望积分参数的函数时，枚举者将首先将“至少”“至少”施加到 int 中。因此，我希望上述代码可以调用 ff（int）。实际上，即使是我的Visual Studio编辑器也表明：（对不起，我知道我们应该避免在这里屏幕截图，但我只想显示我所看到的内容）

我也注意到，如果我不明确指定> 的基础类型ABC ，然后将调用 ff（int）。

因此，我当前的猜测是这样的：如果我们没有明确指定基础类型，则将传递给积分参数传递给积分参数的对象/枚举器将首先将其施加到 int 中。但是，如果明确指定了基础类型，则编译器将首先尝试匹配期望指定类型的过载函数。

我可以问我的猜测是否正确吗？

Answer 1

我可以问为什么要配合的匹配ff（char）而不是ff（int）？

因为具有固定基础类型的枚举可以隐式转换为其基础类型。基础类型为 char ，因此转换为 char 是最喜欢的候选人过载。

所以我当前的猜测是这样的：如果我们不明确指定基础类型，则将对象/枚举器传递给积分参数，将首先施加到int。

演员是明确的转换。此示例中的转换是隐式的。

确切的首选转换取决于枚举的值。语言规则有点复杂，因此我将从标准中逐字复制：

[cons.prom]

未固定基础类型的未枚举类型的贵族可以转换为以下以下第一种类型的prvalue，可以代表枚举的所有值（[dcl.enum]）：int，int，无签名的int int int ，长int，未签名的长int，长long int或未签名的长long int。
如果该列表中的任何类型都不能代表枚举的所有值，则可以将未登记类型的序数转换为具有最低整数转换等级（[CORV.RANK]）的扩展整数类型的provalue长期的列表可以表示枚举的所有值。
如果有两种扩展类型，则选择签名。

我可以问我的猜测是否正确吗？

在这种情况下， int 是一个正确的猜测不普遍适用。

Answer 2

从C ++ 17标准（7.6积分促销）

3一个未引人注目的枚举类型的贵族，其基础类型为
未固定（10.2）可以转换为第一个
以下可以表示枚举的所有值的类型
（即，如10.2中所述，BMIN到BMAX的值）：
int，unsiged int，long int，未签名的长int，长长的int或
未签名的长长。如果该列表中的任何类型都不能
表示枚举的所有值，
枚举类型可以转换为扩展整数的序幕
类型最低整数转换等级（7.15）大于等级
枚举的所有价值都可以是长期长期
代表。如果有两种此类扩展类型，则签名是
选择。

4 一个未指示的枚举类型的贵族，其基础类型为
固定（10.2）可以转换为其基础类型的序言。
此外，如果可以将整体促销应用于其基础类型，则
潜在的枚举类型的贵族，其基础类型是
固定也可以转换为晋升的基础
类型

和（16.3.3.2排名隐式转换序列）

（4.2） - 一种促进枚举的转换
类型固定在其基础类型上比促进的类型要好
如果两者不同。

因此，由于由于积分促销的积分促销，因此转换为固定的基础类型CHAR优于基础类型char向INT的转换，因此选择具有参数char的函数作为最可行的函数。

我还注意到，如果我不明确指定基础类型
对于ABC，然后将ff（int）调用。

因为根据“ 7.6积分促销”部分的报价＃3，枚举类型至少将枚举类型推广到类型 int 。

但是，如果您要声明枚举，例如以下演示程序中所示的以下方式：

#include <iostream>
#include <limits>

enum ABC
{
    a = std::numeric_limits<unsigned int>::max(), b, c
};

void ff( char c )
{
    std::cout << "char\n";
}

void ff( int i )
{
    std::cout << "int\n";
}

int main()
{
    ff( a );
}

那么函数调用将是模棱两可的。

Answer 3

指定枚举的基础类型将 de exto 将其立即与此基础类型兼容：这就是为什么它是您示例中调用的 char 版本的原因。

与C/C ++， int 一样，隐式的基础类型与往常一样。当您不用枚举指定类型时，就会发生这种情况 - 因此 int 版本首先称为。

但是在我的编译器上（MSVC2017尝试时），即使是第一种情况也不起作用：我得到了“呼叫'ff'是模棱两可的 > char 版本...可能是因为 abc_char 是 enum ，而不是“真正的“ char”，而不是真正的“ int”，而是与通过隐式演员。

ff 的其他调用不会产生任何错误 - int 版本，没有任何警告。

请参阅下面的代码：

#include <iostream>

enum ABC_char : char { a1, b1, c1 } ;
enum ABC_short : short int { a2, b2, c2 } ;
enum ABC_int { a3, b3, c3 } ;

void ff(char)
{
    std::cout << "char" << std::endl ;
}

void ff(int)
{
    std::cout << "int" << std::endl ;
}

int main()
{
    ff(a1) ;    // Call to 'ff' is ambiguous
    ff(a2) ;    // short int -> int
    ff(a3) ;    // int -> int
}

ff（a1）指令甚至不会编译。编译器看到两个候选功能，并且不假定两者中的任何一个。

但是此代码适用于所有呼叫/枚举：

#include <iostream>

enum ABC_char : char { a1, b1, c1 } ;
enum ABC_short : short int { a2, b2, c2 } ;
enum ABC_int { a3, b3, c3 } ;

template < typename T > void ff ( T c )
{
    std::cout << typeid(c).name() << " / " << typeid(std::underlying_type_t<T>).name() << std::endl ;
}

int main()
{
    ff(a1) ;    // enum ABC_char / char
    ff(a2) ;    // enum ABC_short / short
    ff(a3) ;    // enum ABC_int / int
}

您可以在模板中使用 std :: is_same 和一些 constexpr 条件，以确保您称呼为“正确的”行为您的功能：

template < typename T > void ff2 ( T )
{
    if constexpr (std::is_same<std::underlying_type_t<T>, char>()) {
        std::cout << "Using char version" << std::endl ;
    } else
    if constexpr (std::is_same<std::underlying_type_t<T>, int>()) {
        std::cout << "Using int version" << std::endl ;
    } else {
        std::cout << "I have luck!" << std::endl ;
    }
}

int main()
{
    ff2(a1) ;    // Using char version
    ff2(a2) ;    // I have luck!
    ff2(a3) ;    // Using int version
}