What is the function of constants in c plus plus?

Answer 1

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.

Answer 2

Unlike a variable, which is expected to change its value from time to time, a constant is a value that we do not expect to change.

When passing references to functions, it's always reassuring to see the reference parameter has been declared const, as this assures us the object's immutable members will not be altered by the function. If the parameter is variable (non-const), we can expect the object to be altered. If we don't want the object altered, we must pass a copy of our object instead.

Copy constructors always use a constant reference. This makes sense since we're only every interested in copying the object's members, not to alter them.

class cMyClass

{

public: // copy constructor...cMyClass( const cMyClass & myClass):m_Data( myClass.m_Data ){}

private: int m_Data;

};

We can also declare values to be constants that are local to a class, or local to a function. For instance, in a playing-card simulation, we know in advance that, in any one deck of cards, there can only ever be 52 playing cards. Since this is highly unlikely to change for the duration the program is running, we can declare a global constant that we can use wherever we would have otherwise used the literal value 52.

static const int MAX_CARDS = 52;

The use of upper-case is a visual aid -- to remind us it is a global constant, not a variable.

Answer 3

Yes, you can. But output of program employing constant functions might surprise you. The best way is to experiment and see how it works.