Introduction to C Programming
☠☠☠ Pointers ☠☠☠
Edgar SIMO-SERRA
Last class summary
- Mathematical libraries
Class Objectives
- ☠☠☠ Pointers ☠☠☠
Computer Memory
- Most modern computers are byte-addressable
- 1 byte = 8 bits (0 or 1 values)
- Compiler automatically assigns memory when using it
- Example:
int my_var = 5000;(hexadecimal 0x00001388)
| Address | Value | Contents |
|---|---|---|
| 0x00000000 | 0x00 | integer |
| 0x00000001 | 0x00 | integer |
| 0x00000002 | 0x13 | integer |
| 0x00000003 | 0x88 | integer |
Example
int my_var = 10000;
double my_double = 10000.;| Address | Value | Contents |
|---|---|---|
| 0x00000000 | 0x00 | integer |
| 0x00000001 | 0x00 | integer |
| 0x00000002 | 0x27 | integer |
| 0x00000003 | 0x10 | integer |
| 0x00000004 | 0x00 | double |
| 0x00000005 | 0x00 | double |
| 0x00000006 | 0x00 | double |
| 0x00000007 | 0x00 | double |
| 0x00000008 | 0x40 | double |
| 0x00000009 | 0xC3 | double |
| 0x0000000A | 0x88 | double |
| 0x0000000B | 0x00 | double |
Program Memory
- Most modern computers come with a Memory Management Unit (MMU)
- Allows detecting when a program is reading different memory
- The Kernel (Operating System) doesn’t allow programs to read other program memory
- If your program does, it gets killed (segmentation fault)
- This is important for safety: if a program could read any memory, it could steal your passwords
- Program are given virtual memory addresses, which are mapped to real memory addresses
☠☠☠ Pointers ☠☠☠
- Variables that point to a memory address
- DO NOT CONTAIN NOR ALLOCATE MEMORY FOR YOU
- Extremely useful in many different applications
- Two new operators
&: gets the pointer value of a variable*: gets the value of a pointer
- To declare add
*after the variable type:int *x; /* x is a pointer to an int-type variable */
Example
int my_variable = 5;
int my_other_variable = 3;
int *my_pointer;
my_pointer = &my_variable;
printf( "%d\n", *my_pointer ); /* 5 */
my_pointer = &my_other_variable;
printf( "%d\n", *my_pointer ); /* 3 */
*my_pointer = 7;
printf( "%d\n", my_other_variable ); /* 7 */Modifying memory
- By modifying the pointer value, you can modify the memory directly
- This allows function parameters to be used as inputs and outputs!
#include <stdio.h>
void my_func( int *x ) {
*x = (*x) * 5 + 3;
}
int main (void) {
int a = 5;
my_func( &a );
printf( "%d\n", a ); /* ?? */
return 0;
}Understanding scanf
- Modifies the value of the variables passed to it
- Variables are passed as pointers!
int n;
scanf( "%d", &n );Arrays and Pointers
- Arrays in C are pointers
- You can do arithmetic on pointers
- The
[]operator is performing arithmetic on pointers
int my_array[3] = { 1, 3, 5 };
int *my_pointer = my_array; /* No need for & */
printf( "%d\n", my_array[1] ); /* 3 */
printf( "%d\n", *(my_array+1) ); /* 3 */
printf( "%d\n", my_pointer[1] ); /* 3 */
printf( "%d\n", *(my_pointer+1) ); /* 3 */
my_pointer = my_pointer + 1;
printf( "%d\n", my_pointer[1] ); /* ?? */Notes about Pointer Arithmetic
- Adding 1 to a pointer depends on it’s type
- integers are 4 bytes, +1 will move 4 bytes
- doubles are 8 bytes, +1 will move 8 bytes
- characters are 1 byte, +1 will move 1 byte
int my_int_array[3];
double my_double_array[3];
printf( "%p\n", my_int_array ); /* 0x7ffe1a6947b4 */
printf( "%p\n", my_int_array+1 ); /* 0x7ffe1a6947b8 */
printf( "%p\n", my_double_array ); /* 0x7ffe1a6947c0 */
printf( "%p\n", my_double_array+1 ); /* 0x7ffe1a6947c8 */
printf( "%d\n", &my_int_array[1]-&my_int_array[0] ); /* 1 */Pointer !!FUN!!
- C Code
#include <stdio.h>
int main (void)
{
int *my_var;
printf( "%d\n", *my_var );
return 0;
}- Compile
$ gcc crash.c -o crash
$ ./crash
bash: segmentation fault (core dumped) ./crashMore Pointer !!FUN!!
#include <stdio.h>
int* my_func( int x ) {
int a[2];
a[0] = x+1;
a[1] = x;
return a;
}
int main (void)
{
int my_var = 5;
int *my_pointer = my_func( my_var );
printf( "%d\n", *my_pointer );
return 0;
}Example 1: swap
#include <stdio.h>
void swap( int *a, int *b ) {
int c = *a;
*a = *b;
*b = c;
}
int main (void) {
int my_var = 3;
int my_other_var = 5;
printf( "var: %d, other: %d\n", my_var, my_other_var ); /* 3, 5 */
swap( &my_var, &my_other_var );
printf( "var: %d, other: %d\n", my_var, my_other_var ); /* 5, 3 */
return 0;
}Example 2: in-place editing
#include <stdio.h>
#define MAXN 30
void process( double *x ) {
*x = (*(x+1) + *x)/2;
}
int main (void) {
double my_array[MAXN];
for (int i=0; i<MAXN; i++) {
my_array[i] = (double)i;
}
for (int i=0; i<MAXN-1; i++) {
process( &my_array[i] );
}
for (int i=0; i<MAXN; i++) {
printf( "%.1f ", my_array[i] );
}
return 0;
}Example 3: pointer to a pointer
#include <stdio.h>
int main (void) {
int my_num = 5;
int *my_pointer = &my_num;
int **my_double_pointer = &my_pointer;
printf( "Value of my_double_pointer = %p\n", *my_double_pointer );
printf( "Value of pointer pointed by my_double_pointer = %d\n", **my_double_pointer );
return 0;
}Exercise 1: output with pointers
- Get the minimum and maximum value of a list using the following code:
#include <stdio.h>
#define N 20
void get_min_and_max( int *array, int n, /* more parameters needed */ ) {
/* implement */
}
int main (void) {
int array[N] = { 18, 16, 10, 12, 4, 21, 2, 20, 9, 7, 11, 19, 5, 14, 3, 15, 13, 8, 6, 17 };
/* get the min and max values of array and print them */
get_min_and_max( array, N, /* what parameters? */ );
return 0;
}Exercise 2: swapping
swap_numsworks butswap_pointersdoes not. Fix it.
#include <stdio.h>
void swap_nums(int *x, int *y) {
int tmp;
tmp = *x;
*x = *y;
*y = tmp;
}
void swap_pointers(char *x, char *y) {
char *tmp;
tmp = x;
x = y;
y = tmp;
}
int main (void) {
int a=3, b=4;
char *s1, *s2;
swap_nums(&a,&b);
printf("a is %d\nb is %d\n", a, b);
s1 = "I should print second";
s2 = "I should print first";
swap_pointers( s1, s2 );
printf("s1 is %s\ns2 is %s\n", s1, s2);
return 0;
}Exercise 3: copy an array backwards
- Copy an array into another but in backwards order
#include <stdio.h>
#define N 20
void copy_array( /* parameters needed */ ) {
/* implement */
}
int main (void) {
int array[N] = { 18, 16, 10, 12, 4, 21, 2, 20, 9, 7, 11, 19, 5, 14, 3, 15, 13, 8, 6, 17 };
int output[N];
/* copy array into output backwards and print the result */
}- Please hand in this exercise through Moodle
Exercise 4: double pointer matrix
- We implement a matrix with a pointer to each row vector
- Implement the following functions
- Code to print the matrix
- Code to swap two rows
- Code to swap two columns
- Use pointers when possible
Template
#include <stdio.h>
#define N 3
void m_print( double **M ) {
/* implement */
}
void m_swap_rows( double **M, int a, int b ) {
/* implement */
}
void m_swap_columns( double **M, int a, int b ) {
/* implement */
}
int main (void) {
double *M[N];
double A[N] = {1, 3, 5};
double B[N] = {2, 4, 6};
double C[N] = {1, 2, 3};
M[0] = A; M[1] = B; M[2] = C;
m_swap_columns( M, 0, 2 );
m_swap_rows( M, 0, 2 );
m_print( M );
return 0;
}Today’s Lesson
- ☠☠☠ Pointers ☠☠☠
Next Week
- ☠☠☠ More Pointers ☠☠☠
- Functions and Global Variables
Introduction to C Programming ☠☠☠ Pointers ☠☠☠ Edgar SIMO-SERRA