C++ Primer Plus

Here, arp is the name of an array; hence, it is the address of its first element. But its first element is a pointer, so ppa has to be a pointer to a pointer to const antarctica_years_end, hence the **. There are several ways you could mess up this declaration. For example, you could omit the const, forget an * or two, transpose letters, or otherwise mangle the structure type. Here is an instance for which the C++11 version of auto is convenient. The compiler is perfectly aware of what type arp is, so it can deduce the correct type for you:

auto ppb = arp; // C++11 automatic type deduction

In the past, the compiler used its knowledge of the correct type to complain about errors you may have made in the declaration; now it can let its knowledge work for you.

How can you use ppa to access data? Because ppa is a pointer to a pointer to a structure, *ppa is a pointer to a structure, so you can use it with the indirect membership operator:

std::cout << (*ppa)->year << std::endl;

std::cout << (*(ppb+1))->year << std::endl;

Because ppa points to the first member of arp, *ppa is the first member, which is &s01. So (*ppa)->year is the year member of s01. In the second statement, ppb+1 points to the next element, arp[1], which is &s02. The parentheses are needed to get the correct associations. For example, *ppa->year would attempt to apply the * operator to ppa->year, which fails because the year member is not a pointer.

Is all this really true? Listing 4.23 incorporates all the preceding statements into a short program.

Listing 4.23. mixtypes.cpp

// mixtypes.cpp -- some type combinations

#include

struct antarctica_years_end

{

    int year;

 /* some really interesting data, etc. */

};

int main()

{

    antarctica_years_end s01, s02, s03;

    s01.year = 1998;

    antarctica_years_end * pa = &s02

    pa->year = 1999;

    antarctica_years_end trio[3]; // array of 3 structures

    trio[0].year = 2003;

    std::cout << trio->year << std::endl;

    const antarctica_years_end * arp[3] = {&s01, &s02, &s03};

    std::cout << arp[1]->year << std::endl;

    const antarctica_years_end ** ppa = arp;

    auto ppb = arp; // C++11 automatic type deduction

// or else  use const antarctica_years_end ** ppb = arp;

    std::cout << (*ppa)->year << std::endl;

    std::cout << (*(ppb+1))->year << std::endl;

    return 0;

}

Here’s the output:

2003

1999

1998

1999

The program compiles and works as promised.

Array Alternatives

Earlier this chapter mentioned the vector and array template classes as alternatives to the built-in array. Let’s take a brief look now at how they are used and at some of the benefits of using them.

The vector Template Class

The vector template class is similar to the string class in that it is a dynamic array. You can set the size of a vector object during runtime, and you can append new data to the end or insert new data in the middle. Basically, it’s an alternative to using new to create a dynamic array. Actually, the vector class does use new and delete to manage memory, but it does so automatically.

At this time we won’t venture very deeply into what it means to be a template class. Instead, we’ll look at a few basic practical matters. First, to use a vector object, you need to include the vector header file. Second, the vector identifier is part of the std namespace, so you can use a using directive, a using declaration, or std::vector. Third, templates use a different syntax to indicate the type of data stored. Fourth, the vector class uses a different syntax to indicate the number of elements. Here are some examples:

#include

...

using namespace std;

vector vi;        // create a zero-size array of int

int n;

cin >> n;

vector vd(n);  // create an array of n doubles

We say that vi is an object of type vector and that vd is an object of type vector. Because vector objects resize automatically when you insert or add values to them, it’s okay for vi to start with 0 size. But for the resizing to work, you would use the various methods that are part of the vector package.

In general, the following declaration creates a vector object vt that can hold n_elem elements of type typeName:

vector<typeName> vt(n_elem);

The parameter n_elem can be an integer constant or an integer variable.

The array Template Class (C++11)