C++ 如果在开关盒内，则限制开关盒

谢谢你的回答

我想知道是否可以使用条件表达式限制swtich case语句的某些情况。就像下面的代码一样

switch(a)
{
    case 1:
    {
        do_1();
        break;
    }
    case 2:
    {
        do_2();
        break;
    }

    if(condition)
    {
        case 3:
        {
            do_3();
            break;
        }

        break;
    }
}

编辑，抱歉，伙计们，我得到了错误的条件，它与切换变量没有任何关系。只是另一个条件，外部条件。 我只是想知道我是否可以限制带有外部条件的案例，否则，如果条件不满足，将无法分析if内部的案例。

---

我需要在if中使用第二次中断吗？

简短的回答是否。您必须颠倒顺序：

case 3: 
    if (condition) 
        do_3();
    break;

不，您可以这样做：

    case 3:
    {
        if (a == condition)
            do_3();
        break;
    }

    break;

---

有两种方法可以做到这一点：

使用预处理器宏，假设您的条件可以通过这种方式进行测试

#ifdef condition
    case 3:
    {

        do_3();
        break;
    }
#endif

将

if

语句移动到

case

块内

case 3:
{
    if (a == condition)
        do_3();
    break;
}

---

检查每种情况下的状况：

switch(a) 
{ 
    case 1: 
    { 
        do_1(); 
        break; 
    } 

    case 2: 
    { 
        do_2(); 
        break; 
    } 

    case 3: 
    { 
        if (condition) 
            do_3(); 
        break;
    } 

    case 4: 
    { 
        if (condition) 
            do_4(); 
        break;
    } 
} 

或者使用带有第二个

开关的
默认
块：

switch(a) 
{ 
    case 1: 
    { 
        do_1(); 
        break; 
    } 

    case 2: 
    { 
        do_2(); 
        break; 
    } 

    default:
    {
        if (condition)
        {
            switch (a)
            {
                case 3: 
                { 
                    do_3(); 
                    break;
                } 

                case 4: 
                { 
                    do_4(); 
                    break;
                } 
            }
        }

        break; 
    }
} 

你将无法在其中放置if条件，因为它不适用于C++语法。您应该将#3移到case语句之外，或者将其作为默认case的一部分并检查其中的条件。
C++不支持这一点。但您可以使用函数调用将交换机拆分为多个部分，以减少代码重复。如果您试图按照以下思路做一些事情：

void func()
{
    switch(a)
    {
        case 1:
        {
            do_1();
            break;
        }
        case 2:
        {
            do_2();
            break;
        }

        if(condition)
        {
            case 3:
            {
                do_3();
                break;
            }

            case 4:
            {
                do_3();
                break;
            }

            case 5:
            {
                do_3();
                break;
            }
            break;
        }
    }
}

你可以这样把它分开：

void func()
{
    if(!func_a(a) && condition)
        func_b(a);
}

bool func_a(a)
{
    switch(a)
    {
        case 1:
        {
            do_1();
            return 1;
        }
        case 2:
        {
            do_2();
            return 1;
        }

        default: return 0;
    }
}

void func_b(a)
{
    switch(a)
    {
        case 3:
        {
            do_3();
            break;
        }

        case 4:
        {
            do_3();
            break;
        }

        case 5:
        {
            do_3();
            break;
        }
    } 
}

编译在C++中。strong>但结果出乎我意料
#包括
#包括
int测试（int动作，bool允许受限制）
{
int success=-1；
开关（动作）
{
案例1：
std：：cout那个条件是什么？我的意思是
a
是一个数字，它没有任何意义。将条件移动到
case
的主体中。记住，
switch/case
只是一个花哨的
goto
。case条件呢：？呃，这就是你的
switch
语句所做的。你可以做任何你需要做的事情每个特定案例。这毫无意义。通过给出一个案例，您已经给出了一个要满足的条件。如果满足该条件，案例代码将被执行。因为已经包含了等式，剩下的唯一条件是比较…但是如果案例是3，我们已经知道了关于a的所有信息，并且没有必要将其与任何东西进行比较。它这就像说
if（a==condition&&a==3）
，这当然是胡说八道。如果
条件
是三，它是多余的，如果它是其他任何东西，下面的块将是死代码。写这样的东西是没有意义的。中断必须超出
如果
，否则它将失败！但这是愚蠢的…它已经打开了
a
a
在这种情况下只能是
3
。@egrunin:good point（虽然写得很好，但不相关，因为
3
是
开关中的最后一个案例）。@BrianRoach:是的，因此在这一点上，它基本上等同于
if（条件==3）
--这仍然有意义。@MooingDuck:谢谢提醒--我已经更新了答案以匹配编辑后的问题。但这太傻了……它已经打开了
a
a
在这种情况下只能是
3
。我想这就是你想要的示例进入的顺序。至少现在人们可以阅读它们了。“你写的是无效的语法。”不，他写的是完全有效的语法。@Rob：这很有趣。你应该从中做出回答（也许解释一下这是GCC功能还是什么）。@Robᵩ 你说得对！让我惊讶的是，如果我可以添加…：）…if永远不会执行（尽管我看到一些为if生成的asm！）…编译器至少应该发出警告（不可访问的语句）…更新后……C++支持它。不，它不是意外的，它是标准的和预期的。此外，这不是OP问题的答案。所以它可能还是不可能？为什么？抓住一个有趣的阅读。
Performing 1
Performing restricted 3
Performing restricted 3


int test_fallthrough(int action, bool allow_restricted)
{
    int success = -1;
    switch(action)
    {
        case 1:
            std::cout << "fallthrough " << 1 << std::endl;
            success = 0;
        case 2:
            std::cout << "fallthrough " << 2 << std::endl;
            success = 0;
        if(allow_restricted)
        {
            case 3:
                std::cout << "fallthrough restricted " << 3 << std::endl;
                success = 0;
            case 4:
                std::cout << "fallthrough restricted " << 4 << std::endl;
                success = 0;
        }
        default:
        break;
    }
    return success;
}


int main()
{
    test_fallthrough(1,false);
    test_fallthrough(1,true);
}


fallthrough 1
fallthrough 2
fallthrough 1
fallthrough 2
fallthrough restricted 3
fallthrough restricted 4

void test_fun_fallthrough(int action, bool allow_restricted)
{
    bool initialize = false;
    switch(action)
    {
        do
        {
            case 1:
                std::cout << "Fun fallthrough, initializing " << 1 << std::endl;
                initialize = false;
            case 2:
                std::cout << "Fun fallthrough " << 2 << std::endl;
            if(allow_restricted)
            {
                case 3:
                    std::cout << "Fun fallthrough restricted " << 3 << std::endl;
                    if(3 == action)
                    {
                        initialize = true;
                        action = 1;
                    }
                case 4:
                    std::cout << "Fun fallthrough restricted " << 4 << std::endl;
            }
        } while(initialize);
        default:
        break;
    }
}

int main()
{
    test_fun_fallthrough(3,true);
    std::cout << "*********************" << std::endl;
    test_fun_fallthrough(3,false);
}


Fun fallthrough restricted 3
Fun fallthrough restricted 4
Fun fallthrough, initializing 1
Fun fallthrough 2
Fun fallthrough restricted 3
Fun fallthrough restricted 4
*********************
Fun fallthrough restricted 3
Fun fallthrough restricted 4
Fun fallthrough, initializing 1
Fun fallthrough 2