CS101x S438A Structures and Pointers Part 1 IIT Bombay PDF

IIT Bombay
Computer Programming
Dr. Deepak B Phatak
Dr. Supratik Chakraborty
Department of Computer Science and Engineering
IIT Bombay
Session: Structures and Pointers Part 1
Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay
Quick Recap of Relevant Topics

IIT Bombay
Structures as collections of variables/arrays/other

structures
Statically declared variables/arrays of structure types
Accessing members of structures
Organization of main memory: locations and addresses
Pointers to variables/arrays of basic data types
Overview of This Lecture

IIT Bombay
Pointers to variables of structure types

Accessing members of structures through pointers
Recall: Memory and Addresses
MAIN
Address (in hexadecimal)

400
10011101
Main memory is a sequence of
401
10111111
physical storage locations
402
10010001
Each location stores 1 byte (8 bits) 403 1 0 1 1 0 1 1 1
404
10010001
Content/value of location
405
10000111
406
11110001
Each physical memory location
407
10000000
identified by a unique address
408
11111111
Index in sequence of memory
00000000
409
locations
11110000
40a
MEMORY
IIT Bombay
Memory for Executing a Program (Process)
STACK SEGMENT
DATA
SEGMENT
CODE SEGMENT
MAIN
Operating system allocates a

part of main memory for use
by a process
Divided into:
Code segment: Stores
executable instructions in
program
Data segment: For
dynamically allocated data
Stack segment: Call stack
MEMORY
IIT Bombay
Structures in Main Memory

IIT Bombay
int main()
{
struct MyStructType {
char z;
int x, y;
};
MyStructType p1;
int a;
Rest of code
return 0;
}
Needs 4 bytes of storage
STACK SEGMENT
a
DATA SEGMENT
CODE SEGMENT
MAIN
int main()
{
char z;
int x, y;
};
MyStructType p1;
int a;
Rest of code
return 0;
}
MEMORY
IIT Bombay

IIT Bombay
int main()
{
char z;
int x, y;
};
MyStructType p1;
int a;
Rest of code
return 0;
}
Needs 1 + 4 + 4,
i.e. 9 bytes of
storage
p1.z
p1.x
p1.y
STACK SEGMENT
a
DATA SEGMENT
CODE SEGMENT
MAIN
int main()
{
char z;
int x, y;
};
MyStructType p1;
int a;
Rest of code
return 0;
}
MEMORY
IIT Bombay
p1.z
p1.x
p1.y
STACK SEGMENT
a
DATA SEGMENT
CODE SEGMENT
MAIN
int main()What is that

{
gap/padding?
char z;Wait for a few
int x, y; slides
};
MyStructType p1;
int a;
Rest of code
return 0;
}
MEMORY
IIT Bombay
10
record of main in call stack
MAIN
int main()
{
STACK SEGMENT
p1.z
p1.x
char z;
p1.y
int x, y;
};
MyStructType p1;
a
int a;
DATA SEGMENT
Rest of code
p1,a: local variables of main
return
0;
SEGMENT
Memory
for p1 and a allocatedCODE
in activation
}
MEMORY
IIT Bombay
11
What Can We Safely Assume About Structures?
No assumptions about
relative layout of different
members within memory
allocated for a structure
p1.z
p1.x
p1.y
STACK SEGMENT
DATA SEGMENT
CODE SEGMENT
MAIN
char z;
int x, y;
};
MyStructType p1;
MEMORY
IIT Bombay
12

p1.z
p1.x
p1.y
STACK SEGMENT
DATA SEGMENT
padding (unused memory locations) after locations
CODE SEGMENT
allocated for different members of
a structure
MAIN
char z;
int x, y;
};
MyStructType p1;
MEMORY
IIT Bombay
13

p1.z
STACK SEGMENT
p1.x
p1.y
DATA SEGMENT
padding (unused memory locations) after locations
CODE SEGMENT
allocated for different members of
a structure
MAIN
char z;
int x, y;
};
MyStructType p1;
MEMORY
IIT Bombay
14

p1.z
p1.x
p1.y
STACK SEGMENT
Memory locations allocated for each

member are
DATA SEGMENT
however contiguous (have consecutive addresses).
E.g., four contiguous locationsCODE
for p1.x,
SEGMENT
four contiguous locations for p1.y
MAIN
char z;
int x, y;
};
MyStructType p1;
MEMORY
IIT Bombay
15
Recall: & and * Operators

IIT Bombay
We used & and * operators with variables of basic data

types
Pointer-to-integer
int a;
data type
int * ptrA;
ptrA = &a;
*ptrA = 10;
16

IIT Bombay

types
Address of (starting location) of
int a;
variable a of type int
int * ptrA;
ptrA = &a;
*ptrA = 10;
17

IIT Bombay

types
int a;
Contents (as int) of memory locations
whose starting address is given by ptrA
int * ptrA;
ptrA = &a;
*ptrA = 10;
18
& and * Operators for Structures

