Web and Mobile Apps Dev

Pointers are the most important and difficult part of C programming language. Most of the bugs and crashes in C programs are caused by pointers.

A pointer is a variable that contains a memory address instead of integers and characters. It often contains the memory address of another variable. For example, an integer variable “x” would corresponce to a pointer variable that contain the memory address of variable “x”.

The memory address of a variable is obtained by the & (and) operator. For example, &x. By using the * (asterisk) operator, the program can indirectly access a variable value through a pointer. It means that the content of a pointer is the variable value. For example, *pointer.

This operator (*) is also used to define a pointer. For example,

int *ptr;

Note that the pointers are declared as integers since memory addresses are formed by several integers.

Here are some interpretation on how to read the C code:

int x; // "x is an integer"
int *ptr; // "ptr is a pointer to an integer"
ptr = &x; // "set ptr to the memory address of x"
*ptr = 5; //"set the contents of ptr to 5"
            or "set the variable name that ptr points to to 5"

The third line is the pointer initialization. The resulting program would produce incorrect behavior if the pointer was declared but not initialized. An uninitialized pointer produces a random memory address rather than a random number for the uninitialized integer.

In the last line, *ptr represents x. It means to set the value of variable x to 5.

The pointers are used for:

• modify the function parameters
• pass of structures as function parameters
• dynamic memory allocation
• Here is the sample code for pointers:

/*
 *
 * pointer.c
 *
 * Program to demonstrate the correct use of pointers
 *
 * by Mark Virtue, 2001.
 *
 */

main() {
 int x;
 int *ptr;

 /*
 * Which of the following statements is a legal and meaningful
 * first step that this program could carry out?
 */

 *ptr = x; // LEGAL, but not meaningful - ptr is not initialized
 &ptr = x; // ILLEGAL - attempting to move ptr in memory
 ptr = &x; // LEGAL and MEANINGFUL - initialize ptr
 ptr = *x; // ILLEGAL and not meaningful - x is not a pointer and it can't point to anything

}

Here is another sample code:

/*
 *
 * pointer2.c
 *
 * Program to demonstrate the correct use of pointers
 *
 * by Mark Virtue, 2001.
 *
 */

#include <stdio.h>

main() {
 float f;
 float *ptr;

 // Assign the value of 3.5 to f without using a statement that begins with "f = "
 ptr = &f;
 *ptr = 3.5;

 printf("The value of f is %fn", f);
}

Here is another example:

/*
 *
 * pointer3.c
 *
 * Program to demonstrate the correct use of pointers
 *
 * by Mark Virtue, 2001.
 *
 */

#include <stdio.h>

main() {
 int x;
 int y;
 char *ptr;

 /*
 * Find out the current memory address of x and y.
 * Note: Do not need to use the pointer "ptr" to do this.
 * Hint: Memory addresses are 32 bit values, so are integers (probably)
 */
 printf("The memory address of x is %pn", &x);
 printf("The memory address of y is %pn", &y);

 /*
 * "ptr" is currently uninitialized
 * Find out the current random character it is pointing to
 * (and the address of this character)
 * Note: This could possibly crash the program
 */
 printf("The current random address in ptr is %pn", ptr);
 printf("The random character ptr is pointing to is %cn", *ptr);

 fflush(stdin);
 getchar();
}

As stated above, the memory addresses are formed by several integers. However, when %d (integer) is placed in the printf() statement, gcc always gave me warning stated that &x and &y, which are referred to as pointers, are “int *” data type. After some research, I concluded that %p is used for output pointers. Also, the random character outputted was unreadable during my compilation test.

One of the reasons that pointers were created is to modify the function parameters during the runtime. A function can’t modify a parameter unless one of the parameters is a pointer. Here is the sample code for using pointer as a function parameter:

/*
 *
 * double.c
 *
 * Program to demonstrate the use of
 * function parameters that are memory addresses
 *
 * by Mark Virtue, 2001.
 *
 */

#include <stdio.h>

double_it(int *n1) {
 *n1 = *n1 * 2;
}

main() {
 int num1;

 printf("Please enter the number: ");
 scanf("%d", &num1);

 double_it(&num1);

 printf("The doubled value is %dn", num1);

 fflush(stdin);
 getchar();

}

Second reason is to convert pointers to structures to make the development process much faster and use less memory. Convert pointers to structures is the same as convert pointers to normal variables. However, to access the fields of a pointer to a structure is different. For example:

struct employee *emp_p;
emp_p.age = 34;

The above lines cannot compile since emp_p is a pointer, not a structure. Below is the correct statements:

struct employee *emp_p;
emp_p->age = 34;

Note that the second line looks like the PHP OOP (Object Oriented Programming) syntax, but it actually is the shorthand version of

(*emp_p).age = 34;

Since there are two operators (* and .), the . (dot) operator comes first, therefore the pointer needs to convert to structure first.

Here is the sample code for the pointers to structures:

/*
 *
 * struct.c
 *
 * Program to demonstrate the use of pointers to structures
 *
 * by Mark Virtue, 2001.
 *
 */

#include <stdio.h>

struct employee {
 char name[31];
 char address[101];
 int age;
 float salary;
};

typedef struct employee emp;

emp read_emp(emp *e) {

 printf("Please enter the age: ");
 scanf("%d", &(e->age));
}

print_emp(emp *e) {
 printf("Age is %dn", e->age);
}

main() {
 emp emp1, emp2;

 read_emp(&emp1);
 emp2 = emp1;
 print_emp(&emp2);

 fflush(stdin);
 getchar();
}