使用枚举将类型分配给一系列整数？

Question

我有一个索引数组 [1 ... 20]。 indicesArray 的前 4 个元素链接到某个类型的文件（称为 A 类），其他 16 个元素链接到 B 类。

我随机打乱数组。我现在希望提取 4 个索引，但最多 4 个索引中只有一个可以是 A 类型。

我想我需要在这里使用枚举函数将索引 1-4 定义为“类型 A”，将索引 5-20 定义为“类型 B”，然后如果我查看例如我新随机化的 indicesArray[0] 的第一个元素我可以判断它是哪种类型并采取相应的行动。

我从示例中看到枚举使用的方式类似于：

enum category { typeA = 0, typeB };

是否可以将索引 1-4 分配给 typeA 并将其余的分配给 typeB，还是我在这里走错了路？提前致谢。

编辑以包含代码 sn-p

我尝试对此进行测试并立即遇到错误

 #import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

int* indices = malloc(20*sizeof(int));

for (int i=0; i<20; i++) {

    indices[i] = i;

}

enum category {typeA, typeB};


enum category categoryForIndex(int index) {
    if (index >= 1 && index <= 4) {
        return typeA;
    } else {
        return typeB;
    }
}

[pool drain];
return 0;

}

当我尝试编译它时，我收到错误“嵌套函数被禁用，请使用 -fnested-functions 重新启用”，这通常发生在第二个主函数意外加入混音或类似情况时。有任何想法吗？

编辑以包含一些显示如何将解决方案付诸实践的代码

#import <Foundation/Foundation.h>

enum category {typeA, typeB};

enum category categoryForIndex(int index) {
if (index >= 1 && index <= 4) {
    return typeA;
   } else {
    return typeB;
    }

}

int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

int* indices = malloc(20*sizeof(int));

for (int i=1; i<=20; i++) {

    indices[i] = i;

}


NSLog(@"index[0] is %i:", indices[16]);

enum category index;

index = indices[16];

switch (categoryForIndex(index)) {   //this tests to see what category 16 belongs to
    case typeA:
        NSLog(@"index is of type A");   
        break;
    case typeB:
        NSLog(@"index is of type B");
        break;
    default:
        NSLog(@"index not valid");
        break;
}

 [pool drain];
 return 0;

}

Answer 1

你跑偏了。您不能为给定的枚举分配 1-4。枚举常量只有一个值，而且只有一个。您可以做的是使用枚举来定义两种类型，例如 typeA 和 typeB，就像您已经完成的那样，然后定义一个将索引映射回类型的函数，例如

enum category categoryForIndex(int index) {
    if (index >= 1 && index <= 4) {
        return typeA;
    } else {
        return typeB;
    }
}

现在您可以对索引进行分类了。

Answer 2

您可以在不先洗牌的情况下做到这一点，这样您就知道 A 总是在前面：

#define IndexCount 20
#define ExtractCount 4
#define TypeACount 4

int indicesRemainingCount = IndexCount;
int indices[IndexCount] = { ... }; // your indices, first 4 are type A
int chosenIndices[ExtractCount]; // to be filled with random elements from indices, max one of type A

int minIndex = 0;
for (int i = 0; i < ExtractCount; ++i) {
    int j = minIndex + arc4random_uniform(indicesRemainingCount - minIndex);
    chosenIndices[i] = indices[j];
    if (j < TypeACount) {
        // Set minIndex so I won't pick another A.
        minIndex = TypeACount;
    } else {
        // Remove the chosen B so I don't pick it again.
        --indicesRemainingCount;
        indices[j] = indices[indicesRemainingCount];
    }
}