Pointers and Structures

 Structures in Functions
 Pointers to structures
 Accessing structure members
 Using pointer as a function argument
 Array of structures
 Self referential structures.

 Like all other types, we can pass structures as
arguments to a function.
 In fact, we can pass, individual members, structure
variables, a pointer to structures etc to the function.
 Similarly, functions can return either an individual
 Similarly, functions can return either an individual
member or structures variable or pointer to the
structure.
 Passing Structure Members as arguments to Function
 Passing Structure Variable as Argument to a Function
 Returning Structure from Function

#include<stdio.h>
/*
structure is defined above all functions so it is global.
*/
struct student
struct student
{
char name[20];
int roll_no;
int marks;
};
void print_struct(char name[], int roll_no, int marks);

Output
Name: Tim
Roll no: 1
Marks: 78
int main()
{
struct student stu = {"Tim", 1, 78};
print_struct(stu.name, stu.roll_no,stu.marks);
return 0;
} Marks: 78
}
void print_struct(char name[], int roll_no, int marks)
{
printf("Name: %sn", name);
printf("Roll no: %dn", roll_no);
printf("Marks: %dn", marks);
printf("n");
}

 If a structure contains two-three members then we
can easily pass them to function but what if there
are 9-10 or more members ?
 Certainly passing 9-10 members is a tiresome and
error-prone process. So in such cases instead of
passing members individually, we can pass
structure variable itself.

#include<stdio.h>
/*structure is defined above all functions so it is global. */
struct student
{
char name[20];
char name[20];
int roll_no;
int marks;
};
void print_struct(struct student stu);

OUTPUT
Name: George
Roll no: 10
Marks: 69
int main()
{
struct student stu = {"George", 10, 69};
print_struct(stu);
return 0;
Marks: 69
return 0;
}
void print_struct(struct student stu){
printf("Name: %sn", stu.name);
printf("Roll no: %dn", stu.roll_no);
printf("Marks: %dn", stu.marks);
printf("n");
}

 Although passing structure variable as an argument allows us to pass
all the members of the structure to a function there are some
downsides to this operation.
 Recall that a copy of the structure is passed to the formal argument.
 Recall that a copy of the structure is passed to the formal argument.
If the structure is large and you are passing structure variables
frequently then it can take quite a bit of time which make the
program inefficient.
 Additional memory is required to save every copy of the structure.

#include<stdio.h>
/*structure is defined above all functions so it is global.
*/
struct employee
{
{
char name[20];
int age;
char doj[10]; // date of joining
char designation[20];
};
void print_struct(struct employee *);

int main()
{
struct employee dev = {"Jane", 25, "25/2/2015", "Developer"};
print_struct(&dev);
return 0;
}
}
void print_struct(struct employee *ptr)
{
printf("Name: %sn", ptr->name);
printf("Age: %dn", ptr->age);
printf("Date of joining: %sn", ptr->doj);
printf("Age: %sn", ptr->designation);
printf("n");
}

 To return a structure from a function we must
specify the appropriate return type in the function
definition and declaration.
struct player check_health(struct player p);
{
{
...
}
 This function accepts an argument of type struct
player and returns an argument of type struct
player.

#include<stdio.h>
/*structure is defined above all functions so it is global.
*/
struct player
{
void print_struct(struct player p);
struct player deduct_fees(struct player p);
int main()
{
char name[20];
float height;
float weight;
float fees;
};
int main()
{
struct player p = {"Joe", 5.9, 59, 5000 };
print_struct(p);
p = deduct_fees(p);
print_struct(p);
return 0;
}

struct player deduct_fees(struct player p)
{
p.fees -= 1000;
return p;
}
OUTPUT
Name: Joe
Height: 5.90
Weight: 59.00
}
void print_struct(const struct player p)
{
printf("Name: %sn", p.name);
printf("Height: %.2fn", p.height);
printf("Weight: %.2fn", p.weight);
printf("Fees: %.2fn", p.fees);
printf("n");
}
Weight: 59.00
Fees: 5000.00
Name: Joe
Height: 5.90
Weight: 59.00
Fees: 4000.00

Array of structures
 Self referential structures.

 A pointer to a structure must be defined
before it is pointed to a structure variable
struct student {
char name[50];
char name[50];
int age;
}s1={"Sanju",12};
struct student *p;
p = &s1; //p points to

 The structure members can be accessed in three
ways; two of them use a pointer with standard and
special notation.
 rect1.length //The standard access mechanism that doesn’t use
a pointer.
a pointer.
 (*p).length //Pointer dereferenced with * and then connected to
the member.
 p->length //Uses a special operator, ->, that works only with
structures.

 The structure members can be accessed in three ways;
two of them use a pointer with standard and special
notation.
//The standard access mechanism that doesn’t use a pointer.
printf("Name: %sn", s1.name);
printf("Age: %dn", s1.age);
printf("Age: %dn", s1.age);
//Pointer dereferenced with * and then connected to the member.
printf("Name: %sn",(*p).name);
printf("Age: %dn", (*p).age);
//Uses a special operator, ->, that works only with structures.
printf("Name: %sn",p->name);
printf("Age: %dn", p->age);

#include <stdio.h>
#include <string.h>
int main(void)
{
struct employee
{
short id;
char name[30];
int pay;
int pay;
} emp = {1024, “Steve Wozniak”, 10000}, *p;
p = &emp;
printf(“Emp-id: %hd, Name: %s, Pay: %dn”, emp.id, (*p).name, p->pay);
(*p).id = 4201; /* Updates id */
strcpy(p->name, “Steve Jobs”); /* Updates name */
p->pay = 20000; /* Updates pay */
printf(“Emp-id: %hd, Name: %s, Pay: %dn”, p->id, p->name, p->pay);
return 0;
}

Output:
Emp-id: 1024, Name: Steve Wozniak, Pay: 10000
Emp-id: 4201, Name: Steve Jobs, Pay: 20000

