6.6. Functions and the const Keyword

Passing data to a function by value provides some insulation between the client (the caller) and the supplier (the function itself). Specifically, any changes made to the data within the function affect only the function's copy. For example, suppose that we want to rewrite the mortgage.cpp example from Chapter 3. The new version moves the code calculating and printing the amortization table to a function called from the program's main:

table(payment, principal, R, N);

table(principal * R / (1 - pow(1 + R, -N)), principal, R, N);

void table(double payment, double balance, double R, int N)
{
    double    total_interest = 0;
    double    total_principal = 0;

    for (int i = 1; i <= N; i++)
    {
        double    to_interest = balance * R;
        double    to_principal = payment - to_interest;
        total_interest += to_interest;
        total_principal += to_principal;

        balance -= (payment - to_interest);

        cout << setw(3) << i << ": " << setw(10) << balance <<
            setw(10) << to_interest << setw(10) << to_principal <<endl;
    }

    cout << endl << setw(25) << total_interest << setw(10) <<
        total_principal << endl;
}

struct ReallyBig
{
	char	code;
	double	cost;
		. . .
};

ReallyBig	widget;
		.
		.
		.
		.
function(widget);

Pass-by-pointer and pass-by-reference solve this problem by not copying the data. They maintain a single instance of the data in the caller's scope and create an alias for it in the function's scope. However, creating an alias eliminates the "protection" that prevents the function from modifying the original data. Applying the const keyword to a function parameter prevents the function from modifying it, even when passed by pointer or by reference, maintaining the protection.

const Reference Parameters

Used with a reference parameter, the const keyword prevents a function from changing it. Consequently, the function can't change the caller's argument. Attempting to change a const reference parameter is a compile-time error - the compiler halts the compilation process, flagging the attempt as a syntax error.

void function(const ReallyBig& big);

void function(const ReallyBig& big)
{
    //big.cost = 29.95;		// error
    //big.code = 'Z';		// error
		. . .
}

const Pointer Parameters

Pass-by-pointer is another efficient way of passing large amounts of data to a function. Like pass-by-reference, the const keyword prevents a function from modifying the data (i.e., the parameters). However, using const with pointer arguments is more complicated because it involves two variables: a pointer storing the address of the data and the data itself. Programmers can make either or both variables constant.

	void function1(const ReallyBig* p); // (c) void function1(ReallyBig const* p); // (c) void function2(ReallyBig* const p); // (d) void function3(const ReallyBig* const p); // (e) int main() { ReallyBig widget = { 'x', 19.95, ... }; function1(&widget); // (c) function2(&widget); // (d) function3(&widget); // (e) return 0; }
(a)	(b)

void function1(const ReallyBig* p) //void function1(ReallyBig const* p) { //p->cost = 29.95; // error p = new ReallyBig; }	void function2(ReallyBig* const p) { p->cost = 29.95; //p = new ReallyBig; // error }	void function3(const ReallyBig* const p) { //p->cost = 29.95; // error //p = new ReallyBig; // error }
(c)	(d)	(e)

Returning Constant Data

Data that a function returns by pointer or reference is also subject to change. Object-oriented programming and operator overloading, introduced in subsequent chapters, will make great use of this. However, there are situations where this changeability is more problematic than beneficial. For example, when returning an array (Chapter 7) or when a getter function returns a class member (Chapter 9). C++ also resolves these problems with the const keyword. The following examples primarily focus on syntax, leaving the details to the subsequent chapters.

Returning const References

const ReallyBig& function1()
{
	static ReallyBig widget = { 'x', 19.95, ... };
	return widget;
}

const ReallyBig& r1 = function1();

//r1.cost = 29.95;	// error
 
 

Returning const Pointers

const ReallyBig* function2()
{
	static ReallyBig widget = { 'x', 19.95, ... };
	return &widget;
}

const ReallyBig* p1 = function2();

//p1->cost = 29.95;		// error

p1 = new ReallyBig;		// okay

ReallyBig* const function3()
{
	static ReallyBig widget = { 'x', 19.95, ... };
	return &widget;
}

ReallyBig* const p2 = function3();

p2->cost = 29.95;		// okay

//p2 = new ReallyBig;		// error

Constant Member Functions

T* foo;

T* member() const;

T* member() const { return foo; }