Arrays and Pointers

Here is an example of an array as we learned when studying them:

#include <iostream>
using namespace std;

int main()
{
    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    cout << "List of Numbers";
    cout << "\nNumber 1:  " << number[0];
    cout << "\nNumber 2:  " << number[1];
    cout << "\nNumber 3:  " << number[2];
    cout << "\nNumber 4:  " << number[3];
    cout << "\nNumber 5:  " << number[4];
    cout << "\nNumber 6:  " << number[5];
    cout << "\nNumber 7:  " << number[6];
    cout << "\nNumber 8:  " << number[7];
    cout << "\nNumber 9:  " << number[8];
    cout << "\nNumber 10: " << number[9];
    cout << "\nNumber 11: " << number[10];
    cout << "\nNumber 12: " << number[11];

    return 0;
}

In this case, the Number variable is an array of 12 integer values. Because a variable declared as array is first of all a variable, using its name, let us find its address. Consider the following program:

#include <iostream>
using namespace std;

int main()
{
    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    cout << "\n Number    :  " << Number;
    cout << "\n&Number    :  " << &Number;
    cout << "\n&number[0] :  " << &number[0] << endl;  

    return 0;
}

This would produce:

 Number    :  1245020

&Number    :  1245020

&number[0] :  1245020

This demonstrates that Number, &Number, and &number[0] have the same value. As we learned with pointers, the use of the ampersand "&" allows us to get the address of a variable. Therefore, &Number gives us the address of the array variable. Furthermore, since &Number and &number[0] have the same value, and seeing that all three (Number, &Number, and &number[0]) have the same value, this demonstrates that the name of the variable in fact carries, or holds, or represents, the address of the first value of the array. In fact, consider the following program:

#include <iostream>



using namespace std;



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };



    cout << "An integer occupies " << sizeof(int) << " bytes\n";

    cout << "\n Number:    " << Number;

    cout << "\n&number[0]: " << &number[0] << endl;

    cout << "\n Number+1:  " << Number+1;

    cout << "\n&Number:[1] " << &number[1] << endl;

    cout << "\n Number+2:  " << Number+2;

    cout << "\n&Number:[2] " << &number[2] << endl;

    

    return 0;

}

This would produce:

An integer occupies 4 bytes



 Number:    1245020

&number[0]: 1245020



 Number+1:  1245024

&Number:[1] 1245024



 Number+2:  1245028

&Number:[2] 1245028

Notice that, by adding numbers to the name of the variable, we are able to get the address of any member of the array.

int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

int *pNumbers = Number;

In other words, pNumbers points to the beginning of the array. As you can see from the previous result, pNumbers holds an address and not a value, that is, not the value of the first member of the array. Since pNumbers points to the first member of the array (by virtue of its relationship to the array, which we have demonstrated by showing that pNumbers and Number hold the same value, which is the same as the address of the first member of the array), to get the value that pNumbers holds, we learned, when studying pointers, that you must use the asterisk operator. Therefore, number[0], which is the value of the first member of the array, is the same as *pNumbers, which is the value of the first member of the array. This can be verified in the following program:

#include <iostream>



using namespace std;



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int *pNumbers = Number;



    cout << "Values";

    cout << "\n  number[0] :  " << number[0];

    cout << "\n*pNumber    :  " << *pNumbers;



    return 0;

}

This would produce:

Values

  number[0] :  31

*pNumber    :  31

We saw already that pNumbers is an address; it is not a value. In the same way, Number is an address. To get the value of a member of the Number array, we know that, using the square brackets, we can provide the index of the member we want and retrieve its value. In the same way, using a pointer that has been initialized to an array variable, we can use the square bracket and the index of the member whose value we want to retrieve. This is demonstrated in the following program:

#include <iostream>



using namespace std;



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int *pNumbers = Number;



    cout << "Addresses";

    cout << "\n Number  :  " << Number;

    cout << "\npNumbers :  " << pNumbers;



    cout << "\n\nValues";

    cout << "\n Number [0] :  " << number[0];

    cout << "\npNumbers[0] :  " << pNumbers[0];

    cout << "\n Number [1] :  " << number[1];

    cout << "\npNumbers[1] :  " << pNumbers[1];

    

    return 0;

}

