C++ 如何简化代码并将开关组合成一个函数？

我的任务是根据

first\u number

和

second\u number

我的版本正在运行，但我必须不断重复

开关

，最后我有很多代码，我很不舒服

问题是变量在任何地方都是不同的，我不知道如何创建一个函数，在这个函数中，我可以为每个

案例

块指定一个数字

switch (first_number)
{
    case 0:
    {
        switch (second_number)
        {
            case 0:
            {
                y = 13;
                cout << y << endl;
            }
            break;

            case 1:
            {
                y = 15;
                cout << y << endl;
            }
            break;
        }
    }
    break;

    case 1:
    {
        switch (second_number)
        {
            case 0:
            {
                y = 3;
                cout << y << endl;
            }
            break;

            case 1:
            {
                y = 1;
                cout << y << endl;
            }
            break;
        }
    }
    break;

    case 2:
    {
        switch (second_number)
        {
            case 0:
            {
                y = 156;
                cout << y << endl;
            }
            break;

            case 1:
            {
                y = 67;
                cout << y << endl;
            }
            break;
        }
    }
    break;
}

开关（第一个\u编号）
{
案例0：
{
开关（第二个_编号）
{
案例0：
{
y=13；
简言之，你不能

假设您的所有输出都是
a、b、c、d、e、f
。您的每个输出都需要一个唯一的输入组合才能产生一个输出。例如

0,0: a
0,1: b
1,0: c
1,1: d
2,0: e
2,1: f

因为您的所有输出都是唯一的，通往它们的路径也必须是唯一的。功能逻辑的一个基本问题是，相同的输入不能有两个不同的输出。在这里，您不能减少输入的组合，因为您的每个输出都是唯一的，因此拥有较短的输入列表将违反t规则

这并不是禁止使用键值映射之类的东西来减少代码，但是您将无法减少检索这些值所需的组合数。
简单地说，您不能

假设您的所有输出都是
a、b、c、d、e、f
。您的每个输出都需要一个唯一的输入组合才能产生一个输出。例如

0,0: a
0,1: b
1,0: c
1,1: d
2,0: e
2,1: f

因为您的所有输出都是唯一的，通往它们的路径也必须是唯一的。功能逻辑的一个基本问题是，相同的输入不能有两个不同的输出。在这里，您不能减少输入的组合，因为您的每个输出都是唯一的，因此拥有较短的输入列表将违反t规则

这并不是禁止使用诸如键值映射之类的东西来减少代码，但您将无法减少检索这些值所需的组合数。
有很多方法可以简化这一点。我的goto解决方案通常是
std:：map
。它通常不是最有效的容器，但它非常有用且性能优异演出是为了以后，当我知道我需要做点什么的时候

我不完全理解您的代码应该做什么（还因为缺少一些重要的细节），但我认为您可以使用以下内容：

#include <map>
#include <utility>
#include <iostream>

void foo(std::pair<int,int> x) {
    static std::map<std::pair<int,int>,int> lookup_table{ 
        { { 1,1 }, 1},
        { { 2,3 }, 42}
    };
    std::cout << lookup_table[x] << '\n';
    // or 
    auto it = lookup_table.find(x);
    if (it != lookup_table.end()) {
        std::cout << it->second << '\n';
    }
}


int main(){
    foo( {1,1} );
}

#包括
#包括
#包括
void foo（标准：：对x）{
静态std:：映射查找_表{
{ { 1,1 }, 1},
{ { 2,3 }, 42}
};
std:：cout有很多方法可以简化这一点。我的goto解决方案通常是
std:：map
。它通常不是最有效的容器选择，但它非常有用，性能是为了以后，当我知道我需要做些什么的时候

我不完全理解您的代码应该做什么（还因为缺少一些重要的细节），但我认为您可以使用以下内容：

#include <map>
#include <utility>
#include <iostream>

void foo(std::pair<int,int> x) {
    static std::map<std::pair<int,int>,int> lookup_table{ 
        { { 1,1 }, 1},
        { { 2,3 }, 42}
    };
    std::cout << lookup_table[x] << '\n';
    // or 
    auto it = lookup_table.find(x);
    if (it != lookup_table.end()) {
        std::cout << it->second << '\n';
    }
}


int main(){
    foo( {1,1} );
}

#包括
#包括
#包括
void foo（标准：：对x）{
静态std:：映射查找_表{
{ { 1,1 }, 1},
{ { 2,3 }, 42}
};
std:：cout将函数编码为表

const int table[3][2] = {{13,15}, {3,1}, {156,67}};
int y = table[first_number][second_number];

将函数编码为表

const int table[3][2] = {{13,15}, {3,1}, {156,67}};
int y = table[first_number][second_number];

我不明白你是如何得出“你不能”的结论的，但除此之外，“相同的输入不能有两个不同的输出”只适用于纯函数（可能不是正确的术语，我对函数的东西不太熟悉）但一般来说，函数可以返回相同的输入的不同结果，没有任何问题。请考虑<代码> int fo（int y）{static int x＝0；返回x+= y；}。
。没有这样的规则，
x
和
y
在这种情况下都可以被视为输入。不，它们不能。从外部看不到
x
。无论如何，使用
静态
变量只是演示它的一种方法。那么
rand（）
呢？还有更多的示例和（）使用数学函数生成数字序列，并在给定相同种子时按顺序生成相同的数字。仅因为您的两个示例没有明确的参数输入并不意味着它们“中断”这条规则。我不明白你在争论什么。除非你提到纯函数应该如何工作，否则一般没有这条规则。如果我错了，我希望看到一个引用，这样我就可以纠正我的错误理解。我不明白你是如何得出“你不能”的结论的，但除此之外，“相同的输入不能有两个不同的输出”对于纯函数（可能不是正确的术语，我不太熟悉功能性的东西）是正确的，但是一般来说，函数可以返回相同的输入而没有任何问题的不同结果。考虑<代码> int fo（int y）{static int x＝0；返回x+= y；}。
。没有这样的规则，
x
和
y
在这种情况下都可以被视为输入。不，它们不能。从外部看不到
x
。无论如何，使用
静态
变量只是演示它的一种方法。那么
rand（）
呢？还有更多的示例和（）使用数学函数生成数字序列，并在给定相同种子时按顺序生成相同的数字。仅因为您的两个示例没有明确的参数输入，并不意味着它们“中断”“这个规则。我不明白你在争论什么。除非你提到纯函数应该如何工作，否则一般没有这样的规则。如果我错了，我希望看到一个引用，这样我就可以纠正我的错误理解。”