can you pass an enum to a function.
********************************
function header
void facing(direction facing)

call
facing(facing);

prototype
void facing(direction);

declaration
enum direction {north, south, east, west};
direction facing;

No reason why you can't. However having your function called "facing" and
your enum variable called "facing" may lead to problems. I am not sure if
the name space for functions and enumerations is completely different. But
otherwise of course you can pass an enumerated value to a function.

it does not allow passing in this way. I will change the name of the
function, but i do not believe this should be an issue. would it work better
possible to create a pointer that targets the enum for incrimination
purposes inside the function.

e.g. *facingPtr++
can you increment an enumeration?
thanks for the help.
peace

No answer so I guess that was not a logical question?
second question that I need someone to read.
why is passing by pointer bad? I do not feel like returning anything.in my
programs. Isn't the size of hard drives capable of handling a little bigger
.exe do pointers allocate such a massive amount of memory to make void
functions passed with only pointers little in pro vs..s. con?

See if this program answers your question.

    #include <iostream>

    using std::cout;
    using std::endl;

    enum direction { north, south, east, west };

    void facing(direction d) {
      switch (d) {
        case north: {
           cout << "North" << endl;
           break;
        }
        case south: {
           cout << "South" << endl;
           break;
        }
        case east: {
           cout << "East" << endl;
           break;
        }
        case west: {
           cout << "West" << endl;
           break;
        }
      }
    }

    int main() {
      direction x = north;
      facing(x);
      facing(west);
    }

It isn't. Passing a pointer allows you to do several things like (1) change
the value being pointed at, and (2) avoid a copy construction which improves
efficiency. If you are passing a pointer to achieve either of these, it is
generally better to use a reference (&) instead. Passing by pointer verses
not passing by pointer will likely not make must of difference in the
program size. In many cases, I would expect it to make no difference at all.

From an ealier message, you asked:

Incrementing a pointer like this is intended for an array. Say you had done
the following:

  direction arr[4] = {north, east, south, west};
  direction* facingPtr = &arr[0];  // points to north in arr
  facing(*facingPtr++);            // prints east

If you are using C++, I'd suggest using a std::vector and an iterator
instead. You're less likely to make type correctness mistakes that way.

No, the operator++ is not defined by default for an enumeration. You can
define your own of course.

Cheerio!

--
Brandon Bray                                          Visual C++ Compiler
This posting is provided AS IS with no warranties, and confers no rights.