Vous êtes sur la page 1sur 38

CSEB114: PRINCIPLE

OF PROGRAMMING
Chapter 9: User Defined Data Types
Objectives
In this chapter you will learn about,
Introduction
Declaring Structure Type & Structure Variables
Referring and initializing structure elements
Passing structures to a function
Using typedef
Example using structure
Enumeration constants
prepared by NI, edited by MAF
Introduction
So far we have only used data types which have
been defined by C such as int, double and char.
It is also possible to create our own data types.
A user defined data type is called a structure.
A structure can contain both built-in data types
and another structure.
The concept of structure is pretty much the
same as arrays except that in an array, all the
data is of the same types but in a structure, the
data can be of different types.
prepared by NI, edited by MAF
Definition
A structure is a derived data type that
represents a collection of a related data items
called components (or members) that are not
necessarily of the same data type.
prepared by NI, edited by MAF
Declaring Structure Type
General syntax:
struct structure_name {
data_type element1;
data_type element2;
. . .
};
Example:
struct student {
char name[20];
int studentID;
char major[50];
};
prepared by NI, edited by MAF
Also called as structure tag
Components / members
Declaring Structure Variables
After declaring a structure type, we may declare
variables that are of that type. A structure
variable declaration requires:
The keyword struct
The structure type name
A list of members (variable names) separated by
commas
A concluding semicolon
Then, assume that variable of structure type
student is my_student. So the declaration
should be written as;
struct student my_student;
prepared by NI, edited by MAF
Based on example: struct student
By including this declaration in our program, we are
informing the compiler about a new data type which is a
user defined data type.
The declaration just makes the compiler aware the
existent of new data type but does not take an action
yet.
Based on the declaration of
struct student my_student;
causes the compiler to reserve memory space for
variable my_student and the components of its
structure.
prepared by NI, edited by MAF
Based on example: struct
student


prepared by NI, edited by MAF
Structure variable Components Values
name
major
studentID
Simon
0078
CS
my_student
Conceptual memory structure variable my_student of type
student (assuming that the components of variable
my_student have already been assigned values)
Based on example: struct
student
It is possible to combine the declarations of a
structure type and a structure variable by
including the name of the variable at the end of
the structure type declaration.

prepared by NI, edited by MAF
struct student {
char name[20];
int studentID;
char major[50];
};
struct student my_student;
struct student {
char name[20];
int studentID;
char major[50];
} my_student;
=
Declaring Nested Structure
Members of a structure declaration can be of
any type, including another structure variable.
Suppose we have the following structure
declaration, which is a member of struct type
student:
struct address {
int no;
char street[20];
int zipcode;
};
prepared by NI, edited by MAF
Declaring Nested Structure
We can rewrite the structure student
declaration as follow:




This structure type student can be written as;

prepared by NI, edited by MAF
struct student {
char name[20];
int studentID;
char major[50];
struct address addr;
} ;
Declaring Nested Structure
struct student {
char name[20];
int studentID;
char major[50];
struct address{
int no;
char street[20];
int zipcode;
};
} ;
prepared by NI, edited by MAF
Referring and Initializing Structure Elements
A structure contains many elements. Each elements of a structure
can be referred to / accessed by using the component selection
operator . (dot).
Let us use the structure student which we have seen before as an
example:






Therefore to refer to the element of a structure, we may write as
follow; my_student.name;
my_student.studentID;
my_student.major;
prepared by NI, edited by MAF
struct student {
char name[20];
int studentID;
char major[50];
};
struct student my_student;
Referring and Initializing Structure Elements
Therefore, we can initialize each elements of a structure
individually such as:
struct student my_student;
my_student.studentID = 10179;
Or we can initialize the structure while we are creating
an instance of the structure:
struct student my_student = {Ahmad, 10179, IT}
Notice that it is possible to use the = operator on a
struct variable. When the = sign is used, each elements
of the structure at the right hand side is copied into the
structure at the left hand side.
prepared by NI, edited by MAF
Example: Structure Initialization
struct birthdate {
int month;
int day;
int year;
};
struct birthdate Picasso = {10, 25, 1881};
printf(Picasso was born : %d/%d/%d\n, Picasso.day,
Picasso.month, Picasso.year);
Output :
Picasso was born : 25/10/1881
prepared by NI, edited by MAF
Passing Structures to a Function
Call by Value:
We can pass the student structure that we have created
before to a function called display( ) as follows:
void display (struct student); /* function prototype */
display (student1); /* function call */
void display (struct student s1); /* function header */
where student1 is a variable of type struct student.
In the above function, a copy of the student structure will
be created locally for the use of the function. Any
changes to the structure inside the function will not
affect the actual structure.
prepared by NI, edited by MAF
Example Using Structure: Call by value
prepared by NI, edited by MAF
#include <stdio.h>
#include <string.h>

