Pointers

2009-05-11T14:34:32Z

81.77.128.31: /* Pointer Arithmetic */

This page contains examples of pointers. These examples assume the reader has the following knowledge: compiling C programs, variable creation and assignment, arrays, functions, basic I/O and an understanding of computer memory layout. These examples build from simple to more complex.

==Basic Pointers==

===Creating, initializing and assigning===
This example shows simple pointer creation, assignment and dereference.
<source lang="c">
#include <stdio.h>

/*Example showing simple pointer assignment operations.
*/
int main(int argc, char *argv[])
{
int *intPtr1;
int *intPtr2;

int a = 5;
int b = 10;

printf("\nBefore Initializing pointers.");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d\n", intPtr2, *intPtr2);

/*Initialize the pointers*/
intPtr1 = NULL;
intPtr2 = NULL;

printf("\nAfter Initializing pointers to NULL");
printf("\nintPtr1: %d", intPtr1);
printf("\nintPtr2: %d\n", intPtr2);

intPtr1 = &a;
intPtr2 = &b;

printf("\nAfter pointing intPtr1 to the address of 'a' and "
"\npointing intPtr2 to the address of 'b'\n");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d", intPtr2, *intPtr2);
printf("\na: %d, b: %d\n", a, b);

*intPtr1 = 7;
*intPtr2 = 12;

printf("\nAfter assigning 7 into the memory location pointed to by "
"intPtr1 \n and assigning 12 into the memory location pointed to by intPtr2");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d", intPtr2, *intPtr2);
printf("\na: %d, b: %d\n", a, b);

intPtr1 = intPtr2;
printf("\nAfter storing the memory location of intPtr2 into intPtr1. \nMakes intPtr2 now point to variable 'b' as well");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d", intPtr2, *intPtr2);
printf("\na: %d, b: %d\n", a, b);

*intPtr2 = 10;
printf("\nAfter assigning '10' into the memory location pointed to by intPtr1 and intPtr2");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d", intPtr2, *intPtr2);
printf("\na: %d, b: %d\n", a, b);

b = 25;
printf("\nAfter assigning '25' into the variable 'b'");
printf("\nintPtr1: %d, *intPtr1: %d", intPtr1, *intPtr1);
printf("\nintPtr2: %d, *intPtr2: %d", intPtr2, *intPtr2);
printf("\na: %d, b: %d\n", a, b);
}
</source>

===Basic Pointers with Functions===
This example shows how pointers can be used in functions. The code gives the reader some questions to consider and answer on their own.
<source lang="c">
#include <stdio.h>

/*Example showing how pointers are used in functions.
*/

/* Only swaps the values within this fuction */
void badSwap(int c, int d);
void goodSwap(int *c, int *d);
void decrement(int *p);
void increment(int *p);

void badSwap(int c, int d) {
int temp = 0;

printf("\nbadSwap");

printf("\n\tBefore swapping in badSwap");
printf("\n\ttemp: %d, c: %d, d: %d", temp, c, d);

temp = c;
c = d;
d = temp;

// Why won't this work?
printf("\n\tAfter swapping in badSwap");
printf("\n\ttemp: %d, c: %d, d: %d", temp, c, d);
}

/* Swaps the values using pointers*/
void goodSwap(int *c, int *d) {
int temp = 0;

printf("\ngoodSwap");

printf("\n\tBefore swapping in goodSwap");
printf("\n\ttemp: %d, c: %u, *c: %d, d: %u, *d: %d", temp, c, *c, d, *d);

temp = *c;
*c = *d;
*d = temp;

// Why does this work?
printf("\n\tAfter swapping in goodSwap");
printf("\n\ttemp: %u, c: %u, *c: %d, d: %u, *d: %d", temp, c, *c, d, *d);
}

void badSwap2(int *c, int *d) {
int *temp = NULL;

printf("\nbadSwap2");

printf("\n\tBefore swapping in badSwap2");
printf("\n\ttemp: %d, c: %u, *c: %d, d: %u, *d: %d", temp, c, *c, d, *d);

temp = c;
c = d;
d = temp;

// c and d have changed values! Great! Why won't their values be changed when
// we return?
printf("\n\tAfter swapping in badSwap2");
printf("\n\ttemp: %u, c: %u, *c: %d, d: %u, *d: %d", temp, c, *c, d, *d);
}

/*Decrements the value pointed to by p */
void decrement(int *p) {
// What we want *p = *p - 1;
(*p)--;
// What does *p-- do?
}

/*Increments the value pointed to by p*/
void increment(int *p) {
int temp = p;
// What we want *p = *p + 1
(*p)++;
// What does *p++ do?

printf("\nincrement");
printf("\n\t p: %u, *p: %u, &p: %u\n", p, *p, &p);

p = p + 1;
printf("\n\t p: %u, *p: %u, &p: %u\n", p, *p, &p);
p = temp;

p = *p + 1;
printf("\n\t p: %u, &p: %u\n", p, &p);
p = temp;

p = &p + 1;
printf("\n\t p: %u, *p: %u, &p: %u\n", p, *p, &p);
p = temp;

*p = p + 1;
printf("\n\t p: %u, *p: %u, &p: %u\n", p, *p, &p);
p = temp;

*p = &p + 1;
printf("\n\t p: %u, *p: %u, &p: %u\n", p, *p, &p);
p = temp;
}