This would produce:

Addresses

 Number  :  1245020

pNumbers :  1245020



Values

 Number [0] :  31

pNumbers[0] :  31

 Number [1] :  28

pNumbers[1] :  28

At this time, we know how to get the address of the first member of the array, with either Number or pNumbers. To get the address of the second member of the array, we increment that address value, as in Number+1. Since Number is an address and not a value, adding 1 to it adds the size of its type, in this case 4 bytes, in order to get to the next address. In the same way, using a pointer that has been initialized with an array, to get the address of the next member of the array, simply increment its name. Here is an example:

#include <iostream>



using namespace std;



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int *pNumbers = Number;



    cout << "Addresses";

    cout << "\n Number    :  " << Number;

    cout << "\npNumbers   :  " << pNumbers;

    cout << "\n Number +1 :  " << Number+1;

    cout << "\npNumbers+1 :  " << pNumbers+1; 

    cout << "\n Number +2 :  " << Number+2;

    cout << "\npNumbers+2 :  " << pNumbers+2;

    

    return 0;

}

This would produce:

Addresses

 Number    :  1245020

pNumbers   :  1245020

 Number +1 :  1245024

pNumbers+1 :  1245024

 Number +2 :  1245028

pNumbers+2 :  1245028

Now we know that by writing pNumbers or pNumbers+n, we get the address of the member that "lives" at pNumbers or pNumbers+n. We already saw that, by writing *pNumbers, we can get the value of the first member of the array. When writing *pNumbers, we are in fact asking the compiler to retrieve the value that pNumbers points to. If we want to get the value of the next member of the array, we must first give its address, which is done by adding the index of the member of the array to pNumbers. Once we have communicated the address, we use the asterisk operator to retrieve the actual value of the member of the array. Because the asterisk operator has a higher precedence than the addition operator, to get the address before the value, you must use parentheses to delimit the operation:

#include <iostream>



using namespace std;



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int *pNumbers = Number;



    cout << "Values - Using the Array";

    cout << "\n number[0]:    " << number[0];

    cout << "\n number[1]:    " << number[1];

    cout << "\n number[2]:    " << number[2];

    cout << "\n number[3]:    " << number[3];

    cout << "\n number[4]:    " << number[4];



    cout << "\n\nValues - Using the Pointer - No Parentheses";

    cout << "\n*pNumbers:     " << *pNumbers;

    cout << "\n*pNumbers+1:   " << *pNumbers+1;

    cout << "\n*pNumbers+2:   " << *pNumbers+2;

    cout << "\n*pNumbers+3:   " << *pNumbers+3;

    cout << "\n*pNumbers+4:   " << *pNumbers+4;



    cout << "\n\nValues - Using the Pointer - With Parentheses";

    cout << "\n*pNumbers:     " << *pNumbers;

    cout << "\n*(pNumbers+1): " << *(pNumbers+1);

    cout << "\n*(pNumbers+2): " << *(pNumbers+2);

    cout << "\n*(pNumbers+3): " << *(pNumbers+3);

    cout << "\n*(pNumbers+4): " << *(pNumbers+4);

    

    return 0;

}

This would produce:

Values - Using the Array

 number[0]:    31

 number[1]:    28

 number[2]:    31

 number[3]:    30

 number[4]:    31



Values - Using the Pointer - No Parentheses

*pNumbers:     31

*pNumbers+1:   32

*pNumbers+2:   33

*pNumbers+3:   34

*pNumbers+4:   35



Values - Using the Pointer - No Parentheses

*pNumbers:     31

*(pNumbers+1): 28

*(pNumbers+2): 31

*(pNumbers+3): 30

*(pNumbers+4): 31



Press any key to continue...

Therefore, as long as you increment the address of the variable, you can use a for loop to navigate the array to get the value of each member of the array:

A Pointer as Argument

Introduction

As we have seen so far, a function can use one or more arguments in order to carry its assignment. When necessary, a function also declares its own variable(s) to get the desired return value. A variable declared in the body of a function is referred to as a local variable. Here is an example:

Here is an example of running the program:

Please enter the original price: 125.55



After applying a 20% discount

Final Price = 100.44

Press any key to continue