IIT Bombay
We can use & and * operators with variables of

structure types in exactly the same way
int a;
char z; int x, y;
int * ptrA;
};
ptrA = &a;
MyStructType
p1;
*ptrA = 10;
MyStructType * ptrP1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
19

IIT Bombay

Pointer-to-MyStructType
int
a;
data type
char z; int x, y;
int * ptrA;
};
ptrA = &a;
MyStructType
p1;
*ptrA = 10;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
20

IIT Bombay

Address of (starting
int
a;
location)
of variable p1 of struct MyStructType {
char z; int x, y;
int *type
ptrA;
MyStructType
};
ptrA = &a;
MyStructType
p1;
*ptrA = 10;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
21

IIT Bombay

Contents (as MyStructType)
a;
ofint
memory
locations whose
char z; int x, y;
int * ptrA;
starting
address is given by
};
ptrP1
ptrA = &a;
MyStructType
p1;
*ptrA = 10;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
22
Accessing Members Through Pointers

IIT Bombay
Can we access p1.x through

ptrP1?
Yes, and by the obvious way:
E.g. (*ptrP1).x = 1 + (*ptrP1).y;
char z; int x, y;
};
MyStructType p1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
23

IIT Bombay

ptrP1?
E.g. (*ptrP1).x = 1 + (*ptrP1).y;
*ptrP1 is an object of
type MyStructType
char z; int x, y;
};
MyStructType p1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
24

IIT Bombay

ptrP1?
E.g. (*ptrP1).x = 1 + (*ptrP1).y;
char z; int x, y;
};
MyStructType p1;
(*ptrP1).x is the member x of ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
the object (*ptrP1) of

type MyStructType
25

IIT Bombay

ptrP1?
E.g. (*ptrP1).x = 1 + (*ptrP1).y;
C++ provides the -> operator for

above situations
E.g. ptrP1->x = 1 + ptrP1->y;
char z; int x, y;
};
MyStructType p1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
ptrVar->memberName is equivalent to (*ptrVar).memberName

26

IIT Bombay
char z; int x, y;
};
MyStructType p1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
(*ptrP1).x = 1 + (*ptrP1).y;
char z; int x, y;
};
MyStructType p1;
ptrP1 = &p1;
ptrP1->z = c; ptrP1->x = 2;
ptrP1->y = 3;
ptrP1->x = 1 + ptrP1->y;
27

IIT Bombay
char z; int x, y;
char z; int x, y;
};
Functionally equivalent}; program fragments
MyStructType p1;
MyStructType p1;
ptrP1 = &p1;
ptrP1 = &p1;
*ptrP1 = {c, 2, 3};
ptrP1->z = c; ptrP1->x = 2;
(*ptrP1).x = 1 + (*ptrP1).y;
ptrP1->y = 3;
ptrP1->x = 1 + ptrP1->y;
28
Summary
IIT Bombay
Pointers to variables of structure data types

Use of & and * operators with structures
Use of -> operator to access members of structures
through pointers.
29

CS101x S438A Structures and Pointers Part 1 IIT Bombay PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

CS101x S438A Structures and Pointers Part 1 IIT Bombay PDF

Hochgeladen von

Copyright:

Verfügbare Formate

IIT Bombay

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Quick Recap of Relevant Topics

Structures as collections of variables/arrays/other

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Overview of This Lecture

Pointers to variables of structure types

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Recall: Memory and Addresses

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Address (in hexadecimal)

Memory for Executing a Program (Process)

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Operating system allocates a

Structures in Main Memory

Needs 4 bytes of storage

Structures in Main Memory

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Structures in Main Memory

Structures in Main Memory

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Structures in Main Memory

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

int main()What is that

Structures in Main Memory

record of main in call stack

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

What Can We Safely Assume About Structures?

What Can We Safely Assume About Structures?

What Can We Safely Assume About Structures?

What Can We Safely Assume About Structures?

Memory locations allocated for each

Recall: & and * Operators

We used & and * operators with variables of basic data

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Recall: & and * Operators

We used & and * operators with variables of basic data

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Recall: & and * Operators

We used & and * operators with variables of basic data

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

& and * Operators for Structures

We can use & and * operators with variables of

& and * Operators for Structures

We can use & and * operators with variables of

& and * Operators for Structures

We can use & and * operators with variables of

& and * Operators for Structures

We can use & and * operators with variables of

Accessing Members Through Pointers

Can we access p1.x through

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Accessing Members Through Pointers

Can we access p1.x through

Accessing Members Through Pointers

Can we access p1.x through

the object (*ptrP1) of

Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, IIT Bombay

Accessing Members Through Pointers

Can we access p1.x through

C++ provides the -> operator for

ptrVar->memberName is equivalent to (*ptrVar).memberName

Accessing Members Through Pointers