avertissement: suggérer des parenthèses autour de cession utilisé comme valeur de vérité de

J'ai ce code, et il est quelque chose que je ne comprends pas

Quand je compile le code suivant:

#include <stdio.h>
#include <stdlib.h>


int main() {

double x=1;
double y=0;

  if (x!=y)
  {
    printf("x!=y\n");
  }
  if (x=y)
  {
  printf("x=y\n");
  }

  return 0;
}

Je aller de l'avertissement suivant: avertissement: suggérer des parenthèses autour de cession utilisé comme valeur de vérité de

Quand je lance le programme j'obtiens le résultat suivant

x!=y
x=y

Pourquoi est-il l'impression x=y si si '=' n'est pas de comparer mais juste pour mettre la valeur, il y a de y dans x.

Je sais. néanmoins, il n'a pas répondu à ma question
Il n'a pas l'impression x=y pour moi. ideone.com/bsmVgy
Oh, désolé ne pas voir que vous semblez avoir la "x=y" de sortie trop. Qui ne peut se faire avec un tout complètement foireuse compilateur, depuis y est de 0. Le compilateur que vous utilisez?
-1 pour quelque chose qui n'est pas reproductible.
Ne peut pas se reproduire.
Ma conjecture est que le programme que vous avez exécuté (qui n'a de sortie x=y) n'est pas exactement le programme que vous avez posté. Fait un changement de source pas obtenir recompilé ? Ou de toute autre manière ne le mauvais binaire se faire rouler?
Ne pouvaient pas se reproduire sur les deux MSVC et de la GCC.

InformationsquelleAutor wantToLearn | 2012-10-31

c compiler-warnings if-statement

8

Le compilateur est pour vous avertir que le résultat de l'expression x = y est utilisé à l'intérieur d'un conditionnel; je parle de cela, même si elle ne semble pas être liée à votre question, parce que ces jours, habituellement cela signifie qu'il y a une erreur de frappe et que l'auteur a voulu écrire == à la place.

Sur la question: depuis x = y évalue à y (un double) et y est égal à zéro, le résultat est false parce que c'est ce que le C standard, selon eux, devrait se produire. De 6.3.1.2:

Quand une valeur scalaire est converti à _Bool, le résultat est 0 si l'
la valeur se compare égal à 0; sinon, le résultat est 1.

Le fait d'exécuter ce code doit pas impression des "égaux" le message, comme d'ailleurs pour moi.
- Pinailler: la norme ne dit que dans 6.3.1.2, mais ce n'est pas pourquoi la direction générale est ignoré, car il n'y a pas de conversion à _Bool dans le cas des OP du programme. La raison la branche n'est pas pris est 6.8.4.1:2 “le premier substatement est exécutée si l'expression compare inégale à 0”. La seule contrainte dans 6.8.4.1:1 est “Le contrôle de l'expression d'une instruction if doit avoir un type scalaire.”
InformationsquelleAutor Jon
1
```
if (x!=y)           //This tests if x is not the same value as y
{
  printf("x!=y\n"); //if x is not the same value as y print this
}

if (x=y)            //This assigns x the value of y, the tests the new value of x
{
  printf("x=y\n");  //if y was not 0, then print this
}
```
Je pense que tu voulais:
```
if (x == y) //if x is the same value as y
```
pour votre deuxième case

MODIFIER

Après la lecture de vos commentaires je vois que vous êtes obtenir à la fois des impressions... je ne suis pas sûr de ce que le compilateur que vous utilisez, mais je ne peux pas reproduire vos résultats. Êtes-vous sûr que le code est correctement copié? Lorsque je cours, je seulement obtenir x!=y comme prévu par mon explication.

Exécuter votre code avec gcc et vous verrez bien... tout ce que je peux penser est que vous êtes en cours d'exécution avec un peu bizarre non standard C compilateur et c'est en vérifiant la valeur de x avant de l'assigner y.

InformationsquelleAutor Mike
1

Vous utilisez la mauvaise opérateur: = est une affectation, == est la vraie comparaison (égalité). Le compilateur détecte et vous avertit juste au cas où ce ne serait pas prévu (il est beaucoup plus probable que vous vouliez faire une comparaison plutôt qu'une cession). C'est parfaitement valide C (en tant que tel, c'est juste un avertissement, pas d'erreur). Juste pour être sûr que c'est intentionnel, il vous demande d'ajouter des parenthèses autour de: if ((x=y)). Cela ne cause pas de différence de code, mais ça montre que la valeur de retour est utilisé sur son propre, et la cession est juste une partie de celui-ci (difficile à décrire).

Edit:
Les deux lignes sont imprimées en raison de la cession:
- x!=y évalue à true - en tant que telle, la première ligne est imprimée.
- x=y est une affectation, ce qui est essentiellement en disant que x doit prendre la valeur de y, qui est 0 dans ce cas.
Que la seconde ligne ne devrait pas être écrit (comme 0 évalue à false), mais en général, je dirais que c'est soit un bug ou d'une certaines erreurs de précision (cela ne devrait pas arriver avec une simple attribution de 0, mais on ne sait jamais).
- Cela n'explique pas pourquoi x=y est censé être imprimé.
- Mario, vous avez raté la vraie question. De Plus, il n'est pas reproductible, au moins, pas sur mon OSX système, donc au moins pour moi, c'est tout simplement sans réponse.
- Mise à jour de ma réponse. C'est probablement un bug ou d'une question de précision (mais il est vraiment ne devrait pas se produire dans ce cas, que vous n'êtes pas à même de faire les calculs).
InformationsquelleAutor Mario
0

C'est une suggestion que peut-être vous fait une faute de frappe.

Habituellement, vous aurez:
```
if(condition)
```
Dans votre cas, la condition est une mission et, partant, si renvoie toujours vrai, d'où la suggestion faite par le compilateur.
- toujours est évaluée à true? Ce sujet lors de l'attribution d'un zéro? Ce n'est pas d'expliquer le signalé le comportement, et puisque le problème ne peut pas être reproduit, c'est difficile de répondre. Je suppose que vous pourriez dire vous devez avoir exécuter un légèrement programme différent de celui que vous avez posté.
InformationsquelleAutor Alok Save
0

Daniel Fischer A répondu à votre question. Vous testez pour voir si x=y. Ce n'est pas, de sorte que votre premier test est vrai. Alors vous êtes attribution de y à x, qui renvoie vrai que cela a fonctionné, et les résultats en sortie de la deuxième instruction print.
- Mais y est égale à zéro, et lorsque I exécuter, il n'est aucun x=y de sortie. Le problème est non reproductible et donc sans réponse.
- Il semble que si il peut être arrêté à un compilateur caprice. Le compilateur avez-vous essayez avec?
- L'attribution y à x ne renvoie pas true. Elle renvoie la valeur de y, qui est 0 dans ce cas.
InformationsquelleAutor Ed.
0

L'opération d'égalité est == et = est l'opérateur d'affectation

La forme correcte est if(x == y) mais aussi il if(x=y)

parce que dans ce cas, si allons d'abord évaluer x=y,et il va assigner une valeur à partir de y à x et, après elle, l'expression sera traiter comme if(x) et il évaluera ensuite.

et maintenant ici si x a 0, puis if(x) traitera comme faux vrai sinon.

Donc, x=y n'obtiendrez pas l'impression que la production.
- et pourquoi faut-il imprimer x=y
- parce que quand vous ne x=y, il assigne la valeur de y à x qui est égal à zéro.
- Mais la valeur de y zéro signifie que "x=y" devrait pas imprimer (et ce n'est pas pour quelqu'un d'autre, apparemment).
InformationsquelleAutor Yograj Gupta

Vous devez vous connecter pour publier un commentaire.