Like other variables, a pointer can be passed to a function. When declaring  and when implementing a function that takes a pointer as an argument, use the asterisk for the argument or for each argument. Here is an example:

When calling the function, use the reference(s) to the variable(s). The function will perform its assignment on the referenced variable(s). After the function has performed its assignment, the changed value(s) of the argument(s) will be preserved and given to the calling function. Here is an example:

Practical Learning: Passing Pointers as Arguments

The Effect of Passing a Pointer as Argument

Notice that the value of the OriginalPrice variable is kept intact in the main() function, as 0, before and after calling the GetTheOriginalPrice() function.

Like a reference, when passing a pointer as argument to a function, the function that is receiving the argument is in fact accessing the argument's address. Therefore, like a reference, the called function has the ability to alter the value held by the pointer. The effect is the same as for the reference: if the called function modifies the value of the pointer, that value is permanently changed. This is a feature you can use to your advantage. This effect is illustrated in the following program:

#include <iostream>

using namespace std;



void GetTheOriginalPrice(double *OrigPrice);



int main()

{

    double OriginalPrice = 0;



    cout << "First in main() --";

    cout << "\nOriginal Price =  $" << OriginalPrice << endl;



    GetTheOriginalPrice(&OriginalPrice);



    cout << "\nBack in main() --";

    cout << "\nOriginal Price =  $" << OriginalPrice << endl;

    

    return 0;

}



void GetTheOriginalPrice(double *OrigPrice)

{

    cout << "\nNow we are in the GetTheOriginalPrice() function";

    cout << "\nPlease enter the original price: ";

    cin >> *OrigPrice;



    cout << "\nIn the GetTheOriginalPrice() function";

    cout << "\nOriginal Price = $" << *OrigPrice << endl;

}

First in main() --

Original Price =  $0



Now we are in the GetTheOriginalPrice() function

Please enter the original price: 100



In the GetTheOriginalPrice() function

Original Price = $100



Back in main() --

Original Price =  $100



Press any key to continue...

Notice that, this time, after calling the GetTheOriginalPrice() function, the value of the OriginalPrice variable is permanently changed and the second time it is accessed in the main() function, it holds a different value than the first time it was called.

Practical Learning: Passing Reference Pointers to Functions

Constant Pointers as Arguments

The previous section demonstrates to us that, when passing a pointer as argument, the effect is the same as passing an argument as reference. This shows that, passing a pointer as argument gives the called function direct access to the address of the variable. Besides permanently changing the value of the argument, this process also speeds up code execution because the called function does not deal with a copy of the variable but the variable itself. Although there are various good reasons to pass pointers as arguments, sometimes you may not want the called function to modify the value held by the variable. In fact you can prevent this.

If a function that receives a pointer as argument is not supposed to modify the value of the argument, you can pass the argument as a constant pointer. To do this, type the const keyword on the left side of the data type of the pointer argument. Here is an example:

Practical Learning: Passing Constant Pointers

Pointers and Multi-Dimensional Arrays

Dynamic Arrays

Allocating Memory

Based on this relationship between arrays and pointers, you can use the new operator to dynamically create an array. This has the advantage of allowing you to allocate the desired amount of space and getting rid of it once not needed anymore. The syntax of dynamically creating an array of pointers is:

DataType *ArrayName = new DataType[Dimensions];

To start, type the kind of array you want to create: this is the DataType.

The ArrayName is a regular name you want to give to the variable. Since this is a pointer, the array name must be preceded by an asterisk operator.

Assign the new operator to the array name.

The new operator is followed by the same kind of data type of the first parameter, DataType.

The the necessary number of members of the array as the Dimension. This Dimension is included between square brackets, as every array.

Here are examples of dynamic arrays:

double *Distance = new double[12];

unsigned int *pRanges = new unsigned int[120];

float *Prices = new float[44];

After dynamically creating an array, the compiler allocates the necessary memory space for all the members of the array, based on the data type and accommodating each. Just like any variable, the memory allocated for each member of the array contains garbage. It is your responsibility to fill it up for appropriate values. This can be taken care of by assigning a value to each member of the array.

Each member of the array can be accessed by using its index on the name of the array. You have two options. You can apply the index of an array member on the name of the pointer. Here is an example:

int *pNumbers = new int[12];



