C++ For Dummies (2014)

---

Contrasting a pointer with an array

There are some differences between an array and a pointer. For one, the array allocates space for the data, whereas the pointer does not, as shown here:

void arrayVsPointer()
{
// allocate storage for 128 characters
char charArray[128];

// allocate space for a pointer but not for
// the thing pointed at
char* pArray;
}

Here charArray allocates room for 128 characters. pArray allocates only 4 bytes — the amount of storage required by a pointer.

Consider the following example:

char charArray[128];
charArray[10] = '0'; // this works fine

char* pArray;
pArray[10] = '0'; // this writes into random location

The expression pArray[10] is syntactically equivalent to charArray[10], but pArray has not been initialized so pArray[10] references some random (garbage) location in memory.

The mistake of referencing memory with an uninitialized pointer variable is generally caught by the CPU when the program executes, resulting in the dreaded segment violation error that from time to time issues from your favorite applications under your favorite, or not-so-favorite, operating system. This problem is not generally the fault of the processor or the operating system, but of the application.

Another implication of this difference is that you can use a range-based for loop on an array where the size of the array is known but not on a pointer where the number of elements is not known:

char charArray[128];
for(char& c : charArray) { c = '\0';} // initialize array

char* pArray = charArray;
for(char& c : pArray) {c = '\0';} //not legal

The first range-based for loop can be used to initialize the charArray to null characters. The second for loop does not compile, however. Even though pArray is assigned the address of the character array with its 128 characters, C++ doesn't keep that size information with the pointer, so it doesn't know how far to iterate in the range-based for loop. (See Chapter 5 for a description of the range-based for loop.)

A second difference between a pointer and the address of an array is that charArray is a constant, whereas pArray is not. Thus, the following for loop used to initialize the array charArray does not work:

char charArray[10];
for (int i = 0; i < 10; i++)
{
*charArray = '\0'; // this makes sense...
charArray++; // ...this does not
}

The expression charArray++ makes no more sense than 10++. The following version is correct:

char charArray[10];
char* pArray = charArray;
for (int i = 0; i < 10; i++)
{
*pArray = '\0'; // this works great
pArray++; // this is ok - not a const pointer
}

When Is a Pointer Not?

C++ is completely quiet about what is and isn’t a legal address, with one exception. C++ predefines the constant nullptr with the following properties:

· It is a constant value.

· It can be assigned to any pointer type.

· It evaluates to false.

· It is never a legal address.

The constant nullptr is used to indicate when a pointer has not been initialized. It is also often used to indicate the last element in an array of pointers in much the same way that a null character is used to terminate a character string.

Actually the keyword nullptr was introduced in the 2011 standard. Before that, the constant 0 was used to indicate a null pointer.

It is a safe practice to initialize pointers to the nullptr (or 0 if your compiler doesn’t support nullptr yet). You should also clear out the contents of a pointer to heap memory after you invoke delete to avoid deleting the same memory block twice:

delete pHeap; // return memory to the heap
pHeap = nullptr; // now clear out the pointer

Passing the same address to delete twice will always cause your program to crash. Passing a nullptr (or 0) to delete has no effect.

Declaring and Using Arrays of Pointers

If pointers can point to arrays, it seems only fitting that the reverse should be true. Arrays of pointers are a type of array of particular interest.

Just as arrays may contain other data types, an array may contain pointers. The following declares an array of pointers to ints:

int* pInts[10];

Given the preceding declaration, pInts[0] is a pointer to an int value. Thus, the following is true:

void fn()
{
int n1;
int* pInts[3];
pInts[0] = &n1;
*pInts[0] = 1;
}

or

void fn()
{
int n1, n2, n3;
int* pInts[3] = {&n1, &n2, &n3};
for (int i = 0; i < 3; i++)
{
*pInts[i] = 0;
}
}

or even

void fn()
{
int* pInts[3] = {(new int),
(new int),
(new int)};
for (int i = 0; i < 3; i++)
{
*pInts[i] = 0;
}
}

The latter declares three int objects off the heap. This type of declaration isn’t used very often except in the case of an array of pointers to character strings. The following two examples show why arrays of character strings are useful.

Utilizing arrays of character strings

Suppose I need a function that returns the name of the month corresponding to an integer argument passed to it. For example, if the program is passed a 1, it returns a pointer to the string “January”; if 2, it reports “February”, and so on. The month 0 and any numbers greater than 12 are assumed to be invalid. I could write the function as follows:

// int2month() - return the name of the month
const char* int2month(int nMonth)
{
const char* pszReturnValue;

switch(nMonth)
{
case 1: pszReturnValue = "January";
break;
case 2: pszReturnValue = "February";
break;
case 3: pszReturnValue = "March";
break;
// ...and so forth...
default: pszReturnValue = "invalid";
}
return pszReturnValue;
}

The switch() control command is like a sequence of if statements.

A more elegant solution uses the integer value for the month as an index into an array of pointers to the names of the months. In use, this appears as follows:

