Question

我有一个switch语句，它根据提供的索引返回一个值。

switch (index) {
  case 0: 
    return arr_1[index];
  case 1: 
    return arr_2[index];
  // and so on
}

而不是使用＆＃34; arr_1＆＃34;或＆＃34; arr_2＆＃34;，我想写一些类似的东西：

switch (index) {
  case 0: 
    return {1, 2, 3}[index];
  case 1: 
    return {10, 45, 199}[index];
  // and so on
}

这样的事情可能吗？

修改

我尝试过的事情：

int X(int x) { return {1, 2, 3, 4}[x]; }
int X(int x) { static_cast<std::array<int, 4>> ({1, 2, 3, 4})[x]; }
int X(int x) { return (int[])({1, 2, 3, 4})[x]; }

Answer 1

您实际上可以使用std::array来实现此目的。以下内容应该有效：

int idx = 0;
std::cout << std::array<int, 3>{1, 2, 3}[idx] << "\n";

可悲的是，这非常冗长。这是一个有效的例子：

#include <iostream>
#include <array>

int testFunction()
{
    int index = 0;
    switch (index)
    {
    case 0:
        return std::array<int, 3>{1, 2, 3}[index];
    case 1:
        return std::array<int, 3>{10, 45, 199}[index];
    }
}

int main()
{
    std::cout << testFunction() << "\n";
}

如果std::initializer_list实施了索引操作符，那么您的代码段可能有效。但是，如果您确实想使用初始化列表，则可以使用以下命令：

#include <iostream>
#include <initializer_list>

using inl = std::initializer_list<int>;

int testFunction()
{
    int index = 0;
    switch (index)
    {
    case 0:
        return (inl{1, 2, 3}.begin())[index];
    case 1:
        return (inl{10, 45, 199}.begin())[index];
    }
}

我不建议这样做，因为与第一次实施相比，目前还不清楚。

Answer 2

您不能通过索引返回/访问std::initializer_list中的值，因为std::initializer_list does not提供下标运算符，也不允许您按成员函数访问元素。使用实现下标运算符的容器，例如std::array，std::vector或类似的。

Answer 3

一些模板魔术，没有繁琐的模板参数，每个人都会更快乐。这是IMO更优雅，更易于使用：

#include <array>

template<class T, class ...Args>
struct first_arg{
    using type = T;
};

template<class ...Args>
using first_arg_t = typename first_arg<Args...>::type;

template<class ...Args>
auto lst(Args &&...args){
    return std::array<first_arg_t<Args...>, sizeof...(Args)>({ std::forward<Args>(args)... });
}

int main(){
    const auto a = lst(1, 2, 3, 4)[2];
    return 0;
}

我知道它没有明确使用初始化列表，但它似乎是你问题的最佳答案。

从初始化列表返回值

3 个答案: