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

不，你这样做：

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

    break;

Answer 3

在每种情况下检查条件：

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

或者使用default块和第二个switch：

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 4

可以采取的两种方式是：

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

#ifdef condition
    case 3:
    {

        do_3();
        break;
    }
#endif

将if语句移到case块内。

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

Answer 5

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

Answer 6

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 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语句失败的情况（当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，我们也可以跳转到受限制的代码是意外。

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

7 个答案: