Tag: const

Const is a constant type, it makes what is talking to a constant value. The value cannot be altered in anyway, a good reason for this could be for a constant string for error codes or if the value of a variable needs to be checked but not altered in anyway.

Pointers can be constants too and also there are many places that you can put the const type. Here are some examples

// constant integer value
const int constValue = 3;
// normal value.
int Value = 10;
 
//pointers can be constants too
const int * pConst = &constValue;
//the pConst is a pointer to a const int value, the value pointed to cannot be altered, but the pConst memory location can to where it is pointing to.
int * const pConst = &Value;
// here the pConst value pointed to can be altered, but the memory location for the pConst for where it is pointing to cannot be altered (always pointing to the same place).
// of course you can have both.
const int * const pConstConst = &constValue;
// here it is a const int value that has a const pointer that is not allow to change.

You can also place const around the function definition as well, there are three places where you can place the const type.

const int returnValue(const int value1) const;

In the order of the const on the function definition list

1. constant return type, cannot alter the returned value (unless you place it in a another variable)
2. constant parameter passed, you cannot alter the value1 in this case
3. constant “this”, this is the class that it is placed in and you cannot alter any values within that class

I have placed below some code that will hopefully explain more for the different types and also the error codes that come if you try and compile up if you are not obeying const rules and I placed the code below for what caused the error.

#include 

using namespace std;
// there are 3 different places you can put a const (constant)

// restriction on a function definition line.

// const int returnConstInt(const int value1) const

// {

// }

// in order of placement in the function definition line

// 1: cannot alter the returning value

// 2: cannot alter the passing value

// 3: cannot alter the values of "this" as being the class this
class constTest {

  private :

    int value;

  public:

    constTest() { value = 0;};
    int returnIntConst(int passingValue) const;

};
// cannot alter any value for the class variables e.g. value in this case.

// of course you could do a const_cast.. which takes off the constant (const) type

int constTest::returnIntConst(int passingValue) const

{

    // cannot alter any value inside the function

    // assignment of data-member