C ++：在switch语句内构造数组

Question

I'm trying to construct an array that has a few different configurations where one will be selected randomly. The code I tried first is:

void createArray() {
    int* tileVals;
    int randInt = rand() % 3;
    switch (randInt) {
    case 0:
            int tileVals[] = {1,1,1,2,2,2,3,3,3};
            break;
    case 1:
            int tileVals[] = {1,1,1,1,2,2,3,3,3};
            break;
    case 2:
            int tileVals[] = {1,1,1,1,2,2,2,3,3};
            break;
    }
    // Do stuff with tileVals
}

But I got the compiler error:

src/Board.cpp:67:7: error: redefinition of 'tileVals'
        int tileVals[] = {1,1,1,1,2,2,2,3,3};
src/Board.cpp:70:7: error: redefinition of 'tileVals'
        int tileVals[] = {1,1,1,2,2,2,2,3,3};
...

I next tried:

void createArray() {
    int* tileVals;
    int randInt = rand() % 3;
    switch (randInt) {
    case 0:
            int case0[] = {1,1,1,2,2,2,3,3,3};
            tileVals = case0;
            break;
    case 1:
            int case1[] = {1,1,1,1,2,2,3,3,3};
            tileVals = case1;
            break;
    case 2:
            int case2[] = {1,1,1,1,2,2,2,3,3};
            tileVals = case2;
            break;
    }
    // Do stuff with tileVals
}

But this came back with a compiler error:

src/Board.cpp:85:2: error: switch case is in protected scope
    case 6:
         ^
src/Board.cpp:82:7: note: jump bypasses variable initialization
    int case5[] = {1,1,1,2,2,3,3,3,3};
...

I know I could do it by having a for loop inside each case statement that then assigned the values to a tileVals array that is created outside the switch statement, but that doesn't seem like a very efficient way to do this. Is there a better way? Thanks.

Answer 1

If you do not modify the content of tileVals in the later code, you could do it as follows:

void createArray() {
    int * tileVals;
    int randInt = rand() % 3;
    int cases[][9] = { {1, 1, 1, 2, 2, 2, 3, 3, 3},
                       {1, 1, 1, 1, 2, 2, 3, 3, 3},
                       {1, 1, 1, 1, 2, 2, 2, 3, 3} };
    tileVals = cases[randInt];
    // Do stuff with tileVals
}

Answer 2

1. So your first example fails because all of the variables declared within a switch statement have the same scope. So you're redefining variables.
2. Your second example fails because you are accessing a piece of stack memory that has gone out of scope.

There's not a great solution to this... I might do:

void createArray() {
    static const int case0[] = {1,1,1,2,2,2,3,3,3};
    static const int case1[] = {1,1,1,1,2,2,3,3,3};
    static const int case2[] = {1,1,1,1,2,2,2,3,3};

    const int *tileVals = NULL;
    int randInt = rand() % 3;

    switch (randInt) {
    case 0:
            tileVals = case0;
            break;
    case 1:
            tileVals = case1;
            break;
    case 2:
            tileVals = case2;
            break;
    }
    // Do stuff with tileVals
}

If you actually needed to edit the contents of tileVals , then I would probably allocate the memory for tileVals before the switch statement, and then use a memcpy() .

Answer 3

To create variables in case statements, you must enclose the case in braces.

switch(condition) {
case 0: {
    int x = 0;
    break;
}
}

Answer 4

The second compiler error can be explained with a simpler example:

void foo()
{
  goto end:
  int x = 0;
  end:
}

When I compile a file containing just that function, I get the following error.

g++    -c -o test-33.o test-33.cc
test-33.cc: In function ‘void foo()’:
test-33.cc:5:7: error: jump to label ‘end’ [-fpermissive]
test-33.cc:3:12: error:   from here [-fpermissive]
test-33.cc:4:11: error:   crosses initialization of ‘int x’
test-33.cc:6:5: error: expected primary-expression before ‘}’ token
test-33.cc:6:5: error: expected ‘;’ before ‘}’ token

What this means to me, is that we are executing a goto statement that jumps initialization of variable x . You could reference x after end: even though initialization of x was by-passed.

You are seeing similar errors in the switch block since case ...: statements are jumping points like the jumping points of goto statements.