const – constants in functions

genux — Fri, 29 Jan 2010 10:43:44 +0000

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

constant return type, cannot alter the returned value (unless you place it in a another variable)
constant parameter passed, you cannot alter the value1 in this case
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 ‘constTest::value’ in read-only structure
    // value = 3;
    const_cast<int&> (value) = passingValue;	// take off the const type restriction
    return value;
}
 
int returnInt(const int value1)
{
  // cannot alter the parameter value1
  //error: assignment of read-only parameter ‘value1’
  // value1 = value1+ 2;
  return (value1 + 2);
}
 
// returning a constant value, which means that you cannot do anything to the 
// returning value, but if you assign that value to another variable you can
const int returnConstInt(int value1)
{
    value1 = value1 + 2;
    return value1;
}
 
int main()
{
    // cannot alter the return value of the returnConstInt 
    //  increment of read-only location ‘returnConstInt(3)’
    // int constValue = returnConstInt(3)++;
    int constValue = returnConstInt(3);
    // but you can alter the value of returning int from returnConstInt if passed to a variable
    constValue++;
    cout << constValue << endl;
 
    constTest cTest;
    cout << cTest.returnIntConst(10) << endl;
    return 0;
}

and the output would be

6
10

Coding Friends » const

const – constants in functions