struct student{
char name[20];
int id;
};
void display(struct student); /* function prototype */
int main(void)
{
struct student student1;
strcpy(student1.name, "Ahmad"); /*initialising variable */
student1.id = 12345; /*initialising variable */
display(student1);
return 0;
}

void display(struct student s1) /* make a local copy of the structure */
{
printf("Name: %s\n", s1.name);
printf("ID: %d\n", s1.id);
}
Example Using Structure: A Function that return a
structure
prepared by NI, edited by MAF
#include <stdio.h>
#include <string.h>
struct student{
char name[20];
int id;
};
struct student read(void); /* function
prototype */
void main(void)
{
struct student student1;
student1 = read(); /*function call
*/
printf("Name: %s",
student1.name);
printf("\nID: %d\n", student1.id);
}
struct student read(void)
{
struct student s1;
printf("Enter name:");
scanf("%s",s1.name); /*
alternative: gets(s1.name); */
printf("Enter ID:");
scanf("%d",&s1.id);
return s1;
}
Call by reference
It is also possible to use pointers and pass the
reference of the structure to the function. This
way, any changes inside the function will
change the actual structure as well.
To pass a structure variable as a reference, the
Read( ) function can be written this way:
void Read(struct student *); /* function prototype */
Read(&student1); /* function call */
void Read(struct student *s1); /* function header */
where student1 is a variable of type struct
student.
prepared by NI, edited by MAF
Call by reference
Take note that when a structure is declared as a pointer,
the elements in the structure cannot be referred to using
the . operator anymore. Instead, they need to be
accessed using the -> operator (indirect component
selection operator).

For example:
void Read(struct student *s1)
{
s1->studentID = 10179;
scanf(%s, s1->name);
}
prepared by NI, edited by MAF
Example Using Structure: Call by reference
#include <stdio.h>
#include <string.h>
struct student{
char name[20];
int id;
};
void Read (struct student *); /* function prototype*/
void main(void)
{
struct student student1;

Read(&student1); /* function call: passing reference */

printf("Name: %s", student1.name);
printf("\nID: %d\n", student1.id);
}
void Read (struct student *s1) /* function header, receive structure as a pointer variable */
{
printf("Enter name:");
scanf("%s",s1->name); /* you can also use: gets(s1->name) */
printf("Enter ID:");
scanf("%d",&s1->id);
}
prepared by NI, edited by MAF
Using typedef in Structure Declarations
The keyword typedef provides a mechanism
for creating synonyms (aliases) for previously
defined data types.
Here is an example on how to use typedef
when declaring a structure:
struct student {
char name[20];
int studentID;
char major[50];
struct address addr;
} ;
prepared by NI, edited by MAF
Using typedef in Structure Declarations
By using typedef:
typedef struct student StudentData;
we are now aliasing the structure with a name to be
used throughout the program. So instead of writing the
word struct before declaring a struct variable like the
following
struct student my_student;
we can now write:
StudentData my_student;
We could use the alias name when passing the structure
to a function:
void display(StudentData s1);
prepared by NI, edited by MAF
Example : using typedef
#include <stdio.h>
#include <string.h>

struct student{
char name[20];
int id;
};

typedef struct student StudentData;

void display(StudentData); /* function prototype
*/

int main(void)
{
StudentData student1;

strcpy(student1.name, "Ahmad");
student1.id = 12345;

display(student1);
return 0;
}