int main(int argc, char *argv[]) {
int *aPtr;
int *bPtr;

int a = 5;
int b = 10;

/*Initialize the pointers*/
aPtr = &a;
bPtr = &b;

/*Before call to badSwap*/
printf("\nBefore call to badSwap");
printf("\n\taPtr: %u, *aPtr: %d", aPtr, *aPtr);
printf("\n\tbPtr: %u, *bPtr: %d", bPtr, *bPtr);
printf("\n\ta: %d, b: %d\n", a, b);

badSwap(a, b);
/* After call to badSwap */
printf("\n\nAfter call to badSwap");
printf("\n\taPtr: %u, *aPtr: %d", aPtr, *aPtr);
printf("\n\tbPtr: %u, *bPtr: %d", bPtr, *bPtr);
printf("\n\ta: %d, b: %d\n", a, b);

/*Before call to goodSwap*/
printf("\nBefore call to goodSwap");
printf("\n\taPtr: %u, *aPtr: %d", aPtr, *aPtr);
printf("\n\tbPtr: %u, *bPtr: %d", bPtr, *bPtr);
printf("\n\ta: %d, b: %d\n", a, b);

goodSwap(aPtr, bPtr);
goodSwap(&a, &b);

/* After call to goodSwap */
printf("\n\nAfter call to goodSwap");
printf("\n\taPtr: %u, *aPtr: %d", aPtr, *aPtr);
printf("\n\tbPtr: %u, *bPtr: %d", bPtr, *bPtr);
printf("\n\ta: %d, b: %d\n", a, b);

badSwap2(aPtr, bPtr);
/* After call to badSwap2*/
printf("\n\nAfter call to badSwap2");
printf("\n\taPtr: %u, *aPtr: %d", aPtr, *aPtr);
printf("\n\tbPtr: %u, *bPtr: %d", bPtr, *bPtr);
printf("\n\ta: %d, b: %d\n", a, b);

increment(&a);
return 0;
}

</source>

==Advanced Pointers==
This section describes how to use pointers to access dynamically allocated memory, point to structures, point to other pointers, point to functions, and point to void.

===Pointers with Malloc===
This example show how pointers can be used with malloc to point to blocks of memory.

<source lang="c">
#include <stdlib.h>
#include <stdio.h>

#define NUM_ALPHA 26

typedef unsigned char uchar;
typedef unsigned int uint;

/*
* Fills the data pointed to by cPtr with the alphabet.
*/
void fillWithAlpha(uchar *cPtr, int size);

void printDataAsChar(uchar *cPtr, int size);

/* This function shows how to malloc data. It shows that data might
* be zero upon initialization, but it is not guaranteed to be 0.
* */
void mallocExample();

/* This function shows malloc data can be passed to a function.
*/
void mallocWithFunction();

int main(int argc, char **argv) {
mallocExample();
mallocWithFunction();
return 0;
}

void mallocExample() {
/* Using malloc */
uint size, i;
printf("\n Enter the desired size: ");
scanf("%d", &size);
uchar *data;
/* Check to make sure a NULL pointer wasn't returned from malloc */
if ((data = (uchar*) malloc(size)) == NULL)
exit(1);

/* Raw data after first malloc. Not guaranteed to be initialized*/
printf("\n After first malloc");
for (i = 0; i < size; i++)
printf("\n [%d]: %d", i, data[i]);

/* Fill */
for (i = 0; i < size; i++)
data[i] = i;

/* After fill */
printf("\n After fill");
for (i = 0; i < size; i++)
printf("\n [%d]: %d", i, data[i]);

/* When data is no longer needed it MUST be freed */
free(data);

if ((data = (uchar*) malloc(size)) == NULL)
exit(1);
/* Raw data after second malloc. Shows how there can be stuff 'left over'
* in memory after malloc call*/
printf("\n Raw data after malloc");
for (i = 0; i < size; i++)
printf("\n [%d]: %d", i, data[i]);

free(data);
}

void mallocWithFunction() {
uint size;
printf("\n Enter the desired size: ");
scanf("%d", &size);
uchar *data;
if ((data = (uchar*) malloc(size)) == NULL)
exit(1);
printDataAsChar(data, size);
fillWithAlpha(data, size);
printDataAsChar(data, size);

}

void fillWithAlpha(uchar *cPtr, int size) {
int i;
for (i = 0; i < size; i++)
cPtr[i] = 'a' + i%NUM_ALPHA;
}

void printDataAsChar(uchar *cPtr, int size) {
int i;
for (i = 0; i < size; i++)
printf("[%d]: %c \n", i, cPtr[i]);
}

</source>

=== Pointers to Structs ===
TODO
=== Double Pointers ===
TODO
=== Triple Pointers ===
TODO
=== Quadruple Pointers ===
TODO
=== Function Pointers ===
TODO
=== Void Pointers ===
TODO

==Pointer Arithmetic==
TODO

==Advanced Pointers with Arrays==
Shows how arrays and pointers can be treated the same.
Example: Creating an array structure with pointers.
Example: Using pointer arithmetic to index array
Example: Using pointers to traverse array.
Example: Passing arrays to functions using pointers

==Function Pointers==

[[Category:C source code examples]]

IdeaWazaWiki - User contributions [en]

Pointers