如果在开关盒内，限制案件

Question

谢谢你的回答。

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

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

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

        break;
    }
}

编辑，对不起伙计们，我得到了错误的条件，它与切换变量完全无关。 只是另一个条件，外部条件。 我只想知道是否可以用外部条件限制案例，否则，如果不满足条件，则不会分析IF内部的案例。
我是否需要在if内进行第二次休息？

Answer 1

最简洁的答案是不。 你必须扭转顺序：

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

Answer 2

在每种情况下检查条件：

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的default块：

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; 
    }
} 

Answer 3

不，你这样做：

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

    break;

Answer 4

它可以做的两种方式是：

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

    #ifdef condition case 3: { do_3(); break; } #endif 

2. 将if语句移到case块内。

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

Answer 5

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;
        }
    } 
}

Answer 6

你将永远无法在那里放置if条件，因为它不适用于C ++语法。 您应该在case语句之外移动＃3，或将其作为默认情况的一部分并检查那里的条件。

Answer 7

它用C ++编译。 但结果对我来说意外 。

#include <iostream>
#include <string>


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

int main()
{
    test(1,false);
    test(3,false);
    test(3,true);
}

这不是我们想要的输出。

Performing 1
Performing restricted 3
Performing restricted 3

它没有按预期工作，因为switch-case语句跳转而不是执行if语句。

但是在if -statement有效的情况下（当action == 3和allow_restricted == false ）。

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

在交换机内部使用while循环，它会变得更有趣。

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

出乎意料的是，即使allow_restricted为false ，我们也可以跳转到受限制的代码。