C 对于这个开关盒构造，有没有更好的实现？

我在一个嵌入式系统上工作，在这个系统中，必须访问一个寄存器，然后再递增，以达到我想要的结果，因为机器正在通知并配置为对我的访问做出反应，以及更改或不更改标志。因此，开关的参数必须保持原样，否则会改变嵌入式系统的行为

但是可能会出现这样一种情况，我不想调用任何一个案例。但是我仍然需要访问并增加

开关的参数

（更深入地说，我正在逐步将模拟值序列转换为数字值转换。索引用于与当前转换保持同步，并将其与相应的情况关联以正确处理图形。可能会出现索引与当前转换不同步的状态，因此必须在不调用任何案例的情况下运行转换（以防止设置错误数据），直到序列完成并且可以执行重新同步）

我目前的做法是：

switch (RunIndex++)/*RunIndex may only be accessed one time per execution
of this construct and has to be incremented in the same step. thats given.*/
{
   if (RunIndexSyncedWithADCensured == false)
   {
     break;
   }
   case 0:
     Case0RelatedData = SomeOperationsForCase0(RawData);
     break;
   case 1:
     Case1RelatedData = SomeOperationsForCase1(RawData);
     break;
   case 2:
     Case2RelatedData = SomeOperationsForCase2(RawData);
     break;
   default:
     RunIndex = 0;
     break;
}

这个构造完成了任务，但看起来有点争议，考虑将其提交到productinal代码中，我感觉不太好

那么，有没有更好的方法来实现同样的目标，而不需要额外的变量或赋值

注意：

也可能与此相关，这是由两部分组成的中断功能的第一部分。
第一部分处理转换完成后必须发生的事情。第二部分处理转换完成后还需要做的事情。因此，如果不进入第二部分，就不能简单地从函数返回。目前没有循环结构中断；

可能会中断。（这也是为什么我将if放在开关范围内的原因，因为它至少在标准上是一种有效的中断方式。）

首先，if（）内部

开关（）

将永远不会执行。
考虑下面的代码片段：

#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 2;

    switch(i) {
        if (i == 2) {
            printf("I M HERE\n");
        }
        case 1:
            printf("1\n");
        break;
        case 2:
            printf("2\n");
        break;
        default:
            printf("default\n");
        break;
    }
    return 0;
}

在case/default（开关构造）之前没有语句：在开关内部执行

现在来回答

我不想调用任何案例。但我仍然需要访问并增加开关的参数

只需将
if（）
向外移动到开关（）

首先，将永远不会执行
switch（）
内的
if（）
。

考虑下面的代码片段：

#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 2;

    switch(i) {
        if (i == 2) {
            printf("I M HERE\n");
        }
        case 1:
            printf("1\n");
        break;
        case 2:
            printf("2\n");
        break;
        default:
            printf("default\n");
        break;
    }
    return 0;
}

在case/default（开关构造）之前没有语句：在开关内部执行

现在来回答

我不想调用任何案例。但我仍然需要访问并增加开关的参数

只需将
if（）
向外移动到开关（）

为什么不先保存值，然后增加值，并在开关中使用保存的值？顺便说一下，这还包括两个访问，第一个是从RunIndex读取值，第二个是增加值

int runIndex = (RunIndex++);
if (RunIndexSyncedWithADCensured )
{
    switch (runIndex)/*RunIndex may only be accessed one time per execution
    of this construct and has to be incremented in the same step. thats given.*/
    {
        case 0:
            Case0RelatedData = SomeOperationsForCase0(RawData);
            break;
        case 1:
            Case1RelatedData = SomeOperationsForCase1(RawData);
            break;
        case 2:
           Case2RelatedData = SomeOperationsForCase2(RawData);
           break;
        default:
           RunIndex = 0;
           break;
    }
}

为什么不先保存值，然后增加值，并在开关中使用保存的值？顺便说一下，这还包括两个访问，第一个是从RunIndex读取值，第二个是增加值

int runIndex = (RunIndex++);
if (RunIndexSyncedWithADCensured )
{
    switch (runIndex)/*RunIndex may only be accessed one time per execution
    of this construct and has to be incremented in the same step. thats given.*/
    {
        case 0:
            Case0RelatedData = SomeOperationsForCase0(RawData);
            break;
        case 1:
            Case1RelatedData = SomeOperationsForCase1(RawData);
            break;
        case 2:
           Case2RelatedData = SomeOperationsForCase2(RawData);
           break;
        default:
           RunIndex = 0;
           break;
    }
}

因为您使用的是相邻的索引号，所以可以创建一个函数指针数组来替换开关。这就是优化器将开关转换为的内容。因此，您得到的不是模糊的开关，而是：

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[RunIndex](RawData);
}

RunIndex++;
if (RunIndex > MAX)
{
  RunIndex = 0;
}


与switch语句设计完全无关：如果
RunIndex
是敏感的易失性变量，如某些硬件寄存器，则不应在任何形式的计算中直接使用它。复制它：

volatile int RunIndex; 
...

int index = RunIndex; // read from RunIndex

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[index](RawData);
}

index++;
if (index > MAX)
{
  index  = 0;
}

RunIndex = index; // write to RunIndex

这是所有此类易失性变量的标准做法。
因为您使用的是相邻的索引号，所以您可以创建一个函数指针数组来替换开关。这就是优化器将开关转换为的内容。因此，您得到的不是模糊的开关，而是：

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[RunIndex](RawData);
}

RunIndex++;
if (RunIndex > MAX)
{
  RunIndex = 0;
}


与switch语句设计完全无关：如果
RunIndex
是敏感的易失性变量，如某些硬件寄存器，则不应在任何形式的计算中直接使用它。复制它：

volatile int RunIndex; 
...

int index = RunIndex; // read from RunIndex

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[index](RawData);
}

index++;
if (index > MAX)
{
  index  = 0;
}

RunIndex = index; // write to RunIndex

这是所有此类易失性变量的标准做法。
为什么在
开关
中包含
if
块？@venki，正如我在OP中所说的那样，以防止在出现无法确保同步的状态时调用这些情况。你知道
if
块从未执行吗？在Santosh向我指出n、 …我正在修复代码段，一分钟。不要与
bool
常量进行比较！这很难读取。而是直接将该值用作条件（此处，您必须求反）：
if（！runindexsyncedwithadconserd）
为什么在
开关中包含
if
块？@venki是为了防止，正如我在OP中所说的，在出现无法确保同步的状态时调用案例。你知道
if
块从不执行吗？我在Santosh指向我之后注意到了它…我正在修复片段，1分钟。不要与
bool
constants！这很难读取。请直接将该值用作条件（此处，必须求反）：
if（！runindexsyncedwithadconserd）
在第一条语句中，它首先在RunIndex中读取并存储RunIndex的值，然后递增。因此，您不需要-1。在这里的任何代码片段中，我看不到任何效率方面的问题。在第一条语句中，它首先在RunIndex中读取并存储RunIndex的值，然后递增。因此您不需要从d到-1。我看不出任何方面的效率问题