0% found this document useful (0 votes)

179 views47 pages

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

You will learn: - to be able to create and use structures, unions and enumerations. - to be able pass structures to functions call by value and call by reference.

Uploaded by

Rangarao Kommineni

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

179 views47 pages

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

You will learn: - to be able to create and use structures, unions and enumerations. - to be able pass structures to functions call by value and call by reference.

Uploaded by

Rangarao Kommineni

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

You are on page 1/ 47

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

Outline
10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 10.9 10.10 10.11 Introduction Structure Definitions Initializing Structures Accessing Members of Structures Using Structures with Functions typedef Example: High-Performance Card Shuffling and Dealing Simulation Unions Bitwise Operators Bit Fields Enumeration Constants

Objectives
In this tutorial, you will learn:
To be able to create and use structures, unions and enumerations. To be able to pass structures to functions call by value and call by reference. To be able to manipulate data with the bitwise operators. To be able to create bit fields for storing data compactly.

10.1 Introduction
Structures
Collections of related variables (aggregates) under one name
Can contain variables of different data types

Commonly used to define records to be stored in files Combined with pointers, can create linked lists, stacks, queues, and trees

10.2 Structure Definitions

Example
struct card { char *face; char *suit; };

struct introduces the definition for structure card card is the structure name and is used to declare variables

of the structure type card contains two members of type char *

These members are face and suit

10.2 Structure Definitions

struct information
A struct cannot contain an instance of itself Can contain a member that is a pointer to the same structure type A structure definition does not reserve space in memory
Instead creates a new data type used to define structure variables

Definitions
Defined like other variables:
card oneCard, deck[ 52 ], *cPtr;

Can use a comma separated list:

struct card { char *face; char *suit; } oneCard, deck[ 52 ], *cPtr;
Copyright 19922004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.

10.2 Structure Definitions

Valid Operations
Assigning a structure to a structure of the same type Taking the address (&) of a structure Accessing the members of a structure Using the sizeof operator to determine the size of a structure

10.3 Initializing Structures

Initializer lists
Example:
card oneCard = { "Three", "Hearts" };

Assignment statements
Example:
card threeHearts = oneCard;

Could also define and initialize threeHearts as follows:

card threeHearts; threeHearts.face = Three; threeHearts.suit = Hearts;

10.4 Accessing Members of Structures

Accessing structure members
Dot operator (.) used with structure variables
card myCard; printf( "%s", myCard.suit );

Arrow operator (->) used with pointers to structure variables

card *myCardPtr = &myCard; printf( "%s", myCardPtr->suit );

myCardPtr->suit is equivalent to
( *myCardPtr ).suit

1 2 3 4 5 6 7 8 9

/* Fig. 10.2: fig10_02.c Using the structure member and structure pointer operators */ #include <stdio.h> /* card structure definition */ struct card { char *face; /* define pointer face */ char *suit; /* define pointer suit */

Outline
fig10_02.c (Part 1 of 2)

10 }; /* end structure card */ 11 12 int main() 13 { 14 15 16 17 18 19 20 21 22 aPtr = &a; /* assign address of a to aPtr */ /* place strings into card structures */ a.face = "Ace"; a.suit = "Spades"; struct card a; /* define struct a */ struct card *aPtr; /* define a pointer to card */

23 24 25 26 27 28

printf( "%s%s%s\n%s%s%s\n%s%s%s\n", a.face, " of ", a.suit, aPtr->face, " of ", aPtr->suit, ( *aPtr ).face, " of ", ( *aPtr ).suit ); return 0; /* indicates successful termination */

Outline
fig10_02.c (Part 2 of 2)

29 } /* end main */

Ace of Spades Ace of Spades Ace of Spades

Program Output

10.5 Using Structures With Functions

Passing structures to functions
Pass entire structure
Or, pass individual members

Both pass call by value

To pass structures call-by-reference

Pass its address Pass reference to it

To pass arrays call-by-value

Create a structure with the array as a member Pass the structure

10.6 typedef
typedef
Creates synonyms (aliases) for previously defined data types Use typedef to create shorter type names Example:
typedef struct Card *CardPtr;

Defines a new type name CardPtr as a synonym for type

struct Card *
typedef does not create a new data type Only creates an alias

10.7 Example: High-Performance Cardshuffling and Dealing Simulation Pseudocode:

