Commutateur avec plage de valeurs

Question

Je dois donc déterminer le salaire de base d'un employé en fonction du nombre d'années que l'employé a travaillé pour l'entreprise.

je dois le faire en utilisant des structures de commutation et je suis gammes indiquées comme suit:

Nombre d'années worked_ __ _base Salaire

0 – 5     $ 9,500 
6 – 11     $12,700 
12 – 17     $15,300 
18 – 29     $22,600 
>= 30     $26,800 

Alors, comment dois-je faire des gammes pour les cas si je ne veux pas juste pour tous les numéros? Ce n'est pas trop compliqué avec celui-ci, mais ensuite je dois calculer la commission basée sur les ventes et cela a des fourchettes comme 0-3.999,99 $ et 16,000-23,999.99 $.

Answer 1

Alors pour la première partie, il suffit de déclarer un commutateur où plusieurs cas suivent un chemin de code. Comme ceci:

int baseSalary 
switch (yearsWorked) 
{ 
    case 0: 
    case 1: 
    case 2: 
    case 3: 
    case 4: 
    case 5: 
    baseSalary = 9500; 
    break; 

    case 6: 
    case 7: 
    case 8: 
    case 9: 
    case 10: 
    case 11: 
    baseSalary = 12700; 
    break; 

    ... etc ... 
} 

Pour la deuxième partie, un commutateur pour chaque numéro unique dans une gamme de milliers est assez infaisable, mais avec un peu de division intelligente, il peut être tout aussi facile. Si vous divisez 2000 par 1000, vous obtenez 2, et si vous divisez 2500 par 1000, vous obtenez également 2 (avec 500 restants). Avec cela, vous pouvez générer une instruction switch:

int sales = 2100; 
int salesRange = sales/1000; // (salesRange = 2) 

int commission 
switch (salesRange) 
{ 
    case 0: // $0-999 sales 
    case 1: // $1000-1999 sales 
    case 2: // $2000-2999 sales 
    case 3: // $3000-3999 sales 
    commission = <some number here>; 
    break; 

    ... etc ... 
} 

Cela étant dit, cela suppose que « doivent utiliser un commutateur » fait partie d'un travail scolaire ou similaire. Comme les autres personnes l'ont mentionné, il vaut mieux utiliser des instructions if avec une plage (par exemple if (sales >= 0 && sales <= 3999)) que d'utiliser un commutateur pour ce type de chose.

Answer 2

Si vous êtes obligé d'utiliser la déclaration switch alors tenir compte du fait que plusieurs cas peuvent être enchaînées:

switch (years) { 
    case 0: 
    case 1: 
    case 2: 
    .. 
    return 9500; 
    case 6: 
    case 7: 
    .. 
} 

Mais une déclaration if semble plus adaptée au problème:

if (years >= 0 && years <= 5) 
    .. 
else if (years >= 6 && years <= 11) 
    .. 

Answer 3

Si vous avez besoin de création dynamique de vos gammes w/o hardcoding, vous pouvez utiliser cet extrait

struct BaseSalary 
{ 
    int requiredExperience; // years in company 
    int amount;    // salary amount 
}; 

struct SortCondition 
{ 
    bool operator()(const BaseSalary& lhs, const BaseSalary& rhs) 
    { 
     return lhs.requiredExperience < rhs.requiredExperience; 
    } 
}; 

struct SearchCondition 
{ 
    bool operator() (const BaseSalary& s, int exp) 
    { 
     return s.requiredExperience < exp; 
    } 
}; 

// Fill base salary list in any appropriate way 

BaseSalary s1; 
s1.requiredExperience = 3; // [0 - 3] 
s1.amount = 3500; 

BaseSalary s2;   // (3 - 7] 
s2.requiredExperience = 7; 
s2.amount = 7000; 

BaseSalary s3;    // (7-10] 
s3.requiredExperience = 10; 
s3.amount = 11000; 


std::vector<BaseSalary> salaries; 
salaries.push_back(s2); 
salaries.push_back(s3); 
salaries.push_back(s1); 

// Sort salaries in ascending order of experience 

std::sort(salaries.begin(), salaries.end(), SortCondition()); 


// Get base salary based on experience 

int exp_to_search = 5; 

std::vector<BaseSalary>::iterator it = std::lower_bound(salaries.begin(), salaries.end(), some_exp, SearchCondition()); 
if(it == salaries.end()) 
{ 
    // > 10 years 
} 
else 
{ 
    int amount = it->amount; 
}