Scribd
Upload
157 views

C Pointers PDF

Pointers in C allow variables to hold the memory addresses of other variables and data types. Pointers use the asterisk (*) and ampersand (&) operators - * accesses the value at a memory address, while & returns the memory address of a variable. Pointers are useful for passing arguments to functions, returning multiple values from functions, and accessing arrays through a single pointer variable. Pointer arithmetic increments or decrements a pointer by the size of its data type. Pointer-to-pointers allow pointers to hold the addresses of other pointer variables. Proper initialization and boundary checking is important to avoid crashes with pointers.

Uploaded by

Indresh B Rajwade
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
157 views

C Pointers PDF

Pointers in C allow variables to hold the memory addresses of other variables and data types. Pointers use the asterisk (*) and ampersand (&) operators - * accesses the value at a memory address, while & returns the memory address of a variable. Pointers are useful for passing arguments to functions, returning multiple values from functions, and accessing arrays through a single pointer variable. Pointer arithmetic increments or decrements a pointer by the size of its data type. Pointer-to-pointers allow pointers to hold the addresses of other pointer variables. Proper initialization and boundary checking is important to avoid crashes with pointers.

Uploaded by

Indresh B Rajwade
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 14

Pointers in C

Omar Mukhtar
Outline


Review of concepts in previous lectures

Introduction to pointers

Pointers as function arguments

Pointers and arrays

Pointer arithmetic

Pointer-to-pointer
Review and Background


Basic data types
− Place-holders for numeric data

Integer numbers (int, short, long)

Real numbers (float, double)

Characters / symbols codes (char)

Arrays
− A contiguous list of a particular data type

Functions
− Give “name” to a particular piece of code
− Modularization & reuse of code
Pointers


The most useful and tricky concept in C
language
− Other high level languages abstract-out this
concept

The most powerful construct too
− Makes C very fast
− Direct interaction with hardware
− Solves very complicated programming
problems
What are pointers?


Just another kind of “placeholder” to hold
“address” of memory location
− Address is also a number
− Itself resides on some memory location

Memory Address Value


0x8004 ...
0x8008 variable A
129
0x800C ...
0x8010 0x8008 address of A
0x8014 ...
What are pointers?

Declare variables a, b
− int a, b;

Declare a pointer
− int* pa;

Set value of a
− a = 10;

Point pa to address of a
− pa = &a;

Set value of a using pa
− *pa = 12; pa = &b;
Pointer Operators


“address-of” operator: &
− Gets address of a variable

De-referencing operator: *
− Accesses the memory location this pointer
holds address of
Pointers and Functions


A function can be passed arguments using
basic data types
− int prod(int a, int b) { return
a*b; }

How to return multiple values from function?
− void prod_and_sum(int a, int b,
int*p, int* s)
{ *p = a*b; *s = a+b; }
In & Out Arguments of Function


A function may like to pass values and get the
result in the same variables. e.g. a Swap
function.

void swap(int* a, int* b) { int c;
c = *b; *b = *a; *a = c; }

int a = 5; b = 6;

swap(&a, &b);

// a hold 6 and b hold 5 now.
Pointers and Arrays


Since arrays are a contiguous set of variables
in memory, we can access them with pointers

int arr[5];

int *p = &arr[0];

*(p+0) = 1; // arr[0]

*(p+1) = 2; // arr[1]

*(p+2) = 4; // arr[2]

*(p+3) = 8; // arr[3]

...
Pointer Arithmetic

Arithmetic operators work as usual on ordinary
data types.
− int a = 1; a++; // a == 2

It gets a bit complicated when arithmetic
operators are used on pointers

int* p = 0x8004; p++;

What does p hold now? 0x8005???

Compiler knows that p is a pointer to integer
type data, so an increment to it should point to
next integer in memory. Hence 0x8008.
Pointer Arithmetic

So an arithmetic operator increases or
decreases its contents by the size of data type
it points to

int* pi = 0x8004; double* pd =
0x9004; char* pc = 0xa004;

pi++; // pi == 0x8008

pd++; // pd == 0x900c

pc++; // pc == 0xa005

Only '+' and '-' operator are allowed. '*' and '/'
are meaningless.
Pointer-to-Pointer

Pointer variable is just a place-holder of an
address value, and itself is a variable.
− Hence a pointer can hold address of other
pointer variable. In that case it is called a
“double pointer”.

int*p; int **pp; pp = &p;

e.g a function may like to return a pointer
value

void pp_example(int** p) { *p =
0x8004; }

int *p; pp_example(&p);
Pointer Pitfalls

Since pointer holds address of memory
location, it must never be used without proper
initialization.

An uninitialized pointer may hold address of
some memory location that is protected by
Operating System. In such case, de-
referencing a pointer may crash the program.

An initialized pointer does not know the
memory location, it is pointing to is, holds a
valid value or some garbage.

A pointer cannot track boundaries of an array.

You might also like