Thread: what is meaning of enum in C

I know the data type like int, char, flot.etc enum is also data type I have some doubt on enum.

Code:

#include <stdio.h>

enum color { red, green, blue };

enum  color favorite_color;

int main()
{
    favorite_color = blue;
    
    printf("colour %d",favorite_color);
    
    return 0;
}

I think color is name of enum and favorite_color is variable where we can store value red, green and blue in that variable

What is basic of enum and where it is used ?

= is assignment. == is a comparison operator.

Code:

if (favorite_color = 0)

is always false as favorite color becomes 0 by assignment.

Code:

if (favorite_color = 1)

is always true for the same reason.

Code:

if (favorite_color = 2)

is always true as well.

Originally Posted by abhi143

still not clear, why assigning zero would be treated as false.

Let's step away from enums for awhile and consider this program:

Code:

#include <stdio.h>

int main(void)
{
    int x = 0;
    if (x)
    {
        printf("one\n");
    }
    else
    {
        printf("two\n");
    }
    return 0;
}

If you compile and run the above program, you will see the output of "two" because the value of x is 0, which means "false" in the boolean context of an if statement's condition. Now consider:

Code:

#include <stdio.h>

int main(void)
{
    int x = 123;
    if (x = 0)
    {
        printf("one\n");
    }
    else
    {
        printf("two\n");
    }
    return 0;
}

What is happening here is that 0 is assigned to x, and then the result of that expression, i.e., the value of x, is evaluated. Of course, since you just assigned 0 to x, the value of x is 0, hence you end up with the same output as the previous program.

Originally Posted by abhi143

I don't think there is matter of logical operator. we just need to look weather condition is true or false

jack jordan is correct: you used the assignment operator = when it looks like you wanted to use the equality comparison operator == instead. Again, let's step away from enums and consider this program:

Code:

#include <stdio.h>

int main(void)
{
    int x = 0;
    if (x = 123)
    {
        printf("one\n");
    }
    else
    {
        printf("two\n");
    }
    return 0;
}

If you compile and run the above program, you will see the output of "one". This is because in the condition of the if statement, 123 is assigned to x, and then the result of that expression, i.e., the value of x, is evaluated. Of course, since you just assigned 123 to x, the value of x is 123, and since 123 is not zero, it is "true" in the boolean context of the if statement.

Now, let's change the use of the assignment operator to be the equality comparison operator:

Code:

#include <stdio.h>

int main(void)
{
    int x = 0;
    if (x == 123)
    {
        printf("one\n");
    }
    else
    {
        printf("two\n");
    }
    return 0;
}

If you compile and run the above program, you will see the output of "two". This is because in the condition of the if statement, the value of x is compared for equality with 123, and since the value of x is 0, and 0 is not equal to 123, the result is 0, i.e., "false" in the boolean context of the if statement.

Going back to enums, we can apply the above idea: if you want to compare to see if the value of favorite_color is equal to the enum constant red, then you should write:

Code:

if (favorite_color == red)

Note that you could have written:

Code:

if (favorite_color == 0)

but here 0 is a magic number that doesn't convey meaning unlike the use of the enum constant red, which is a motivation for using enums in the first place.

Just a little somthing to look at pretainging to emun

Code:

#include <stdio.h>
enum MyNumsy { FIVE, FOUR, THREE, TWO, ONE };

enum MyNumsy mynumy;

int main (void)
{
    char d;
    d = THREE;
    printf("my element %d\n", (int)d);
    
    switch (d)
    {
        case 0:
            printf("my element %d\n", (int)d);
            break;
        case 1:
            printf("my element %d\n", (int)d);
            break;
        case 2:
            printf("my element %d\n", (int)d);
            break;
        case 3:
            printf("my element %d\n", (int)d);
            break;
        case 4:
            printf("my element %d\n", (int)d);
            break;
        default:
            break;    
        
    }
    switch (d)
    {
        case TWO:
            printf("my element TWO %d\n", (int)d);
            break;
        case FIVE:
            printf("my element FIVE %d\n", (int)d);
            break;
        case FOUR:
            printf("my element  FOUR %d\n", (int)d);
            break;
        case ONE:
            printf("my element ONE %d\n", (int)d);
            break;
        case THREE:
            printf("my element THREE %d\n", (int)d);
            break;
        default:
            break;    
        
    }
        
return 0;    
}

output

Code:

userx@slackwhere:~/bin
$ ./enum
my element 2
my element 2
my element THREE 2

the usage of ENUM with assigning them to a char, then using a switch to get to them and seeing that it does not matter the means you use, be it a number, or the name used in enum, nor the order on puts them in using a switch. so yeah he may lean something from it.

Oh yeah casting to get the number to print if assigned to a char and or other possibilities.

because his original code too can even be made into a switch. it is faster as well.

Originally Posted by whiteflags

The correct type to use would be MyNumsy.


Well, it does matter -- you are making guesses as to what may be appropriate to use for this purpose, and have a forgiving compiler. I think it is pretty likely that vendors just use the largest int type available, in order to support the longest lists, and so implicit conversions up and down in size would appear to work. I wouldn't say it is a good habit to get into though. If you need to store an enum constant, give the enum a type name and use that name.

I don't think there is a well-defined way to print enums, either. The standard says that the range of the integer type used is implementation defined, but for similar reasons as before, you can do things that appear to work like casting to an int. Again though, this is dangerous because it assumes that an int is large enough to represent the constant. So printing the value largely means that you have to know the value already and choose an appropriate result type.

In fact, the loose language in C regarding enums are why enum classes are in C++ now.

being the programmer that is programming that. I would hope they would know what the value means else it defeats the purpose. as for the rest of it. It depends on the program thus depends on the programmer and what it i doing with the particular program.

Code:

$ ls -l /usr/bin/gcc*
lrwxrwxrwx 1 root root      9 Oct 25 14:35 /usr/bin/gcc -> gcc-5.3.0