Advanced C 1992

Part II • Managing Data in C

char *szSaying[35]; int nLength[35];

};

I create a definition of a structure, but I do not declare the structure (that is, I do not allocate storage). I assign the name SAYING to the optional tag position. This name can be referred to in future declarations of structures of the same type.

Next, I declare the structure, which has two members: Murphy and Peter. The structure is then initialized:

struct

{

struct SAYING Murphy; struct SAYING Peter;

} OurSaying = {{...},{...}};

Note the use of initialization braces: the entire initializer is enclosed with a set of braces, then each of the nested structure’s initializers is enclosed in a set of braces. By grouping the initializers into two blocks, these braces tell the compiler which initializer goes with which nested structure.

Then the structure is accessed using the same syntax shown in the previous examples, except a name (either Murphy or Peter) is added to tell the compiler which member to use:

for (i = 0; OurSaying.Murphy.szSaying[i]; i++)

{

OurSaying.Murphy.nLength[i] = strlen(OurSaying.Murphy.szSaying[i]);

}

A saying or length in the Murphy part of the structure is accessed with

OurSaying.Murphy.

and a saying or length in the Peter part of the structure is accessed with

OurSaying.Peter.

Bit Fields in Structures

In a scalar data object, the smallest object that can be addressed directly is usually a byte. In a structure, you can define data objects from 1 to 16 bits long.

206

Suppose your program contains a number of TRUE/FALSE variables grouped in a structure called Status, as follows:

This structure requires 20 bytes of storage, which is a lot of memory for saving a few TRUE/FALSE variables. It would be better to save each variable using only one bit. Perhaps you could use a single, bit-mapped variable (described in Chapter 5, “Decimal, Binary, Hex, and Octal”). Sometimes, however, your flags must keep the identity that a unique name offers.

C offers the capability to define the width of a variable, but only when the variable is in a structure called a bit field. For example, you could rewrite the definition of Status as follows:

The :1 that appears after each variable’s name tells the compiler to allocate one bit to the variable. Thus, the variable can hold only a 0 or a 1. This is exactly what is needed, however, because the variables are TRUE/FALSE variables. The structure is only two bytes long (one tenth the size of the previous example).

207

Part II • Managing Data in C

A bit field can hold more than a single bit. For example, it can hold a definition of a structure member, such as

unsigned int nThreeBits:3;

In this example, nThreeBits can hold any value from 0 to 7.

The most critical limitation to using bit fields is that you cannot determine the address of a bit field variable. If you use the address of operator, a compile-time error results. This means that you cannot pass a bit-field’s address as a parameter to a function.

When the compiler stores bit fields, it packs them into storage without regard to alignment. Therefore, storage is used most efficiently when all your bit fields are grouped together in the structure. You can force the compiler to pad the current word so that the next bit field starts on a word boundary. To do so, specify a dummy bit field with a width of 0, for example:

The bReserved1 bit field tells the compiler to pad to the next word boundary, which results in the bIsBoxed bit field starting on a known boundary. This technique is useful when the compiler is packing structures and you need to know that the alignment is as optimal as possible. (Some computers access objects faster when the objects are aligned on word or double word boundaries.)

Using the typedef Keyword

I think that the typedef keyword is one of the best parts of the C language. It enables you to create any data type from simple variables, arrays, structures, or unions.

The typedef keyword is used to define a type of variable, just as its name implies. You can define any type from any other type. A variable created with typedef can be used just like any other variable. Listing 7.6, CREATEDB.C, is a simple example of using typedef with structures.

208

Listing 7.6. CREATEDB.C.

/* CREATEDB, written 1992 by Peter D. Hipson

*This program demonstrates typedef. The program

*has minimal error checking; it will fail if

*you enter a field value that is too long for

*the structure member that holds the value.

*Use with caution!

*/

#include <string.h> #include <ctype.h> #include <stdio.h> #include <process.h> #include <stdlib.h>

#define CUSTOMER_RECORD 1 #define SUPPLIER_RECORD 2

/* Define the structure for the customer database */

} CUSTNAME;

typedef CUSTNAME near *NPCUSTNAME; typedef CUSTNAME *PCUSTNAME;

void main()

continues

209

Part II • Managing Data in C

Listing 7.6. continued

