Module 02 Pointers in C

See through C
Module 2
Pointers
Tushar B Kute
http://tusharkute.com

Objectives
Be able to use arrays, pointers, and strings in
C programs
Be able to explain the representation of these
data types at the machine level, including
their similarities and differences
http://www.tusharkute.com 2

Arrays in C
No bounds checking!
Allowed – usually causes no error
array[10] may overwrite b
Unlike Java, array size in declaration
int array[10];
int b;
array[0] = 3;
array[9] = 4;
array[10] = 5;
array[-1] = 6;
Compare: C: int array[10];
Java: int[] array = new int[10];
All elements of same type – homogenous
First element (index 0)
Last element (index size - 1)

Array Representation
Homogeneous → Each element same size – s bytes
 An array of m data values is a sequence of m×s bytes
 Indexing: 0th value at byte s×0, 1st value at byte s×1, …
m and s are not part of representation
 Unlike in some other languages
 s known by compiler – usually irrelevant to programmer
 m often known by compiler – if not, must be saved by
programmer
a[0]
a[1]
a[2]
0x1000
0x1004
0x1008
int a[3];

Array Representation
char c1;
int a[3];
char c2;
int i;
c1
a[0]
a[1]
a[2]
i
0x1000
0x1004
0x1008
0x100C
0x1014
c20x1010
Could be optimized
by making these
adjacent, and
reducing padding
(by default, not)
Array aligned by
size of elements

Array Sizes
What is
sizeof(array[3])?
sizeof(array)?
int array[10];
4
40
returns the size of
an object in bytes

Multi-Dimensional Arrays
int matrix[2][3];
matrix[1][0] = 17;
matrix[0][0]
matrix[0][1]
matrix[0][2]
0x1000
0x1004
0x1008
matrix[1][0]
matrix[1][1]
matrix[1][2]
0x100C
0x1010
0x1014
Recall: no bounds checking
What happens when you write:
matrix[0][3] = 42;
“Row Major”
Organization

Sample Program
#include<stdio.h>
int main()
{
int arr[10], c;
printf(“Enter 10 elements: “);
for(c=0;c<10;c++)
scanf(“%d”,&arr[c]);
printf(“Array elements are: “);
for(c=0;c<10;c++)
printf(“n%d”,arr[c]);
}

Exercise Programs
Program-1
 Write a program to input 10 elements from user
and find addition of all the numbers.
Program-2
 Write a program to input 5 numbers from keyboard
and find greatest among all the elements.
Program-3
 Write a program input 10 array elements and
separate odd and even numbers from the array.

Memory Addresses
Storage cells are typically viewed as being
byte-sized
 Usually the smallest addressable unit of memory
• Few machines can directly address bits individually
 Such addresses are sometimes called
byte-addresses
Memory is often accessed as words
 Usually a word is the largest unit of memory access
by a single machine instruction
• CLEAR’s word size is 8 bytes (= sizeof(long))
 A word-address is simply the byte-address of the
word’s first byte

Pointers
Why Pointers?
Advantages?
Disadvantages?

Pointers
Special case of bounded-size natural numbers
 Maximum memory limited by processor word-size
 232 bytes = 4GB, 264 bytes = 16 exabytes
A pointer is just another kind of value
 A basic type in C
int *ptr;
The variable “ptr” is a pointer to an “int”.

Pointer Operations in C
Creation
& variable Returns variable’s memory address
Dereference
* pointer Returns contents stored at address
Indirect assignment
* pointer = val Stores value at address
Of course, still have...
Assignment
pointer = ptr Stores pointer in another variable

Using Pointers
int i1;
int i2;
int *ptr1;
int *ptr2;
i1 = 1;
i2 = 2;
ptr1 = &i1;
ptr2 = ptr1;
*ptr1 = 3;
i2 = *ptr2;
i1:
i2:
ptr1:
0x1000
0x1004
0x1008
…
ptr2:
…
0x100C
0x1010
0x1014
1
2
0x1000
0x1000
3
3

Using Pointers (cont.)
Type check warning: int_ptr2 is not an int
int1 becomes 8
int int1 = 1036; /* some data to point to */
int int2 = 8;
int *int_ptr1 = &int1; /* get addresses of data */
int *int_ptr2 = &int2;
*int_ptr1 = int_ptr2;
*int_ptr1 = int2;
What happens?