Create an array of card structures Put cards in the deck Shuffle the deck Deal the cards

1 2 3 4 5 6 7 8 9 10

/* Fig. 10.3: fig10_03.c The card shuffling and dealing program using structures */ #include <stdio.h> #include <stdlib.h> #include <time.h> /* card structure definition */ struct card { const char *face; /* define pointer face */ const char *suit; /* define pointer suit */

Outline
fig10_03.c (Part 1 of 4)

11 }; /* end structure card */ 12 13 typedef struct card Card; 14 15 /* prototypes */ 16 void fillDeck( Card * const wDeck, const char * wFace[], 17 const char * wSuit[] ); 18 void shuffle( Card * const wDeck ); 19 void deal( const Card * const wDeck ); 20 21 int main() 22 { 23 24 Card deck[ 52 ]; /* define array of Cards */

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

/* initialize array of pointers */ const char *face[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"}; /* initialize array of pointers */ const char *suit[] = { "Hearts", "Diamonds", "Clubs", "Spades"}; srand( time( NULL ) ); /* randomize */ fillDeck( deck, face, suit ); /* load the deck with Cards */ shuffle( deck ); /* put Cards in random order */ deal( deck ); /* deal all 52 Cards */ return 0; /* indicates successful termination */

Outline
fig10_03.c (Part 2 of 4)

41 } /* end main */ 42 43 /* place strings into Card structures */ 44 void fillDeck( Card * const wDeck, const char * wFace[], 45 46 { 47 48 int i; /* counter */ const char * wSuit[] )

49 50 51 52 53 54

/* loop through wDeck */ for ( i = 0; i <= 51; i++ ) { wDeck[ i ].face = wFace[ i % 13 ]; wDeck[ i ].suit = wSuit[ i / 13 ]; } /* end for */

Outline
fig10_03.c (3 of 4)

55 } /* end function fillDeck */ 56 57 /* shuffle cards */ 58 void shuffle( Card * const wDeck ) 59 { 60 61 62 63 64 65 66 67 68 69 70 71 72 } /* end function shuffle */ 73 /* loop through wDeck randomly swapping Cards */ for ( i = 0; i <= 51; i++ ) { j = rand() % 52; temp = wDeck[ i ]; wDeck[ i ] = wDeck[ j ]; wDeck[ j ] = temp; } /* end for */ int i; int j; /* counter */ /* variable to hold random value between 0 - 51 */

Card temp; /* define temporary structure for swapping Cards */

74 /* deal cards */ 75 void deal( const Card * const wDeck ) 76 { 77 78 79 80 81 82 83 84 85 } /* end function deal */ /* loop through wDeck */ for ( i = 0; i <= 51; i++ ) { printf( "%5s of %-8s%c", wDeck[ i ].face, wDeck[ i ].suit, ( i + 1 ) % 2 ? '\t' : '\n' ); } /* end for */ int i; /* counter */

Outline
fig10_03.c (4 of 4)

Four Three Four Nine Three Eight Deuce Seven Ace Ace Seven Eight Five Queen Queen Jack Eight King Eight Ace Four Deuce Deuce Seven King Ten

of of of of of of of of of of of of of of of of of of of of of of of of of of

Clubs Diamonds Diamonds Hearts Clubs Clubs Clubs Clubs Clubs Spades Diamonds Spades Spades Spades Diamonds Diamonds Hearts Spades Diamonds Hearts Spades Hearts Spades Spades Clubs Hearts

Three Three Ace Ten Four Nine Queen Jack Five Five Six Queen Deuce Six Seven Nine Five Six Ten King Jack Jack Ten Nine Six King

of of of of of of of of of of of of of of of of of of of of of of of of of of

Hearts Spades Diamonds Clubs Hearts Diamonds Clubs Spades Diamonds Clubs Spades Hearts Diamonds Hearts Hearts Spades Hearts Clubs Spades Hearts Hearts Clubs Diamonds Clubs Diamonds Diamonds

Outline
Program Output

10.8 Unions
union
Memory that contains a variety of objects over time Only contains one data member at a time Members of a union share space Conserves storage Only the last data member defined can be accessed

union definitions
Same as struct
union Number { int x; float y; }; union Number value;
Copyright 19922004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.

10.8 Unions
Valid union operations
Assignment to union of same type: = Taking address: & Accessing union members: . Accessing members using pointers: ->

1 2 3 4 5 6 7 8 9 10

/* Fig. 10.5: fig10_05.c An example of a union */ #include <stdio.h> /* number union definition */ union number { int x; /* define int x */ double y; /* define double y */ }; /* end union number */

Outline
fig10_05.c (1 of 2)

11 int main() 12 { 13 14 15 16 17 18 19 20 21 value.x = 100; /* put an integer into the union */ printf( "%s\n%s\n%s%d\n%s%f\n\n", "Put a value in the integer member", "and print both members.", "int: ", value.x, "double:\n", value.y ); union number value; /* define union value */

22 23 24 25 26 27 28 29 30

value.y = 100.0; /* put a double into the same union */ printf( "%s\n%s\n%s%d\n%s%f\n", "Put a value in the floating member", "and print both members.", "int: ", value.x,

Outline
fig10_05.c (2 of 2)

"double:\n", value.y ); return 0; /* indicates successful termination */

31 } /* end main */

Put a value in the integer member and print both members. int: 100 double: -92559592117433136000000000000000000000000000000000000000000000.000000

Put a value in the floating member and print both members. int: 0 double: 100.000000

10.9 Bitwise Operators

All data represented internally as sequences of bits
Each bit can be either 0 or 1 Sequence of 8 bits forms a byte
Operator
& | ^ << >>

bitwise AND bitwise inclusive OR bitwise exclusive OR left shift right shift

Description The bits in the result are set to 1 if the corresponding bits in the two operands are both 1. The bits in the result are set to 1 if at least one of the corresponding bits in the two operands is 1. The bits in the result are set to 1 if exactly one of the corresponding bits in the two operands is 1. Shifts the bits of the first operand left by the number of bits specified by the second operand; fill from the right with 0 bits. Shifts the bits of the first operand right by the number of bits specified by the second operand; the method of filling from the left is machine dependent.

Fig. 10.6

ones complement All 0 bits are set to 1 and all 1 bits are set to 0. The bitwise operators.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/* Fig. 10.7: fig10_07.c Printing an unsigned integer in bits */ #include <stdio.h> void displayBits( unsigned value ); /* prototype */ int main() { unsigned x; /* variable to hold user input */ printf( "Enter an unsigned integer: " ); scanf( "%u", &x ); displayBits( x ); return 0; /* indicates successful termination */

Outline
fig10_07.c (1 of 2)

18 } /* end main */ 19 20 /* display bits of an unsigned integer value */ 21 void displayBits( unsigned value ) 22 { 23 24 unsigned c; /* counter */

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

/* define displayMask and left shift 31 bits */ unsigned displayMask = 1 << 31; printf( "%7u = ", value ); /* loop through bits */ for ( c = 1; c <= 32; c++ ) { putchar( value & displayMask ? '1' : '0' ); value <<= 1; /* shift value left by 1 */ if ( c % 8 == 0 ) { /* output space after 8 bits */ putchar( ' ' ); } /* end if */ } /* end for */ putchar( '\n' );

Outline
fig10_07.c (2 of 2)

42 } /* end function displayBits */

