Faire en sorte que le compilateur suppose que tous les cas sont traités dans le commutateur sans valeur par défaut

Vous pouvez le faire compiler sans avertissement simplement en ajoutant une étiquette default à l'un des cas:

uint16_t colorData = 345;
switch(iteration)
{
case 0:
    colorData = 123;
    break;
case 1:
    colorData = 234;
    break;
}

Alternativement:

switch(iteration)
{
case 0:
    colorData = 123;
    break;
case 1:
    colorData = 234;
    break;
case 2: default:
    colorData = 345;
    break;
}

Essayez les deux et utilisez le plus court des deux.

Je sais qu'il y a eu de bonnes solutions, mais alternativement Si vos valeurs vont être connues au moment de la compilation, au lieu d'une instruction switch, vous pouvez utiliser constexpr avec un modèle de fonction statique et quelques énumérateurs ; cela ressemblerait à quelque chose comme ceci dans une seule classe:

int main() {
    uint8_t input;
    std::cout << "Please enter input value [0,2]\n";
    std::cin >> input;

    auto output = ColorInfo::updateColor(input);

    std::cout << "Output: " << output << '\n';

    return 0;
}

Les instructions cout dans le if constexpr ne sont ajoutées qu'à des fins de test, mais cela devrait illustrer une autre façon possible de le faire sans avoir à utiliser une instruction switch à condition que vos valeurs soient connues au moment de la compilation. Si ces valeurs sont générées au moment de l'exécution, je ne suis pas tout à fait sûr qu'il existe un moyen d'utiliser constexpr pour obtenir ce type de structure de code, mais si c'est le cas, j'apprécierais si quelqu'un d'autre avec un peu d'expérience supplémentaire pourrait expliquer comment cela pourrait être fait avec constexpr en utilisant les valeurs de runtime . Cependant, ce code est très lisible car il n'y a pas de nombres magiques et le code est assez expressif.

- Mise à jour - p >

Après avoir lu plus d'informations sur constexpr , il est venu à mon attention qu'ils peuvent être utilisés pour générer des constantes de temps de compilation . J'ai également appris qu'ils ne peuvent pas générer de constantes d'exécution mais qu'ils peuvent être utilisés dans une fonction d'exécution . Nous pouvons prendre la structure de classe ci-dessus et l'utiliser dans une fonction d'exécution en tant que telle en ajoutant cette fonction statique à la classe:

#include <iostream>

int main() {
    auto output0 = ColorInfo::colorUpdater<ColorInfo::CR_0>();
    auto output1 = ColorInfo::colorUpdater<ColorInfo::CR_1>();
    auto output2 = ColorInfo::colorUpdater<ColorInfo::CR_2>();

    std::cout << "\n--------------------------------\n";
    std::cout << "Recipient0: " << output0 << '\n'
              << "Recipient1: " << output1 << '\n'
              << "Recipient2: " << output2 << '\n';
    return 0;
}

Cependant je veux pour changer les conventions de dénomination des deux fonctions. La première fonction que je nommerai colorUpdater () et cette nouvelle fonction que je viens de montrer ci-dessus je la nommerai updateColor () car elle semble plus intuitive de cette façon. Ainsi, la classe mise à jour ressemblera maintenant à ceci:

class ColorInfo {
public:
    enum ColorRecipient {
        CR_0 = 0,
        CR_1,
        CR_2
    };

    enum ColorType {
        CT_0 = 123,
        CT_1 = 234,
        CT_2 = 345
    };

    static uint16_t updateColor(uint8_t input) {
        if ( (input - '0') == CR_0 ) {
            return colorUpdater<CR_0>();
        }
        if ( (input - '0') == CR_1 ) {
            return colorUpdater<CR_1>();
        }
        if ( (input - '0') == CR_2 ) {
            return colorUpdater<CR_2>();
        }

        return colorUpdater<CR_0>(); // Return the default type
    }

    template<const uint8_t Iter>
    static constexpr uint16_t colorUpdater() {

        if constexpr (Iter == CR_0) {
            std::cout << "ColorData updated to: " << CT_0 << '\n';
            return CT_0;
        }

        if constexpr (Iter == CR_1) {
            std::cout << "ColorData updated to: " << CT_1 << '\n';
            return CT_1;
        }

        if constexpr (Iter == CR_2) {
            std::cout << "ColorData updated to: " << CT_2 << '\n';
            return CT_2;
        }
    }
};

Si vous voulez l'utiliser uniquement avec des constantes de temps de compilation, vous pouvez l'utiliser comme avant mais avec le nom mis à jour de la fonction.

static uint16_t colorUpdater(const uint8_t input) {
    // Don't forget to offset input due to std::cin with ASCII value.
    if ( (input - '0') == CR_0)
        return updateColor<CR_0>();
    if ( (input - '0') == CR_1)
        return updateColor<CR_1>();
    if ( (input - '0') == CR_2)
        return updateColor<CR_2>();

    return updateColor<CR_2>(); // Return the default type
}

Et si vous souhaitez utiliser ce mécanisme avec des valeurs runtime , vous pouvez simplement faire ce qui suit:

#include <iostream>

class ColorInfo {
public:
    enum ColorRecipient {
        CR_0 = 0,
        CR_1,
        CR_2
    };

    enum ColorType {
        CT_0 = 123,
        CT_1 = 234,
        CT_2 = 345
    };

    template<const uint8_t Iter>
    static constexpr uint16_t updateColor() {

        if constexpr (Iter == CR_0) {
            std::cout << "ColorData updated to: " << CT_0 << '\n';
            return CT_0;
        }

        if constexpr (Iter == CR_1) {
            std::cout << "ColorData updated to: " << CT_1 << '\n';
            return CT_1;
        }

        if constexpr (Iter == CR_2) {
            std::cout << "ColorData updated to: " << CT_2 << '\n';
            return CT_2;
        }
    }
};

int main() {
    const uint16_t colorRecipient0 = ColorInfo::updateColor<ColorInfo::CR_0>();
    const uint16_t colorRecipient1 = ColorInfo::updateColor<ColorInfo::CR_1>();
    const uint16_t colorRecipient2 = ColorInfo::updateColor<ColorInfo::CR_2>();

    std::cout << "\n--------------------------------\n";
    std::cout << "Recipient0: " << colorRecipient0 << '\n'
              << "Recipient1: " << colorRecipient1 << '\n'
              << "Recipient2: " << colorRecipient2 << '\n';

    return 0;
}

Eh bien, si vous êtes sûr de ne pas avoir à gérer d'autres valeurs possibles, vous pouvez simplement utiliser l'arithmétique. Élimine le branchement et la charge.

void updateColor(const uint8_t iteration)
{
    dummyColorRecepient = 123 + 111 * iteration;
}