pNumbers[0] = 31;

pNumbers[1] = 29;

pNumbers[2] = 31;

pNumbers[3] = 30;

You can also access the address of the desired member, then assign it a value. Here is an example:

int *pNumbers = new int[12];



*(pNumbers+4) = 31;

*(pNumbers+5) = 30;

*(pNumbers+6) = 31;

*(pNumbers+7) = 31;

In the same way, you can use either method to retrieve the value of a member of the array:

#include <iostream>

using namespace std;





int main()

{

    int *pNumbers = new int[12];



      pNumbers[0]  = 31;

      pNumbers[1]  = 29;

      pNumbers[2]  = 31;

      pNumbers[3]  = 30;

    *(pNumbers+4)  = 31;

    *(pNumbers+5)  = 30;

    *(pNumbers+6)  = 31;

    *(pNumbers+7)  = 31;

    *(pNumbers+8)  = 30;

    *(pNumbers+9)  = 31;

      pNumbers[10] = 30;

      pNumbers[11] = 31;



    cout << "List of numbers";

    cout << "\nNumber 1:  " << *pNumbers;

    cout << "\nNumber 2:  " << *(pNumbers+1);

    cout << "\nNumber 3:  " << *(pNumbers+2);

    cout << "\nNumber 4:  " << *(pNumbers+3);

    cout << "\nNumber 5:  " << pNumbers[4];

    cout << "\nNumber 6:  " << pNumbers[5];

    cout << "\nNumber 7:  " << pNumbers[6];

    cout << "\nNumber 8:  " << pNumbers[7];

    cout << "\nNumber 9:  " << *(pNumbers+8);

    cout << "\nNumber 10: " << *(pNumbers+9);

    cout << "\nNumber 11: " << pNumbers[10];

    cout << "\nNumber 12: " << pNumbers[11];



    

    

    return 0;

}

This would produce:

List of numbers

Number 1:  31

Number 2:  29

Number 3:  31

Number 4:  30

Number 5:  31

Number 6:  30

Number 7:  31

Number 8:  31

Number 9:  30

Number 10: 31

Number 11: 30

Number 12: 31



Press any key to continue...

Disposing of Memory

Dynamic Multi-Dimensional Arrays

Pointers and Arrays With Functions

Single Dimensional Arrays and Functions

When we studied arrays and functions, we saw that, to pass an array as argument to a function, you can type the name of the argument followed by parentheses. If you want to process the members of the array, you should also pass another argument that holds the number of members of the array. Here is an example:

int  SumOfNumbers(int Nbr[], int Size);

When calling such a function, the name of the argument is sufficient to the compiler:

#include <iostream>

using namespace std;



int  SumOfNumbers(int Nbr[], int Size)

{

    int Sum = 0;

    for(int i = 0; i < Size; i++)

        Sum += Nbr[i];



    return Sum;

}



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int numberOfMembers = sizeof(Number) / sizeof(int);



    int Value = SumOfNumbers(number, numberOfMembers);



    cout << "Sum of numbers: " << Value;



    

    

    return 0;

}

This would produce:

Sum of numbers: 365

When calling the function, the name of the array allows the compiler to pass the whole array because that name is in fact a pointer to the variable. Based on this, instead of passing an array as argument, you can instead use a pointer. We have established that, once a pointer has been initialized as holding the address of an array, the name of the array and the name of the pointer point to the same address. This means that you can also use the name of the pointer when calling such a function. Remember that the name of the pointer preceded by an asterisk is a value; therefore, you should not use it as argument when calling the function.

Based on the relationship we have studied so far between pointers and arrays, the above program can also be written as follows:

#include <iostream>

using namespace std;



int  SumOfNumbers(int *nbr, int size)

{

    int sum = 0;

    for(int i = 0; i < size; i++)

        sum += nbr[i];



    return Sum;

}



int main()