Enter an unsigned integer: 65000 65000 = 00000000 00000000 11111101 11101000

10.9 Bitwise Operators

Bit 1 Bit 2 Bit 1 & Bit 2

0 1 0 1
Fig. 10.8

0 0 1 1
Results of combining two bits with the bitwise AND operator &.

0 0 0 1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/* Fig. 10.9: fig10_09.c Using the bitwise AND, bitwise inclusive OR, bitwise exclusive OR and bitwise complement operators */ #include <stdio.h> void displayBits( unsigned value ); /* prototype */ int main() { unsigned number1; /* define number1 */ unsigned number2; /* define number2 */ unsigned mask; /* define mask */ unsigned setBits; /* define setBits */ /* demonstrate bitwise & */ number1 = 65535; mask = 1; printf( "The result of combining the following\n" ); displayBits( number1 ); displayBits( mask ); printf( "using the bitwise AND operator & is\n" ); displayBits( number1 & mask );

Outline
fig10_09.c (1 of 4)

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

/* demonstrate bitwise | */ number1 = 15; setBits = 241; printf( "\nThe result of combining the following\n" ); displayBits( number1 ); displayBits( setBits ); printf( "using the bitwise inclusive OR operator | is\n" ); displayBits( number1 | setBits ); /* demonstrate bitwise exclusive OR */ number1 = 139; number2 = 199; printf( "\nThe result of combining the following\n" ); displayBits( number1 ); displayBits( number2 ); printf( "using the bitwise exclusive OR operator ^ is\n" ); displayBits( number1 ^ number2 ); /* demonstrate bitwise complement */ number1 = 21845; printf( "\nThe one's complement of\n" ); displayBits( number1 ); printf( "is\n" ); displayBits( ~number1 );

