I believe the question is better answered by demonstrating what pointers
do.
There are a couple of common reasons to use pointers:
- Optional semantics
- Pass without copy
- Write to a object outside the current scope
- Create an object that must exist outside its current scope
- Variable length data
Let us look at each in turn.
[indent=1]
Optional semantics
The first is simple. We have a function, and one or more parameters are "optional", that is the function has meaningful behaviour even if the parameter is omitted. Let us imagine you want to write a function that turns a string into an integer. Sometimes, when the string is not an integer, you want to report that as a critical error. Other times, you are happy enough to go with a default - you want to pass that in and have it returned.
One way to write that is to have two implementations, one with a parameter indicating the default:
int tryParseInt(std::string string) {
std::stringstream stream(string);
int result;
if(stream >> std::ws && stream >> result && stream >> std::ws && stream.eof()) {
return result;
}
throw std::runtime_error("Failed to parse " + string + " as integer");
}
int tryParseInt(std::string string, int defaultValue) {
std::stringstream stream(string);
int result;
if(stream >> std::ws && stream >> result && stream >> std::ws && stream.eof()) {
return result;
}
return defaultValue;
}
Now, we have duplicated the essential logic here.
Another way of implementing this is to have the logic written once, and use a pointer parameter for the "defaultValue". If the pointer is null, then there is no default and we throw an exception.
namespace {
int tryParseInt(std::string string, int *defaultValue) {
std::stringstream stream(string);
int result;
if(stream >> std::ws && stream >> result && stream >> std::ws && stream.eof()) {
return result;
}
if(defaultValue) {
return *defaultValue;
}
throw std::runtime_error("Failed to parse " + string + " as integer");
}
}
int tryParseInt(std::string string) {
return tryParseInt(string, nullptr);
}
int tryParseInt(std::string string, int defaultValue) {
return tryParseInt(string, &defaultValue);
}
Now we only have one function which needs to worry about how to parse strings, and it is configurable in how it deals with errors. Here I have presented it as a hidden helper function. I'm not necessarily advocating this as the most appropriate solution here, I'm just trying to give a simple example of an "optional" parameter.
This idea of optionality can also apply to member variables. Consider a simple Guard Ogre class. If it has seen a Player, it must chase them. If it has not, then it must walk around search for a Player, or some other edible morsel. One implementation is to treat the currently chased player as an
optional member. We can again use a pointer to indicate this.
We might write:
class OgreGuard {
public:
void update() {
if(!player) {
player = trySeePlayer();
}
if(player) {
chase(*player);
} else {
searchForPlayer();
}
}
private:
// ...
Player *target;
};
Again, there are other solutions.
In all cases, we are relying on the null pointer to provide a special value that can be tested for to indicate the presence of a value.
[indent=1]
Pass without copy
Let us imagine we have a lot of data in our program - a container with millions of elements for example. A simple example might be searching this container for a given element, returning the index on success and a negative value on failure.
A naive implementation might copy the elements into the function, and then do a linear search on the copy:
int searchCopy(std::vector<int> v, int value) {
for(int i = 0 ; i < v.length() ; ++i) {
if(v == value) {
return i;
}
}
return -1;
}
An alternative to passing a copy is somehow allow the function to see the original data. We can do this with a pointer or reference:
int searchPointer(const std::vector<int> *v, int value) {
if(!v) {
// TODO: what to do if passed NULL?
}
for(int i = 0 ; i < v->length() ; ++i) {
if((*v) == value) {
return i;
}
}
return -1;
}
int searchRef(const std::vector<int> &v, int value) {
for(int i = 0 ; i < v.length() ; ++i) {
if(v == value) {
return i;
}
}
return -1;
}
Note that the searchRef looks almost identical to the searchCopy, with the added bonus that it avoids copying. Sweet! Also note that searchPointer has a corner case: how should it handle being passed NULL?
Finally, note that by using "const" the compiler will warn us if we accidentally try to change the vector. We will see why this is a problem below.
[indent=1]
Write to a object outside the current scope
Now imagine we want to reverse strings. Like in the above case, the string might be very long. Again, the naive implementation might return a freshly reversed string:
std::string reverse(const std::string &input) {
std::string result;
for(int i = input.size() - 1 ; i >= 0 ; --i) {
resut.push_back(input);
}
return result;
}
However, we often don't care about the original order of the data, we just want it reversed. The naive implementation forces us to have both the original data and the reversed copy in memory, at least during the sorting process.
One approach is to instead reverse the data "in place". That is, instead of returning a fresh, sorted container, we simply re-arrange the elements in the original data. We can do this with a pointer or reference:
void reverseRef(std::string &string) {
int length = string.size();
for(int i = 0 ; i < length / 2 ; ++i) {
std::swap(string, string[length - i - 1]);
}
}
void reversePointer(std::string *string) {
if(!string) {
return;
}
int length = string->size();
for(int i = 0 ; i < length / 2 ; ++i) {
std::swap((*string), (*string)[length - i - 1]);
}
}
Again, we note that using a pointer here is uglier and introduces a special case where the input is NULL.
Note that this approach retains flexibility, because if the caller does care about the original order, they can always make a copy themselves and ask our function to sort this new copy in place:
int main() {
std::string original = readFile("reallyBigFile.txt");
std::string copy = original;
reverseRef(copy);
// Use reversed copy...
}
[indent=1]
Create an object that must exist outside its current scope
In C++, any automatically allocated objects exist in a given scope. For function local objects, once the function ends they are destroyed. We can only copy them out of the function. Sometimes, a copy isn't sufficient. Some objects are not copyable (e.g. file streams, sockets, in fact most OS level resources have no intuitive copy semantics). What would a copy of std::cin be? In other cases object "identity" is important, as distinct from the object's values. In these cases, we can use
new to allocate memory and create an object for us. This memory exists in a separate space to the automatic allocations, which means that when the function returns this memory is still valid. We receive a pointer to this memory.
We can return this pointer to calling functions, or possibly pass this pointer into a function which stores it (e.g. push_back the pointer into a vector). Conversely, if we do not store or return the pointer, we must de-allocate it, because when we return from the function the memory will not be cleaned up automatically.
[indent=1]
Variable length data
Imagine you want to read data from a file, or the console, but you don't know how much there is in advance. Also, you do not have access to the standard library for some reason (yes, it is contrived =P).
Again, the naive approach is to use a "really big" array, and hope that you never are asked to read more data than that.
int main() {
const int MAX = 1000; // Surely enough???
int array[MAX];
int index = 0;
while(std::cin) {
if(index == MAX) {
std::cerr << "Sorry bud, out of luck. This program supports up to " << MAX << " numbers.\n";
return 1;
}
if(std::cin >> array[index]) {
++index;
}
}
// Use the data
}
We can trivially see that if we enter 1001 numbers into this program, it cannot handle it.
However, another approach is to dynamically allocate the variable length data:
int main() {
int allocated = 1000;
int *data = new int[allocated];
int index = 0;
while(std::cin) {
if(index == allocated) {
int more = allocated * 2;
int *pointer = new int[more];
std::copy(data, data + allocated, pointer);
std::swap(data, pointer);
delete [] pointer;
allocated = more;
}
if(std::cin >> data[index]) {
++index;
}
}
// Use the data
}
This is bascially what std::string and std::vector do under the hood.
[hr]
Some of these are advanced concepts, and you might not have come across them yet.
Please note I have not tested any of the above code, it is just for illustration.
