C++ Array: Working With Arrays in C++

About Arrays in C++


Declaring and Intializing Arrays in C++: Arrays of Objects and Primitives


Arrays and Strings


C++ Array Size: The Size of an Array in C++


C++ Array of Arrays: Multidimensional Arrays in C++


Multidimensional Arrays in C++ Revisited: Dealing with Large Arrays


C++ Array Sort: Sorting Arrays in C++





About Arrays in C++



Arrays are relatively straightforward in C++, but as with everything else in C++, you don't get much fancy functionality without using add-on libraries.



If you need anything beyond basic array functionality in C++, you can often use functions in the algorithm standard library.



Beyond that you have two choices. Either link with the free industry-standard Boost libraries (which may slow down your compilation or even execution to the point where you feel like you want to tear your eyes out or emigrate to Yemen -- don't say I didn't warn you!), or you can use STL (Standard Template Library) vector class, which should come with your compiler.



Since C++ includes no automatic runtime error checking, arrays are a major source of memory leaks and 'access violations' or memory over-runs in C++; this reason alone commends the use of vector instead of the primitive array type for many applications.



Declaring and Intializing Arrays in C++: Arrays of Objects and Primitives



Declaring an array in C++ is very straightforward; you just give the array a name and specify how many items it should contain in square brackets after the name.



The following program declares two arrays.



    

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
// Array of five ints
int numbers[5];

// Array of four strings
string texts[4];
}



If you want to put a lot of data in your array, you'll probably want to put your data on the heap rather than the stack, where you can manage it yourself.



This basically means using new and delete to create and free the array, as follows. In this program, strictly speaking we're declaring pointers, not arrays.



However, pointers and arrays behave similarly in C++ for many purposes, and we can use the pointers declared below in pretty much the same ways that we'd use arrays.



    

#include <string>

using namespace std;

int main(int argc, char *argv[])
{
// Array of five hundred ints
int *numbers = new int[500];

// Array of four hundred strings
string *texts = new string[400];

// Free the memory
delete [] numbers;
delete [] texts;
}



If you want to declare your arrays and initialize them with data at the same time, you can do the following.



    

#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int numbers[] = {1, 2, 5, 10};

string texts[] = {"Apple", "Banana", "Orange"};

// Access element at index 0
cout << numbers[0] << endl;

// Access element at index 2
cout << texts[2] << endl;
}



    

1
Orange



Arrays and Strings



In C++ there is a primitive string type and also a standard string class (used above). The primitive string type is actually an array of 1-byte characters, where the last character is a null character (a numerical zero, in other words).



This program illustrates the fact.



    

#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
char text[] = "Hello there";

// Display the 'H'
cout << text[0] << endl;

// Display the null-terminator as a number
cout << (int)text[11] << endl;
}



    

H
0



C++ Array Size: The Size of an Array in C++



Short answer: use sizeof(array)/sizeof(element type) .



For example: sizeof(scores)/sizeof(int), where scores is an array of ints.



This does not work with pointers.



Long answer:



You can use the sizeof operator in C++ to find the size of a true array. However, if you've declared a pointer and allocated an array on the heap, you can't use sizeof . This is a key difference between true arrays and pointers in C++; an array knows its own size, but a pointer does not have any concept of how much memory it's pointing to -- it only knows how big each element is.



Let's take a look. This program creates two arrays, one 'normal' array and one array of values on the heap, referenced by a pointer. We then do a sizeof on both.



    

#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
// Create an array holding 3 fruits.
string fruit[] = {"Apple", "Orange", "Banana"};

// Create an array on the heap with new.
string *stuff = new string[3];
stuff[0] = "Apple";
stuff[1] = "Orange";
stuff[2] = "Banana";

// What does sizeof give us?
cout << sizeof(fruit) << endl;
cout << sizeof(stuff) << endl;

// Must always free memory allocated with new.
// The [] is needed because it's an array.
delete [] stuff;
}



    

12
4



Using sizeof on the true array has given us the total amount of memory the array takes up; on other words, the size of one item (4 bytes for a string object) multiplied by the number of items (3 in this case).



On the other hand, sizeof on the pointer only gives us the size of the pointer variable itself ; even a pointer to a char (one byte) would still give us 4 with sizeof , since the pointer itself requires 4 bytes to hold a memory address.



This means that if we have a pointer to an array in C++, there is no way to find out how many elements the pointer points to; it points to however many you imagine it to point to, and you can point it wherever you like -- be that at memory that you're allowed to write to, or memory that you definitely shouldn't write to.



With a true array, we can find out its size using sizeof(array)/sizeof(element type), as you can see in the following example.



    

#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
// Create an array holding 3 fruits.
string fruit[] = {"Apple", "Orange", "Banana"};

// This would not work if fruit was a pointer.
int size = sizeof(fruit)/sizeof(string);

// Loop through and print all values.
for(int i=0; i < size; i++) {
cout << fruit[i] << endl;
}
}



    

Apple
Orange
Banana



C++ Array of Arrays: Multidimensional Arrays in C++



