pointers.cpp

 
/*
 * Simple program to demonstrate a couple uses for pointers. This program was
 * written so I could learn more about how to apply pointers and their syntax.
 * As I'm a C novice, please don't just take this file for granted as it may
 * contain errors and or bad practises.
 *
 * By Gerard (gerjo) Meier
 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
// Some function prototypes as we're using a "One-pass compiler":
void pointersAndArrays(void);
void referencesAndVariables(void);
void referencesAndStructs(void);
void testingArrays(void);
void pointerToStruct(void);
void pointerToFunction(void);
void pointerToFunctionInStruct(void);
 
int  multiply(int a, int b);
int  add(int a, int b);
int* getArray1();
int* getArray2();
int* getArray3();
 
// Point of entry:
int main(int argc, char *argv[]) {
   
    printf("Testing pointers and arrays: \n --------------------\n");
    pointersAndArrays();
   
    printf("\n\n\nTesting references and variables: \n --------------------\n");
    referencesAndVariables();
   
    printf("\n\n\nTesting references and structs: \n --------------------\n");
    referencesAndStructs();
   
    printf("\n\n\nTesting Arrays: \n --------------------\n");
    testingArrays();
   
    printf("\n\n\nTesting Pointers to Structs: \n --------------------\n");
    pointerToStruct();
   
    printf("\n\n\nTesting Pointers to functions: \n --------------------\n");
    pointerToFunction();
   
    printf("\n\n\nTesting Pointers to functions within structs (fake classes?): \n --------------------\n");
    pointerToFunctionInStruct();
   
    system("PAUSE");   
    return 0;
}
 
// Demonstrate that an array is nothing more than a bunch of memory "blocks" in a row.
void pointersAndArrays(void) {
    int i;
    int array[] = {0,1,2,3,4,5,6,7,8,9};
    int *pointerToArray;
   
    pointerToArray = array; // Notice the lacking &, which apparently has to be ommitted when using arrays.
   
   
    for(i = 0; i < 10; ++i) {
        // Using an index is the same as incrementing the pointer address. (unsure how "safe" this actually is)
        assert(array[i] == *(pointerToArray + i));
       
        printf("Values:(%i == %i)  Addresses:(%i == %i)\n", array[i], *(pointerToArray + i), &array[i], (pointerToArray + i));
    }
}
 
// Reference two variables to hold the same "value"
void referencesAndVariables(void) {
    int value;
    int *pointerToValue;
   
    value            = 100;
    pointerToValue   = &value;
    value            = 99;
   
    // The address of value is the same as pointerToValue!
    assert(&value == pointerToValue);
    printf("%i == %i\n", &value, pointerToValue);
   
    // The values are the same, too.
    assert(value == *pointerToValue);
    printf("%i == %i\n", value, *pointerToValue);
}
 
// Reference a variable with in a struct:
void referencesAndStructs(void) {
 
    int value;      // Some value that we'll be playing with.
    struct Wrapper; // Forward declaration.
 
    // Create some structure:
    struct Wrapper {
        int *pointerToValue;      
    } foo;
   
    // "link" the pointer to the actual int:
    foo.pointerToValue = &value; // The & makes sure we retrieve the memory address, not the memory value.
                                 // notice the lacking * as we're setting the actual memory address, not memory value.
   
    // Assign some values to both variables:
    *foo.pointerToValue = 102;  // Notice the * is used this time to access the actual memory value, and not the memory address.
    value = 78;                 // Set the original variable.
   
    // Variables hold the same data!
    assert(value == *foo.pointerToValue);
    printf("%i == %i\n", value, *foo.pointerToValue);
}
 
 // This is how it should NOT be done. It will "probably" compile just fine,
 // and "may" execute too, if you're "lucky".
int* getArray1(void) {
    int array[] = {0,1,2,3,4,5,6,7,8,9}; // Privately allocated array.
   
    // Return a pointer to a privately allocated array is not "allowed":
    return array; // Will mostlikely yield a compiler "warning", not an "error".
}
 
// This is the right idea, however, sooner or later we might cause a buffer
// overflow and override some vital part in the memory. The memory I believe is also
// privately "allocated".
// In short: This is NOT how it should be done.
int* getArray2(void) {
    int *array;
    int i;
     
    // We just "assume" that the next 9 memory blocks are free, while this will
    // probably "work" most of the time, it's best to first actually allocate the
    // memory (as seen in the next function)
    for(i = 0; i < 10; ++i) array[i] = i;
   
    return array;
}
 
// This is how it should be done. Much like the C++ new keyword, the
// memory has to be released after use via the "free(*pointer)" function. (called delete/delete[] in C++)
int* getArray3(void) {
    int *array = (int*)malloc(10 * sizeof (int));  // Dynamically allocate memory (array)
    int i;
   
    if(array == NULL) abort();// The computer ran out of memory? Probably want to abort the program here.
   
    // Fill the array:
    for(i = 0; i < 10; ++i) array[i] = i;
   
    // Do not forget to eventually release the memory, too!
    return array;
}
 
void testingArrays(void) {
    //int* array1 = getArray1(); // This will probably crash the application, or otherwise cause unexpected behavior.
    //int* array2 = getArray2(); // This will probably crash the application, or otherwise cause unexpected behavior.
    int* array3 = getArray3();   // The only correct function to return an int[10] array
    int i;
   
    for(i = 0; i < 10; ++i) {
        assert(i == array3[i]);  
       
        // Notice how variable i remains at the same memory address!
        printf("Values:(%i == %i)  Addresses:(%i != %i)\n", i, array3[i], &i, &array3[i]);
 
    }
   
    // No memory leak in this awesome application!
    free(array3);
}
 
void pointerToStruct(void) {
    // Define some basic structure:
    struct someStruct {
        int a;
    } myStruct;
   
    //struct someStruct myStruct;
    struct someStruct *pointerToStruct;
   
    pointerToStruct     = &myStruct; // Point the pointer towards the actual struct instance.
    pointerToStruct->a  = 101; // Set "a" via the pointer. (notice the -> instead of .)
    myStruct.a          = 102; // or set "a" directly. (notice the . instead of ->)
   
    assert(myStruct.a == pointerToStruct->a);
    printf("%i == %i\n", myStruct.a, pointerToStruct->a);
}
 
 
int multiply(int a, int b) {
    return a * b;  
}
 
int add(int a, int b) {
    return a + b;  
}
 
void pointerToFunction(void) {
    // pointer to function, notice how the return types and arguments are definend.
    int (*pointerToFunction) (int, int) = &multiply;
   
    assert(multiply(3, 3) == pointerToFunction(3, 3));
    //printf("%i == %i\n", multiply(3, 3), pointerToFunction(3, 3));
    printf("Values:(%i == %i)  Addresses:(%i == %i)\n", multiply(3, 3), pointerToFunction(3, 3), &multiply, pointerToFunction);
}
 
// Fancy that! functions in a struct:
void pointerToFunctionInStruct(void) {
    // A simple wrapper struct for some "math" tools:
    struct MathTools {
        int (*multiply) (int, int);
        int (*add) (int, int);
    } tools;
 
    // Point the pointers towards the functions:
    tools.multiply = &multiply;
    tools.add      = &add;
   
    // Assertions:
    assert(tools.multiply(3, 3) == tools.add(6, 3));
    printf("%i %i\n", tools.multiply(3, 3), tools.add(6, 3));
}