opérateur binaire "<"

Question

Considérons cette expression en tant que "sélection" structure de contrôle de nombre entier "x": x < 10, avec l'intention que la structure retourne TRUE si "x" est dans la plage 1. .9.

1. Expliquez pourquoi un compilateur ne doit pas accepter cette expression. (En particulier, quelles sont les questions relatives à l'opérateur binaire « < »?
2. Expliquer comment un opérateur préfixe pourrait être introduit si l'expression peut être traitée avec succès.

Answer 1

1. L'expression ne lit pas comme une opération binaire, mais ressemble à un opérateur ternaire.Il y a 3 paramètres à ce que vous avez déclaré avec 0 < x < 10, comme 0, x, et 10 sont tous les jetons pour l'analyseur d'interpréter, non? Si vous vouliez un paire de < pour former un opérateur ternaire qui est une histoire différente

2. On pourrait voir l'opération ternaire comme se divisant en une paire de comparaisons et chaque comparaison est évaluée avec les résultats combinés par une opération ET. Cela aurait du sens dans mon esprit.

Answer 2

Considérez les types de retour de l'opérateur <.

Answer 3

Je ne vois aucune raison pour laquelle cette mystérieuse compilateur ne pouvait pas transformer cette expression en:

x > 0 && x < 10 

Answer 4

Le code est syntaxiquement valide en C et C++, mais il est unlikley sémantiquement correct dans les deux langues. Nous devrons deviner la langue en ce moment. Lorsque je l'ai compilé en tant que C++ VC++ 2008, j'ai émis un avertissement qui donnait plutôt la réponse, alors vous pouvez essayer. Voici mon code de test:

int main() 
{ 
    volatile int x = 0 ; 
    if(x < x < 10) 
    { 
     x = 5 ; 
    } 
} 

Lorsque la compilation C était utilisée, elle l'acceptait silencieusement.

Quant à savoir pourquoi il peut être un problème, le compilateur considère l'expression comme (0 < x) < 10. Conseil: quel est le type de la partie gauche de la deuxième « < »?

Cependant, cela peut ne pas être la réponse que vous recherchez, car il semble que vous deviez faire référence à une langue différente si le compilateur ne devait pas l'accepter.

Answer 5

C++ est satisfait. Vous pouvez même lui donner la bonne sémantique:

#include <iostream> 
#include <cstdlib> 
#include <cassert> 

using namespace std; 

class Int 
{ 
public: 
    int x; 
    Int() { } 
    Int (int z) : x (z) { } 
}; 

class BoolRange 
{ 
public: 
    bool value; 
    int left; 
    int right; 

    BoolRange() : value (false) { } 

    BoolRange (bool v, int l, int r) 
     : value (v), left (l), right (r) { } 

    operator bool() 
    { 
     return value; 
    } 
}; 

ostream& operator<< (ostream& out, Int i) 
{ 
    return out << i.x; 
} 

ostream& operator<< (ostream& out, BoolRange b) 
{ 
    return out << b.left << '[' << b.value << ']' << b.right; 
} 

BoolRange operator< (Int l, Int r) 
{ 
    return BoolRange (l.x < r.x, l.x, r.x); 
} 

BoolRange operator< (Int l, BoolRange r) 
{ 
    return r.value 
     ? BoolRange (l.x < r.left, l.x, r.right) 
     : BoolRange(); 
} 

BoolRange operator< (BoolRange l, Int r) 
{ 
    return l.value 
     ? BoolRange (l.right < r.x, l.left, r.x) 
     : BoolRange(); 
} 

BoolRange operator< (BoolRange l, BoolRange r) 
{ 
    return l.value && r.value 
     ? BoolRange (l.right < r.left, l.left, r.right) 
     : BoolRange(); 
} 

// Test driven development! 
int main() 
{ 
    for (int i = 0; i < 1000000; ++i) 
    { 
     Int v = rand() % 100; 
     Int w = rand() % 100; 

     if (Int(1) < v < w < Int(10)) // Look here! 
     { 
      assert (1<v.x && v.x<w.x && w.x<10); 
     } else 
     { 
      assert (1>=v.x || v.x>=w.x || w.x>=10); 
     } 
    } 
}