#08 (06/25/2025)

Pointer Manipulation

Address operator &

When a C compiler reads your source code, it maps each variable defined in the code to an appropriate location in RAM that holds the value of that variable.

#include <stdio.h>
int main()
{
  float a =20.0, b=50.0;
  float *pa, *pb;
  pa=&a; pb=&b;
  printf("%f %f\n", a, b);
  printf("%f %f\n", *pa, *pb);
  return 0;
}

Memory map of a fictitious machine:

Variable name	Machine absolute address	Contents
…	100	…
…	101	…
a	102	20.0
…	…	…
b	150	50.0
…	151	…
…	…	…
pa	200	102
…	…	…
pb	220	150

In this fictitious machine, the variable a is mapped to (absolute) memory location of 102 in RAM which holds the value of 20.0. Similarly, the variable b is mapped to memory location of 150 that holds the value of 50.0.

You can find out the memory location (address) that holds the value of a given variable by placing an & (ampersand, called the address operator) in front of the variable name. Thus in the example above, a represents 20.0 and &a represents 102.

Example

#include <stdio.h>
int main()
{
  int a=10;
  printf("Address of a=%d\n", &a);
  return 0;
}

You can use %p instead of %d to display the memory address in hexadecimal mode.

#include <stdio.h>
int main()
{
  int a=10;
  printf("Address of a=%p\n", &a);
  return 0;
}

Examine the following:

#include <stdio.h>
int main()
{
  int a[]={100,2,-56};
  printf("%p\n", &a[0]);
  printf("%p\n", &a[1]);
  printf("%p\n", &a[2]);
  return 0;
}

Note that the address of adjacent component is incremented by 4 bytes which implies that the C compiler stores an integer variable in 4 bytes.

#include <stdio.h>
int main()
{
  double a[]={100,2,-56};
  printf("%p\n", &a[0]);
  printf("%p\n", &a[1]);
  printf("%p\n", &a[2]);
  return 0;
}

In the example above, it is seen that the C compiler stores double precision (double) numbers in 8 bytes.

Pointer

A pointer is a variable just like a above. The only difference is that it stores the "address of another variable." So if pa is a pointer variable, the content of pa is not like 20.0 or 50.0 but like 102 or 150 in the example above.

You must declare a pointer variable just like you declare an integer variable.

#include <stdio.h>
int main()
{
  float a=20.0;
  float *pa;

  pa=&a;

  printf("%p\n", pa);
  printf("%p\n", &a);

  return 0;
}

In the program above, float *pa¹ declares pa as a pointer. Note that the value that a pointer holds is always an integer (memory address location) so the type of a pointer (float in the example above) merely implies that the variable pointed by the pointer pa is of float type.

Sometimes within the program you may want to examine what values the pointer actually refers to, i.e. you want to know the content of the variable pointed by the pointer. Let's look at the following program:

#include <stdio.h>
int main()
{
  float a=20.0;
  float *pa;

  pa=&a;

  printf("%f\n", *pa);
  printf("%f\n", a);
  return 0;
}

As seen in the program above, * (asterisk - known as the de-referencing operator) before the variable works the same way as using a directly ²

So if pa is a pointer pointing to a floating variable a, the use of a and *pa within a program is identical:

#include <stdio.h>
int main()
{
  float a=20.0;
  float *pa=&a;

  a=30.0;
  *pa = 40.0;
  printf("%f\n", *pa);
  printf("%f\n", a);
  return 0;
}

This way, one can effectively change the content of a without directly mentioning a (more later).

The C language uses pointers extensively for the following reasons:

Arguments in function calls can be modified using pointers (discussed later).
In general, it is faster to use pointers to move data around.
You can directly control hardware with pointers (dangerous !).

The disadvantage of using pointers includes

The concept of pointers may be hard to understand first.
With abusing/misusing pointers, it's easy to crash the machine.

Run the following code to verify that *pa and a are the same.

#include <stdio.h>
int main()
{
  float a=10.0,b=20.5;
  float *pa, *pb;

  pa=&a; pb=&b;

  printf("Address of a=%p\n", &a);
  printf("Address of b=%p\n", &b);
  printf("\n");
  printf("Pointer pa=%p\n", pa);
  printf("Pointer pb=%p\n", pb);
  printf("\n");
  printf("Value pointed by pa=%f\n",*pa);
  printf("Value pointed by pb=%f\n",*pb);
  return 0;
}

