Thread: Need help with const pointers

It's dangerous in the sense that you might make a mistake inside a function you make.

Passing a regular pointer to a function means the function can mutiliate the object or primitive type that the pointer points to with almost no care whatsoever. Some functions need to alter the objects they are passed. For that, that's fine. Go for it.

The idea, though, is that if a function doesn't need to alter data, then it shouldn't be given the opportunity. It also improves readability to specifically denote parameters as being const when you don't want them to be messed with. If you notice the function takes a const pointer, you know right away that the function doesn't edit the pointer. That way, if you make a mistake inside the function, the compiler will warn you.

If the concept of disabling yourself seems like a foreign idea, think of it in terms of other items where you do the same thing. For example, using local variables instead of global ones. They improve readability, but they also protect you from mixing them up and using ones that are already being used by other functions. When you get to classes, you'll see that the identifiers public, protected, and private are all there to protect you from yourself (and others using your code from themselves). From the position of the computer, everything could be declared global or public or in this case with pointers, non-const, and all could be well. Since programmers are humans (well most of us for now ), and we tend to make mistakes, it's a good idea to employ safety items like this.

As for the prototype:

Code:

const SimpleCat * const FunctionTwo (const SimpleCat * const theCat);

The return type is this:

Code:

const SimpleCat * const

This means it returns a pointer to a SimpleCat object. The two const properties denote the following restrictions:

1. The pointer may not be made to point to another object (ie. the pointer itself is const).
2. The data that the pointer points to is considered to be const.

And so forth for the parameter.

Don't worry with protected for now. You'll come to it when you start reading about class inheritance.

As for the const keyword, do read about it. Particularly it's use with references and pointers. It's one of the most prevalent keywords you'll encounter and general advice is be pro-active about the constness of your declarations. That is, consider declaring everything const (variables, function parameters, member functions) unless you prove you shouldn't.

By the way, here's a trick to understand const with pointers. Read the line backwards:

const SimpleCat * const theCat

"theCat is a constant pointer to a SimpleCat that is constant".
-- This means, inside the function, you cannot change the pointer OR the object being pointed at.

This is functionally identical to:

SimpleCat const * const theCat

"theCat is a constant pointer to a constant SimpleCat"

That is, "const [typename] *" is the same as "[typename] const *" (the first way is the more common to write, but both are correct and equivalent).


Compare those to:

const SimpleCat * theCat

"theCat is a pointer to a SimpleCat that is constant".
-- This means, inside the function, you CAN change the pointer (to make it point to a different object) but CANNOT change the object being pointed at.

SimpleCat * const theCat

"theCat is a constant pointer to a SimpleCat ".
-- This means, inside the function, you cannot change the pointer, but you CAN change the object being pointed at.

Oh, and as to the question about why make it const at all:

Const correctness is a major goal of any program. When you make a function/method, when you're deciding what parameters you need, you should be deciding if they should be constant, too.

For example, let's say I'm making a function that takes a char * string (I really SHOULD use std::string but this is just an example) and displays it somewhere:

void displayString(char * str)

I ask myself "do I need to change the contents of the string?" and I answer "No." so I make the string constant:

void displayString(const char * str)

Then I ask myself "do I need to change which string the pointer points at?" and I answer "No" again, so I make the pointer constant too:

void displayString(const char * const str)


There's one other key use of const, and that is in the methods of a class. For example, consider this simple class:

Code:

class GameCharacter
{
     public:
          int GetHP();
          int GetMP();

     // Other stuff would go here...

};

Now, when I look at GetHP(), I ask "does this function need to change any of the variables of this class?", and I answer "No" because it reads the variables but doesn't alter them. Likewise for GetMP().

I then change the class as follows:

Code:

class GameCharacter
{
     public:
          int GetHP() const;
          int GetMP() const;

     // Other stuff would go here...

};