Datatype booléen

Dans le de l'informatique, le datatype booléen , a parfois appelé le le datatype logique , est un datatype primitif ayant une de deux valeurs : un et zéro (qui sont équivalents au vrai et au faux, respectivement). C'est le cas spécial d'un datatype numérique binaire du de seulement un chiffre, ou le peu , et peut également être représenté dans n'importe quelle autre radix en limitant la gamme des valeurs permises pour certaines opérations.

Dans quelques langues le datatype booléen est défini pour représenter plus de deux valeurs de vérité. Par exemple l'OIN SQL : la norme 1999 a défini un type de données booléen pour le SQL qui pourrait tenir trois valeurs possibles : vrai, faux, inconnu (la nulle de SQL est traitée en tant qu'équivalent à la valeur de vérité inconnue, mais seulement pour le type de données booléen).

Ce datatype est employé dans opérations booléennes et autres telles que le et le (AND, &, *), le ou le (OR, |, +), or/not exclusif équivalent (xor, NEQV, ^), égal (EQV, =, ==) et pas (NOT, ~, ! ) ce qui correspondent à certaines des opérations de l'algèbre booléenne et du arithmétique.

ADA

ADA définit Boolean dans la norme de paquet comme un type énuméré avec les valeurs False et True où False < True.

lang=" de le type booléen est (faux, vrai) ; p : Booléen : = rectifier ; … si p alors … finir si ;

Les opérateurs de relation (=, /=, < ; , < ; =, > ; , > ; =) s'appliquent à tous les types énumérés, y compris Boolean. Les opérateurs booléens and, or, xor, et not sont définis sur Boolean et n'importe quel sous-type avoué. Les opérateurs booléens s'appliquent également aux choix de valeurs de Boolean.

Algol

Algol 60 a eu un datatype de Boolean et des opérations associées, définis dans le rapport d'algol 60. Ceci a été abrégé à bool dans algol 68 .

Un extrait réel des spécifications de langue d'algol 68 (page 177) où les opérateurs booléens sont définis :

