10
votes

Les valeurs booléennes négatives sont-elles définies?

en C, au moins chaque valeur positive sauf 0 est traitée comme une version booléenne. Mais qu'en est-il d'une valeur négative? J'ai fait des tests et il semble que les valeurs négatives sont également traitées comme une vraie Booléenne. Est-ce un comportement défini ou une implémentation spécifique?

(Je suis venu réfléchir à cela lorsque j'ai vu dans une question, une personne qui promouvait déclarer "vrai" et "faux" dans une énumération comme 1 et 0.)

2 commentaires

Tout ce qui n'est pas false est vrai ?


                                        
                                                                            Je pense que ce  Stackoverflow.com/ Questions / 727196 / ...  répondrait à votre question



                                    
                    5 Réponses :
                    
                                            
                            
                                
                                    23
 votes
                                
                            
                            
                                
                                     Ceci est un comportement défini. Je chercherai le paragraphe standard de C99 indiquant en tant que tel 


    § 6.3.1.2  

  Lorsqu'une valeur scalaire est convertie en _bool, le résultat est 0 si
  La valeur se compare égale à 0;
  Sinon, le résultat est de 1. 
                                


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    +1 La norme  bool  est bonne. J'utilise un  ENUM  en cas de retombe au cas où un compilateur particulier manque de support C99.                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     en C, il n'y a pas de type booléen; 0 et 0.0f sont considérés comme "faux" dans des contextes booléens, tout le reste est "vrai". 
 déclarant "vrai" et "faux" dans un énorme est faux, car le code suivant se cassera:  < Pré> xxx  
 (2 devrait être évalué comme "vrai", mais si TRUE a été défini comme 1, les deux valeurs ne sont pas considérées comme égales).                                  

                                                                    
                                    
                                    
                                        4 commentaires
                                        
                                                                                            
                                                    Toute personne teste si une valeur est égale à  true  est fausse, car le test ne doit pas être fait en premier lieu. Un  Enum  est bien dans certaines situations.                                                

                                                
                                                                                            
                                                    Il y a un type booléen en C99, voir ma réponse                                                
                                                
                                                                                            
                                                    Être un nitpick ici, mais l'énumé, lorsqu'il est utilisé, ressemble à un type booléen approprié mais ne se comporte pas comme un. C'est pourquoi je préfère ne pas l'avoir en premier lieu et il suffit d'utiliser 0 et 1 à la place.                                                
                                                
                                                                                            
                                                    Assez juste. Je n'écrirais pas  si (x == true)  même s'il s'agissait d'un type booléen approprié. J'aime juste avoir un type booléen fonctionnel à revenir des fonctions parfois.                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Je crois que 0 est faux et tout le reste est vrai. 

 Voir la réponse de @ Casper ici:  Fil  


   Je prendrais un indice de C ici, où False est défini absolument comme 0 et est défini comme non fausse. Ceci est une distinction importante, par rapport à une valeur absolue pour le vrai. Sauf si vous avez un type qui n'a que deux États, vous devez prendre en compte toutes les valeurs de ce type de valeur, ce qui est vrai et ce qui est faux. 
                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Ceci est le comportement correct, en C  0  est  faux  et  tout le reste  est  vrai                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    -1
 votes
                                
                            
                            
                                
                                     c définie 0 comme faux et tout le reste comme vrai. Positif, négatif, peu importe. 
 Je crois que j'ai récemment préconisé l'utilisation de  Typedef Enum {False, True} Bool;  Je vais donc posséder. (Si mon code d'origine n'avait pas de  Typedef  impliqué, c'était une erreur de jugement de ma part.) Toutes les valeurs non nulles sont vraies, donc je ne préconiserais pas à l'aide d'un énuméré  bool  Type pour des choses comme ceci:   xxx  
 i généralement perforez simplement  si (x)  ou  si (! x) < / code> à des tests explicites contre les valeurs booléennes. Cependant, il est parfois bon d'avoir un type booléen:   xxx  
 ceci n'est pas meilleur que le type être  int , mais au moins tu es Étant explicite avec ce que le résultat est censé.  
 aussi, selon quelqu'un d'autre ci-dessus, un meilleur  bool  pourrait être le suivant:   xxx  
 Je pense que !  est garanti de retourner 0 ou 1, mais je pourrais avoir tort, et ce qui précède fonctionne bien de toute façon.                                  


                                                                    
                                    
                                    
                                        4 commentaires
                                        
                                                                                            
                                                    Juste ne fais pas ça.  bool ,  true  et  false  est défini dans "stdbool.h" et faire la bonne chose.                                                

                                                
                                                                                            
                                                    @Jens - Tous les systèmes n'auront pas de support C99, peut-être que le compilateur de quelqu'un est vraiment vieux ou est fabriqué par Microsoft, et il est si facile de définir un remplissage  bool  type au cas où quelqu'un n'en a pas que si vous allez utiliser un type  bool  en premier endroit, vous pourriez aussi bien avoir une sauvegarde.                                                

                                                
                                                                                            
                                                    Ensuite, vous feriez mieux de faire comment il est prévu dans C89, à savoir avoir  int  pour les valeurs booléennes. Et définissez votre remplacement dans un fichier séparé qui les définit sous forme de macros  bool == int ,  false == 0  et  true == 1 . Sinon, une fois que vous auriez un compilateur C99, ce serait une véritable douleur au port.                                                

                                                
                                                                                            
                                                    @Jens - En désaccord. Je ne pense pas que cela compte si vous les définissez comme des macros ou comme un  Enum  tant que vous le définissez pour fonctionner de même, utilisez-le de manière cohérente (c'est-à-dire aucune hypothèse sur la valeur de  true , ne testez pas les valeurs  BOOL  contre  BOOL  valeurs, etc.), et définissez-la sous condition pour tout ce qui n'est pas supporté en C99, il n'y a aucun moyen de ne fonctionnera pas. Et  bool  n'est pas extrêmement utile de toute façon, alors même si quelque chose se casse, il ne peut pas vraiment casser trop mal.

Articles qui pourrait vous intéresser : Que puis-je utiliser pour la conversion d'entrée au lieu de scanf? Comment puis-je calculer a * b / c lorsque a et b sont tous deux plus petits que c, mais que a * b déborde? Comment vérifier si un pointeur void (void *) est l'un des deux types de données? L'écran LCD affiche des caractères aléatoires (MPLAB)