derived types

• The type definition• Enumerated types• Accessing structures• Complex structures• Arrays of structures• Structures and functions

Derived Types

Type Definition (typedef)• It gives the name to a data type by creating a new type that can

be used anywhere a type is permitted• Advantage

o Allows to replace a complex name such as a pointer declaration with mnemoic that makes the program easier to read and follow

o typedef type IDENTIFIER ;o e.g. o typedef int INTEGER;o char * stringPtrArray[20]; can be written as

typedef char *STRING; STRING stringPtrArray[20];

Derived Types

Keywordstandard or derived type

Traditionally upper case

Enumerated types• enum is built on integer types• Each integer value is given an identifier called an enumeration

constant• It allows to use symbolic names rather than numbers which makes

our programs much more readable • Once enumerated types are defined, we can create variables from

standard types• C allows the enumerated constants or variables that hold

enumerated constants, to be used anywhere that integers can be used

• Keep enumerated types separate from integer types

Derived Types

• enum { enumeration constants } variable_identifier;o Format 1 : Enumerated variable

• enum tag { enumeration constants };• enum tag variable_identifier;

o Format 2: enumerated tag• To use multiple enumerated types in a program, you need to

create an enumerated type• It includes a tag after the keyword enum; the tag is an enum

identifier• Example of enumeration

o enum months { jan, feb, mar,april,may};• It is list of one or more identifiers separated by commas

o Here jan equates to 0, feb to 1 and so ono enum months {jan=1, feb , jun=6, aug=1};o enum months birthmonth;

Derived Types

Enumerated types

Enumerated type definition• enum colors{ red, white, blue};• enum colors acolor;

o Format 1 : Enumerated variable• typedef enum{ red,white, blue } COLORS;• COLORS aColor;

o Format 2: Enumerated typedef

Derived Types

example• /* program to demonstrate the use of enum in switch*/• Main( )• {• enum items {laptop=1,cellphone,TV, ironbox};• int choice;• printf(“enter your choice”);• scanf(“%d”,&choice);• switch(choice)• {• case laptop: printf(“ you pressed laptop”);• break; • case cellphone:printf(“ you pressed cellphone”);• break; • case TV: printf(“ you pressed TV”);• break; • case ironbox: printf(“ you pressed ironbox”);• }• } • Here meaningful names are given in switch instead of

number.

Derived Types

Structure format variation struct {

… …

} variable_identifier;-------------------------------------------------------------------------------- struct tag {

… …

} variable_identifier; struct tag variable_identifier; ----------------------------------------------------------------------------------------typedef

struct { … …

} TYPE_ID;• TYPE_ID variable_identifier;

Derived Types

Example typedef struct { int x; int y; float t; char u; } SAMPLE; SAMPLE sam1; SAMPLE *ptr; ptr=&sam1; Derive

d Types

Accessing structures• Each field in a structure can be accessed and manipulated using

expressions and operators• Period (.) is used to distinguish normal identifiers from the

members in the structureo e.g. If (employee1.gender = = ‘M’ ) employee1.salary +=employee1.hra;o scanf(“%d %f %c “, &sam1.empcode, &sam1.salary, &sam1.gender);o (.) precedence 17, postfix -16, unary increment -15o sam1.x++ and ++sam2.x are valid

Derived Types

Structure operations• A structure can only be copied to another structure of the same

type using the assignment operator

Derived Types

Pointers to structures• Define a pointer for the structure

o SAMPLE *ptr;o ptr=&sam1;o Structure can be accessed using indirection operator (*) refering to the

whole structureo E.g.

(*ptr ).x Brackets essential because precedence of member operator (17) is higher than

indirection operator (15) *ptr.x is interpreted as *(ptr.x) (*pointername ).fieldname same as pointername-> fieldname

Derived Types

Complex structure• Structure within structure (nested structures), arrays within

structures, arrays of structures • Nesting must be done from inside out- innermost structure first,

then next level, working upward toward the outer most inclusive structure

• Each structure must be initialized completely before proceeding to the next number

• Each structure enclosed in the braces

Derived Types

Defining arrays for structures• Structures can have more than one array as members. They can

be accessed either by indexing through pointers as long as they are properly qualified with member operators

• Like structures an array may be included within the structure or may be declared separately and then included

• If declared separately, the declaration must be complete before it can be used in the structure

• Regardless of how we declare the structure, each element will have the same reference. First to the structure and then to the array element

• When structure contains array we can use pointers to refer directly to the array elements

Derived Types

Array initialization in structures• Since array is a separate member, its values must be included in

a separate set of braces• Use of pointers can save memory• e.g.

o char may[]=“May”o stamp.date.month=may;// assigns month “May” to the structure

Derived Types

Array of structures• Create the array as done for normal array of integers

o E.g. o STUDENT stuary[50];o To access the midterm marks of one of the subject 1 for student 4, we

can writeo studAry[4].midterm[1];o The index operator the member operator, the selection operator have

same precedence and associativity is from left to right

Derived Types

Structures and functions• For structures to be useful, we must be able to pass them to

functions and return them• A function can access the members of a structure in three ways

o Individual members can be passed to the functiono Whole structure can be passed and the function can access the member

using pass by valueo The address of a structure or member can be passed, and the function

can access the members through indirection and selection operators ( pass by address)

• We can send the individual elements or the whole structure to a function

• A function can also return a structure

Derived Types

Passing structures through pointers• When structures are large, efficiency could suffer, especially with

heavily used function• You will find that structures are passed through pointers• It is common to pass structures thorugh pointers when the

structure is in dynamic memory• Selection operator () has higher precedence than the address

operator(&) and it can be coded without parenthesis• e.g.

&ptrnumerator &(*pFr).denominator // member operator has higher precedence over indirection operator and address operatorSince the address and member operator are the same level, we need to use the parenthesis only around the pointer dereference

Derived Types

unions

• A union is a construct that allows memory to be shared between different data types.

• Declaration syntax is similar to that of structure except the keyword struct to be replaced by union.

• union sharedData{• char chAry[2]; • short num; };• Both share the same location i.e chAry[0] is MSB byte of

num and chAry[1] is LSB byte of num.• Member accessing is similar to structures.

Derived Types

• Only the first type declared in the union can be initialized while defining union variable.

• Other types can be read or assigned value using assignment operator.

• While initializing, values must be enclosed in {}• A structure member can be an union. And vice versa.• Example Derive

d Types