 A structure variable can be passed as function arguments
 This will behave as pass-by-value.
 This mechanism is safe and it protects the original structure
from modification by the function.
from modification by the function.
 However, large structures can consume a lot of memory, so we
may need to pass a pointer to a structure instead of the entire
structure.
 Updating a member’s value using a pointer represents a
memory-efficient technique because the function copies not the
structure (36 bytes) but its pointer (4 bytes).

/* update_pay.c: Uses a pointer to a structure as a function argument to update the structure. */
#include <stdio.h>
struct employee
{
short id;
char name[30];
int pay;
} emp = {1024, “Steve Wozniak”, 10000};
void update_pay(struct employee *f_emp, int f_pay);
int main(void)
{
printf(“Old pay = %dn”, emp.pay);
update_pay(&emp, 20000);
printf(“New pay = %dn”, emp.pay);
return 0;
}

void update_pay(struct employee *f_emp, int f_pay)
{
f_emp->pay = f_pay; /* Updates member pay of emp */
}
OUTPUT:
Old pay = 10000
New pay = 20000

 We used two structure variables, stud1 and stud2, to handle
data of two students.
 This technique won’t work with 500 students.
 C supports an array of structures, whose definition may or may
not be combined with the declaration of the structure.
 The following statement defines an array of type struct student
that can hold 50 sets (or records) of student data.
that can hold 50 sets (or records) of student data.

 Alternatively, you can separate the declaration and definition.
 You can also use typedef to replace struct student with
STUDENT.
 Because stud is an array, its elements are laid out contiguously
in memory.
 The size of each array element is equal to the size of the
structure in memory after accounting for slack bytes.
 Pointer arithmetic can easily be employed here to access each
array element, and using a special notation (->)

 This array can be partially or fully initialized by enclosing the
initializers for each array element in a set of curly braces.
 Each set is separated from its adjacent one by a comma, while
the entire set of initializers are enclosed by outermost braces:

 Each member of each element of this array is accessed by using
a dot to connect the member to its array element.
 You can use scanf to input values to each member using
pointers to these variables (like &stud[i].marks).
 A simple for loop using the array index as the key variable
prints the entire list

#include <stdio.h>
#include <string.h>
struct student
{
int id;
char name[30];
float percentage;
};
};
int main()
{
int i;
struct student record[2];
// 1st student's record
record[0].id=1;
strcpy(record[0].name, "Raju");
record[0].percentage = 86.5;

// 2nd student's record
record[1].id=2;
strcpy(record[1].name, "Surendren");
// 3rd student's record
record[2].id=3;
strcpy(record[2].name, "Thiyagu");
for(i=0; i<3; i++)
{
printf(" Records of STUDENT : %d n", i+1);
printf(" Id is: %d n", record[i].id);
printf(" Name is: %s n", record[i].name);
printf(" Percentage is: %fnn",record[i].percentage);
} return 0;
}

OUTPUT:
Records of STUDENT : 1
Id is: 1
Name is: Raju
Percentage is: 86.500000
Id is: 2
Id is: 2
Name is: Surendren
Id is: 3
Name is: Thiyagu

 Self referential structures

 A structure can have members which point to a structure variable of the same type.
 These types of structures are called self referential structures and are widely used in
dynamic data structures like trees, linked list, etc.
 Syntax to define self referential structure
struct node
{
---
---
---
struct node *next;
};
Here, next is a pointer to a struct node variable.
 It should be remembered that a pointer to a structure is similar to a pointer to any
other variable
 A self referential data structure is essentially a structure definition which includes at
least one member that is a pointer to the structure of its own kind.

struct student
{
char name[20];
int roll;
char gender;
int marks[5];
struct student *next;
};
 This is a self-referential structure where next is a struct student type
structure pointer.
 We will now create two structure variables stu1 and stu2 and initialize
them with values.
 We will then store the address of stu2 in next member of stu1.

void main()
{
struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}, NULL};
struct student stu2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}, NULL};
stu1.next = &stu2;
}
}

 We can now access the members of stu2 using stu1 and next
void main()
{
printf("Name: %sn", stu1.next->name);
printf("Roll: %dn", stu1.next->roll);
printf("Roll: %dn", stu1.next->roll);
printf("Gender: %cn", stu1.next->gender);
for(int i = 0; i < 5; i++)
printf("Marks in %dth subject: %dn",i,stu1.next->marks[i]);
}

 OUTPUT
Name: Max
Roll: 33
Gender: M
Gender: M
Marks in 0th subject: 87

 Suppose we want a different structure variable after stu1,
that is insert another structure variable between stu1 and
stu2. This can be done easily.
void main()
{
struct student stu3 = { "Gasly", 23, 'M', {83, 64, 88, 79, 91},
NULL};
NULL};
st1.next = &stu3;
stu3.next = &stu2;
}

 Now stu1.next stores the address of stu3. And stu3.next has
the address of stu2. We can now access all three structures
using stu1.
printf("Roll Of %s: %dn", stu1.next->name, stu1.next->roll);
printf("Gender Of %s: %cn", stu1.next->next->name,
stu1.next->next->gender);
stu1.next->next->gender);
 OUTPUT
Roll Of Gasly: 23
Gender Of Max: M

Pointers and Structures

In this document

More Related Content

What's hot

Similar to Pointers and Structures

More from Gem WeBlog

Recently uploaded

Pointers and Structures