{

    int number[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    int *pNumbers = number;

    int numberOfMembers = sizeof(number) / sizeof(int);



    int Value = SumOfNumbers(pNumbers, numberOfMembers);



    cout << "Sum of numbers: " << Value;

    

    return 0;

}

This would produce the same result.

Multi-Dimensional Arrays and Functions

To declare a function that takes a multi-dimensional array as argument, you can type the array name followed by an empty pair of square brackets, followed by a second pair of square brackets that contain the number of columns. If you are using a pointer as argument, for example a variable that points to a two-dimensional array, provide the type of variable followed by an asterisk that indicates that the argument is a pointer, and followed by a pair of square brackets. The square brackets can be empty or contain the number of columns. Such a function can be declared as follows:

void  DisplayNumbers(int *nbr[]);

Before calling such a function, after appropriately initializing the pointer, provide only the name of the pointer. Here is an example:

#include <iostream>
using namespace std;

void  DisplayNumbers(int *Nbr[]);

int main()
{
    int number[2][6] = { { 31, 28, 31, 30, 31, 30 },
                         { 31, 31, 30, 31, 30, 31 } };

    int *pNumbers[2];

    *pNumbers = number[0];
    (*pNumbers)[0]     = number[0][0];
    (*pNumbers)[1]     = number[0][1];
    (*pNumbers)[2]     = number[0][2];
    (*pNumbers)[3]     = number[0][3];
    (*pNumbers)[4]     = number[0][4];
    (*pNumbers)[5]     = number[0][5];

    *(pNumbers+1) = number[1];
    (*(pNumbers+1))[0] = number[1][0];
    (*(pNumbers+1))[1] = number[1][1];
    (*(pNumbers+1))[2] = number[1][2]; 
    (*(pNumbers+1))[3] = number[1][3];
    (*(pNumbers+1))[4] = number[1][4];
    (*(pNumbers+1))[5] = number[1][5];

    cout << "List of Numbers";
    DisplayNumbers(pNumbers);

    return 0;
}

void  DisplayNumbers(int *nbr[])
{
    cout << "\n(*pNumbers)[0]     = " << (*nbr)[0];
    cout << "\n(*pNumbers)[1]     = " << (*nbr)[1];
    cout << "\n(*pNumbers)[2]     = " << (*nbr)[2];
    cout << "\n(*pNumbers)[3]     = " << (*nbr)[3];
    cout << "\n(*pNumbers)[4]     = " << (*nbr)[4];
    cout << "\n(*pNumbers)[5]     = " << (*nbr)[5] << endl;

    cout << "\n(*(pNumbers+1))[0] = " << (*(nbr+1))[0];
    cout << "\n(*(pNumbers+1))[1] = " << (*(nbr+1))[1];
    cout << "\n(*(pNumbers+1))[2] = " << (*(nbr+1))[2];
    cout << "\n(*(pNumbers+1))[3] = " << (*(nbr+1))[3];
    cout << "\n(*(pNumbers+1))[4] = " << (*(nbr+1))[4];
    cout << "\n(*(pNumbers+1))[5] = " << (*(nbr+1))[5] << endl;
}

If you want to process the argument in the function where it is passed as argument and if you would not know the dimension of the array in advance, you can pass two additional arguments that represent the rows and columns of the array. Here is an example:

#include <iostream>
using namespace std;

void  DisplayNumbers(int *Nbr[], int r, int c);

int main()
{
    int number[2][6] = { { 31, 28, 31, 30, 31, 30 },
                         { 31, 31, 30, 31, 30, 31 } };

    int *pNumbers[2];

    *pNumbers = number[0];

    for(int i = 0; i < 6; i++)
        (*pNumbers)[i] = number[0][i];

    *(pNumbers+1) = number[1];

    for(int i = 0; i < 6; i++)
        (*(pNumbers+1))[i] = number[1][i];

    cout << "List of Numbers";
    DisplayNumbers(pNumbers, 2, 6);

    return 0;
}



void  DisplayNumbers(int *nbr[], int rows, int columns)

{

    for(int i = 0; i < rows; i++)

        for(int j = 0; j < columns; j++)

            cout << "\nNumber[" << i << "][" << j << "]: " << (*(nbr+i))[j];

}

Here is an example of executing this program:

List of Numbers

Number[0][0]: 31

Number[0][1]: 28

Number[0][2]: 31

Number[0][3]: 30

Number[0][4]: 31

Number[0][5]: 30

Number[1][0]: 31

Number[1][1]: 31

Number[1][2]: 30

Number[1][3]: 31

Number[1][4]: 30

Number[1][5]: 31