Using constants with functions

There always seems to be confusion in using const with functions. I am not referring to const functions that have const after the function name, that is straightforward. Also, the way functions behave when you have const before them is different than the built-in types. I have earlier provided a table for that.

Here is a simple program that shows different types of const with functions.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
#include<iostream>
#include<string>

using namespace std;

class A
{
public:
  int x;
};

class B
{
public:
  string y;
};

A* const createA()
{
  return (new A);
}

const B* createB()
{
  return (new B);
}

int main()
{
  A* a = NULL;
  a = createA();
  a->x = 100;
  cout<<"a.x = "<<a->x<<endl;
  delete a;

  const B* b = NULL;
  b = createB();
  //b->y = "Hello"; - Compilation error because b is constant
  (const_cast<B*>(b))->y = "Hello";
  cout<<"b.y = "<<b->y<<endl;
  delete b;

  A* const a2 = NULL;
  //a2 = createA(); - Compilation Error: 
                   // you cannot assign to a variable that is const

  A* const a3 = new A; //not possible to change what a3 points to now
  a3->x = 23456;
  cout<<"a3.x = "<<a3->x<<endl;
  delete a3;
  
  return 0;
}

The output is as follows:

Changing objects in 'const member functions' via Mutable

We saw last time an example of 'Const Member Functions' (also known as 'Inspectors'). In contrast the member functions without the const suffix are known as 'non-const member functions' or 'mutators'.

Sometimes it may be necessary to modify a data member (variable or object in your class) in a const member function. There are two approaches to do that. One is to use the const_cast and the other to use 'mutable'. I use both the approaches in the example below:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//This example shows how to change objects in const member functions
#include<iostream>

using namespace std;

class ABC
{
public:
  int func1(int a, int b);
  int func2(int a, int b) const;
private:
  int x;
  mutable int y;
};

int ABC::func1(int a, int b)
{
  x = a, y = b;
  cout<<"x = "<<x<<" and y = "<<y<<endl;
  return 0;
}

int ABC::func2(int a, int b) const
{
  //x = a; - COMPILE ERROR because its const
  int *temp = const_cast<int*>(&x); //Removing the const
  *temp = a; //OK now
  y = b; //OK because its defined as mutable
  cout<<"x = "<<x<<" and y = "<<y<<endl;
  return 0;
}

int main()
{
  ABC abc;
  abc.func1(3, 7);
  abc.func2(20, 40);
  return 0;
}

The output is as follows:

Const after a function name

Here is a classic example of putting const after a function name. What this means is that this function will not modify any private members of this class.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//This example shows what happens if const is put after a function
#include<iostream>

using namespace std;

class ABC
{
public:
  int func1(int a, int b);
  int func2(int a, int b) const;
private:
  int x,y;
};

int ABC::func1(int a, int b)
{
  x = a, y = b;
  cout<<"x = "<<x<<" and y = "<<y<<endl;
  return 0;
}

int ABC::func2(int a, int b) const
{
  //x = a, y = b; - NOT POSSIBLE, Compile Error
  cout<<"Cant change x and y"<<endl;
  return -1;
}

int main()
{
  ABC abc;
  abc.func1(3, 7);
  abc.func2(20, 40);
  return 0;
}

The output is as follows: