Odds'n'Ends

Enumeration

enum is a way of creating a user-defined integral type which can be assigned a limited number of constant values
- enum enum-name { const-list} variable-name;
  (where enum-name and variable-name are optional and const-list is a list of one or more constant names)
For example, to create a user-defined datatype named enum shapetype and associate three constant values (circle, triangle, square) with it:
```
{
	enum shapetype {circle, triangle, square} s1, s2;

	s1 = circle;
	s2 = s1 + 1;
	if (s2 != triangle)
		return 0;
	return 1;
}
```
enum name is usually just an alias for int and the enumerated values are just aliases for integral constants (in the enum shapetype above, triangle == 0, circle == 1 and square == 2)
- The first enumerated value is assigned 0 by default and each succeeding value is computed by adding one to the previous value, but arbitrary integral values may be assigned to enumerated values:
```
enum wierdtype {first = 5, min = first, second, third,
		fourth = 28, fifth = fourth - 6, sixth,
		seventh = 1, max = seventh};
```
  is almost the same as
```
#define first		5
#define min		5
#define second		6
#define third		7
#define fourth		28
#define fifth		22
#define sixth		23
#define seventh		1
#define max		1
```
The range of values assigned to an enum variable is not strictly limited to the values associated with that enum and an enumerated value may be assigned to variables other than those declared with the enum associated with that enumerated value
- For example, the following:
```
{
	enum dwarf {happy, sleepy, sneezy, dopey,
		    doc, grumpy, bashful} d;
	enum {anonymous, unnamed, hidden};
	int i;
	enum dwarf x;

	d = 17;
	i = happy;
	x = hidden;
}
```
  are all legal, though they may cause the compiler to issue a warning
- In other words, an enum name is merely a suggestion that an "int-like" variable use the associated constants; the compiler does nothing to enforce it or to restrict the values to those specified by the enum
Enumerated value namespace is shared with variable namespace
- If you do enum vowel {a, e, i, o, u};, you cannot use i as a variable name later
Why use enum instead of const int?
- Compilers usually treat a const int as a variable, meaning its value must be fetched from memory before being used
- enum values are usually treated just like integral constants and are thus immediately accessible
Why use enum instead of #define?
- #defined values are replaced with integral constants by the preprocessor, so the compiler never sees them
- enum values are handled by the compiler and thus can have entries in the symbol table which could be used by a debugger

struct

struct is a way of encapsulating a group of related values in a single object

For example:

{
	struct timestamp {
		int hour;
		int minute;
		int second;
	} t;

	t.hour = 9;
	t.minute = 45;
	t.second = 32;
}

The -> operator may be used to access the members of a structure via a pointer:
```
{
	struct timestamp *tp = &t;

	tp->hour += 1;
	tp->second = 0;
}
```

Structure initialization is similar to array initialization:

{
	struct timestamp t2 = { 12, 0, 0 };
	struct datestamp {
		int year;
		char month[4];
		int day;
	} d = { 1996, "Jan", 24 };
}

Structures may include other structures:

{
	struct stamp {
		struct timestamp ts;
		struct datestamp ds;
	} dt = { { 1, 2, 3 }, { 1492, "Feb", 28 } };

	dt.ts.hour = dt.ts.minute = dt.ts.second = 0;
	dt.ds.year = 1776;
	dt.ds.day = 4;
}

Structures may even include pointers to themselves:

	struct list {
		int ival;
		double dval;
		struct list *next;
	};

Structure members are placed in memory in the same order in which they are declared
There may be unused areas of memory between structure members in order to ensure that members are properly aligned
- The following two structures are actually different sizes:
```
	struct small {
		char c1, c2, c3;
		int i1, i2, i3;
	};
	struct big {
		char c1;
		int i1;
		char c2;
		int i2;
		char c3;
		int i3;
	};
```

bitfield

Bitfields may be used inside a structure to pack several members into a single word of memory:
```
	struct smaller {
		unsigned sevenbits : 7;
		unsigned fourvals : 2;
	} s;
```
creates a structure with two members: sevenbits which can hold values between 0 (binary 0000000) and 127 (binary 1111111), and fourvals which can hold values between 0 (binary 00) and 3 (binary 11)
- The bitfield length may be a constant expression, similar to an array length specifier
Bitfields are addressed just like other structure members:
```
	s.sevenbits = 32;
	s.fourvals /= 2;
```
Bitfields can be either signed or unsigned (though pre-ANSI compilers may only allow unsigned)

Bitfields may be unnamed, to act as padding between named fields:

	struct holey {
		unsigned sea : 3;
		unsigned     : 3;
		unsigned see : 3;
	};

The & operator cannot be applied to a bitfield, since a bitfield is only a subset of the bits in a word and thus has no address
Bitfields may be mixed in with other types in a structure
Some machine-level details of bitfields are implementation-defined:
- Bitfields may be stored left to right (big-endian) or right to left (little-endian), depending on the machine architecture
- Some compilers will allow bitfields to overlap a word boundary, others will silently add padding bits
- The maximum size of a bitfield is implementation-defined
These implementation-defined aspects make data created with bitfields inherently nonportable between dissimilar machines

union

A union is a way of defining two or more variables which share the same memory:
```
	union manytypes {
		char c;
		int i;
		double d;
		unsigned *up;
	} u;
```
Since memory is shared, assigning a value to u.i and then assigning a value to u.c will cause some part of the value of u.i to be overwritten
Attempting to use unions to manipulate datatypes behind the compiler's back will void your warantee
References to a union look just like struct references (though the effect is totally different):
```
{
	union manytypes mt, *mtp;

	mtp = &mt;
	mt.d = 1.2345;
	mtp->i = 3;
}
```
sets mt.d to 1.2345, then sets mt.i to 3 (which destroys the mt.d value, since the two share the same memory)

typedef

typedef is used to create an alias for another type:
```
	typedef char *string;
```
creates a keyword named string which can be used as an alias for "pointer to character":
```
	string str;
	char *cp;
```
both create pointers to char
typedef is a bit more flexible than #define because, since typedef is handled by the compiler, more complex types can be handled with typedef than could be dealt with by the textual manipulations available to the preprocessor
- There is no easy way to do something like:
```
	typedef int (*CmpFunc)(const char *, const char *);
	CmpFunc strcmp, numcmp;
```
  using only the preprocessor

Previous, Next, Index