Outline
fig10_09.c (2 of 4)

49 50

return 0; /* indicates successful termination */

Outline
fig10_09.c (3 of 4)

51 } /* end main */ 52 53 /* display bits of an unsigned integer value */ 54 void displayBits( unsigned value ) 55 { 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 } /* end for */ if ( c % 8 == 0 ) { /* output a space after 8 bits */ putchar( ' ' ); } /* end if */ /* loop through bits */ for ( c = 1; c <= 32; c++ ) { putchar( value & displayMask ? '1' : '0' ); value <<= 1; /* shift value left by 1 */ printf( "%10u = ", value ); /* declare displayMask and left shift 31 bits */ unsigned displayMask = 1 << 31; unsigned c; /* counter */

putchar( '\n' );

75 } /* end function displayBits */

Outline
fig10_09.c (4 of 4) Program Output

The result of combining the following 65535 = 00000000 00000000 11111111 11111111 1 = 00000000 00000000 00000000 00000001 using the bitwise AND operator & is 1 = 00000000 00000000 00000000 00000001
The result of combining the following 15 = 00000000 00000000 00000000 241 = 00000000 00000000 00000000 using the bitwise inclusive OR operator 255 = 00000000 00000000 00000000 The result of combining the following 139 = 00000000 00000000 00000000 199 = 00000000 00000000 00000000 using the bitwise exclusive OR operator 76 = 00000000 00000000 00000000

00001111 11110001 | is 11111111

10001011 11000111 ^ is 01001100

The one's complement of 21845 = 00000000 00000000 01010101 01010101 is 4294945450 = 11111111 11111111 10101010 10101010

10.9 Bitwise Operators

Bit 1
0 1 0 1

Bit 2
0 0 1 1

Bit 1 | Bit 2
0 1 1 1

Fig. 10.11 operator |.

Results of combining two bits with the bitwise inclusive OR

10.9 Bitwise Operators

Bit 1
0 1 0 1

Bit 2
0 0 1 1

Bit 1 ^ Bit 2
0 1 1 0

Fig. 10.12 operator ^.

Results of combining two bits with the bitwise exclusive OR

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

/* Fig. 10.13: fig10_13.c Using the bitwise shift operators */ #include <stdio.h> void displayBits( unsigned value ); /* prototype */ int main() { unsigned number1 = 960; /* initialize number1 */ /* demonstrate bitwise left shift */ printf( "\nThe result of left shifting\n" ); displayBits( number1 ); printf( "8 bit positions using the " ); printf( "left shift operator << is\n" ); displayBits( number1 << 8 ); /* demonstrate bitwise right shift */ printf( "\nThe result of right shifting\n" ); displayBits( number1 ); printf( "8 bit positions using the " ); printf( "right shift operator >> is\n" ); displayBits( number1 >> 8 );

Outline
fig10_13.c (1 of 2)

25 26

return 0; /* indicates successful termination */

