C++ “OU” opérateur

cela peut être fait en quelque sorte?

if((a || b) == 0) return 1;
return 0;

si c'est comme...si a OU b est égal à zéro, alors...mais ça ne fonctionne pas pour moi.
mon code est:

bool Circle2::contains(Line2 l) {
    if((p1.distanceFrom(l.p1) || p1.distanceFrom(l.p2)) <= r) {
        return 1;
    }
    return 0;
}

Comme noter votre code de mise en forme dans le second est horrible. Il est facile de rater le return 1; et pense que return 0; est la "puis" de la clause, et de ne pas l'implicite "else" de la clause.
Veuillez utiliser return true ou return false. Oui, je suis conscient que les compilateurs pour les interpréter correctement, mais... si vous allez déclarer le type bool, au moins utiliser le bool mots-clés.
je n'ai même pas vu le return 1 !
Vous êtes à la recherche pour l'ICÔNE langage de programmation, pas du C++, c'est une langue où vous pouvez écrire des choses comme if (i|j|k) == (10|20) avec le sens de "soit i, j et k sont égaux à 10 ou 20" ... cs.arizona.edu/icon
Une bonne question sur les bases, parce que le compilateur accepter ces fragments et de faire quelque chose qu'un débutant peut trouver surprenant.

OriginalL'auteur Jaanus | 2011-02-20

c++codeblocks programming-languages

15

Vous avez besoin d'écrire l'expression complète:
```
(a==0)||(b==0)
```
Et dans le deuxième code:
```
if((p1.distanceFrom(l.p1)<= r) || (p1.distanceFrom(l.p2)<=r) )
    return 1;
```
Si vous ne ((a || b) == 0) cela signifie "Est le ou logique de a et b égal à 0. Et ce n'est pas ce que vous voulez ici.

Et comme une note de côté: le if (BooleanExpression)return true; else return false modèle peut être réduit à return BooleanExpression;

LOL, c'est la ruée! +1 pour votre vitesse folle-répondre à des compétences.

OriginalL'auteur CodesInChaos
2

Vous devez spécifier la condition séparément à chaque fois:
```
if (a == 0) || (b == 0))
    bla bla;
```
Lorsque vous ne
```
if ((a || b) == 0)
    bla bla;
```
il a un sens différent: a || b) signifie "si a ou b est non nul (c'est à dire. vrai), le résultat de cette expression est vraie".
Ainsi, lorsque vous vous (a||b) == 0, vous de vérifier si le résultat de l'été expliqué précédemment expression est égale à zéro (ou faux).

OriginalL'auteur Rao
2

Le langage C++ indique que les opérandes de || ("ou") des expressions booléennes.

Si p1.distanceFrom(l.p1) n'est pas booléenne (qui est, si distanceFrom retourne int ou double, ou certaines numérique type de classe), le compilateur va tenter de la convertir en une valeur booléenne.

Pour les construit dans le type numérique, la conversion est la suivante: non-zéro convertit à la vraie, zéro convertit à false. Si le type de p1.distanceFrom(l.p1) est de type classe Foo, le compilateur va appeler un (et un seul) défini par l'utilisateur de conversion, par exemple, Foo::operator bool(), pour convertir la valeur de l'expression bool.

OriginalL'auteur tpdi

Je pense que vous voulez vraiment quelque chose comme ceci:

bool Circle2::contains(Line2 l) {
if((p1.distanceFrom(l.p1) <= r) || (p1.distanceFrom(l.p2) <= r)) return 1;
    return 0;
}

OriginalL'auteur Jim Lewis

Plaisir avec les modèles:

template <typename T>
struct or_t
{
  or_t(const T& a, const T& b) : value1(a), value2(b)
  {
  }

  bool operator==(const T& c)
  {
    return value1 == c || value2 == c;
  }

private:
  const T& value1;
  const T& value2;
};

template <typename T>
or_t<T> or(const T& a, const T& b)
{
  return or_t<T>(a, b);
}

En cours d'utilisation:

int main(int argc, char** argv)
{
  int a = 7;
  int b = 9;

  if (or(a, b) == 7)
  {
  }

  return 0;
}

Il effectue la même comparaison que vous le feriez normalement, mais, mais, à votre convenance.

Et maintenant, allez de court-circuit de la version... 😉

OriginalL'auteur Marlon

1

Si vous avez beaucoup de ce code, vous pouvez envisager un coup de méthode:
```
bool distanceLE (Point p1, Point p2, double threshold) {
    return (p1.distanceFrom (p2) <= threshold)
}

bool Circle2::contains (Line2 l) {
    return distanceLE (p1, l.p1, r) && distanceLE (p1, l.p2, r);
}
```
Si vous avez parfois l' <, parfois, <=, >, >= et ainsi de suite, peut-être que vous devriez passer l'opérateur de trop, sous la forme d'une fonction.

Dans certains cas, vos intentions par écrit ceci:
```
if ((a || b) == 0) return 1;
return 0;
```
pourrait être exprimée par un bit à bit ou:
```
if ((a | b) == 0) return 1;
return 0;
```
et simplifié pour
```
return  ! (a | b);
```
Mais lire sur les opérations au niveau du bit et de les tester avec soin. Je les utilise rarement et surtout je n'ai pas utiliser C++ pour un certain temps.

Note, que vous avez inversé le sens entre vos exemples 1 et 2, le retour le vrai et le faux dans le sens inverse.

Et au niveau du bit moins égal n'a pas de sens, bien sûr. 🙂

OriginalL'auteur user unknown
0

C++ ne prend pas en charge toutes les construire comme ça. Utilisation if (a == 0 || b == 0).

Il n', mais ils ont un sens différent.
Je voulais dire du point de vue sémantique. (a || b) == 0 sera vrai si les deux a et b sont fausses.
ouais je cherche de la fonction que dans les mathématiques discrètes, de sorte (a || b) == 0 serait vrai si les deux sont true et false si au moins 1 est fausse

OriginalL'auteur Cat Plus Plus
0

Votre état de santé devrait être (a == 0 || b == 0) ou (p1.distanceFrom(l.p1) <= r || p1.distanceFrom(l.p2)) <= r)

OriginalL'auteur helium

C++ n'est pas intelligent. Que vous avez à faire chaque comparaison manuellement.

bool Circle2::contains(Line2 l) {
if((p1.distanceFrom(l.p1) <= r) || (p1.distanceFrom(l.p2) <= r)) return 1;
    return 0;
}

OriginalL'auteur KyleWpppd

Vous devez vous connecter pour publier un commentaire.