Here is one of the biggest reasons to use pointers

Suppose you want to write a function that takes a variable and multiply 10 by that variable.

#include <stdio.h>

void tentimes(float a)
{
a = 10.0*a;
}

int main()
{

 float b=20;
 tentimes(b);
 printf(" b = %f\n", b);
 return 0;
}

This program will not work as intended.

In this example, suppose we want to write a function that takes two variables as arguments and exchange the values of the two variables. You might write a program like

#include <stdio.h>

void swap(float x, float y)
{
 float tmp;
 tmp = x;
 x = y;
 y = tmp;
}

int main()
{
 float a=10.0, b=50.0;

 printf("Old a = %f and old b = %f\n",a,b);

 swap(a, b);

 printf("New a = %f and new b = %f\n", a,b);

 return 0;
}

Unfortunately this program does not work as expected either. The way C handles function arguments is such that when a function is called with an argument, a copy of the value of the argument is passed to the function and the actual argument variable is never altered. This is not a bug but a feature !!!

YOU CANNOT CHANGE THE VALUE OF ARGUMENTS PASSED BY FUNCTIONS. This is a feature of C. When a function is called in a C program, a copy of the argument is passed to the function (call by value) so that the argument variable is never changed.

So here is a corrected program:

#include <stdio.h>

void swap(float *pa, float *pb)
{
 float tmp;
 tmp=*pa;
 *pa=*pb;
 *pb=tmp;
}

int main()
{
 float a=10.0, b=50.0;

 printf("Old a = %f and old b = %f\n",a,b);

 swap(&a,&b);

 printf("New a = %f and new b = %f\n", a,b);

 return 0;
}

In the example above, the addresses of variables, a and b, are passed as the arguments of the function swap. You can then access to the location (address) directly and alter the value at that location by de-referencing (*).

Another example:

#include <stdio.h>
void twice(float a)
{
  a = 2.0 * a;
}

int main()
{
 float a = 20.0;
 twice(a);
 printf("a= %f\n", a);
 return 0;
}

The function, twice, is supposed to double the argument variable so you expect that the program above prints 40. Unfortunately this is not the case.

Corrected program:

#include <stdio.h>
void twice(float *pa)
{
 *pa = 2.0* *pa;
}
int main()
{
  float a = 20.0;
  twice(&a);
  printf("a = %f\n",a);
  return 0;
}

Summary

The following usage of pointers is illegal:
#include <stdio.h> int main() { int a=3, b=2,*pa=&a, *pb=&b; &b = pa; pa = a; *pa = pb; pa = *pb; return 0; }
- &b = pa is invalid as the address of variable b cannot be changed.
- pa=a is invalid because pa is a pointer and a is not.
- *pa = pb is invalid because *pa and pb are of different types.
- pa = *pb is invalid as *pb and pa are of different types.
The asterisk (*) in C has the following meanings:
1. Multiplication if used as a binary operator (a*b).
2. The value at the address contained in a pointer if used as a unary operator (*pa).
3. Declaration of a variable as a pointer used in the declaration statement (int *pa).
The ampersand symbol (&) in C has the following meanings:
1. The address of a variable if used as a unary operator (&a).
2. Logical AND if used as a binary operator (a==1.0 && b==2.0).
3. Bitwise AND between two binary numbers (a & b).
Pointers must be used if the values of arguments in a function need to be changed.

Pointers can be incremented or decremented just as any other variables. This operation is almost always performed for arrays as will be explained later. The difference between increment of pointers and increment of regular variables is that the value of increment for the pointer depends on the type of the variable the pointer is pointing to.

#include <stdio.h>
int main()
{
	float  a[3]={1.0, 2.0, 3.0}, *pa=&a[0];
	double b[3]={1.2345670, 2.009876555, 3.14159265}, *pb=&b[0];


	printf("float  %p %p %p\n", pa, pa+1, pa+2);
	printf("double %p %p %p\n", pb, pb+1, pb+2);

	return 0;

}

