C++ 如何在C++；11使用自动关键字？

我有一个类似这样的类：

class Container {
    public:
        Container(){
            Doubles["pi"] = 3.1415;
            Doubles["e"] = 2.7182;

            Integers["one"] = 1;
            Integers["two"] = 2;
        }

        // Bracket.cpp:23:9: error: 'auto' return without trailing return type
        // auto& operator[](const std::string&);
        auto& operator[](const std::string& key);

    private:
        std::map<std::string, double> Doubles;
        std::map<std::string, int> Integers;
};

有没有办法创建一个

操作符[]

函数来返回多个类型？

这是用以下简单代码驱动的：

int main(){

    Container Bucket;

    double pi(Bucket["pi"]);

    std::cout << "The value of pi is: " << pi << std::endl;

    return 0;
 }

intmain（）{
集装箱吊桶；
双圆周率（桶[“圆周率]）；
std:：coutC++11版本的
auto
作为返回类型仅允许您将返回类型声明推迟到函数参数声明之后：

template<typename T1, typename T2>
auto add(T1 x, T2 y) -> decltype(x + y) { return x + y; }

模板
自动添加（T1 x，t2y）->decltype（x+y）{return x+y；}

在这里，您不能编写
decltype（x+y）add（…）
，因为编译器不知道
x
和
y
是什么

auto
的C++14版本允许编译器对返回类型进行推断。它告诉编译器根据函数体推断函数的返回类型，但它仍然是一个单一的返回类型，因此它仍然不能执行您想要的操作。
作为返回类型的C++11版本的
auto
只允许您推迟返回时间声明函数参数之前的pe声明：

template<typename T1, typename T2>
auto add(T1 x, T2 y) -> decltype(x + y) { return x + y; }

模板
自动添加（T1 x，t2y）->decltype（x+y）{return x+y；}

在这里，您不能编写
decltype（x+y）add（…）
，因为编译器不知道
x
和
y
是什么

C++14版本的
auto
允许编译器对返回类型进行推断。它告诉编译器根据函数体推断函数的返回类型，但它仍然是一个单一的返回类型，因此它仍然不能执行您想要的操作。

只能创建重载多个转换运算符的类：

struct FooReturnProxy {
    FooReturnProxy (int val) : val(val) {}

    operator int() const {
        return val*2;
    }

    operator std::string() const {
        return "Dizzle izzle dolizzle black boom shackalack tempizzle";
    }

    // and so on

private:
    int val;
};


FooReturnProxy foo() {
    return FooReturnProxy(42);
}

int main () {
    int x = foo():
    std::string y = foo();
}

您还可以将这些转换运算符设置为模板

或者，您可以使用
boost:：any
来允许任何类型

然而。。。
但是，如果没有人在C++社区中真正使用这种方法，这最好是一个黑客攻击。真正的解决方案可能需要你在更高的层次上审视你的设计。你真的需要它吗？或者你只是想要它？如果只有后者，最好避免这里提出的解决方案（当然，除了探索C++）。.
黑客
只能创建重载多个转换运算符的类：

struct FooReturnProxy {
    FooReturnProxy (int val) : val(val) {}

    operator int() const {
        return val*2;
    }

    operator std::string() const {
        return "Dizzle izzle dolizzle black boom shackalack tempizzle";
    }

    // and so on

private:
    int val;
};


FooReturnProxy foo() {
    return FooReturnProxy(42);
}

int main () {
    int x = foo():
    std::string y = foo();
}

您还可以将这些转换运算符设置为模板

或者，您可以使用
boost:：any
来允许任何类型

然而。。。
但是，如果没有人在C++社区中真正使用这种方法，这最好是一个黑客攻击。真正的解决方案可能需要你在更高的层次上审视你的设计。你真的需要它吗？或者你只是想要它？如果只有后者，最好避免这里提出的解决方案（当然，除了探索C++）。.
不，您不能这样做。函数必须有一个在编译时已知的返回类型；
auto
只需在编译器可以从上下文中确定它必须是什么时，您就不必键入它

根据运行时的决定，您可以使用或封装一个（如）的类来保存不同类型的值。这可以使您获得具有可变返回类型的效果。
不，您不能这样做。函数必须具有编译时已知的单一返回类型；
auto
只需在编译器可以从上下文中找出它必须是什么

根据运行时的决定，您可以使用或封装的类（例如）来保存不同类型的值。这可以使您具有可变返回类型的效果。
您可以检查
Doubles
是否有键
键
如果没有，请检查
整数
，如果两者都不包含该值，则引发异常关键：

自动容器：：运算符[]（常量std：：字符串和键）
->decltype（查找双精度（键）→双精度->秒：整数->秒）；
布尔查找双精度（常量标准：：字符串和键）常量
{
返回Doubles.find（key）！=Doubles.end（）；
}
bool find_integer（const std:：string&key）const
{
返回整数。查找（键）！=Integers.end（）；
}

然后在
操作符[]
中执行以下操作：

return find\u double（键）？Doubles->second
：查找整数（键）？整数->秒
：throw std:：无效的_参数（“找不到键：+key”）；
您可以检查
double
是否有键
键
，如果没有，请检查
整数
，如果两者都不包含该键，则引发异常：

自动容器：：运算符[]（常量std：：字符串和键）
->decltype（查找双精度（键）→双精度->秒：整数->秒）；
布尔查找双精度（常量标准：：字符串和键）常量
{
返回Doubles.find（key）！=Doubles.end（）；
}
bool find_integer（const std:：string&key）const
{
返回整数。查找（键）！=Integers.end（）；
}

然后在
操作符[]
中执行以下操作：

return find\u double（键）？Doubles->second
：查找整数（键）？整数->秒
：throw std:：无效的_参数（“找不到键：+key”）；
为了安全起见，C++被设计为静态类型。但是，您可以重新设计，将事物从内到外转换为使用多态性来获得您想要的效果

其想法是定义一个通用的数字类型，存储在查找映射键/对象引用中。double&int的数字子类实现所需的操作，如stringify、数学运算和转换，以允许精确的整数加减或方便的浮点乘法和除法

面向对象设计的优点是，如果以后需要添加更多的类号实现类型，可能是为了无限精度，而不影响使用对象方法开发的算法。对于桌面计算器类型的问题，这很可能过于复杂。
C++被设计为针对saf的静态类型不管你怎么说
int|double get_foo( std::string bob ) {
  if (bob=="alice")
    return double{3.14};
  else
    return int(7);
}
int main() {
   int|double x = bob("alice");
   std::cout << x << "\n";
}