대형 switch 문에 대해보다 세련된 솔루션이 있습니까?

Question

저는 맵에 0-300 = 10, 300-600 = 20, 600-900 = 30 ... 2500000-2700000 = 7000과 같은 값의 범위가 있습니다. switch-statement/if-block하지만이 작은 문제를 해결하기위한보다 우아한 접근 방법이 있는지 궁금합니다.

0-300 : 25 
301-600. : 45 
601-900 : 65 
901-1200. : 85 
1201-1500: 105 

1501-2000 : 133 
2001-2500 : 161 
2501-3000: 189 
3001-3500:217 
3501-4000:245 

4001-4500:273 
4501-5000:301 
5001-6000:338 

Answer 1

switch 문을 제거하기위한 가장 일반적인 패턴은 사전을 사용하는 것입니다 : 여기에 좋아

은 실제 데이터가있는 테이블의 작은 하위 집합입니다. 귀하의 경우 범위를 매핑하므로 범위를 자르는 대신 NSArray을 사용하게됩니다. 실제로

NSArray *rangeCutoffs = [NSArray arrayWithObjects:[NSNumber numberWithInt:300],[NSNumberWithInt:600],...,nil]; 
NSArray *values = [NSArray arrayWithObjects:[NSNumber numberWithInt:10], [NSNumber numberWithInt:20],...,nil]; 

int mappedInt; 
for (int index=0; index <= [rangeCutoffs count]; index++) { 
    if (intToMap < [[rangeCutoffs objectAtIndex:index] intValue]) { 
     mappedInt = [[values objectAtIndex:index] intValue]; 
    } 
} 
if (mappedInt == 0) { 
    mappedInt = [[values lastObject] intValue]; 
} 

은 당신이 그들을 하드 코딩하는 대신 PLIST에서 rangeCutoffs 및 values를로드 할 것 : 이것은 당신의 int를 처리하는 경우처럼 보일 것 인 것이다.

Answer 2

테이블을 사용할 수 있습니다. 예 : 다음

struct Lookup 
{ 
    int min; 
    int max; 
    int value; 
}; 

struct Lookup table[] = 
{ 
    {  0,  300, 10 }, 
    {  301,  600, 20 }, 
    {  601,  900, 30 }, 
    // other ranges 
    { 2500000, 2700000, 7000 }, 
    { -1, -1, -1 } // marks the end of the table 
}; 

그리고

단순히 대신 이진 검색을 사용할 수 있습니다, 그것은 정말 큰 테이블의 경우 권리 범위를

int result = -1; 
for (int i = 0 ; table[i].min != -1 && result == -1 ; ++i) 
{ 
    if (table[i].min <= value && value <= table[i].max) 
    { 
     result = table[i].value; 
    } 
} 

을 찾아 그것을 통해 반복.

Answer 3

당신이 (C 예) 같은 것을 할 수있는 :

#include <stdio.h> 
#include <stdlib.h> 

typedef int range_type; 
typedef int value_type; 

typedef struct { 
    range_type min; 
    range_type max; 
    value_type value; 
} range_t; 

const range_t *find_range(const range_t *ranges, size_t rangesSize, 
    value_type valueToFind) 
{ 
    for (size_t i = 0; i < rangesSize; ++i) { 
     if (ranges[i].min <= valueToFind && valueToFind <= ranges[i].max) 
      return &ranges[i]; 
    } 
    return NULL; 
} 

int main() { 
    const range_t ranges[] = { 
     { 0, 300, 10 }, 
     { 301, 600, 20 }, 
     { 601, 900, 30 }, 
     { 901, 1200, 40 } 
     // And so on... 
    }; 

    value_type testValues[] = { 
      -1,     // None 
      0, 299, 300, // [ 0, 300] 
     301, 599, 600, // [301, 600] 
     601, 899, 900, // [601, 900] 
     901, 1199, 1200, // [901, 1200] 
     // And so on... 
    }; 

    for (size_t i = 0; i < sizeof(testValues)/sizeof(testValues[0]); ++i) { 
     const range_t *match = find_range(
      ranges, sizeof(ranges)/sizeof(ranges[0]), testValues[i]); 
     if (match != NULL) 
      printf("%d found at [%d..%d]\n", testValues[i], match->min, 
       match->max); 
     else 
      printf("%d not found\n", testValues[i]); 
    } 
    return EXIT_SUCCESS; 
} 

해야 출력 :

-1 not found 
0 found at [0..300] 
299 found at [0..300] 
300 found at [0..300] 
301 found at [301..600] 
599 found at [301..600] 
600 found at [301..600] 
601 found at [601..900] 
899 found at [601..900] 
900 found at [601..900] 
901 found at [901..1200] 
1199 found at [901..1200] 
1200 found at [901..1200]