Note that double precision variables occupy more memory locations (8 bytes) than single precision variables (4 bytes). Hence the increment of double precision pointers is larger than the one of single precision pointers even though the increment in the program is "1."

Pointers and arrays

When an array is declared as

#include <stdio.h>

int main()
{
 int a[3]={1, 2, 3};
 return 0;
}

the compiler actually interprets "a" as a pointer and reserves appropriate memory space.

So an array "a" is actually a pointer to the 0-th element of the array while a[0], a[1] and a[2] act just like regular variables.

The content of a is the address which points to a[0].

Since it is a pointer, dereferencing the array name ("*a") will give the 0-th element of the array, i.e. a[0]. This gives us a range of equivalent notations for array access. In the following examples, a is an array.

Array access	Pointer equivalent
a[0]	*a
a[1]	*(a+1)
a[2]	*(a+2)

Array name (e.g. a) = Pointer

Array element (e.g. a[3])= Regular variable

So a[i] and *(a+i) are identical just like &a[i] and (a+i) are identical. An increment of a by i (i.e. a+i) means that the pointer is advanced to the memory location at a + i ×4 (for integer and float), not by i bytes.

Execute the following program and examine the result:

#include <stdio.h>

int main()
{
 float a[3]={1.0, 2.0, 3.0};
 printf("%f\n", *a);
 printf("%f\n", a[0]);
 printf("\n");
 printf("%f\n", *(a+2));
 printf("%f\n", a[2]);
 return 0;
}

Since an array is like a pointer, we can pass an array to a function, and modify elements of that array. Here is an example:

#include <stdio.h>
void twice(float *a)
{
 int i;
 for (i = 0; i < 3; i++)
 a[i] = 2 * a[i];
}

int main()
{
 float b[3] = {1.0, 2.0, 3.0};
 int i;
 twice(b);
 for (i = 0; i < 3; i++) printf("%f\n", b[i]);
 return 0;
}

The program above is to use a function that takes an array as an input and doubles all the elements in that array. When we discussed pointers, we noted that the only way to modify the argument in a function is to use a pointer, instead of the variable itself. This principle also works for arrays as the name of an array IS a pointer. Therefore, when passing an array to a function, you don't have to add "&" before the array name.

The following program does the same effect as the one above.

#include <stdio.h>
void twice(float a[3])
{
 int i;
 for (i = 0; i < 3; i++)
  a[i]=2*a[i];
}

int main()
{
	float b[3] = {1.0, 2.0, 3.0};
	int i;
	twice(b);
	for (i = 0; i < 3; i++) printf("%f\n", b[i]);
        return 0;
}

Summary

When a compiler sees an array, it reserves consecutive memory locations. Using a pointer is faster and more efficient to move a block of data from one location to another.
A function can take an array as an argument and can modify the contents of the array.

Misc. notes