10. Opérations sur des opérandes booléens style=" de

    ∨ op du de
  1. = (bool a de , b) bool : (a | vrai | b) ;
    2. ∧ op du de
  2. = (bool a de , b) bool : (a | b | faux) ;
    3. ¬ op du de
  3. = (bool de bool de a) : (a | faux | vrai) ;
    4. de
  4. op = = (bool a de , b) bool : (∨ d'a∧b) (¬b∧¬a) ;
    5. ≠ op du de
  5. = (bool a de , b) bool : ¬ (a=b) ;
  6. ABS op de du de
  7. = ( international de bool de a) : (a | 1 | 0) ;

C

Avant le C99 , les normes pour le langage de programmation du C n'ont fourni aucun type booléen. Ceci cependant ne signifie pas que C ne peut pas stocker des valeurs booléennes, comme en valeurs différentes de zéro de C signifient le vrai et les valeurs nulles signifient le faux. Ainsi, il est commun pour stocker des valeurs booléennes dans les variables d'un autre type, telles qu'un nombre entier ou un enum. Pour la convenance, c'est également terrain communal pour créer un Typedef pour un type booléen, qui résout à un certain datatype existant. La norme du C99 fournit également un type booléen intégré.

Pour illustrer des booleans dans C, noter que le code de C : lang=" de si (my_variable) { printf (" ; Vrai ! \ n" ;); } autrement { printf (" ; Faux ! \ n" ;); }

est équivalent à : lang=" de si (my_variable ! = 0) { printf (" ; Vrai ! \ n" ;); } autrement { printf (" ; Faux ! \ n" ;); }

C'est franc pour des datatypes du nombre entier . Puisque les normes de C exigent que 0 soit interprété comme pointeur nul une fois utilisé dans un contexte d'indicateur ou la fonte à un indicateur, le constuct ci-dessus peut également être employée pour examiner un indicateur pour assurer la NULLE, bien que quelques modèles de code de découragent cette utilisation. Tandis que le même conditionnel est également valide pour des valeurs à point mobile du , le soin spécial doit être pris en les comparant pour l'égalité, puisqu'elles contiennent souvent des résultats arrondis. Traditionnellement, des nombres entiers sont employés pour contenir des variables booléennes.

Tandis qu'il n'est pas nécessaire d'appeler les valeurs vraies et fausses afin d'examiner des variables pour la vérité ou la fausseté, il est nécessaire de faire ainsi afin de leur assigner des valeurs. (L'one-way est d'employer les valeurs zéro et une, qui ont l'avantage d'être language-independent.) Alternativement, le mot-clé de l'enum de de tient compte d'appeler des éléments dans la langue de votre choix, par exemple : lang=" de booléen _boolean d'enum de typedef {FAUX, VRAI} ; … b booléen ;

Les macros typiques suivants du préprocesseur sont également employés souvent.

lang=" de définir les 0

  • FAUX définir 1 VRAI … international f = FAUX ;

    Parfois TRUE peut être défini en tant que -1 ou ~0 (au niveau du bit le complément de zéro). Ceci signifie que tout le peu du nombre entier est placé à 1, sur les architectures informatiques communes du complément du deux de now.

    Cependant, n'importe quelle valeur différente de zéro représente vrai dans le C. Ainsi tandis que dans d'autres langues, le if (== de foo VRAI)… est simplement superflu, dans C, il est réellement code incorrect du .

    Sur un compilateur C récent (soutenant la norme C99), il y a un type de _Bool, qui est employé pour définir bool par le < ; stdbool.h> ; en-tête de :

    lang=" de inclure bool b = faux ; … b = rectifient ;

    C++

    Pendant son procédé d'étalonnage, le langage de programmation de du C++ a présenté les mots-clés de bool, de true et de false, ajoutant un datatype indigène pour soutenir des données booléennes. Sa taille est exécution définie.

    Des macros de préprocesseur peuvent être employés pour transformer bool en _Bool, false dans 0 et true dans 1, permettant la compatibilité avec l'utilisation C99 mentionnée ci-dessus de l'en-tête de stdbool.

    La bibliothèque standard de 1998 C++ définit une spécialisation de la classe de vector. Pour optimiser l'espace, les éléments sont emballés de sorte que chaque bool emploie seulement un bit de mémoire. Ceci est largement considéré une erreur. vector ne répond pas aux exigences pour un récipient de STL. Par exemple, un container : : le reference doit être un vrai Lvalue du type T. Ce n'est pas le cas avec vector. De même, le vector : : iterator ne rapporte pas un bool& quand le a déréférencé . Il y a un consensus général parmi le Comité standard de C++ et le groupe de travail de bibliothèque que vector devrait être désapprouvé ou entièrement enlevé de la prochaine version de la norme.

    C#

    Dans le C# , des variables booléennes sont identifiées par le mot réservé bool, qui est un nom d'emprunt pour le type prédéfini System.Boolean de struct. Conversion standard n'existe pas entre bool et d'autres types. La langue fournit également un type booléen bool ? qui peut représenter trois valeurs : true, false, et null. C'est semblable au type utilisé pour des expressions booléennes dans le SQL

    Coder pour produire un booléen pourrait être représenté comme ceci :

    lang=" de myBool de bool = (== d'I 5) ; System.WriteLine (myBool ? " ; I = 5" ; : " ; I ! = 5" ;);

    Fortran

    Le mot-clé de LOGICAL et les opérations associées . ont été présentés dans les années 50 , avant que Fortran ait été normalisé.

    Java

    Dans le langage de programmation de Java , des variables booléennes sont représentées par le type primitif boolean. Les abrégés sur la machine virtuelle (JVM) de Java de à partir de la représentation réelle dans la mémoire, ainsi les auteurs de JVM peuvent représenter des booleans dans quelque façon soit commode (par exemple, un byte, ou un mot ).

    Les spécifications de langue de Java ne permettent aucune fonte explicite ou implicite à ou de boolean. Ainsi, elles exigent du compilateur de rejeter ce code :

    lang=" de international i = 1 ; si (i) System.println (" ; i n'est pas zero." ;); autrement System.println (" ; i est zero." ;);

    parce que la variable de nombre entier i ne peut pas être moulée à un booléen, et le rapport de if exige un état de boolean.

    Dans Java, des valeurs de boolean (comme d'autres types primitifs) peuvent être apposées aux cordes. Ce dispositif fournit une représentation visuelle de défaut d'un booléen (true est montré comme " ; true" ; et false comme " ; false" ;). Dans tous autres cas, des objets sont considérés vrais.

    Les opérateurs booléens et les types intégrés booléens renvoient toujours un des valeurs de bool vraies et de faux excepté pour le " d'opérateurs ; or" ; et " ; and" ; ce qui renvoient un de leurs opérandes (de gauche à droite, le premier opérande qui détermine la valeur booléenne de l'expression). lang=" de >>> Spam de classe : passage # Spam est assigné un objet de classe. … >>> oeufs = " ; eggs" ; # des oeufs est assignés un objet de corde. >>> oeufs de == de Spam # (double signe d'égales de note pour l'essai d'égalité). Faux >>> Spam ! = eggs # ! = et valeurs toujours de retour de bool de ==. Vrai >>> Spam et oeufs # et retours un opérande. « eggs » >>> le Spam ou les oeufs # ou renvoie également un opérande.spam à 0x01292660> >>>

    Rubis

    Le langage de programmation rouge n'a pas un type de données booléen en tant qu'élément de la langue. Comme beaucoup d'autres langues interprétées, toutes les variables sont dynamiquement dactylographiées. Au lieu de cela, le rubis définit les valeurs explicites de false et de nil, et tout autrement est considéré true, y compris 0, et le " de corde vide ; " ;. Les valeurs true, false, et nil peuvent être assignées aux variables, être retournées des fonctions ou des méthodes, et comparer dans des expressions booléennes.

    lang=" de a = 0 si (a) " d'impression ; true" ; autrement " d'impression ; false" ; extrémité

    imprimera le " ; true" ; , qui pourrait venir comme surprise pour un nouvel utilisateur de la langue.

    Puisque le rubis est une langue pure de la programmation orientée objectivement , même le " ; explicitly" ; les valeurs définies de vrai, de faux et zéro sont des objets ce que chacune a leur propre classe :

    lang=" de p false.class

    Produirait le " ; FalseClass" ; , " ; TrueClass" ; et " ; NilClass" ; respectivement.

    SQL

    Le SQL soutient la logique three-valued (3VL), et les attributs de comparaison dans le SQL peuvent renvoyer n'importe lequel de trois résultats possibles : vrai, faux, ou inconnu. Le datatype booléen a été présenté à l'OIN SQL : 1999 la norme, qui a spécifié qu'en plus des trois valeurs booléennes possibles de SQL, des exemples du datatype pourrait être fixée pour annuler. Pour DBMSs qui mettent en application l'OIN SQL : la norme 1999, le code suivant crée une table qui tient des exemples du type de données booléen.

    lang=" de CRÉER LA TABLE test1 ( un international, b booléen ) ;

    INSERTION DANS test1 VALEURS (1, rectifient) ;

    INSERTION DANS test1 VALEURS (2, faux) ;

    INSERTION DANS test1 VALEURS (3, nulle) ;

    -- Le SQL : la norme 1999 indique que les fournisseurs peuvent employer la nulle au lieu du -- Inconnu de valeur booléenne de SQL. Il est laissé au fournisseur pour décider si -- la nulle devrait être employée pour remplacer complètement l'inconnu. La norme également -- dit que la nulle devrait être traitée en tant qu'équivalent à l'inconnu, qui est -- contradiction. La ligne suivante peut ne pas travailler à tout le SQL : 1999-compliant -- systèmes.

    INSERTION DANS test1 VALEURS (4, inconnu) ;

    CHOISIR * De test1 ;

    Le type de données booléen de SQL n'a pas gagné l'adoption répandue, dû aux contradictions dans le niveau et le manque d'appui des fournisseurs. La plupart d'utilisation de SQL DBMSs d'autres types de données aiment le peu, le byte, et le char simuler le comportement des types de données booléens.

    Visual Basic

    Dans Visual Basic des valeurs booléennes des comparaisons peuvent être stockées dans les variables avec le type de données de Boolean, qui est stocké comme nombre entier signé de 16 bits, mais devraient seulement avoir le True de valeurs (- 1) et le False (0) . Par exemple : lang=" de Faible isSmall comme booléen l'isSmall = l'intMyNumber < la 'expression 10 évalue pour rectifier ou faux S'isSmall alors MsgBox (" ; Le nombre est small" ;) Finir si

    Le faible hellFreezesOver en tant que 'variables booléennes booléennes sont initialisés comme faux le hellFreezesOver = faux 'ou vous peut employer une instruction d'affectation Faire Appeler CheckAndProcessUserInput () Faire une boucle jusqu'au hellFreezesOver

    Note : Bien que les valeurs booléennes devraient seulement être -1 ou 0, d'autres valeurs peuvent être contraintes dans elles en appelant une fonction avec un paramètre variable de ByRef. Il est fortement - recommandé que vous ne faites pas ceci. lang=" de Voo secondaire (ByRef v comme variante) v = 1 Sous-marin d'extrémité

    Barre secondaire (ByRef b comme booléen) b = 1 Sous-marin d'extrémité

    Faible b1 comme booléen, b2 comme booléen b1 = rectifient b2 = rectifient Debug.Print (b1 = b2) 'rectifient Appel Voo (b2) Debug.Print (b1 = b2) 'faux Barre d'appel (b2) Debug.Print (b1 = b2) 'rectifient

    Notes et références

    .
    Random links:471 AVANT JÉSUS CHRIST | L'Armée de l'Air Co-Belligérante italienne | Salle de Charles (VC) | Station de Shek Kip Mei | Terry Lewis (commissaire de police) | Datatype_boleano