Using Pointers (cont.)
Type check warning: *int_ptr2 is not an int *
Changes int_ptr1 – doesn’t change int1
int int1 = 1036; /* some data to point to */
int int2 = 8;
int *int_ptr1 = &int1; /* get addresses of data */
int *int_ptr2 = &int2;
int_ptr1 = *int_ptr2;
int_ptr1 = int_ptr2;
What happens?

Pointer Arithmetic
pointer + number pointer – number
E.g., pointer + 1 adds 1 something to a pointer
char *p;
char a;
char b;
p = &a;
p += 1;
int *p;
int a;
int b;
p = &a;
p += 1;In each, p now points to b
(Assuming compiler doesn’t
reorder variables in memory)
Adds 1*sizeof(char) to
the memory address
Adds 1*sizeof(int) to
the memory address
Pointer arithmetic should be used cautiously

The Simplest Pointer in C
Special constant pointer NULL
 Points to no data
 Dereferencing illegal – causes segmentation fault
 To define, include <stdlib.h> or <stdio.h>

Generic Pointers
void *: a “pointer to anything”
Lose all information about what type of thing
is pointed to
 Reduces effectiveness of compiler’s type-checking
 Can’t use pointer arithmetic
void *p;
int i;
char c;
p = &i;
p = &c;
putchar(*(char *)p);
type cast: tells the compiler to
“change” an object’s type (for
type checking purposes – does
not modify the object in any way)
Dangerous! Sometimes
necessary…

Pass-by-Reference
void
set_x_and_y(int *x,
int *y)
{
*x = 1001;
*y = 1002;
}
void
f(void)
{
int a = 1;
int b = 2;
set_x_and_y(&a,&b);
}
1
2
a
b
x
y
1001
1002

Arrays and Pointers
Dirty “secret”:
Array ≈ pointer to the initial
(0th) array element
a[i] ≡ *(a+i)
An array is passed to a function
as a pointer
 The array size is lost!
Usually bad style to interchange
arrays and pointers
 Avoid pointer arithmetic!
Really int *array
int
foo(int array[],
unsigned int size)
{
… array[size - 1] …
}
int
main(void)
{
int a[10], b[5];
… foo(a, 10)… foo(b, 5) …
}
Must explicitly
pass the size
Passing arrays:

Arrays and Pointers
int a[]={4,5,1,2,8,9,3,0,7,6};
int *p, i;
p = a; // points first element.
//p = &a[0];
printf("nArray elements are: n");
for(i=0;i<10;i++)
{
printf(" %dn", *p);
p++;
}

Passing arrays to functions
Arrays can be passed to the functions as
parameters.
In such cases the arrays and pointers are not
differentiated.
e.g.
int print(int *a, int c)
{
int i;
for(i=0;i<c;i++,a++)
printf("%dn",*a);
}

Returning pointers from functions
Pointer can be the return type of the function.
It is used for returning multiple values from
function.
e.g.
int * increment(int *a, int c)
{
int i, *p;
p = a;
for(i=0;i<c;i++,a++)
*a = *a + 1;
return p;
}

Call by value vs. reference
Call by value Call by reference
The function is called by
directly passing value of
variable as argument
The function is called by
directly passing address of
variable as argument
We need to declare a general
variable as function argument
We need to declare a pointer
variable as argument.
Calling function by value does
not changes actual values of
variables
Calling function by reference
changes actual values of
variables
It is a slow way of calling
function as we are calling it by
passing value
It is a fast way of calling
function as we are calling it by
passing address of a variable

Example-2:
int swap1(int x, int y)
{
int t;
t = x;
x = y;
y = t;
}
int swap2(int *x, int *y)
{
int t;
t = *x;
*x = *y;
*y = t;
}

Pointer to Pointer (char **argv)
Passing arguments to main:
int
main(int argc, char **argv)
{
...
}
an array/vector of
char *
Recall when passing an
array, a pointer to the
first element is passed
size of the argv array/vector
Suppose you run the program this way
UNIX% ./program hello 1 2 3
argc == 5 (five strings on the
command line)

char **argv
argv[0]
argv[1]
argv[2]
0x1000
0x1008
0x1010
argv[3]
argv[4]
0x1018
0x1020
“./program”
“hello”
“1”
“2”
“3”
These are strings!!
Not integers!

Thank you
This presentation is created using LibreOffice Impress 3.6.2.2

Module 02 Pointers in C

More Related Content

What's hot (20)

Similar to Module 02 Pointers in C (20)

More from Tushar B Kute (20)

Recently uploaded (20)

Module 02 Pointers in C