27 } /* end main */ 28 29 /* display bits of an unsigned integer value */ 30 void displayBits( unsigned value ) 31 { 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 putchar( '\n' ); 51 } /* end function displayBits */ } /* end for */ if ( c % 8 == 0 ) { /* output a space after 8 bits */ putchar( ' ' ); } /* end if */ /* loop through bits */ for ( c = 1; c <= 32; c++ ) { putchar( value & displayMask ? '1' : '0' ); value <<= 1; /* shift value left by 1 */ printf( "%7u = ", value ); /* declare displayMask and left shift 31 bits */ unsigned displayMask = 1 << 31; unsigned c; /* counter */

Outline
fig10_13.c (2 of 2)

The result of left shifting 960 = 00000000 00000000 00000011 11000000 8 bit positions using the left shift operator << is 245760 = 00000000 00000011 11000000 00000000 The result of right shifting 960 = 00000000 00000000 00000011 11000000 8 bit positions using the right shift operator >> is 3 = 00000000 00000000 00000000 00000011

Outline
Program Output

10.9 Bitwise Operators

Bitwise assignment operators
&= |= ^= <<= >>=

Bitwise AND assignment operator. Bitwise inclusive OR assignment operator. Bitwise exclusive OR assignment operator. Left-shift assignment operator. Right-shift assignment operator. The bitwise assignment operators.

Fig. 10.14

10.9 Bitwise Operators

Operator
() [] . + * + / -> & * ~ sizeof (type) ++ -- ! %

Associativity left to right right to left left to right left to right left to right left to right left to right left to right left to right left to right left to right left to right right to left

Type Highest Unary multiplicative additive shifting relational equality bitwise AND bitwise OR bitwise OR logical AND logical OR conditional assignment comma

<< >> < <= > >=

== != & ^ | && || ?: = , += -= *= /= &= |= ^= <<= >>= %=

right to left left to right

Fig. 10.15

Operator precedence and associativity.

10.10 Bit Fields

Bit field
Member of a structure whose size (in bits) has been specified Enable better memory utilization Must be defined as int or unsigned Cannot access individual bits

Defining bit fields

Follow unsigned or int member with a colon (:) and an integer constant representing the width of the field Example:
struct BitCard { unsigned face : 4; unsigned suit : 2; unsigned color : 1; };
Copyright 19922004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.

10.10 Bit Fields

Unnamed bit field
Field used as padding in the structure Nothing may be stored in the bits
struct Example { unsigned a : 13; unsigned : 3; unsigned b : 4; }

Unnamed bit field with zero width aligns next bit field to a new storage unit boundary

1 2 3 4 5 6 7 8 9 10

/* Fig. 10.16: fig10_16.c Representing cards with bit fields in a struct */ #include <stdio.h> /* bitCard structure definition with bit fields */ struct bitCard { unsigned face : 4; unsigned suit : 2; /* 4 bits; 0-15 */ /* 2 bits; 0-3 */

Outline
fig10_16.c (1 of 3)

unsigned color : 1; /* 1 bit; 0-1 */

11 }; /* end struct bitCard */ 12 13 typedef struct bitCard Card; 14 15 void fillDeck( Card * const wDeck ); /* prototype */ 16 void deal( const Card * const wDeck ); /* prototype */ 17 18 int main() 19 { 20 21 22 23 24 25 26 return 0; /* indicates successful termination */ fillDeck( deck ); deal( deck ); Card deck[ 52 ]; /* create array of Cards */

27 } /* end main */ 28 29 /* initialize Cards */ 30 void fillDeck( Card * const wDeck ) 31 { 32 33 34 35 36 37 38 39 40 41 } /* end function fillDeck */ 42 43 /* output cards in two column format; cards 0-25 subscripted with 44 46 { 47 48 49 int k1; /* subscripts 0-25 */ int k2; /* subscripts 26-51 */ k1 (column 1); cards 26-51 subscripted k2 (column 2) */ 45 void deal( const Card * const wDeck ) /* loop through wDeck */ for ( i = 0; i <= 51; i++ ) { wDeck[ i ].face = i % 13; wDeck[ i ].suit = i / 13; wDeck[ i ].color = i / 26; } /* end for */ int i; /* counter */

Outline
fig10_16.c (2 of 3)

50 51 52 53 54 55 56 57

/* loop through wDeck */ for ( k1 = 0, k2 = k1 + 26; k1 <= 25; k1++, k2++ ) { printf( "Card:%3d printf( "Card:%3d } /* end for */ Suit:%2d Suit:%2d Color:%2d ", wDeck[ k1 ].face, wDeck[ k1 ].suit, wDeck[ k1 ].color ); Color:%2d\n", wDeck[ k2 ].face, wDeck[ k2 ].suit, wDeck[ k2 ].color );

Outline
fig10_16.c (3 of 3)

58 } /* end function deal */

Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card:

0 1 2 3 4 5 6 7 8 9 10 11 12 0 1 2 3 4 5 6 7 8 9 10 11 12

Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit:

0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1

Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color:

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card: Card:

0 1 2 3 4 5 6 7 8 9 10 11 12 0 1 2 3 4 5 6 7 8 9 10 11 12

Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit: Suit:

2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3

Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color: Color:

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Outline
Program Output

10.11 Enumeration Constants

Enumeration
Set of integer constants represented by identifiers Enumeration constants are like symbolic constants whose values are automatically set
Values start at 0 and are incremented by 1 Values can be set explicitly with = Need unique constant names

