Mastering Pointers in C/C++: 10 Practical Coding Exercises for Beginners

If you are diving into C or C++ programming, there is one concept you simply cannot escape: Pointers. Often considered the first major hurdle for beginners, pointers are actually incredibly powerful tools that give you direct access to memory and help you write highly efficient code.

Before jumping into the exercises below, if you need a quick conceptual refresher, I highly recommend checking out some classic guides such as [Pointers in C Programming: What is Pointer, Types & Examples] or an [Introduction to C Pointers].

To help you solidifying your understanding, here are 10 practical pointer exercises, complete with reference solutions. Let's code!

Exercise 1: Basic Pointer Syntax

Goal: Design a C program to demonstrate the foundational syntax of pointers, including pointer declaration, address-of retrieval (&), and dereferencing (*).

Reference Solution:

/* Pointer Basic Syntax 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 50;     // Variable declaration
    int *ip;        // Pointer declaration
    
    ip = &n;        // Assigning the address of 'n' to pointer 'ip'
    
    printf("The address of n (&n): %X\n", &n);
    printf("The value of n: %i\n", n);
    printf("The address of ip (&ip): %X\n", &ip);
    printf("The value stored in ip (address of n): %X\n", ip);
    printf("The value decompressed/dereferenced (*ip): %i\n", *ip);
    
    return 0;
}

Exercise 2: Dynamic Memory Allocation

Goal: Write a C program that dynamically allocates memory for an array of integers based on user input using malloc(), and make sure to release it properly using free().

Reference Solution:

/* Dynamic memory allocation 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
int main() {
    int n;
    int *pI;
    
    printf("How many integers? ");
    scanf("%d", &n);
    
    // Allocating memory dynamically using malloc
    pI = (int *) malloc(n * sizeof(int));
    
    if(pI == NULL) // Error handling if allocation fails
    {
        printf("Couldn't allocate memory\n");
        return 0; // Exit the program
    }
    
    printf("Memory successfully allocated.\n");
    
    // Always remember to free the memory allocated by malloc
    free(pI);
    return 0;
}

Exercise 3: Multiplying Two Numbers Using Pointers

Goal: Create a simple program that takes two numbers from the user and multiplies them together. The catch? You must perform the math using pointers!

Reference Solution:

/* Multiplying two numbers with pointers 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
int main() {
    int n1, n2;
    int *pn1, *pn2, product;
    
    printf("Enter num1: ");
    scanf("%d", &n1);
    printf("Enter num2: ");
    scanf("%d", &n2);
    
    // Assigning addresses to pointers
    pn1 = &n1;
    pn2 = &n2;
    
    // Dereferencing the pointers to multiply the values
    product = *pn1 * *pn2;
    
    printf("The product of %d and %d is %d\n", *pn1, *pn2, product);
    return 0;
}

Exercise 4: Navigating Arrays with Pointers

Goal: In C, arrays and pointers are closely related. Write a program that uses a pointer to access and print every element of an integer array.

Reference Solution:

/* Pointer and array 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
#define N 5
int main() {
    int a[N] = {2, 3, 5, 7, 11};
    int *pI = a; // Point to the base address of the array
    
    for(int i = 0; i < N; i++) {
        // Accessing array elements using pointer offsets
        printf("a[%d] = %d\t", i, *(pI + i));
    }
    return 0;
}

Exercise 5: Pointer Arithmetic (Increment and Decrement)

Goal: In Exercise 4, we accessed elements by adding an integer to the pointer (*(pI + i)). For this exercise, achieve the exact same behavior, but use the increment (++) and decrement (--) operators instead.

(Tip: If you want to know more about the underlying mechanics, search for tutorials on "How pointer arithmetic works".)

Reference Solution:

/* Pointer Arithmetic: increment and decrement 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
#define N 5
int main() {
    int a[N] = {2, 3, 5, 7, 11};
    int *pI = a;
    
    printf("Pointer increment:\n");
    // Print and move the pointer forward
    for(int i = 0; i < N; i++) {
        printf("a[%d] = %d\t", i, *(pI++));
    }
    
    printf("\n\nPointer decrement:\n");
    // Move the pointer backward to read in reverse order
    for(int i = N - 1; i >= 0; i--) {
        printf("a[%d] = %d\t", i, *(--pI));
    }
    return 0;
}

Exercise 6: Calculating String Length

Goal: Strings in C are character arrays terminated by a null character ('\0'). Write a program that calculates the exact length of a user-inputted string using pointer traversal.

Reference Solution:

/* Length of a string 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
int main() {
    char str[100];
    int len = 0;
    
    printf("Enter a string: ");
    // Allows reading string with spaces until a newline is hit
    scanf("%[^\n]s", str);
    
    char *pC = str;
    
    // Loop through the characters until hitting the null terminator
    while(*pC != '\0') {
        len++;
        pC++; // Move to the next character address
    }
    
    printf("The length of the given string [%s] is: %d", str, len);
    return 0;
}

Exercise 7: Swapping Two Numbers (Call by Reference)

Goal: Create a user-defined function that swaps the values of two variables. You must pass the variables by reference using pointers so the changes persist outside the function.

Reference Solution:

/* Swap two numbers 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
// Function prototype utilizing pointer arguments
void swapV(double *x, double *y);
int main() {
    double n1, n2;
    
    printf("Enter number 1: ");
    scanf("%lf", &n1);
    printf("Enter number 2: ");
    scanf("%lf", &n2);
    
    printf("Before swap - n1: %lf, n2: %lf\n", n1, n2);
    
    // Passing addresses of n1 and n2
    swapV(&n1, &n2);
    
    printf("After swap  - n1: %f, n2: %f\n", n1, n2);
    return 0;
}
// Function implementation
void swapV(double *x, double *y) {
    double t = *x;
    *x = *y;
    *y = t;
}
Exercise 8: Manual String Concatenation

Goal: Without using built-in string functions like strcat(), write a program that uses pointers to combine two separate strings into a single target buffer.

Reference Solution:

/* String concatenation 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
#define LEN 256
int main() {
    char str1[LEN];
    char str2[LEN];
    char str3[LEN * 2];
    
    printf("Enter str1: ");
    scanf("%[^\n]%*c", str1);
    printf("Enter str2: ");
    scanf("%[^\n]%*c", str2);
    
    char *pC = str1;
    char *pStr = str3;
    
    // Copy first string to buffer
    while(*pC) {
        *pStr = *pC;
        pC++;
        pStr++;
    }
    
    // Append second string to buffer
    pC = str2;
    while(*pC) {
        *pStr = *pC;
        pC++;
        pStr++;
    }
    
    // Crucial step: manually terminate the string with '\0'
    *pStr = '\0';
    
    printf("Str1: %s\nStr2: %s\nConcatenated Str3: %s\n", str1, str2, str3);
    return 0;
}

Exercise 9: Handling the Null Pointer

Goal: A null pointer points to nowhere. Attempting to dereference it will crash your program. Write a program that demonstrates how to safely check for NULL before accessing pointer data.

Reference Solution:

/* NULL pointer 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
int main() {
    int *iP = NULL; // Initializing pointer to NULL
    
    if(iP == NULL) {
        printf("The value of iP is %u (It is a NULL pointer)\n", iP);
        
        // WARNING: De-commenting the line below will crash your application!
        // printf("The value of *iP is %d", *iP); 
    } else {
        printf("The value of iP is %u\n", iP);
        printf("The value of *iP is %d\n", *iP);
    }
    return 0;
}

Exercise 10: Function Pointers

Goal: Pointers don't just point to data; they can also point to functions! Create basic arithmetic functions (add, subtract, multiply, divide) and execute them dynamically through a single function pointer.

Reference Solution:

/* Function pointers 
   Author: Holan */
#include <stdio.h>
#include <stdlib.h>
// Mathematical function prototypes
double add(double n1, double n2);
double sub(double n1, double n2);
double mul(double n1, double n2);
double divi(double n1, double n2);
int main() {
    double a = 3.44, b = 9.999;
    
    // Declaring a function pointer and initializing it to 'add'
    double (*op)(double, double) = add;
    printf("The addition of %f and %f is %f\n", a, b, op(a, b));
    
    op = sub;
    printf("The subtraction of %f and %f is %f\n", a, b, op(a, b));
    
    op = mul;
    printf("The multiplication of %f and %f is %f\n", a, b, op(a, b));
    
    op = divi;
    printf("The division of %f and %f is %f\n", a, b, op(a, b));
    
    return 0;
}
double add(double a, double b) { return a + b; }
double sub(double a, double b) { return a - b; }
double mul(double a, double b) { return a * b; }
double divi(double a, double b) { return a / b; }

Wrapping Up

Pointers might feel intimidating at first, but once you master how addresses and variables interact in memory, they become an invaluable asset in your programming toolkit.

If you found these exercises helpful, please consider supporting the blog by clicking the ads or buying me a coffee. Happy coding!

搜尋此網誌