Introduction to Programming 3D Applications CE0056-1 Lecture 12 Structure Pointers and Memory...
-
Upload
andrew-evans -
Category
Documents
-
view
221 -
download
4
Transcript of Introduction to Programming 3D Applications CE0056-1 Lecture 12 Structure Pointers and Memory...
Introduction to Programming 3D Applications
CE0056-1
Lecture 12
Structure Pointers and Memory Management in C
Purpose of structures
Computing applications often need data of
different kinds to be associated. A typical place
where this occurs is in a record. For example a
database record for a particular student might
contain the student number, full name, course-
code and year of entry.
Record declaration
struct student { char studno[12]; // or char *studno; char name[50]; char course[7]; int startyear;};
More examples
struct coord { float x,y; };struct complex { float real,imaginary; };
The data does not have to be of different types. Structures help with the naming of related parts of a record object.
Allocating memory to records
The above declarations don't create any space for data storage, but they provide a template for data of the appropriate types to be allocated. Let's allocate some storage to data variables:
struct coord origin, cursor; /* 2 x-y coordinates called origin and cursor */struct student sdn_year2[50]; /* array for 50 students */
Defining a new data type
Better to have one word e.g. COORD to declare the type of data than 2 words e.g. struct coord. This needs a typedef statement:
struct coord { float x,y; };typedef struct coord COORD; /* COORD now same as struct coord */COORD origin, cursor; /* declare 2 x-y coordinates called origin and cursor */
Use of the dot structure member access operator
Members x and y of origin and cursor can now be accessed as origin.x, origin.y, cursor.x and
cursor.y e.g.
origin.x=3.5;origin.y=2.0;
Programmer defined data type
We can now declare stuctured data with a single word in a similar way that we use other built-in data types such as float and int. This simplification is useful if the name of the data type is going to appear in many places within our program, e.g. for declaring types of local data within functions or function parameters.
It may not seem the case, but having many smaller functions which communicate cleanly is going to make programming much easier.
Functions which communicate using structure parameters
float distance(COORD a, COORD b){ /* calculate distance between a and b */ float z,vert,horiz; /* z = distance, vert = y1 - y2, horiz = x1 - x2 */ horiz=a.x - b.x; /* the horizontal distance */ vert=a.y - b.y; /* the vertical distance */ /* calc z as the hypotenuse of a right angle triangle */ z=sqrt((horiz*horiz) + (vert*vert)); /* Pythagorus */ return z; /* z*z = x*x + y*y */}
Functions which communicate using structured return values
COORD getcoord(void){ /* prompts for & returns a coordinate */ COORD temp; printf("Enter x and y coordinates \n"); scanf("%f%f",&temp.x,&temp.y); return temp; /* note returned type is COORD */}
A program using distance and getcoord
#include <stdio.h>#include <math.h> /* needed to use sqrt() square root */ struct coord { float x,y; }; /* declare structure coord as having x and y members */typedef struct coord COORD; /* COORD is now same as struct coord */COORD origin, cursor; /* declare 2 x-y coordinates called origin and cursor */
/* function prototypes */float distance(COORD a, COORD b); COORD getcoord(void);
A program using distance and getcoord
int main(void){ COORD origin, cursor; float gap; printf("enter details for origin:\n"); origin=getcoord(); printf("enter details for cursor:\n"); cursor=getcoord(); gap=distance(origin,cursor); printf("distance between origin and cursor is %f\n“,gap); return 0;}
Use of structure pointers
Members x and y of coordinates a and b can also be accessed through pointers to a and b If pointer p stores the address of a: p=&a; Then
p->x directly accesses member x of a or a.x
Rewrite previous program using pointers
/* declarations above here of headers , struct coord and typedef COORD same as before so not repeated */float distance(COORD *a, COORD *b); /* a and b are now pointers to COORD */void getcoord(COORD *t); /* inputs coordinate through COORD* pointer t */
Rewrite using pointersint main(void){ COORD origin, cursor, *orig,*curs; orig=&origin; curs=&cursor; /* store addresses in pointers orig and curs */ float gap; printf("enter details for origin:\n"); getcoord(orig); printf("enter details for cursor:\n"); getcoord(curs); gap=distance(orig,curs); printf("the distance between origin and cursor %f\n",gap); getch(); return 0;}
Rewrite using pointers
float distance(COORD *a, COORD *b){ /* calculate distance between a and b */float z,vert,horiz; /* z = distance, vert = y1 - y2, horiz = x1 - x2 */horiz=a->x - b->x; /* horizontal distance note -> pointer syntax */vert=a->y - b->y; /* the vertical distance *//* calculate z as the hypotenuese of a right angle triangle */z=sqrt((horiz*horiz) + (vert*vert)); /* pythagorus theorem: */return z;/* z*z = x*x + y*y */
}
void getcoord(COORD *t){ /* inputs x-y coordinate using pointers */ printf("please enter x and y coordinates\n"); scanf("%f%f",&t->x,&t->y); /* -> has higher precedence than & */}
Structures and arraysHaving individual names for 10 coordinates is very awkward. We can declare the data as an array:
typedef struct coord { float x,y; } COORD;COORD graph[10];
We can then assign members of our structure array like this:
graph[9].x = 12.5; graph[9].y = 7.3; /* assign values to tenth element [9] of graph array */
input values into all coordinates using a loop
int i; for(i=0;i<10;i++){ printf("Enter x value for coordinate%d\n" ,i+1); scanf("%f",&graph[i].x); printf("Enter y value for coordinate%d\n" ,i+1); scanf("%f",&graph[i].y);}
Or using structure pointer notation
int i;
for(i=0;i<10;i++){
printf("Enter x value for coordinate%d\n" ,i+1);
scanf("%f",&(graph+i)->x);
/* -> has higher precedence than & */
printf("Enter y value for coordinate%d\n" ,i+1);
scanf("%f",&(graph+i)->y);
}
A structure containing an arraytypedef struct student { char name[30]; float mark;} STUDENT;
STUDENT you;printf ("enter name and mark\n");scanf ("%s%f",you.name,&you.mark);
/* you.name is the address of the name array *//* so no &ersand needed to get address*//* BUT you.mark is not an array so needs & */
printf ("hello %s your mark is %f\n",you.name,you.mark);printf ("The first letter of your name is %c\n",you.name[0]);
Assigning structuresUnlike arrays, structures can be copied as a complete entity using a single assignment. This savestime. So instead of writing:
strcpy(temp.name,you.name); /* use function strcpy to copy a string */temp.mark = you.mark; /* can assign mark in one go */
we can write:
temp=you; /* copy structure in one go */
Allocation of Static Memory
A declaration such as char name[1000][21], allocates sufficient memory for 1000 names of 21 characters each.
This storage of 21 000 characters is reserved at compilation time, i.e. before the program begins execution.
This wastes space as most names are rather less than 20 letters.
It also restricts names to a maximum of 20 characters. We can resolve this wastage and restriction by allocation of
memory as and when required, during execution of the program.
Dynamic Allocation using malloc function
A standard function, malloc(n) allocates n bytes (for n characters) in memory and returns a pointer to it.
For example: the following code Prompts the user for the size of the string Reads the size Allocates memory for a string of this size Reads the string
Example using malloc
int size;
char *s;
printf(“\nhow many characters?\n”);
scanf(“%d”, &size);
s = malloc(size+1); // one extra for ‘\0’
printf(“type string\n”);
gets(s);
allocates only enough memory for the expected string.
Use of malloc for any data type
malloc can be used to allocate memory for any <data type>.
<data type> *<variable>; // pointer to <data type>
// some other code here
<variable> = (<data type> *)malloc(n * sizeof(<data type>));
allocates sufficient memory for n values of <data type> and returns a pointer which must be casted as the same pointer type as the <variable>.
Using malloc for an array of integers
For example:
To allocate storage for 10 integers
int *p;
p = (int *) malloc (10 * sizeof(int));
This is machine-independent, as sizeof returns
size of an integer for any machine.
Ragged Arrays
Declare 6 variable length names – array of string pointers
char *name[6] =
{“abdul”, “abraham”, “al “, “bill”, “fred”, “jean-pierre”};
We can declare functions on ragged arrays:
void print_list(char *table1[ ], int n)
so that it can deal with strings of any length.
Ragged array example
Read a list of strings (one on each line) into an array wherethe size of each element is precisely the length of eachstring, ie the strings are of variable length - a ragged array.
#include "stdio.h"#include "string.h"#include "stdlib.h" // for malloc// prototypes
void sort(char *[], int);int read_strings(char *[], int);void print_strings(char *[], int);
Main function
int main(void){char *list[1000];
// array of 1000 string pointers int n; // actual number of strings n = read_strings(list, 1000);
// read n strings, max of 1000 sort(list, n); // sort n strings print_strings(list, n); // print n strings return (0);}
print_strings function
void print_strings(char *list[], int n)
{
int i;
printf("\nalphabetical order is\n\n");
for (i=0; i<n; i++)
{
printf("%s\n", list[i]);
}
}
void sort(char *a[], int n) { // array of n strings as pointers
int i, j;char *temp; // string pointerfor (j = n -1; j > 0; j--){ // each pass of j
comparisonsfor (i=0; i < j; i++){ // each comparison
if (strcmp(a[i], a[i+1]) > 0)
{ // swap the POINTERS temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; } // else no swap } // end of pass } // end of all passes} // end sort
int read_strings(char *list[], int max){
int i = 0;char line[81]; // store for each lineprintf("\ntype one string per line\n");while (gets(line) != NULL && i < max) { // while not end of input
list[i] = malloc (strlen(line)+1); // list[i] big enough
// for line + 1 for ‘\0’
strcpy(list[i], line); // copy line into list[i]
i++; // next element}return i; // actual number of strings
}