prepared by NI, edited by MAF
void display(StudentData s1)
{
printf("Name: %s\n", s1.name);
printf("ID: %d\n", s1.id);
}
Example: Array of structure
prepared by NI, edited by MAF
#include <stdio.h>
#define NUM_STUDENTS 10
struct student {
int studentID;
char name[20];
int score;
char grade;
};
typedef struct student StudentData;
void Read (StudentData student[]);
void CountGrade (StudentData student[]);
void main ( )
{
StudentData student[NUM_STUDENTS];
Read(student);
CountGrade(student);
}
Example: Array of structure
prepared by NI, edited by MAF
void Read (StudentData student[])
{
int i;
for (i = 0; i < NUM_STUDENTS; i++) {
printf("Enter the studentID: ");
scanf("%d", &student[i].studentID);
printf("Enter the name: ");
scanf("%s", student[i].name);
printf("Enter the score: ");
scanf("%d", &student[i].score);
printf("\n");

}
}
Example: Array of structure
prepared by NI, edited by MAF
void CountGrade (StudentData student[])
{
int i;
for (i = 0; i < NUM_STUDENTS; i++) {
if (student[i].score > 90)
student[i].grade = 'A';
else if (student[i].score > 80)
student[i].grade = 'B';
else if (student[i].score > 65)
student[i].grade = 'C';
else if (student[i].score > 50)
student[i].grade = 'D';
else
student[i].grade = 'F';
printf("The grade for %s is %c\n", student[i].name, student[i].grade);
printf("\n");
}
}
Sample Output
prepared by NI, edited by MAF
/* Sample Output
Enter the studentID: 789654
Enter the name: Salman
Enter the score: 96

Enter the studentID: 741258
Enter the name: Jack
Enter the score: 79
:
:
:
The grade for Salman is A

The grade for Jack is C
:
:
Press any key to continue
*/
Example
prepared by NI, edited by MAF
#include <stdio.h>
struct car{
char maker[20];
char model[20];
int year;
};
void input(struct car*);
void output(char*, char*, int*);
void main()
{
struct car firstcar;
input (&firstcar);
output(firstcar.maker, firstcar.model, &firstcar.year);
printf("End of my act!\n");
}
Example
prepared by NI, edited by MAF
void input(struct car *sp)
{
printf("What is the maker of your car? ");
gets(sp->maker);
printf("What is the model of your car? ");
gets(sp->model);
printf("What year is your car? ");
scanf("%d", &sp->year);
}

void output(char *sp1, char*sp2, int*sp3)
{
printf("Your car is : %s, %s, %d\n", sp1, sp2, *sp3);
printf("Nice car\n");
}

Sample Output
prepared by NI, edited by MAF
/* Sample output
What is the maker of your car? Honda
What is the model of your car? Stream
What year is your car? 2003
Your car is : Honda, Stream, 2003
Nice car
End of my act!
Press any key to continue
*/
Enumeration Constants
An enumeration, introduced by the keyword enum, is a
set of integer constants represented by identifiers. (to
specify one after another)
Example:
enum islamic_months {
muharam, safar, rabiulawal, rabiulakhir,
jamadilawal, jamadilakhir, rejab, syaaban,
ramadhan, syawal, zulkaedah, zulhijjah
};
Each of the identifiers actually has a value, starting with
0 (unless specified otherwise). Therefore, we can treat
them as integers.
prepared by NI, edited by MAF
Enumeration Constants
If we want the enumeration to start with a value
other than 0, we can assign the value to the first
identifier:
enum islamic_months {
muharam = 1, safar, rabiulawal, rabiulakhir,
jamadilawal, jamadilakhir, rejab, syaaban,
ramadhan, syawal, zulkaedah, zulhijjah
};
Same as with the other data types, before an
enum can be used, a variable needs to be
declared:
enum islamic_months months;
prepared by NI, edited by MAF
Enumeration Constants
There are cases where it is appropriate for us to
use an enum. This is an example of such a
case:
enum islamic_months months;
GetMonth (&months);
switch (months) {
case muharam:
. . .
break;
case safar:
. . .
break;
. . .
}
prepared by NI, edited by MAF
Enumeration Constants
This is another case where it is appropriate to use an
enum:
enum Boolean {FALSE, TRUE};
void main ( ) {
int list[];
Boolean found;

Read(list);
found = Search(list);
if (found == TRUE)
printf(FOUND!!);
else
printf(Cannot find the requested item);
}
prepared by NI, edited by MAF
Example
prepared by NI, edited by MAF
#include <stdio.h>

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

void main ( ) {
enum months month;
char *monthsName[] = {January, February, March,
April, May, June, July, August, September,
October, November, December};

for (month = JAN; month <= DEC; month++)
printf(%d %s, month, monthName[month-1]);
}

Output
prepared by NI, edited by MAF
Output:
1 January
2 February
3 March
4 April
5 May
6 June
7 July
8 August
9 September
10 October
11 November
12 December
SUMMARY
In this chapter you have learnt about
Structure type and variable declarations
How structure members can be accessed
How structure can be initialized
Passing structure to function
Enumeration

prepared by NI, edited by MAF

Vous aimerez peut-être aussi