In C++, an array is a homogeneous collection of data that is stored in a contiguous memory location. We can store almost all types of data as array elements. In this article, we will learn how to store the array of pointers to strings in C++.
Array of Pointers to Strings in C++
A pointer to a string means that the pointer points to the first character in the sequence of characters that is terminated by a null character. In C++, we can use this pointer to represent strings.
An array of pointers to strings will simply be an array whose each element is a pointer that points to a string. We can also visualize this array as a 2D array of characters where each row contains a string and its size is also equal to that string.
To create an array of pointers to strings in C++, we declare an array of pointer types where each element points to a character.
Declaration of Array of Pointers to Strings
The basic form of declaring an array of pointers to strings in C++ is shown below.
Syntax
data_type* array_name[x];where,
- data_type: Type of data to be stored in each element. In this case, it’s char for strings.
- array_name: name of the array
- x: Number of pointers (or strings).
For Example, we can declare an array of pointers to strings say ‘str’ with 5 strings as:
char* str[5];Note: In this type of declaration, the array is allocated memory in the stack and the size of the array should be known at the compile time i.e. size of the array is fixed. We can also create an array dynamically in C++ by using new keyword as shown below.
Initialization of Array of Pointers to Strings
We can initialize an array of pointers to strings in C++ by using an initializer list as shown in the example below
char* str[5] = {"Hello", "World", "I", "am", "here"};Accessing Elements of Array of Pointers to Strings
We can access the strings stored in this array using their index value as usual:
array_name[i]where i is the index of the string.
Moreover, we can even access the character of a particular string by treating this array as 2d array.
array_name[i][j]where j is the index of the character.
We can also use the pointer representation for accessing the character
*(array_name[i] + j)or even treat the array as pointer too.
*(*(array_name + i) + j)The above is a property of array and is same for all other types of array. To learn more, visit - C++ Arrays
Updating the Elements of Array of Pointers to Strings
The elements of array of pointers to strings are pointers themselves so we can easily change where they points to by simply assigning the new address. So, we can directly assign the new string to the index where we want to.
Syntax
array_name[index] = "newString";Its fine till you want to update or modify the array element by element but dont try to change the characters of the string that an element is pointing to because they are stored as string literals in the read-only memory. Although it is possible to get their address, but as the name implies, it is not legal to modify the values stored in the read-only memory.
Example of Array of Pointer to Strings
// C++ Program to illustrate how to use array of pointers to
// strings
#include <cstring>
#include <iostream>
using namespace std;
#define SIZE 5
int main()
{
// declaring and initializing array of pointers
char* names[SIZE]
= { "Rahul", "Aman", "Abdul", "Ram", "Pradeep" };
// printing the last character of each string
for (int i = 0; i < SIZE; i++) {
int currentStrLen = strlen(names[i]);
// accessing character
char lastChar = names[i][currentStrLen - 1];
cout << lastChar << " ";
}
cout << endl;
// printing whole strings
for (int i = 0; i < SIZE; i++) {
cout << names[i] << " ";
}
cout << endl;
// updating element
names[2] = "Fashil";
// printing whole strings
for (int i = 0; i < SIZE; i++) {
cout << names[i] << " ";
}
return 0;
}
Output
l n l m p Rahul Aman Abdul Ram Pradeep Rahul Aman Fashil Ram Pradeep
Memory Representation
The advantages of using array of pointer to strings over 2D arrays of characters is that they are space efficient. Consider the following array of pointer to strings:
char* arr[3] = {"Geek", "Geeks", "Geeksfor"}To store the above strings in 2D array of chars, we have the following statement:
char arr[3][9] = {"Geek", "Geeks", "Geeksfor"}Now, the below image shows the memory representation of the two arrays. The lighter part is present only in the 2D array.
As we can see, even for the smallest string, the 2D array still have to allocate the same amount of space as that of the largest string. While, this is not the case of array of pointer to string.
Dynamic Array of Pointers to Strings in C++
All the above declarations are static and will be allocated in the heap. We can also create a dynamic array of pointers to strings using the new keyword.
Syntax of Dynamic Array of Pointers to Strings
char** array_name = new char*[size] {initial values....}In this way, we will create an array of pointer which is stored inside the heap memory. But the strings will still be stored in the read only memory. To store the strings in the dynamic memory, we will have to create a new memory block for each element of this array.
char** array_name = new char*[size];
array_name[i] = new char[strlen("value")];
strcpy(array_name[i], "value");
We can do this for dynamic array of pointer to strings OR...... we can directly use the inbuit containers for dynamic array and strings namely std::vector and std::string where we dont have to worry about size every time we do something.
Example of Dynamic Array of Pointers to String
// C++ Program to illustrate how to create a dynamic array
// of pointers to strings
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#define SIZE 3
using namespace std;
// driver code
int main()
{
// first method to create a dynamic array of pointers to
// strings
char** names1
= new char* [SIZE] { "Geek", "Geeks", "Geeksfor" };
// second method
char** names2 = new char*[SIZE];
// adding elements
names2[0] = new char[strlen("Ram")];
strcpy(names2[0], "Ram");
names2[1] = new char[strlen("Arun")];
strcpy(names2[1], "Arun");
names2[2] = new char[strlen("Vivek")];
strcpy(names2[2], "Vivek");
// using vector and strings
vector<string*> names3;
names3.push_back(new string("Geek"));
names3.push_back(new string("Geeks"));
names3.push_back(new string("Geeksfor"));
// printing all
cout << "First Array: ";
for (int i = 0; i < SIZE; i++) {
cout << names1[i] << " ";
}
cout << endl;
cout << "Second Array: ";
for (int i = 0; i < SIZE; i++) {
cout << names2[i] << " ";
}
cout << endl;
cout << "Last Array: ";
for (int i = 0; i < SIZE; i++) {
cout << *names3[i] << " ";
}
// freeing all memory
delete[] names1;
for (int i = 0; i < SIZE; i++)
delete[] names2[i];
delete[] names2;
// vector of string pointer will be deleted
// automatically
return 0;
}
Output
First Array: Geek Geeks Geeksfor Second Array: Ram Arun Vivek Last Array: Geek Geeks Geeksfor