Valeur par défaut pour bool en C ++

Je suis la refonte d'un constructeur de classe en C++ et que vous avez besoin pour attraper une quelconque bool. J'ai utilisé des valeurs par défaut pour tous les autres paramètres, mais à partir de ma compréhension bool ne peut être initialisé à true ou false. Depuis deux de ces cas ont de sens que dans la classe, comment dois-je gérer la vérification pour le changement d'une valeur par défaut?

source d'informationauteur voteblake | 2009-05-05

boolean c++

39

La réalité est que vous ne pouvez pas faire cela. Bool a de la valeur, que ce soit vrai ou faux, et si vous n'avez pas initialisé, puis il est au hasard vrai ou faux, peut-être différente à chaque exécution du programme ou de l'attribution de cette catégorie.

Si vous avez besoin d'avoir un type avec plus d'options, définissez un enum.
```
typedef enum MyBool {
    TRUE,
    FALSE,
    FILENOTFOUND
} MyBool;
```
35

Tristate bool est le chemin vers le côté obscur. Tristate bool mène à la colère. La colère mène à la haine. La haine mène à la souffrance.

Préférez ne pas utiliser une tristate bool.

Au lieu de cela, utiliser un booléen pour savoir si le premier booléen est "initialisé" (ou mieux, "connu") ou pas.
```
class Prisoner : public Person
{


  ...

  bool is_veredict_known;
  bool is_guilty;
}
```
Si le veredict n'est pas encore connu, vous ne pouvez pas dire si le Prisonnier est vraiment coupable, mais votre code peuvent se différencier entre les différentes situations. Bien sûr, la Constitution garantit que la valeur par défaut de is_guilty doit être fausse, mais, tout de même... 🙂

Par le chemin, la classe invariant devrait inclure:
```
assert(is_veredict_known || !is_guilty);
```
18

Il semble que vous voulez boost::tribool ou peut-être boost::optional<bool>.

Si c'est ce que vous avez besoin, créez une valeur qui représente le concept de valeur qui n'ont pas été initialisé.

template <typename T>
struct Maybe {
  Maybe() : m_hasValue(false) {}
  bool HasValue() const { return m_hasValue; }
  T& Value() { ThrowIfFalse(m_hasValue); return m_value; }
  const T& Value() const { ThrowIfFalse(m_hasValue); return m_value; }
  void SetValue( _In_ const T& value) { m_value = value; m_hasValue = true; }
private:
  bool m_hasValue;
  T m_value;
};

Maintenant, vous pouvez représenter tous les 3 états dont vous avez besoin.

class SomeType { 
  ...
  Maybe<bool> m_myBool;
}

4

En C++ un bool n'est qu'un bit d'information, un 0 ou un 1. Puisque vous voulez représentent les trois états possibles, vous avez besoin d'un peu plus d'informations. Il existe deux techniques:
1. Utiliser un autre bool valeur pour indiquer si la valeur est "par défaut" ou pas, ou
2. Utiliser un type d'énumération avec trois valeurs à indiquer (par défaut, true, false).
Je serais probablement choisir l'option 1.

struct Bool { //guaranteed initialized bool
    bool v;

    Bool() : v(false) {}
    operator bool() const { return v; }
    bool& operator=(const bool val){ return v = val; }
};

Utiliser le bon boost::optional. Et pas seulement pour les booléens, mais pour tous les autres endroits que vous avez utilisé
certains sale pas initialisées avec des valeurs. Elle s'utilise comme ceci:

void function(optional<int> value) {
   if (value)
      std::cout << "value is defined: " << value.get() << "\n";
   else
      std::cout << "value is not defined\n";
}

Et voici un exemple de fonction de retour facultatif:

struct MapClass {
   map<string,int> m_map;

   optional<int> getValue(string key) {
      optional<int> result = none;
      if (m_map.find(key) != m_map.end())
         result = m_map[key];
      return result;
   }
}

2

Vous pourriez avoir un membre privé qui indique si la valeur booléenne a effectivement été initialisé ou non.
1

Je n'ai pas tout à fait comprendre, mais je vais essayer...

Valeurs par défaut sont appliquées lorsque vous avez un agrégat d'initialiseur que les feuilles des valeurs quelconques. Dans ce cas, booléen par défaut est false. Dans une classe, la valeur "par défaut" serait non initialisée, le sens qu'il pourrait être n'importe quelle valeur et peuvent changer d'une exécution.

Si vous êtes intéressé à savoir si ou non un bool a changé, votre meilleure option est de garder une trace de celui-ci avec un deuxième défaut bool false, ou utiliser un enum représentant les 3 états possibles. Si vous voulez vraiment 3 états, vous ne voulez vraiment pas un booléen.

Vous ne pouvez vraiment pas. Pourriez-vous fournir un deuxième constructeur, par exemple:

class MyClass {
  public:
    MyClass(bool bFlag); //<-- not default
    MyClass(void);       //<-- default
};

0

Au lieu d'un booléen, utiliser une énumération. Par exemple, pour contrôler le niveau de magie:
```
enum {
    MY_ENUM_NO_MAGIC,
    MY_ENUM_SOME_MAGIC,
    MY_ENUM_MORE_MAGIC
} MagicLevel;
```
Ensuite, demandez à votre constructeur accepter un paramètre MagicLevel magic = MY_ENUM_NO_MAGIC.

class aclass
{
    <stuff> lots of other things
    bool mybool
    bool ismyboolinit

    void setmybool(bool b)
    {
        mybool = b;
        ismyboolinit = true;
    }

}

Eh bien, si votre utilisation de fonctions et de classes, juste de surcharge.

ie:

    class thing
{
  public:
   void f1(bool); //bool input
   void f1(int = 3); //default with out bool being known
  private:
   //stuff
};     
void thing::f1 (bool hasAFace)
{
  if(hasAFace)
   f1(0);
  if(!hasAFace)
   f1(1);

}

void thing::f1 (int tri)
{
  bool actionTime;
  if(tri == 1)
    actionTime = true;
   else if(tri == 0)
    actionTime = false;
   else
    //input defualt action here.
}

//et là vous allez. Aussi, vous n'avez pas besoin d'avoir une classe que vous pouvez simplement utiliser les fonctions surchargées.

Vous devez vous connecter pour publier un commentaire.