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 in the function only affect 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);

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;
}

However, there is a potential disadvantage of pass-by-value. If the data passed to the function is large, the system requires additional time to copy it. Pass-by-pointer and pass-by-reference solve the copying problem by not copying the data and maintaining a single copy of the data in the caller's scope. They create an alias for the data in the function's scope by passing a pointer or reference to one of the function's parameters. However, creating an alias eliminates the "protection" that prevents the function from modifying the original data. Is there some way to enjoy the advantage of a fast-passing technique while maintaining the protection? Applying the const keyword to a function parameter prevents the function from modifying it.

const Reference Parameters

Used with a parameter, the const keyword forms a promise or guarantee that the function will not change its parameter and, therefore, it won't change the caller's argument. If the function attempts to change the parameter, the compiler halts the compilation process, flagging the attempt as a syntax error.

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

ReallyBig	large;
		.
		.
		.
		.
function(large);

void function(const ReallyBig& big)
{
	double tax = big.cost * 0.077;
	//big.code = 'Z';
		. . .
}

const Pointer Parameters

Pass-by-pointer is another efficient way of passing large data items to functions. Like pass-by-reference, the const keyword prevents a function from modifying the data (i.e., the parameters). However, using const with pointer arguments requires a little more thought than it did with references because a pointer subtly requires two related but distinct variables: the pointer storing the address of the data and the data itself. Programmers can make either or both variables constant.

	void function1(const ReallyBig* p); void function2(ReallyBig* const p); int main() { ReallyBig widget = { 'x', 19.95, . . . }; function1(&widget); function2(&widget); return 0; }
(a)	(b)
void function1(const ReallyBig* p) { //p->cost = 29.95; // error p = new ReallyBig; }	void function2(ReallyBig* const p) { p->cost = 29.95; //p = new ReallyBig; // error }
(c)	(d)

Returning Constant Data

Data a function returns by pointer or reference is also subject to change. This condition is beneficial sometimes but becomes increasingly problematic when the returned data is an array (the next chapter), C-string (Chapter 8), or a class member (Chapter 9). C++ also resolves these problems with the const keyword.

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

object.member()

void member() const;

void member() const { . . . }