What is the function of constants in c plus plus?

Constants are simply variables that do not change value. This is particularly useful when we need to continually refer to the same value, such as the length of a fixed-length array:

const int array_max = 100;

int array[array_max];

for (int i=0; i<array_max; ++i) {

array[i] = i * i;

}

// ...

Using a constant in this way reduces the maintenance burden considerably. For example, suppose we later decide that we really needed 200 integers in our array instead of just 100. So long as our code uses the constant, array_max, we need only change the constant's value and that change will be reflected wherever the constant is used. If we has used the literal constant, 100, instead, we'd need to search through our code and update each usage of that literal. That can lead to human errors and inconsistency in our code.

All constants are allocated in the static segment (where all static variables are allocated) even when they are declare locally. The one exception is a constant formal argument:

void f (const int i) {

// ...

}

Arguments are always passed by value, so i will hold a copy of whichever value was passed to it. Being a copy, any changes made to i will not be reflected in the calling code, however if the function must not modify the value, declaring the formal argument constant ensures we don't inadvertently change the value.

Typically we use constant formal arguments when those arguments are pointers or references rather than values. When we pass an object by reference or by pointer, we are passing a copy of the object's address and this would allow the function to indirectly modify the object. This is known as a side-effect and is undesirable. To give assurance to the caller that the object will not be changed, we use a constant reference or pointer:

void f (const obj& x) {

// ...

}

If we actually want the function to modify the object, the best method of doing so is to return a new object by value and leave the argument constant:

obj f (const obj& x) {

// ...

}

In this way the caller can decide what to do with the returned object:

obj y;

obj z = f (y); // create a new object from y without changing y

y = f (y); // modify y

f (z); // ignore the modification completely

Note that returning objects by value is normally expensive as the object must be copied. However, objects that implement the move semantic can be returned extremely efficiently, particularly those objects that are really just resource handles. This includes all the standard library containers such as std::vector and std::list. Moving a vector is many times quicker than copying one because all we're really doing is changing ownership of the resource; and that's (almost) as efficient as copying a pointer and assigning NULL to the original.