You can declare multidimensional arrays in C++. Let's take a look at declaring and using a small, simple multidimensional array on the stack.



    

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
// Multidimensional array of numbers.
// We need to specify sizes for
// all except the first dimension.
int numbers[][3] =
{
{0, 1, 2},
{3, 4, 5}
};

for(int row=0; row < 2; row++)
{
for(int col=0; col < 3; col++)
{
cout << numbers[row][col] << endl;
}
}
}



    

0
1
2
3
4
5



At first it can be hard to remember which array index is which. The way I like to think of it is this. Suppose we've got a two-dimensional array of numbers, as above.



Since we've got an array of other arrays, numbers[i] then refers to an array. With the first index you specify, you're saying which array you want to use. The second index then specifies the element within that array; numbers[i][k].



Incidentally, this is the same order that you'd use with subscript matrix notation in mathematics; row first, then column.



You can of course create arrays of strings . However, take my advice and don't create arrays of primitive character strings unless really necessary. The possibilities for memory leaks are too great. Create arrays of standard 'string' types instead. You can find an example further up this page.



Multidimensional Arrays in C++ Revisited: Dealing with Large Arrays



If you have a large multidimensional array in C++, you probably don't want to store all your data on the stack. Consider working with an array of pointers, where each pointer is allocated with new and cleaned up with delete (or new [] and delete [] if you want your pointers to be pointers to arrays -- see the example earlier on).



Often the easiest solution is to store everything in a one-dimensional array, but then treat it as a multidimensional array conceptually.



In the following example, we work conceptually with a two dimensional array of ints; however, the ints are actually stored linearly.



    

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{

// Imagine we want a 2D array,
// 3 x 3 (usually you'd probably
// be working with much bigger
// numbers, or else these
// techniques would be overkill).
int width = 3;
int height = 3;

// Allocate enough memory for all
// 3 x 3 = 9 members.
// Note: we haven't caught the
// exception here; new() will
// most likely terminate your
// program at this point if there
// isn't enough memory available.
// Check your compiler's docs.
int *data = new int[width * height];

// Let's assign random values for
// each array element. Here
// we're treating the array
// as being one-dimensional.
for(int i=0; i < width * height; i++)
{
data[i] = rand();
}

// Now we'll treat the array as
// being conceptually 2D.
for(int row = 0; row < width; row++)
{
for(int col = 0; col < height; col++)
{
cout << data[row * width + col] << " ";
}
}

// Newline.
cout << endl;

// If you're worried about efficiency,
// you can do away with multiplications
// like this. Of course this only works
// if you're iterating sequentially.
int index = 0;
for(int row = 0; row < width; row++)
{
for(int col = 0; col < height; col++)
{
cout << data[index] << " ";
index++;
}
}

// Newline.
cout << endl;

// And finally, you can also do the
// same thing using pointers.
int *pData = data;
for(int row = 0; row < width; row++)
{
for(int col = 0; col < height; col++)
{
// De-reference the pointer to
// get at the data.
cout << *pData << " ";

// Move the pointer to point at
// the next item in the array.
// This works because pointers
// know what size chunks of data
// they're pointing to.
// You can't do this with a true
// array; you'd have to declare
// a pointer to the array, just
// like we've done here.
// Here, we didn't have to declare
// a new pointer (since we don't have
// a true array, just a pointer to data),
// but you might want to use a new
// pointer just so your original
// pointer carries on pointing at
// your data.
pData++;
}
}

// Newline.
cout << endl;
// Free the memory.
delete [] data;
}



    

16838 5758 10113 17515 31051 5627 23010 7419 16212
16838 5758 10113 17515 31051 5627 23010 7419 16212
16838 5758 10113 17515 31051 5627 23010 7419 16212



C++ Array Sort: Sorting Arrays in C++




You can sort an array in C++ using the STL sort() function found in in the standard namespace.


The sort function takes three parameters, the third one being optional. In fact in this case, sorting string objects in alphabetical order, we could have omitted our custom sort function. Your custom sort function just needs to return true if the first argument is less than the second. But you can omit the custom sort function if your objects overload the < operator, so that they can be compared using <.


The string class already overloads this operator, as it happens.


In the following example, you could sort in reverse alphabetical order just by swapping a and b in the custom sort function.


You can also sort numbers using sort() of course -- then you won't need a custom sort function unless you want them in reverse order or something.


    

#include <string>
#include <algorithm>
#include <iostream>

using namespace std;

bool sort_strings(const string& a, const string& b)
{
return a < b;
}

int main(int argc, char *argv[])
{
// Declare and initialize an array of strings.
string strings[] = {
"Fox",
"Beetroot",
"Zebra",
"Aardvark",
"Cabbage"
};

// Sort the array with STL sort.
sort(strings, strings + 5, sort_strings);

for(int i=0; i < sizeof(strings)/sizeof(string); i++)
{
cout << strings[i] << endl;
}
}



    

Aardvark
Beetroot
Cabbage
Fox
Zebra