如何用枚举检查这种情况-C ++

Question

Class Direction

class Direction
{
public:
 enum value
 {
  UP,
  RIGHT,
  DOWN,
  LEFT,
  STAY
 };
};   

Class Point

 #include "Direction.h"
        class Point {

         int x , y;

        public:

         Point() { x=0; y=0; };
         Point(int x1 , int y1) : x(x1) , y(y1) {};
         void setX(int newX) { x = newX; };
         void setY(int newY) { y = newY; };
         int getX() { return x; }
         int getY() { return y; }
         void move(Direction d) {
          if(d==UP);
        };

The problem is if(d==UP) I don't understand how can I check the condition I receive an error checking this.

Any ideas? Any help will be appreciated.

Answer 1

UP is declared inside class Direction , so outside that scope you should write Direction::UP to refer to it:

if (...something... == Direction::UP)
    ...

Your Direction class creates the value enumeration type, but doesn't have any data members yet, so it's not clear what in d you might want to compare to Direction::UP . You could add a data member by inserting an extra line just before the final }; in class Direction :

value value_;

Then your comparison would become:

if (d.value_ == Direction::UP)
    ...

All that said, if your class Direction is not going to contain anything other than the enum , you might consider getting rid of the class part altogether and simply declaring the enum alone:

enum Direction { UP, ... };

Then your comparison would simplify to:

if (d == UP)
    ...

Answer 2

I think you didn't need to having create class Direction . Simple enum is enough.

enum class Direction
{
    UP,
    DOWN,
    LEFT,
    RIGHT,
    STAY,
};

Then you can write similar function to following one:

void do_move(Direction d)
{
    switch (d) {
    case Direction::LEFT:
        cout << "LEFT" << endl;
        break;
    case Direction::RIGHT:
        cout << "RIGHT" << endl;
        break;
    case Direction::UP:
        cout << "UP" << endl;
        break;
    case Direction::DOWN:
        cout << "DOWN" << endl;
        break;
    case Direction::STAY:
        cout << "STAY" << endl;
        break;
    default:
        break;
    }
}

And simply call it:

Direction d = Direction::UP;
do_move(d);
do_move(Direction::STAY);

Answer 3

What you really want is Direction to be an enum, not a class:

enum Direction { UP, RIGHT, DOWN, LEFT, STAY };

Now you can call move simply like this:

move(UP);

And your if(d==UP); will work as expected.

Answer 4

I notice your Direction class doesn't have anything except an enum in it, in that case you could simply:

enum class Direction {
  UP,
  ...
};

The difference is with enum class the enumerations will be encapsulated in it. You will still have to do if (d == Direction::UP) .

If you make it a regular enum:

enum Direction {
  UP,
  ...
};

Then you can directly if (d == UP) as in your original code.

Also, this way you can have Direction d which is a little more conspicuous than value d or Direction::value d .

What you have now is a regular enum which is not encapsulated in value but is encapsulated in the Direction class in which value is. You can only address it directly inside Direction , but outside of it, you will have to specify the scope of the encapsulating class.

Answer 5

if(d.value == UP)

d is of Type class Direction not of Type Enum value . Hence you cannot compare d and `UP