Example:
enum Months { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};

Creates a new type enum Months in which the identifiers are set to the integers 1 to 12

Enumeration variables can only assume their enumeration constant values (not the integer representations)
Copyright 19922004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.

1 2 3 4 5 6 7 8 9

/* Fig. 10.18: fig10_18.c Using an enumeration type */ #include <stdio.h> /* enumeration constants represent months of the year */ enum months { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }; int main() enum months month; /* can contain any of the 12 months */ /* initialize array of pointers */ const char *monthName[] = { "", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; /* loop through months */ for ( month = JAN; month <= DEC; month++ ) { printf( "%2d%11s\n", month, monthName[ month ] ); } /* end for */ return 0; /* indicates successful termination */

Outline
fig10_18.c

10 { 11 12 13 14 15 16 17 18 19 20 21 22 23 24 } /* end main */

1 2 3 4 5 6 7 8 9 10 11 12

January February March April May June July August September October November December

Outline
Program Output

Module 05
No ratings yet
Module 05
20 pages
018 - Bits, Characters and Strings
No ratings yet
018 - Bits, Characters and Strings
87 pages
01 Procedural Vs Objects
No ratings yet
01 Procedural Vs Objects
59 pages
2-d Arrays
No ratings yet
2-d Arrays
40 pages
TIMO Final 2020-2021 P3
100% (3)
TIMO Final 2020-2021 P3
5 pages
Unit I: Structures and Unions (Co1) : Syntax For The Declaration of A Structure
No ratings yet
Unit I: Structures and Unions (Co1) : Syntax For The Declaration of A Structure
53 pages
CENG 110 W1 Structuresr
No ratings yet
CENG 110 W1 Structuresr
119 pages
OOP - Chapter 6
No ratings yet
OOP - Chapter 6
40 pages
Chapter12 - Struct Union Enum
No ratings yet
Chapter12 - Struct Union Enum
47 pages
Amazingc 110901051139 Phpapp01
No ratings yet
Amazingc 110901051139 Phpapp01
39 pages
CS201 16
No ratings yet
CS201 16
22 pages
C Declarations and Initialisations
No ratings yet
C Declarations and Initialisations
33 pages
Portfolio Chapter 3
No ratings yet
Portfolio Chapter 3
29 pages
Interview Questions !
No ratings yet
Interview Questions !
22 pages
Structures
No ratings yet
Structures
64 pages
Module5 Chap2
No ratings yet
Module5 Chap2
31 pages
Module 5
No ratings yet
Module 5
75 pages
Programming in C - 181-200
No ratings yet
Programming in C - 181-200
20 pages
Lec 14
No ratings yet
Lec 14
26 pages
MIT6 087IAP10 Lec08
No ratings yet
MIT6 087IAP10 Lec08
23 pages
Structures
No ratings yet
Structures
23 pages
Unit Iv
No ratings yet
Unit Iv
36 pages
chtp7 10
No ratings yet
chtp7 10
141 pages
EST102: Programming in C: Structures and Unions
No ratings yet
EST102: Programming in C: Structures and Unions
15 pages
ITC Lect 19 (Pointers and Strings - III)
No ratings yet
ITC Lect 19 (Pointers and Strings - III)
14 pages
Object Oriented Idea Extra C Microsoft C: Type Specifiers Struct, Typedef, Enum, Union
No ratings yet
Object Oriented Idea Extra C Microsoft C: Type Specifiers Struct, Typedef, Enum, Union
17 pages
Pop Assign2
No ratings yet
Pop Assign2
17 pages
Structures and ENUM
No ratings yet
Structures and ENUM
6 pages
Structures and Union in C Programming
100% (1)
Structures and Union in C Programming
84 pages
C Unit-4
No ratings yet
C Unit-4
9 pages
04 Structures
No ratings yet
04 Structures
20 pages
Card Shuffling
No ratings yet
Card Shuffling
4 pages
Structures: Structure: An Example
No ratings yet
Structures: Structure: An Example
8 pages
t15AStructuresDeclarations Pps
No ratings yet
t15AStructuresDeclarations Pps
9 pages
CHTP5e - 10-Structures 1
No ratings yet
CHTP5e - 10-Structures 1
35 pages
Chapter 4
No ratings yet
Chapter 4
8 pages
CH 10 Deitel How To Program
No ratings yet
CH 10 Deitel How To Program
5 pages
UNIT-5 Structures & Unions
No ratings yet
UNIT-5 Structures & Unions
10 pages
Structured Dat at Pes
No ratings yet
Structured Dat at Pes
7 pages
10 Structs 2
No ratings yet
10 Structs 2
6 pages
Module 5 - Structure and Union
No ratings yet
Module 5 - Structure and Union
11 pages
An If
No ratings yet
An If
9 pages
Lecture 15 Structures, Unions, Enums Etc
No ratings yet
Lecture 15 Structures, Unions, Enums Etc
13 pages
CHTP5e - 07-Pointers 4
No ratings yet
CHTP5e - 07-Pointers 4
31 pages
t15BStructuresFunctionsAndArrays Pps
No ratings yet
t15BStructuresFunctionsAndArrays Pps
14 pages
05 Structures
No ratings yet
05 Structures
25 pages
Type Def
No ratings yet
Type Def
3 pages
17 Examples Using Structs
No ratings yet
17 Examples Using Structs
30 pages
Prog LECTURE 2
No ratings yet
Prog LECTURE 2
11 pages
C Lab Worksheet 14 C Structures, Struct Part 1
No ratings yet
C Lab Worksheet 14 C Structures, Struct Part 1
5 pages
C Lab Worksheet 11A - 1 C & C++ Pointers Part 3: Pointers, Array and Functions
No ratings yet
C Lab Worksheet 11A - 1 C & C++ Pointers Part 3: Pointers, Array and Functions
5 pages
SH 2
No ratings yet
SH 2
2 pages
Card Shuffling Program
No ratings yet
Card Shuffling Program
3 pages
08 Structs
No ratings yet
08 Structs
7 pages
Unit 10 Structures and Unions
No ratings yet
Unit 10 Structures and Unions
18 pages
C Language
No ratings yet
C Language
72 pages
Group 3contemporary
50% (2)
Group 3contemporary
22 pages
Online Platforms For Ict Content Development
100% (1)
Online Platforms For Ict Content Development
21 pages
Geographic Grid: Latitudes and Longitudes: I. Short Answer Questions
No ratings yet
Geographic Grid: Latitudes and Longitudes: I. Short Answer Questions
20 pages
Marine Science - The People Behind The Science
100% (2)
Marine Science - The People Behind The Science
193 pages
Economic Theory by ShumPeter
No ratings yet
Economic Theory by ShumPeter
16 pages
(Tom Bottomore) The Frankfurt School and Its Criti
100% (3)
(Tom Bottomore) The Frankfurt School and Its Criti
92 pages
Lec 2. Processing Room Design
No ratings yet
Lec 2. Processing Room Design
59 pages
World Eaters 9e Codex OCR
No ratings yet
World Eaters 9e Codex OCR
54 pages
Pick and Place Robotic Arm Implementation Using Arduino
No ratings yet
Pick and Place Robotic Arm Implementation Using Arduino
9 pages
The Crystal
No ratings yet
The Crystal
2 pages
PMI Online Setup and Commisioning
No ratings yet
PMI Online Setup and Commisioning
25 pages
UNIT IX LESSON 17 Art and Psychology Perception and Symbolism
No ratings yet
UNIT IX LESSON 17 Art and Psychology Perception and Symbolism
27 pages
How To Assemble A Basic Desktop PC
No ratings yet
How To Assemble A Basic Desktop PC
5 pages
Survey Q
No ratings yet
Survey Q
5 pages
Intro Shapes Lesson Plan
No ratings yet
Intro Shapes Lesson Plan
3 pages
Haifa Al Buainain
No ratings yet
Haifa Al Buainain
36 pages
Research Problem and Questionnaire
No ratings yet
Research Problem and Questionnaire
42 pages
Length-Weight Relationship and Condition Factor of Channa Aurantimaculata (Musikasinthorn, 2000) Studied in A Riparian Wetland of Dhemaji District, Assam, India
No ratings yet
Length-Weight Relationship and Condition Factor of Channa Aurantimaculata (Musikasinthorn, 2000) Studied in A Riparian Wetland of Dhemaji District, Assam, India
6 pages
Computational Linguistics and Audio-Visual Readability: Analysing Linguistic Features of Intralingual-Subtitles Corpora
No ratings yet
Computational Linguistics and Audio-Visual Readability: Analysing Linguistic Features of Intralingual-Subtitles Corpora
14 pages
08e - Mbembe - The Idea of A Borderless World
No ratings yet
08e - Mbembe - The Idea of A Borderless World
10 pages
An Application of Integer Programming To Playoff Elimination in Football Championships
No ratings yet
An Application of Integer Programming To Playoff Elimination in Football Championships
6 pages
Case Study: Amazon AWS: CSE 40822 - Cloud Computing Prof. Douglas Thain University of Notre Dame
No ratings yet
Case Study: Amazon AWS: CSE 40822 - Cloud Computing Prof. Douglas Thain University of Notre Dame
33 pages
Train Signal (Lab 11) - Network Security
No ratings yet
Train Signal (Lab 11) - Network Security
103 pages
Enterprise Network Products Recommended Version List 2015Q4
No ratings yet
Enterprise Network Products Recommended Version List 2015Q4
36 pages
Excerpt From "Awkward" by Ty Tashiro
No ratings yet
Excerpt From "Awkward" by Ty Tashiro
1 page
Zwroty Używane W Listach Angielskich
No ratings yet
Zwroty Używane W Listach Angielskich
24 pages
Postmodernizma Nesto Nesto
No ratings yet
Postmodernizma Nesto Nesto
14 pages
Globalization and The Nation-State: Sovereignty and State Welfare in Jeopardy
No ratings yet
Globalization and The Nation-State: Sovereignty and State Welfare in Jeopardy
8 pages
Winning: Jack Welch
No ratings yet
Winning: Jack Welch
19 pages
Customizing AutoCAD 2020, 13th Edition
From Everand
Customizing AutoCAD 2020, 13th Edition
Prof. Sham Tickoo
No ratings yet
Catia V5-6R2019 for Designers 17th Edition
From Everand
Catia V5-6R2019 for Designers 17th Edition
Prof. Sham Tickoo
No ratings yet
Computer and Network Technology: BCS Level 4 Certificate in IT study guide
From Everand
Computer and Network Technology: BCS Level 4 Certificate in IT study guide
Gary Thornton
No ratings yet
Exam AZ-800: Administering Windows Server Hybrid Core Infrastructure Preparation
From Everand
Exam AZ-800: Administering Windows Server Hybrid Core Infrastructure Preparation
Georgio Daccache
No ratings yet

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

