在C++；？ 我在C++中练习切换语句，我想知道我是否可以添加布尔表达式，以及它是I/OR对应的。有没有可能合并这个

以下是我的基本代码：

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <Windows.h>
#include <stdlib.h>
#include <time.h>
#include <random>

using namespace std;


int main()
{
    int HouseValue;
    cout << "Enter your total house value estimate:";
    cin >> HouseValue;

    switch (HouseValue)
    {
        case 1:
            (HouseValue < 100000 && HouseValue > 50000);
            cout << "";
            break;
        case 2:
            (HouseValue < 250000 && HouseValue > 100000);
            cout << "";
            break;
        case 3:
            (HouseValue < 500000 && HouseValue > 250000);
            cout << "";
            break;
        case 4:
            (HouseValue < 1000000 && HouseValue > 500000);
            cout << "";
            break;
        case 5:
            (HouseValue < 3000000 && HouseValue > 1000000);
            cout << "";
            break;
    }
    return 0;
}

#包括“stdafx.h”
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
内部价值；
cout>房屋价值；
开关（房屋价值）
{
案例1：
（房屋价值<100000和房屋价值>50000）；
10万美元）；
25万库特）；
50万美元）；
100万美元）；
cout您不能直接在开关中使用条件，因为它们需要编译时常量表达式。在任何情况下，您的方法都缺少精确值的分支（例如，
HouseValue==100000
），并且是多余的

最简单的解决方案是使用
if/else
链：

if (HouseValue < 50000)
  ...
else if (HouseValue < 100000)
  ...
else if (HouseValue < 250000)
  ...
else if (HouseValue < 500000)
  ...

if（房屋价值<50000）
...
否则，如果（房屋价值<100000）
...
其他条件（房屋价值<250000）
...
其他条件（房屋价值<500000）
...
<代码> > p>不。C++没有这种交换结构：<代码>开关< /> >只与常量一起使用。

该控件结构的C++实现为
if (HouseValue >= 50000 && HouseValue < 100000) {
   ...
} else if (HouseValue >= 100000 && HouseValue < 150000) {
   ...
} else if (HouseValue >= 150000 && HouseValue < 200000) {
   ...
} else {
   ...
}

if（HouseValue>=50000&&HouseValue<100000）{
...
}否则，如果（房屋价值>=100000和房屋价值<150000）{
...
}否则，如果（房屋价值>=150000和房屋价值<200000）{
...
}否则{
...
}

或者，简化一点

if (HouseValue >= 50000 && HouseValue < 100000) {
   ...
} else if (HouseValue < 150000) {
   ...
} else if (HouseValue < 200000) {
   ...
} else {
   ...
}

if（HouseValue>=50000&&HouseValue<100000）{
...
}否则如果（房屋价值<150000）{
...
}其他条件（房屋价值<200000）{
...
}否则{
...
}
在推导案例值时，您可以使用
开关（）的值来获得创造性。例如：

switch((HouseValue + 50000)/50000)

由于以下原因，将产生下表中的潜在结果：

房屋价值（N）（房屋价值+50000）/50000
===================================================
不，不能那样做

switch
语句并不是作为chained
if
switch
语句的“语法糖”引入到语言中的，而是专门为“参数化goto”提供更好的结构化替换功能，即带有运行时跳转目标的
goto
，可立即从参数值派生。
switch
必须始终立即知道准确跳转的位置。这就是
switch
语句背后的全部思想。您的条件不符合该思想。（第二个想法是，它们有点复杂，但它们仍然被原始的
开关
标准“太复杂了”。）

您正试图通过链式
if
实现。如果您不喜欢它，您可以发明其他东西，比如某种范围集合，它可以从给定的
HouseValue
有效地生成整数范围索引（1、2、3等）。您将能够在该索引上进行
切换。（见@WhozCraig的答案。）

当然，由于您的
HouseValue
是一个整数，因此您可以使用包含所有可能
HouseValue
值的大小写标签进行
切换
，但除了纯粹的幽默之外，这几乎没有任何价值

还应该注意的是，一些编译器（例如GCC）支持
swith
语句中的“范围”大小写标签，如

switch (HouseValue)
{
    case 50000 ... 100000:
        ...
        break;
    case 100000 ... 250000:
        ...
        break;
    ...
}

但这是一个非标准语言扩展。
这里有另一个解决方案，只需在交换机中插入
ValueBracket（HouseValue）

static const std::array<int, 6> Values = { 50000, 100000, 250000, 500000, 1000000, 3000001 };
size_t ValueBracket(int value) {
    return std::lower_bound(Values.begin(), Values.end(), value) - Values.begin();
}

这可能只是一个快乐的GCC

但case只能是编译时常量，如constexpr…
另一种解决方案：带函数指针的查找表

typedef void (*Ptr_Processing_Function)(void);

void Process_Range_1(void);
void Process_Range_2(void);
void Process_Range_3(void)

struct Range_Entry
{
  unsigned int lower_price;
  unsigned int high_price;
  Ptr_Processing_function process_function;
};

const Range_Entry table[] =
{
  {50000, 10000, Process_Range_1},
  {10000, 15000, Process_Range_2},
  //...
};
const unsigned int entries_in_table =
    sizeof(table) / sizeof(table[0]);

//...
cin >> price;
for (unsigned int i = 0; i < entries_in_table; ++i)
{
  if ((price >= table[i].lower_price) && (price < table[i].high_price))
  {
    table[i].processing_function();
    break;
  }
}

typedef void（*Ptr_处理函数）（void）；
作废流程\范围\ 1（作废）；
无效过程_范围_2（无效）；
作废流程\范围\ 3（作废）
结构范围\u项
{
无符号整数较低的价格；
未签字的国际高价；
Ptr_加工_功能加工_功能；
};
常量范围_条目表[]=
{
{50000，10000，过程范围{1}，
{10000，15000，进程范围{2}，
//...
};
表中的常量无符号整数项=
sizeof（表）/sizeof（表[0]）；
//...
cin>>价格；
for（无符号整数i=0；i<表中的条目；++i）
{
如果（（价格>=表[i]。低价）和&（价格<表[i]。高价））
{
表[i]。处理函数（）；
打破
}
}
我知道我来不及参加聚会了，但你可以把它变成这样的开关：

int mycase = HouseValue / 50000;

switch (mycase) {
  case 0: /* HouseValue < 50000) */
    ...
  case 1: /* HouseValue >= 50000 && HouseValue < 100000 */
    ...
  case 2: /* HouseValue >= 100000 && HouseValue < 250000 */
  case 3:
  case 4:
  case 5:
    ...
  /* etc */
}

int mycase=HouseValue/50000；
开关（mycase）{
案例0:/*房屋价值<50000）*/
...
案例1:/*房屋价值>=50000和房屋价值<100000*/
...
案例2:/*房屋价值>=100000和房屋价值<250000*/
案例3：
案例4：
案例5：
...
/*等*/
}

这样你就可以交易（可能的）用一个整除和一个跳转来计算5个if语句。度量哪一个对您的用例更快。
编译时必须知道case表达式。我之前添加了if，但我姐姐说这不可能，所以我删除了它们，它们的行为很糟糕。@Chantola即使它们在那里，在这段代码中也没有用。切换r
案例1:
例如，已经确定
房屋价值是……嗯..
1
。测试它是否在50000到100000之间有些毫无意义，因为它显然不是（它的
1
）.好的，我只是想知道在switch语句中是否可能出现类似的情况，答案是否定的。谢谢你们的超级快速回复。我不知道在
开关中设置条件如何比
if（）
构造和
if（）更有效
construct更具表现力。因此，我看不到任何好处。
开关的真正功能是编译器可以利用分支的静态特性（如构建跳转表）。
constexpr int Return1() {
    return 1;
}


switch(index) {
case Return1():
        break;
}

typedef void (*Ptr_Processing_Function)(void);

void Process_Range_1(void);
void Process_Range_2(void);
void Process_Range_3(void)

struct Range_Entry
{
  unsigned int lower_price;
  unsigned int high_price;
  Ptr_Processing_function process_function;
};

const Range_Entry table[] =
{
  {50000, 10000, Process_Range_1},
  {10000, 15000, Process_Range_2},
  //...
};
const unsigned int entries_in_table =
    sizeof(table) / sizeof(table[0]);

//...
cin >> price;
for (unsigned int i = 0; i < entries_in_table; ++i)
{
  if ((price >= table[i].lower_price) && (price < table[i].high_price))
  {
    table[i].processing_function();
    break;
  }
}

int mycase = HouseValue / 50000;

switch (mycase) {
  case 0: /* HouseValue < 50000) */
    ...
  case 1: /* HouseValue >= 50000 && HouseValue < 100000 */
    ...
  case 2: /* HouseValue >= 100000 && HouseValue < 250000 */
  case 3:
  case 4:
  case 5:
    ...
  /* etc */
}