{

FILE *DataFile;

CUSTNAME Customer;

printf(“Please enter customer database name: “);

gets(szFileName);

DataFile = fopen(szFileName, “wb”);

if (DataFile == NULL)

{

printf(“ERROR: File ‘%s’ couldn’t be opened.\n”, szFileName);

exit(4);

}

Customer.szName[0] = ‘A’; // To get past while() the first time

i = 0; Customer.nRecordNumber = 0;

while (strlen(Customer.szName) > 0)

{

memset(&Customer, 0, sizeof(CUSTNAME));

printf(“Enter the Customer’s name: “); gets(Customer.szName);

210

if (strlen(Customer.szName) > 0)

{

Customer.nRecordNumber = i;

do

{

printf(“Enter 1 for customer, 2 for supplier “); gets(szBuffer);

sscanf(szBuffer, “%d”, &Customer.nRecordType);

}

while (Customer.nRecordType != CUSTOMER_RECORD && Customer.nRecordType != SUPPLIER_RECORD);

printf(“Enter address line 1: “); gets(Customer.szAddr1); printf(“Enter address line 2: “); gets(Customer.szAddr2); printf(“Enter City: “); gets(Customer.szCity);

printf(“Enter state postal abbreviation: “); gets(Customer.szState);

printf(“Enter ZIP code: “); gets(szBuffer);

sscanf(szBuffer, “%d”, &Customer.nZip); printf(“Enter total sales: “); gets(szBuffer);

sscanf(szBuffer, “%f”, &Customer.dSalesTotal);

nResult = fwrite((char *)&Customer, sizeof(CUSTNAME), 1, DataFile);

if (nResult != 1)

{

printf(“ERROR: File ‘%s’, write error.\n”, szFileName);

fclose(DataFile);

exit(4);

}

continues

211

Part II • Managing Data in C

Listing 7.6. continued

++i;

}

}

fclose(DataFile);

}

In Listing 7.6, the lines that define the structure that holds the customer’s name and address use the typedef keyword. This enables us to define the data object using only one line of code:

CUSTNAME Customer;

This line creates a structure named Customer. As many different structures as needed could have been created using the name CUSTNAME.

You access a structure created by a typedef in the same way as you access a structure created by any other method. However, now the compiler has a data type that it can work with, so you can obtain the size of the structure type by referring to its name. This is valuable when you must allocate memory for the structure—you cannot get the size from the object because it doesn’t exist yet!

The program clears the structure’s contents to 0 by using sizeof() with the name:

memset(&Customer, 0, sizeof(CUSTNAME));

In the call to memset(), you must pass the address of the structure (&Customer), the value that you are setting all the bytes to (0), and the size of the structure (sizeof(CUSTNAME)). The memset() C library function then stores the specified value in all the bytes in

Customer.

The rest of CREATEDB is straightforward. The program reads from the keyboard each field in the structure. Fields that are not character fields (such as

.dSalesTotal) are converted to the correct type for the field before being saved in the structure.

212

Using the offsetof() Macro

ANSI C introduced a new macro, called offsetof(), that you use to determine the offset of a member in a structure. There are many reasons for wanting to know the location of a member in a structure. You might want to write part of a structure to a disk file or read part of a structure in from the file.

Using the offsetof() macro and simple math, it is easy to compute the amount of storage used by individual members of a structure. An example use of the offsetof() macro is shown in Listing 7.7.

Listing 7.7. OFFSETOF.C.

/* OFFSETOF, written 1992 by Peter D. Hipson

*This program illustrates the use of the

*offsetof() macro.

*/

#include <stdio.h> // Make includes first part of file #include <string.h> // For string functions

#include <stddef.h> // For offsetof()

#define MAX_SIZE 35

int main(void); // Define main(), and the fact that this program doesn’t // use any passed parameters

int main()

{

int i;

continues

213

Part II • Managing Data in C

Listing 7.7. continued

typedef struct

{

SAYING Murphy;

SAYING Peter;

SAYING Peter1;

SAYING Peter2;

SAYING Peter3;

SAYING Peter4; } OURSAYING;

OURSAYING OurSaying = {{

“Firestone’s Law of Forecasting:”,

“Chicken Little has to be right only once.”, “”, “”,

“Manly’s Maxim:”,

“Logic is a systematic method of coming to”,

“the wrong conclusion with confidence.”,

“”,

“”,

“Moer’s truism:”,

“The trouble with most jobs is the job holder’s”,

“resemblance to being one of a sled dog team. No one”,

“gets a change of scenery except the lead dog.”, “”, “”,

“Cannon’s Comment:”,

“If you tell the boss you were late for work because you”,

“had a flat tire, the next morning you will have a flat tire.”, NULL /* Flag to mark the last saying */

}, {

“David’s rule:”,

“Software should be as easy to use as a Coke machine.”,

“”,

214

To use the offsetof() macro, you supply both the structure and the member name. In addition, the structure name must be created using typedef because the offsetof() macro must create the pointer type with a value of 0, and an identifier— not a variable name—is required.

Here is another use of the offsetof() macro. Suppose that a structure has 75 members that consist of strings, structures, and scalar variables. You want to save the middle 30 members in a file. You have to know the starting address and how many bytes to write to the file.

You could use the sizeof() keyword to compute the size of the block of memory to write, but this would be difficult and complex. You would have to get the size of each member that you want to save to the file, then add the results. Also, serious problems would result if members contained packing bytes (to align them on word boundaries).

215