How to access enum defined within a struct in C program

Question

I am new to the C language and struggling with how to access enum's within a struct.

My code is the following:

bankHeader.h File

struct bankAcct{
 int amount;
 enum typeOfAcc{chck = 0, saving = 1};
 int balance;
}

bank.c File

#include <stdio.h>
#include "bankHeader.h"

struct bankAcct test;
test.amount=100;
// I want to be able to get the value within my typeOfAcc
// example something like test.typeOfAcct = "chck" should return 0;

I reviewed some of the forms but I dont see anything that was easy to understand or worked.

Answer 1

If the enum is meant to be local to the struct, use an anonymous enum:

struct bankAcct{
    int amount;
    enum {chck = 0, saving = 1} type_of_acct;
    int balance;
};

You could also put a tagged enum inside the struct:

 struct bankAcct{
    int amount;
    enum typeOfAcc {chck = 0, saving = 1} type_of_acct;
    //^this misleadingly puts `enum typeOfAcc` in filescope 
    int balance;
 };

but a tagged (as opposed to an anonymous one) inner definition of an enum (or struct or union) will be hoisted. In effect, the latter snippet is just a confusing way of doing:

 enum typeOfAcc {chck = 0, saving = 1};

 struct bankAcct{
    int amount;
    enum typeOfAcc type_of_acct;
    int balance;
 };

Note that as peter-reinstate-monica points out in his comment below, the chck and saving constants will be "hoisted" regardless of whether or not you choose to use an anonymous embedded enum type.

Answer 2

Every field in your struct declaration is in the form

type fieldName;

With

enum typeOfAcc{chck = 0, saving = 1};

you have specified the type... but not the field name. That's just like defining a structure in this way

struct foo {
    int;
}

So, basically, what you need is a field name:

struct bankAcct{
    int amount;
    enum typeOfAcc{chck = 0, saving = 1} type;
    int balance;
}

You will be able to access it with

struct bankAcct var;

printf("%d\n", var.type);

---

Addendum

I would not recommend defining an enumeration inside a struct, first of all for readability reasons. Another reason might be incompatibility with C++: I wasn't able to compile an example C++ code in which the symbols of the inner enum were accessed. The following assignment

struct bankAcct var;

var.type = chck;

raised an error on gpp because the symbol chck could not be referenced outside the struct definition scope. Even assigning an integer to the enum field lead the compiler to complain, and I could not even perform the casting

b.type = (enum typeOfAcc) 1;

because an error was raised: the enum typeOfAcc wasn't be accessible as well.

But in C these assignments would be ok, and both enum tags and constant identifiers (named and anonymous) would be "reachable". As explained in C specification 6.2.1§4, the scope of an identifier outside any code block is the whole translation unit:

Every other identifier has scope determined by the placement of its declaration (in a declarator or type specifier). If the declarator or type specifier that declares the identifier appears outside of any block or list of parameters, the identifier has file scope, which terminates at the end of the translation unit.

Just for completeness, after saying where the scope ends, we must say where the scope begins (C specification 6.2.1§7):

Structure, union, and enumeration tags have scope that begins just after the appearance of the tag in a type specifier that declares the tag. Each enumeration constant has scope that begins just after the appearance of its defining enumerator in an enumerator list. Any other identifier has scope that begins just after the completion of its declarator.