// define an array containing the names of the months
const char *const pszMonths[] = {"invalid",
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"};

// int2month() - return the name of the month
const char* int2month(int nMonth)
{
// first check for a value out of range
if (nMonth < 1 || nMonth > 12)
{
return "invalid";
}

// nMonth is valid - return the name of the month
return pszMonths[nMonth];
}

Here int2month() first checks to make sure that nMonth is a number between 1 and 12, inclusive (the default clause of the switch statement handled that in the previous example). If nMonth is valid, the function uses it as an offset into an array containing the names of the months.

This technique of referring to character strings by index is especially useful when writing your program to work in different languages. For example, a program may declare a ptrMonths of pointers to Julian months in different languages. The program would initialize ptrMonth to the proper names, be they in English, French, or German (for example), at execution time. In that way, ptrMonth[1] points to the correct name of the first Julian month, irrespective of the language.

A program that demonstrates int2Month() is included in the extras at www.dummies.com/extras/cplusplus as DisplayMonths.

Accessing the arguments to main()

Now the truth can be told — what are all those funny argument declarations to main() in our program template? The second argument to main() is an array of pointers to null-terminated character strings. These strings contain the arguments to the program. The arguments to a program are the strings that appear with the program name when you launch it. These arguments are also known as parameters. The first argument to main() is the number of parameters passed to the program. For example, suppose that I entered the following command at the command prompt:

MyProgram file.txt /w

The operating system executes the program contained in the file MyProgram (or MyProgram.exe on a Windows machine), passing it the arguments file.txt and /w.

Consider the following simple program:

// PrintArgs - write the arguments to the program
// to the standard output
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

int main(int nNumberofArgs, char* pszArgs[])
{
// print a warning banner
cout << "The arguments to "
<< pszArgs[0] << " are:\n";

// now write out the remaining arguments
for (int i = 1; i < nNumberofArgs; i++)
{
cout << i << ":" << pszArgs[i] << "\n";
}

// that's it
cout << "That's it" << endl;

// wait until user is ready before terminating program
// to allow the user to see the program results
cout << "Press Enter to continue..." << endl;
cin.ignore(10, '\n');
cin.get();
return 0;
}

As always, the function main() accepts two arguments. The first argument is an int that I have been calling (quite descriptively, as it turns out) nNumberofArgs. This variable is the number of arguments passed to the program. The second argument is an array of pointers of type char* that I have been calling pszArgs.

Accessing program arguments DOS-style

If I were to execute the PrintArgs program from the command prompt window as

PrintArgs arg1 arg2 arg3 /w

nArgs would be 5 (one for each argument). The first argument is the name of the program itself. This could be anywhere from the simple “PrintArgs” to the slightly more complicated “PrintArgs.exe” to the full path — the C++ standard doesn’t specify. The environment can even supply a null string “ ” if it doesn’t have access to the name of the program.

The remaining elements in pszArgs point to the program arguments. For example, the element pszArgs[1] points to “arg1” and pszArgs[2] to “arg2”. Because Windows does not place any significance on “/w”, this string is also passed as an argument to be processed by the program.

Actually, C++ includes one final value. The last value in the array, the one after the pointer to the last argument of the program, contains nullptr.

To demonstrate how argument passing works, you need to build the program from within Code::Blocks and then execute the program directly from a command prompt. First ensure that Code::Blocks has built an executable by opening the PrintArgs projects and choosing Build⇒Rebuild.

Next, open a command prompt window. If you are running Unix or Linux, you’re already there. If you are running Windows, choose Programs⇒Accessories⇒Command Prompt to open an 80-character-wide window with a command prompt.

Now you need to use the CD command to navigate to the directory where Code::Blocks placed the PrintArgs program. If you used the default settings when installing Code::Blocks, that directory will be C:\CPP_Programs_from_Book\Chap09\PrintArgs\bin\Debug.

You can now execute the program by typing its name followed by your arguments. The following shows what happened when I did it in Windows 7:

C:\Users\Randy>cd \cpp_programs_from_book\chap09\printargs\bin\debug

C:\CPP_Programs_from_book\Chap09\PrintArgs\bin\Debug>PrintArgs arg1 arg2 arg3 /n
The arguments to PrintArgs are:
1:arg1
2:arg2
3:arg3
4:/n
That's it
Press Enter to continue...

Wild cards such as *.* may or may not be expanded before being passed to the program — the standard is silent on this point. The Code::Blocks/gcc compiler does perform such expansion on Windows, as the following example shows:

C:\CPP_Programs_from_book\Chap09\PrintArgs>bin\debug\PrintArgs *.*
The arguments to bin\debug\PrintArgs are:
1:bin
2:main.cpp
3:obj
4:PrintArgs.cbp
That's it
Press Enter to continue...

Here you see the names of the files in the current directory in place of the *.* that I entered.

Wild-card expansion is performed under all forms of Linux, as well as on the Macintosh.

Accessing program arguments Code::Blocks-style

You can add arguments to your program when you execute it from Code::Blocks as well. Choose Project⇒Set programs' arguments from within Code::Blocks. Enter the command line you would like in the Program arguments window.

Accessing program arguments Windows-style

Windows passes arguments as a means of communicating with your program as well. Try the following experiment: Build your program as you would normally. Find the executable file using Windows Explorer. (As noted earlier, the default location for the PrintArgs program isC:\CPP_Programs_from_book\Chap09\PrintArgs\bin\Debug.) Now grab a file and drop it onto the filename. (It doesn’t matter what file you choose because the program won’t hurt it anyway.) Bam! The PrintArgs program starts right up, and the name of the file that you dropped on the program appears.

Now try again, but drop several files at once. Select multiple filenames while pressing the Ctrl key or by using the Shift key to select a group. Now drag the lot of them onto PrintArgs.exe and let go. The name of each file appears as output.

I dropped a few of the files that appear in my \Program Files\WinZip folder onto PrintArgs as an example:

The arguments to C:\CPP_Programs_from_book\Chap09\PrintArgs\bin\Debug\PrintArgs.exe are:
1:C:\Program Files\WinZip\VENDOR.TXT
2:C:\Program Files\WinZip\WHATSNEW.TXT
3:C:\Program Files\WinZip\WINZIP.CHM
4:C:\Program Files\WinZip\WINZIP.TXT
5:C:\Program Files\WinZip\WINZIP32.EXE
6:C:\Program Files\WinZip\WZ.COM
That's it
Press Enter to continue...

Notice that the name of each file appears as a single argument, even though the filename may include spaces. Also note that Windows passes the full pathname of the file.