Uploaded by

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

Uploaded by

Chapter 10 - C Structures, Unions, Bit Manipulations, and Enumerations

10.2 Structure Definitions

of the structure type card contains two members of type char *

10.2 Structure Definitions

Can use a comma separated list:

10.2 Structure Definitions

10.2 Structure Definitions

10.3 Initializing Structures

Could also define and initialize threeHearts as follows:

10.4 Accessing Members of Structures

Arrow operator (->) used with pointers to structure variables

Ace of Spades Ace of Spades Ace of Spades

10.5 Using Structures With Functions

Both pass call by value

To pass structures call-by-reference

To pass arrays call-by-value

Defines a new type name CardPtr as a synonym for type

10.7 Example: High-Performance Cardshuffling and Dealing Simulation Pseudocode:

Card temp; /* define temporary structure for swapping Cards */

"double:\n", value.y ); return 0; /* indicates successful termination */

10.9 Bitwise Operators

42 } /* end function displayBits */

Enter an unsigned integer: 65000 65000 = 00000000 00000000 11111101 11101000

10.9 Bitwise Operators

return 0; /* indicates successful termination */

75 } /* end function displayBits */

00001111 11110001 | is 11111111

10001011 11000111 ^ is 01001100

10.9 Bitwise Operators

Fig. 10.11 operator |.

Results of combining two bits with the bitwise inclusive OR

10.9 Bitwise Operators

Fig. 10.12 operator ^.

Results of combining two bits with the bitwise exclusive OR

return 0; /* indicates successful termination */

10.9 Bitwise Operators

10.9 Bitwise Operators

<< >> < <= > >=

== != & ^ | && || ?: = , += -= *= /= &= |= ^= <<= >>= %=

right to left left to right

Operator precedence and associativity.

10.10 Bit Fields

Defining bit fields

10.10 Bit Fields

unsigned color : 1; /* 1 bit; 0-1 */

58 } /* end function deal */

10.11 Enumeration Constants

You might also like