Scribd
Upload
6 views

Lecture Seven

Uploaded by

alvinmwangisir
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
6 views

Lecture Seven

Uploaded by

alvinmwangisir
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

UNIVERSITY OF EMBU

SCHOOL OF PURE AND APPLIED SCIENCES


DEPARTMENT OF MATHEMATICS, COMPUTING & IT

STA 121: PROGRAMMING METHODOLOGY

WRITTEN BY: EDITED BY:


MR JOHN KIRWA

Copyright © UNIVERSITY OF EMBU, AUGUST 2020


All Rights Reserved
LESSON 7: POINTERS
A pointer is a variable that holds a memory address, usually the location of another variable in
memory.
Defining a Pointer Variable
int *iptr;
iptr can hold the address of an int
Pointer Variables Assignment:
int num = 25;
int *iptr;
iptr = #
To access num using iptr and indirection operator *
printf("%d", iptr); /* prints address */
printf("%d", *itptr); /* prints 25 */
Similarly, the following declaration shows:
char *cptr;
float *fptr;
cptr is a pointer to character and fptr is a pointer to float value.

Pointer Arithmetic
Some arithmetic operators can be used with pointers:
- Increment and decrement operators ++, --
- Integers can be added to or subtracted from
pointers using the operators +, -, +=, and -=
Each time a pointer is incremented by 1, it points to the memory location of the next element of
its base type.
If “p” is a character pointer then “p++” will increment “p” by 1 byte.
If “p” were an integer pointer its value on “p++” would be incremented by 4 bytes.

Pointers and Arrays


The array name is the base address of an array
int vals[] = {4, 7, 11};
printf("%d", vals); // displays 0x4a00
printf("%d", vals[0]); // displays 4
Lets takes an example:
int arr[]={4,7,11};
int *ptr = arr;
What is ptr + 1?
It means (address in ptr) + (1 * size of an int)
printf("%d", *(ptr+1)); // displays 7
printf("%d", *(ptr+2)); // displays 11
Array Access
Array notation arr[i] is equivalent to the pointer notation *(arr + i)
Assume the variable definitions
int arr[]={4,7,11};
int *ptr = arr;
Examples of use of ++ and --
ptr++; // points at 7
ptr--; // now points at 4

Character Pointers and Strings


Initialize to a character string.
char* a = “Hello”;
a is pointer to the memory location where ‘H’ is stored. Here “a” can be viewed as a character
array of size 6, the only difference being that a can be reassigned another memory location.
char* a = “Hello”;
a gives the address of ‘H’
*a gives ‘H’
a[0] gives ‘H’
a++ gives the address of ‘e’
*a++ gives ‘e’

Pointers as Function Parameters


A pointer can be a parameter. It works as a reference parameter to allow change to an argument
from within function

#include<stdio.h>

void swap(int *, int *);

int main()
{
int a=10,b=20;
swap(&a, &b);
printf("%d %d", a, b);
return 0;
}

void swap(int *x, int *y)


{
int t;
t = *x;
*x = *y;
*y = t;
}
Pointers to Constants and Constant Pointers
Pointer to a constant: cannot change the value that is pointed at
Constant pointer: address in pointer cannot change once pointer is initialized

Pointers to Structures
We can create pointers to structure variables
struct Student {int rollno; float fees;};
struct Student stu1;
struct Student *stuPtr = &stu1;
(*stuPtr).rollno= 104;
-or-
Use the form ptr->member:
stuPtr->rollno = 104;

Static allocation of memory


In the static memory allocation, the amount of memory to be allocated is predicted and
preknown. This memory is allocated during the compilation itself. All the declared variables
declared normally, are allocated memory statically.

Dynamic allocation of memory


In the dynamic memory allocation, the amount of memory to be allocated is not known. This
memory is allocated during run-time as and when required. The memory is dynamically
allocated using the new operator.

Free store
The free store is a pool of unallocated heap memory given to a program that is used by the
program for dynamic allocation during execution.

Dynamic Memory Allocation


We can allocate storage for a variable while the program is running by using the new operator
To allocate memory of type integer
int *iptr=malloc( sizeof( int ) );
To allocate dynamic structure variables or objects
Student *sptr = malloc( sizeof( struct Student ) );; /* Student is tag name of structure */
Releasing Dynamic Memory
Use delete to free dynamic memory
free iptr;
To free dynamic structure
free Student;

Memory Leak
If the objects, that are allocated memory dynamically, are not deleted using delete, the memory
block remains occupied even at the end of the program. Such memory blocks are known as
orphaned memory blocks. These orphaned memory blocks when an increase in number, bring
adverse effects on the system. This situation is called a memory leak

Self-Referential Structure
The self-referential structures are structures that include an element that is a pointer to another
structure of the same type.
struct node
{
int data;
struct node* next;
};

Related links

The development of C language by Dennis M. Ritchie

DJGPP a complete 32-bit C/C++ development system for Intel 80386 and higher PCs.

List of Free C Compilers and interpreters available on the internet.

https://www.sanfoundry.com/c-programming-examples/

You might also like