How can you print a double quotation character (") ?


#include <stdio.h>
int main()
{
printf("\" is a double quotation character.\n");
return 0;
}

printf options


#include <stdio.h>
int main()
{
float a=3.14;

printf("%f\n",a);
printf("%10f\n",a);
printf("%20f\n",a);
printf("%30f\n",a);

printf("%10.3f\n",a);
printf("%10.4f\n",a);
printf("%10.5f\n",a);
printf("%10.6f\n",a);
return 0;
}

What is a=b=20 ?

#include <stdio.h>

int main()
{
float a, b;
printf("%f\n", a=20.0);

b=a=30.0;

printf("%d\n", a==20.0);
return 0;
}

a=b=20;

Cast operators

int < float < double

#include <stdio.h>
int main()
{
  int a=3, b=5;
  
  printf("%f\n", a/b);
  return 0;
}

#include <stdio.h>
int main()
{
  int a=3, b=5;
  
  printf("%f\n", 1.0*a/b);
  return 0;
}

#include <stdio.h>
int main()
{
  int a=3, b=5;
  
  printf("%f\n", a/b*1.0);
  return 0;
}

A cast operator (an operator to allow to change the type of a variable to a specified type temporarily):

#include <stdio.h>
int main()
{
  int a=3, b=5;
  
  printf("%f\n", (float)a/b);
  return 0;
}

Piping
```
$ a.out | more
```
A counter variable used in for statements must be declared as an integer.
$ gcc -lm myprogram.c -o myprogram
This generates an executable program, myprogram in the same directory ³.

define preprocessor:

#include <stdio.h>

#define PI 3.141592	/* define pi */

int main()
{
float a;
printf("Enter radius = ");
scanf("%f", &a);
printf("The area of circle is=%f \n", a*a*PI);
return 0;
}

Sorting algorithm (bubble sort)

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	67	12	34	25	39

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	67	12	34	25	39

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	12	67	34	25	39

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	12	34	67	25	39

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	12	34	25	67	39

x[0]	x[1]	x[2]	x[3]	x[4]	x[5]
45	12	34	25	39	67

The largest element has bubbled to the top index of the array. In general, a bubble step is performed by the loop:

#define N 6
for (i=0; i < N-1; i++)
if (x[i] > x[i+1]) swap(&x[i], &x[i+1])

If this process is repeated again for (i=0; i< N-2; i++), then, the second largest element is located at the second right most place.

Repeat this for (i=0; i< N-3; i++), for (i=0; i< N-4; i++), for (i=0; i< N-5; i++)

#include <stdio.h>
#define N 6

void swap(float *a, float *b)
{
float tmp;
tmp=*a;
*a=*b;
*b=tmp;
}

int main()
{

float a[N]={45, 67, 12, 34, 25, 39};
int  i, j;

for (j=1; j < N; j++)
 {for (i=0; i< N-j; i++)
   if ( a[i]> a[i+1]) swap(&a[i], &a[i+1]);
  }

 for (i=0;i<N; i++) printf("%f ", a[i]);
   printf("\n");
 return 0;
}

Demo

String manipulation

#include <stdio.h>
int main()
{
float a=2.0;
printf("%f\n",a);
return 0;
}

#include <stdio.h>
int main()
{
char a='A';
printf("%c\n",a);
return 0;
}

#include <stdio.h>
int main()
{
float a[]={2.0, 3.0, 4.0, 5.0};
printf("%f\n",a[0]);
return 0;
}

#include <stdio.h>
int main()
{
char a[]="MAE2360";
printf("%c\n",a[0]);
return 0;
}

Use the %s format to represent the entire string instead of the %c format that represents only one character.

#include <stdio.h>
int main()
{
char *a;
a="MAE2360";
printf("%c\n",a[0]);
return 0;
}

#include <stdio.h>
int main()
{
char *a;
a="MAE2360";
printf("%s\n",a);
return 0;
}

"ABC" (double quotation) is for a string of characters and is an array (pointer).
'A' (single quotation) is for a single character !!

Consider this example:

#include <stdio.h>
int main()
{
  char s[3] = "ABC";

  printf("%s\n", s);
  return 0;
}

To read a string from the standard input (i.e. keyboard),

#include <stdio.h>
int main()
{
char str[100];
printf("Enter string = ");
scanf("%s", str);
printf("%s\n",str);
return 0;
}

Note that there is no "&" before str in the scanf function as "str" is already a pointer. The C compiler automatically adds "\0" after the end of the last character in the string.

String copy/compare/length

To copy a string to another string or to compare a string against another string, it is best to use functions, strcpy and strcmp, found in string.h (you can avoid all the hassles associated with pointer manipulation). Reference to C functions

#include <stdio.h>
#include <string.h>
int main()
{
    char c1[] = "ABCDE", c2[6];

    strcpy(c2,c1);
    printf("%s\n",c2);
    return 0;
}

The function, strcpy(c2,c1), copies the contents pointed by c1 to the address pointed by c2.

To compare two strings, use strcmp found in string.h.

#include <stdio.h>
#include <string.h>

int main()
{
    char s[100];

    printf("Enter \"MAE2360\" = ");
    scanf("%s", s);

    if (strcmp(s,"MAE2360") == 0) printf("MAE2360 was entered correctly.\n");
    
    else printf("Wrong. %s was entered.\n",s);
    return 0;
}

The strcmp function takes two strings as the arguments and returns 0 if the two strings match. Note that you can output " (double quotation mark) by "escaping" it using the backslash character.

To find the length of the string, you may want to use the strlen function.

#include <stdio.h>
#include <string.h>
int main()
{
char c[50];
printf("Enter string = ");
scanf("%s", c);
printf("You entered %s\n", c);
printf("Its length is %d\n", strlen(c));
return 0;
}

File handling (from DOS/Shell prompt)

I/O Redirection (Standard input/output redirection)

Notion	Meaning
$ a.out `>` filename	output to file
$ a.out `>>` filename	append output to file
$ a.out `<` filename	get input from file


$ gcc myprogram.c
$ a.out > result.dat
$ more result.dat


$ gcc myprogram.c
$ a.out < data.dat > result.dat
$ more result.dat


c:\dir > filelist.dat

File handling (from within a program)


#include <stdio.h>

int main()
{
	FILE *fp;
 	fp = fopen("filename","w");
   /*
      write something on fp 
   */
	fclose(fp);
        return 0;
}

The function, fopen, takes a (append), w (write) or r (read) as possible arguments.


#include <stdio.h>
int main()
{
	FILE *fp;
	fp=fopen("junk.dat","w");
	fprintf(fp,"Hello!\n");
	fclose(fp);
        return 0;
}


#include <stdio.h>
int main()
{
	FILE *fp; float a,b,c;
	fp=fopen("junk.dat","r");
	fscanf(fp,"%f %f %f", &a, &b, &c);

	printf("%f %f %f", a,b,c);

	fclose(fp);
        return 0;
}


#include <stdio.h>
int main()
{
	FILE *fp1, *fp2; 
        float a,b,c;
	fp1=fopen("junk1.dat","w");
        fp2=fopen("junk2.dat","w");
	fprintf(fp1,"This is the first file.\n");
	fprintf(fp2,"This is the second file.\n");

	fclose(fp1); fclose(fp2);
        return 0;
}

Command line parameters

$ gcc -lm add.c -o add
$ junk 
(interactive session)

$ gcc -lm add.c -o add
$ junk 3421 8756
(executes program to manipulate 3421 and 8756 and prints results)

int main(int argc, char *argv[])

The first argument, argc, is of integer type and is assigned the number of command line arguments including the command name itself. The second argument, argv, is a pointer to an array of strings and is assigned pointers to each command line argument. Note that argv[] is an array so that it can take multiple command line arguments. ⁴

#include <stdio.h>

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

  printf("Number of parameters = %d\n", argc);

  for(i=0; i<argc; i++)
    printf("%d: %s\n", i, argv[i]);
  
  return 0;
}

atoi (ASCII to INTEGER) or atof (ASCII to FLOAT) found in the stdlib.h library.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
printf("%d\n", atoi(argv[1]));
return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
int i;
int b[100]; /* reserve ample space*/

for (i=1; i< argc; i++)
b[i]=atoi(argv[i]);

for (i=1; i< argc ; i++)
 printf("%d\n", b[i]);

return 0;
}

Footnotes:

¹float* pa; is allowed too.

² In C, the asterisk, *, is used in three different ways;

Multiplication (a*b)
Declaration of a pointer (int *a)
De-referencing (*pa = 25.0)

³ -lm is needed when math.h is to be read by the preprocessor directive.

⁴ Actually, argv[] is a pointer to another pointer (an array of another array) as each element of argv[] is a string of characters.

File translated from T_EX by T_TH, version 4.03.
On 23 Jun 2025, 22:45.

Pointer Manipulation

Address operator &

Pointer

Summary

Pointers and arrays

Array name (e.g. a) = Pointer Array element (e.g. a[3])= Regular variable

Summary

Misc. notes

Sorting algorithm (bubble sort)

String manipulation

"ABC" (double quotation) is for a string of characters and is an array (pointer). 'A' (single quotation) is for a single character !!

String copy/compare/length

File handling (from DOS/Shell prompt)

I/O Redirection (Standard input/output redirection)

File handling (from within a program)

Command line parameters

Footnotes:

Array name (e.g. a) = Pointer
Array element (e.g. a[3])= Regular variable

"ABC" (double quotation) is for a string of characters and is an array (pointer).
'A' (single quotation) is for a single character !!