Understanding C++ Program Structure

This chapter is from the book

Navigating C++ and Object-Oriented Design (Bk/CD-ROM)

Learn More Buy

This chapter is from the book

This chapter is from the book 

Navigating C++ and Object-Oriented Design (Bk/CD-ROM)

Learn More Buy

This chapter examines C++ program structure from the perspective of functions and data. We begin with function definitions, inline functions, recursion, pointers to functions, and functions with default arguments. To organize data for functions to access, we present structures and unions, member functions, and how to pass structures and unions as functions arguments efficiently with references. We also look at C++ storage classes, exceptions, and namespaces. Lastly, we discuss the run-time allocation and release of free store memory, using the C++ operators new and delete.

3.1 Functions

Functions group program statements into logical units. We do this to encapsulate actions that functions perform. Encapsulation is important because it separates and hides a function's programming details from its caller. With libraries of functions that provide separate compilation and linking of modules, we can call functions from anywhere in a program.

As with variables, you must define or declare functions before you call them. C++ functions have two formats. The first format is a function declaration, often called a function prototype.

 Type function_name(Type arg1, Type arg2, Type argN); 

Function prototypes give the compiler all the information it needs to verify the correctness of a function call: the function's name, its return type, the number of arguments, and each argument's type. A comma-separated list of types and argument names is a function's signature. In a signature, each Type may be distinct or the same as another one, and a function's return Type may be void or any built-in or user-defined type. A prototype whose signature is either empty or void designates a function with no arguments. Function prototypes must always precede function calls.

Function signatures specify unique functions, much like handwriting signatures identify people. Here are several examples of function prototypes.

 char *memcat(char *p, const char *q);   // legal
 void init(void);             // legal
 double getvalue();            // legal, (void) optional
 long fellow(int n, m);          // illegal, no type for m
 double area(double);           // legal, arg name optional
 input(char *);              // illegal, no return type

If a function's return type is void, the compiler reports compilation errors when you try to use its return value in a program. The argument names following their data types (p and q, for example) are optional in function prototypes, but a type must appear for each argument (as in long fellow(int n, int m)). Function prototypes with no arguments either use empty parentheses (as in getvalue()) or use the keyword void (as in init(void)).

The second format is a function definition.

 Type function_name(Type arg1, Type arg2, Type argN)
 {
  function body
 }

The first line has the same format as a function prototype but without the terminating semicolon. The rest of the definition (function body) is a block enclosed with { and }. Signatures that are not void must specify a type and a name for each argument. The scope of an argument (where it's valid) is inside the body of a function. Any C++ statement or construct is legal within the body of a function except another function definition.

 void g()
 {
  f();        // call function f()- error
  . . .
 }

 void f()
 {
  g();        // call function g()
  . . .
 }

A compilation error occurs where g() calls f() because the compiler has not seen a prototype for f(). Moving the function definition for f() before g() doesn't solve the problem, since f() now calls g() without a prototype. In this situation, a function prototype for f() or g() is necessary (void f(); for example) and must appear before its call.

Here's the function definition for area(), whose prototype appears earlier.

 double area(double radius) {
  const double pi = 3.14159;
  return pi * radius * radius;
 }

Note that area() uses a return statement to report a double result back to the caller. The formats for return are

 return;
 return (expression);
 return expression;

A return statement by itself appears only in functions whose return type is void. The parentheses are optional in return statements with expression. (We prefer to omit parentheses to improve readability and to cut down on typing.)

Our first example of a function is main(), where C++ programs begin execution. The formats are

 int main() { statements; }
 int main(int argc, char *argv[]) { statements; }

The first format works with programs that you execute with only a program name. The second format handles programs with character string command-line arguments. The second format makes each argument and the total number of command-line words available to your program. The variable argc is an integer equal to the number of words on the command line, including the program name (argc is always at least one). The variable argv is a pointer to an array of pointers to characters. Each pointer in the array points to the words on the command line. The first pointer, which is argv[0], points to the program name.

 int main(int argc, const char *argv[]) { statements; }

Suppose, for example, we execute a C++ program called com, as follows.

 $ com -r file 

The first command-line word is com, the name of the program (pointed to by argv[0]). The second word is -r (presumably a program option). The third command-line word is a file name called file. Figure 3.1 shows the memory layout.

Figure 3.1. Command-line arguments memory layout

Each element of the pointer array is a pointer to a NULL terminated (\0) character string from the command line. The last element of this pointer array is 0.

We use argv to access both characters and words from the command line, as Listing 3.1 shows.

Listing 3.1 Command-line arguments

 // com.C - command-line arguments
 #include <iostream.h>

 int main(int argc, const char *argv[])
 {
  if (argc != 3) {
    cerr << "Usage: " << argv[0] << " option filename" << endl;
    return 1;
  }
  cout << argv[1] << '\t' << argv[2] << endl;
  cout << argv[1][0] << '\t' << argv[1][1] << endl;
  return 0;
 }

 $ com
 Usage: com option filename

 $ com -r file
 -r  file
 -   r

The if statement verifies that com has two arguments (three words on the command line). If not, we use cerr to display a usage message on standard error and return a nonzero status (1) to the operating system.

The notation argv[i] is a pointer to the i'th word (starting at 0) on the command line. Likewise, argv[i][j] is the j'th character of the i'th command-line word (both indices start at 0). We return 0 (normal status) at the end of the program.

 argv[i][j] = *(argv[i] + j)  // equivalent expressions 

Our next example is a C++ program with function prototypes and definitions for our own functions.

Listing 3.2 Function prototypes and definitions

 // func.C - function prototypes and definitions
 #include <iostream.h>
 #include <stdlib.h>

 float f(float);           // outside function prototype

 int main(int argc, const char *argv[])
 {
  void g(float *);         // inside function prototype

  if (argc != 2) {
    cerr << "Usage: " << argv[0] << " number" << endl;
    return 1;
  }
  float m = atof(argv[1]);     // convert command-line number

  m = f(m);             // call by value
  cout << m << endl;

  g(&m);              // call by address
  cout << m << endl;
  return 0;
 }

 float f(float val)          // pass value
 {
  return val + 2;          // return value
 }
 void g(float *pf)           // pass address
 {
  *pf += 2;             // modify argument
 }

 $ func 6.5
 8.5
 10.5

The program displays a usage message on standard error if you execute it without a command-line argument. The prototype for atof(), an ASCII-to-float library routine, appears in the standard header file <stdlib.h>. Calls to function f() pass a floating point value, and calls to function g() pass a pointer to a float. Inside f(), we return a float that's two greater than the argument's value. We then use an assignment statement in the main program to modify m. Function g(), on the other hand, modifies argument m directly (updating it by 2) through the pointer argument. The output verifies that m changes with either approach (call by value followed by assignment or call by address with no assignment).

The function prototypes for f() and g() are forward references that direct the compiler's actions and provide type checking for the function calls. Note that a function prototype may appear inside or outside a function's definition. Now consider what happens when we add the following statements to this program.

 int n = atoi(argv[1]);         // convert command line number
 m = f(n);               // legal - convert int to float
 g(&n);                 // illegal - int *, not float *

The function atoi(), an ASCII-to-integer library routine, converts the command-line number to an integer. We pass this integer value to f() and assign the function's return value to m because C++ conversion rules allow int-to-float conversions, and vice versa. Conversion rules, however, do not apply to pointers. Hence, the compiler reports a compilation error when we call g() with the address of an int instead of the address of a float.

Inline Functions

C++ functions typically use a run-time stack to push arguments and return values. Programs that call functions repeatedly may therefore perform slowly. In these situations, the keyword inline can make function calls execute faster. The formats are

 inline Type function_name(Type arg1, Type arg2, Type argN);

 inline Type function_name(Type arg1, Type arg2, Type argN)
 {
  function body
 }

The compiler inserts function body code where you call an inline function. Inline functions, therefore, eliminate the code to push arguments and return values from the run-time stack. A program's performance improves (no function call overhead), but its size increases (each call inserts code from the body of an inline function).

Chapter 2 introduces macros that eliminate function call overhead with textual substitution (see "Macros" on page 51). Macros, however, are not type safe. Inline functions, on the other hand, give you the type safety of functions with the performance of macros. The compiler performs type checking with inline function arguments, and debuggers can trace program execution and set breakpoints. Furthermore, pointers to inline functions are legal. None of these features apply to macros.

Macros also have problems that do not apply to inline functions. To illustrate, let's contrast an inline function with a macro. The following MAX macro, for instance, determines a maximum from its two arguments. What happens when we use a ++ operator with one of its arguments?

 #define MAX(A, B) ((A) > (B) ? (A) : (B))

 int i = 8, j = 5;
 cout << MAX(i++, j) << endl;    // displays 9 (incorrect)

With a post increment (i++), the cout statement should display 8, but instead displays 9. The preprocessor output after textual substitution reveals the problem.

 cout << ((i++) > (j) ? (i++) : (j)) << endl; 

This expression evaluates incorrectly because variable i increments twice. In general, we can't use operators ++ or -- with macro arguments because textual substitution generates side effects.

Now let's convert MAX to an inline function for integers called max() and compare it to our macro version.

 inline int max(int a, int b) { return a > b ? a : b; }

 int i = 8, j = 5;
 cout << max(i++, j) << endl;    // displays 8 (correct)

The compiler inserts the code from the return statement in max() directly where we call the function. We pass the value of i before we increment it, resulting in 8, the correct answer.

Side effects are not the only problem with macros. Pointer arguments, for instance, compile with macro MAX, and the result may not be what you want. Inline function max(), on the other hand, generates compilation errors with pointer arguments.

Although we were successful in rewriting macro MAX as an inline function, it's not always possible to convert macros to inline functions. Consider what happens with the NELEMS macro (Listing 2.2 on page 76), which computes the number of elements in any array at compile time.

 #define NELEMS(A) (sizeof(A) / sizeof A[0])

 int buf[] = { 1, 3, 5, 7, 9 };
 cout << NELEMS(buf) << endl;         // displays 5

The NELEMS macro uses the sizeof operator to divide the size of an array by the size of its first element, resulting in the number of items in the array. The cout statement correctly displays 5, the number of elements in array buf. Now let's convert the NELEMS macro to an inline function called nelems() for integers and examine the result.

 inline int nelems(int a[]) { return sizeof(a) / sizeof a[0]; }

 int buf[] = { 1, 3, 5, 7, 9 };
 cout << nelems(buf) << endl;          // displays 1

The cout statement displays 1, which is incorrect. Why? When you pass the name of an array as an argument to a function, the compiler uses a pointer (int *a, or int a[], in this case). Therefore, nelems() divides the size of a pointer by the size of the first element of the array. (This is the same size on most machines, resulting in 1.) Not only does nelems() fail to work, it's not even as general as the macro version (NELEMS works for any array data type, whereas nelems() works only for integer arrays).

Despite isolated cases like NELEMS, we still recommend inline functions over macros. Judicious use of inline functions can make C++ programs perform well in most cases.

Recursive Functions

C++ functions may call themselves. Depending on the algorithm, recursive functions can simplify designs. Recursive functions, on the other hand, use the run-time stack extensively, making some programs run slowly.

Suppose, for example, we need to write a function to convert integers to hexadecimal character strings for display. Listing 3.3 is a program that calls a recursive function to perform the conversion.

Listing 3.3 Recursive integer-to-hexadecimal conversion

 // itoh.C - recursive integer-to-hex conversion
 #include <iostream.h>
 #include <stdlib.h>

 int main(int argc, const char *argv[])
 {
  unsigned int num;
  void itoh(unsigned int);

  if (argc == 1) {
    cerr << "Usage: " << argv[0] << " number" << endl;
    return 1;
  }
  num = atoi(argv[1]);
  itoh(num);           // conversion routine
  cout << endl;
  return 0;
 }

 void itoh(unsigned int n) {
  int digit;
  const char *hex = "0123456789abcdef";

  if ((digit = n / 16) != 0)
    itoh(digit);        // recursive call
  cout << hex[n % 16];
 }

 $ itoh 23456
 5ba0

The program expects one number on the command line, which it converts to an unsigned integer with atoi(). Otherwise, a cerr statement displays a usage message on standard error. The algorithm for the recursive function itoh() uses a "divide down" approach, converting the number (n) to a digit by dividing the number by 16. Each time itoh() calls itself, the run-time stack allocates new memory locations for digit and hex. Recursion continues until the division yields 0. At this point, the run-time stack "unwinds," and successive cout statements display the characters one at a time. The algorithm uses the remainder from a modulus operation (%) as an offset into a character string (hex) to convert an integer number between 0 and 15 to the ASCII characters '0' to '9' and 'a' to 'f'.

The itoh() function is short and simple because the recursive design easily implements the algorithm. Nonrecursive solutions are possible but not always as straightforward (see Exercise 1 on page 165).

 inline unsigned int fact(unsigned int n) {
  return (n <= 1) ? 1 : n * fact(n-1);
 }

Pointers to Functions

C++ pointers may point to your own functions or library functions. Pointers to functions are different than other pointer types because the addresses they contain typically reside in the code segment (often called the text area). The format for a pointer to a function is

 Type (*pfname)(Type arg1, Type arg2, Type argN); 

where pfname is a pointer to a function whose signature is (Type arg1, Type arg2, Type argN) and whose return type is Type. We need the parentheses surrounding the indirection operator and pointer (*pfname); otherwise, pfname is a function (not a pointer) that returns a pointer to Type. Figure 3.2 shows an example of a pointer to a function.

Figure 3.2. Pointers to functions

Once you define a function pointer, you assign it to the name of a function with the same signature you specify in your function pointer prototype. Here are several examples.

 int help(short, const char *);   // function prototype
 double game(int);         // function prototype
 int (*p)(short, const char *);   // pointer to function, returns int
 double (*q)(int) = game;      // initialize pointer to game()
 p = help;             // assign address to pointer p
 q = help;             // illegal - signatures don't match

Assigning help()'s address to p is legal because their signatures match. We cannot, however, assign help()'s address to q because q points to a function with a different signature.

You may initialize a function pointer on the same line as the function prototype declaration, as in

 double game(int), (*q)(int) = game;      // legal 

There are two ways to call functions with initialized function pointers.

 (*pfname)(arg1, arg2, argN);       // with dereference
 pfname(arg1, arg2, argN);        // without dereference

The indirection operator in the first format dereferences the pointer (parentheses are necessary). In the second format, the compiler calls the function with a pointer name (instead of a function name). To illustrate, suppose you want to call game() with a function pointer q. Either one of the following statements does the job.

 cout << (*q)(30);     // call game(30), return double
 cout << q(30);      // call game(30), return double

A common application of pointers to functions is dispatch tables, or arrays of pointers to functions. With a dispatch table, an index or simple lookup scheme calls a function from a table entry. The following program uses a dispatch table of mathematical functions from the math library. For simplicity, we restrict each table entry to a pointer to a math function that takes one double argument.

Listing 3.4 Dispatch table

 // calc.C - dispatch table for math functions
 #include <iostream.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>

 #define NELEMS(A) (sizeof(A) / sizeof A[0])

 struct math {
  const char *name;       // name of math function
  double (*pmf)(double);     // ptr to math function
 };

 math mtab[] = {          // dispatch table
  "sin", sin,
  "cos", cos,
  "exp", exp,
  "tan", tan,
  "sqrt", sqrt
 };

We build the dispatch table with two pointers, one that points to the name of a math function and one that points to the address of a math function with one double argument. Here is the rest of the program, which accesses the dispatch table and calls the appropriate math function.

Listing 3.5 Main program with dispatch table

 int main(int argc, const char *argv[])
 {
  if (argc != 3) {
    cerr << "Usage: " << argv[0] << " math_func double" << endl;
    return 1;
  }

  int mf;
  for (mf = 0; mf < NELEMS(mtab); mf++)       // lookup table
    if (strcmp(argv[1], mtab[mf].name) == 0)
      break;

  if (mf == NELEMS(mtab)) {         // found it?
    cerr << "math_func " << argv[1] << " not found" << endl;
    return 1;
  }

  double arg = atof(argv[2]);        // convert the argument
  cout << mtab[mf].pmf(arg) << endl;     // call function, display
  return 0;
 }

The NELEMS macro determines the number of elements in dispatch table mtab. If we do not find a function name from the command line that matches a table entry, we display an error message. Otherwise, we break from the for loop when we find a matching name. The statement

 cout << mtab[mf].pmf(arg) << endl;    // call function, display 

calls the appropriate math function from the dispatch table. Here are some sample runs.

 $ calc sqrt 81
 9
 $ calc exp 3
 20.0855

 typedef void (*Pfunc)(void *, int);   // ptr to void function

 void gather(void *, int);        // void function
 Pfunc pf = gather;           // initialize pointer
 

The Right-Left Rule

It's not always easy to decipher declarations that have pointers to functions and arrays in C++. Consider the following.

 block *(*g())[10];     // what does this mean? 

A technique called the Right-Left Rule¹<span class="docEmphasis"></span> helps you interpret advanced declarations like this. In C++, a declaration may include various combinations of pointers, arrays, and functions. To parse such declarations, the compiler has to sort out the attributes listed in Table 3.1.

Table 3.1. Attributes

For simplicity, we assume void signatures for function attributes. Recall that () and [] evaluate left-to-right and have a higher precedence than * (see "C++ operator precedence" on page 776). This means the declarations in Table 3.2 are legal.

Table 3.2. Legal attribute combinations

Of course, we can extend these concepts to even greater complexity. For example, *[][] is a two-dimensional array of pointers. The fundamental attributes for pointers (*), arrays ([]), and functions (()), however, are all we need to derive more complex combinations.

Not all combinations of these attributes are legal. Table 3.3 lists some illegal ones.

Table 3.3. Illegal attribute combinations

You may, however, have functions that return pointers to arrays, arrays of function pointers, and functions that return pointers to functions.

Table 3.4 lists the English keywords for the attributes, followed by the Right-Left Rule.

Table 3.4. Attributes and Keywords

Right-Left Rule:

1. Start with the identifier.

2. Look to the right for an attribute.

3. If none is found, look to the left.

4. If found, substitute English keyword.

5. Continue right-left substitutions as you work your way out.

6. Stop when you reach the data type in the declaration.

This rule applies to any C++ declaration or definition, simple or complicated. Let's try it with some simple definitions first.

 unsigned long buf[10];   // buf is an array of 10 unsigned longs
 unsigned long *p[2];    // p is an array of 2 pointers to
               // unsigned longs

In the first example, buf is the identifier. Look to the right for the [] attribute. We stop at the data type (unsigned long). Therefore, buf is an array of 10 unsigned longs. In the second example, p is the identifier. Look to the right for the [] attribute, then to the left for the *. This means p is an array of 2 pointers to unsigned longs.

Remember that multidimensional arrays use the [] attribute more than once.

 data *ps[3][4];      // ps is a 3 by 4 array of pointers to data 

In this case, continue to the right until you've run out of []'s before you look left. Here, ps is an array of 3 arrays of 4 pointers to type data. This, of course, is better understood as a 3 by 4 array of pointers to type data.

Now let's try a more complicated declaration.

 int (*pa[5])();       // pa is an array of 5 pointers to functions
               // that return integers

pa is the identifier. Looking right, we find that pa is an array. Looking left, we see that it's an array of pointers. Looking right, we discover each array element is the address of a function that returns an integer. This means pa is an array of 5 pointers to functions that return integers.

 int *pa[5]();     // illegal 

A small change to the original declaration creates a slightly different one.

 int *(*pa[5])();      // pa is an array of 5 pointers to functions
              // that return pointers to integers
 

Now let's apply the Right-Left Rule to decipher the declaration from the start of this section.

 block *(*g())[10];     // g is a function that returns a pointer
              // to an array of pointers to block
 

g is the identifier. Looking right, we know that g is a function. Looking left, we see that this function returns a pointer. Looking right, we find that the function returns a pointer to an array. Looking left once more, we discover that each array element is a pointer to type block. Therefore, g is a function that returns a pointer to an array of 10 pointers to type block. Again, note that the parentheses between the () and [] attributes are necessary.

The Right-Left Rule also helps you construct C++ declarations from English sentences. See if you agree with the following steps for an array of 10 pointers to functions that return pointers to integers. Start with the name of the array (buf) and place the first attribute on the right.

 buf[10]        // buf is an array of 10
 *buf[10]        // buf is an array of 10 pointers
 (*buf[10])()      // buf is an array of 10 pointers to functions
 int *(*buf[10])();   // buf is an array of 10 pointers to functions
            // that return pointers to integers

Arrays as Function Arguments

The Basic Rule (page 40) explains the relationship between arrays and pointers and how array subscripts and pointer expressions are equivalent. Another part of C++ where arrays and pointers play a major role is with function arguments. Instead of passing entire arrays to functions (which is inefficient), the compiler passes only their addresses. You cannot, therefore, pass arrays by value in C++.

When you pass the name of an array as an argument to a function, the compiler actually passes a pointer. To demonstrate, let's investigate function prototypes for one-dimensional arrays.

 void f(int *);             // 1D function prototype
 void f(int []);             // 1D equivalent prototype

 int a[10];               // 1D array of 10 integers
 f(a);                  // call function with 1D array

 void f(int *p)  { ... p[i] ... }    // 1D function definition
 void f(int p[]) { ... p[i] ... }    // 1D equivalent definition

In prototypes with one-dimensional arrays, [] and * are synonymous. You may use either [] (array notation) or * (pointer notation) in the corresponding function definition. The length of a one-dimensional array ([10], in this example) is not necessary in either a function prototype or a definition. The Basic Rule explains why.

 p[i] = *(p + i)          // 1D pointer expression 

Inside function definitions with one-dimensional array arguments, the compiler resolves array subscripts with an offset (i) from the array's starting address (p). Even if you include an array's length inside square brackets (int p[10], for instance), the compiler ignores it.

When you pass the name of a multidimensional array as an argument to a function, the compiler still passes a pointer, but the notation changes. Let's start with two-dimensional arrays.

 void f(int (*)[10]);       // 2D function prototype
 void f(int [][10]);       // 2D equivalent prototype

 int a[5][10];          // 2D array of 5 x 10 integers
 f(a);              // call function with 2D array

 void f(int (*p)[10]) {     // 2D function definition
  ... p[i][j] ...        // 2D array subscript
 }

 void f(int p[][10]) {      // 2D equivalent definition
  ... p[i][j] ...        // 2D array subscript
 }

With two-dimensional array arguments in function prototypes and definitions, the first size (5) is optional but the second size (10) is not. You must include parentheses (*) with pointer notation, and the second size must be a constant integer expression. To help you understand this notation and why you must follow these rules, let's discuss how the compiler builds two-dimensional arrays and resolves p[i][j] array subscripts.

For two-dimensional arrays, the first size is the number of rows and the second size is the number of columns.

 int a[5][10];           // 5 rows by 10 columns 

The compiler allocates a block of memory that holds 50 (5 times 10) integers. When you use two-dimensional array subscripts (a[i][j]), the compiler generates the following pointer expression to locate array elements.

 *(&a[0][0] + 10 * i + j)       // 2D storage map equation 

We call this pointer expression a storage map equation. Every multidimensional array in a program has one. Storage map equations are machine and compiler dependent, but most compilers locate array elements by multiplying the first subscript (i) by the number of columns, then add this value to the second subscript (j) to calculate an offset from the base of the array (&a[0][0]). Dereferencing this pointer offset (*) evaluates to an array element. Note that the number of rows does not appear in a storage map equation for two-dimensional arrays.

When you pass the name of a two-dimensional array to a function, the compiler uses the array's starting address (p) and a storage map equation to resolve array subscripts.

 p[i][j] = *(p + 10 * i + j)   // 2D pointer expression 

Since the number of rows (5) does not appear in the storage map equation, it is not necessary to include it in either a function prototype or a function definition. You must, however, include the number of columns (10); otherwise, the compiler generates compilation errors.

 void f(int *[10]);         // 1D function prototype

 int a[5][10];            // 2D array of 5 x 10 integers
 f(a);                // illegal - doesn't match

 int *b[10];             // 1D array of 10 ptrs to ints
 f(b);                // legal - matches

 void f(int (*)[10][20]);        // 3D function prototype
 void f(int [][10][20]);         // 3D equivalent prototype

 int a[5][10][20];            // 3D array of 5 x 10 x 20 ints
 f(a);                  // call function with 3D array

 void f(int (*p)[10][20]) {       // 3D function definition
  ... p[i][j][k] ...          // 3D array subscript
 }

 void f(int p[][10][20]) {       // 3D equivalent definition
  ... p[i][j][k] ...          // 3D array subscript
 }

 int a[5][10][20];    // 5 grids by 10 rows by 20 columns 

 *(&a[0][0][0] + 10 * i + 20 * j + k)   // 3D storage map equation 

 p[i][j][k] = *(p + 10 * i + 20 * j + k)   // 3D pointer expression 

 Type function_name(Type arg1 = value1, Type argN = valueN); 

 static double dval = 3.4;         // external static
 double val = 5.6;             // global

 void sub() {
  enum { max = 100 };           // enumeration
  int m1 = 10;              // local integer
  static int m2 = 6;           // local (static) integer
  void f(double s = sin(.5));       // legal - function call
  void g(int i = m1);           // illegal - local
  void h(int m = max);          // legal - enumeration
  void w(int j = val);          // legal - global
  void x(double d = dval);        // legal - external static
  void y(int k = m2);           // legal - local static
  void s(char *p, int len = strlen(p));  // illegal - local
 }

 Type function_name(Type arg1, Type argN = valueN); 

 void u(int i=5, float m=3, char c='x');    // legal
 void w(int i, float m=3, char c='x');     // legal
 void x(int i, float m, char c ='x');     // legal
 void y(int i=5, float m, char c='x');     // illegal
 void z(int i=5, float m=3, char c);      // illegal

 // error.h - default arguments
 void error(const char *msg = "fatal error", int dlevel = 0);

 error("start process");  // legal - msg = "start process", dlevel = 0
 error("bad token",1);   // legal - msg = "bad token", dlevel = 1
 error("no value", 2);   // legal - msg = "no value", dlevel = 2
 error();          // legal - msg = "fatal error", dlevel = 0
 error(1);         // illegal - no msg specified

 void error(const char *msg, int dlevel) {
  extern int Debug;
  if (dlevel == 0 || Debug >= dlevel)
    cerr << msg << endl;
 }

 // error.h - default arguments (extended)
 void error(const char *msg = "fatal error", int dlevel = 0,
      bool kill = false);

 void error(const char *msg, int dlevel, bool kill) {
  extern int Debug;

  if (dlevel == 0 || Debug >= dlevel)
    cerr << msg << endl;
  if (kill)
    exit(1);
 }

 // old calls - same as before
 error("start process"); // legal - msg = "start process", dlevel = 0
 error("bad token",1);  // legal - msg = "bad token", dlevel = 1
 error("no value", 2);  // legal - msg = "no value", dlevel = 2
 error();         // legal - msg = "fatal error", dlevel = 0
 error(1);        // illegal - no msg specified

 // new calls
 error("no memory", 2, true);   // legal - msg = no memory",
                 // dlevel = 2, kill = true
 error(2,1);       // illegal - no msg specified

 #include <stdarg.h> 

 Type function_name(Type arg, ...); 

 Type function_name(const char *fmt, ...);
 Type function_name(int num, ...);

 int printf(const char *fmt, ...); 

 char buf[80]; int m;
 printf("%s %d\n", buf, m);

 Type function_name(int num, ...); 

 char *merge(int num, ...);
 char buf1[max1], buf2[max2], buf3[max3];

 cout << merge(2, buf1, buf2);
 cout << merge(3, buf1, buf2, buf3);

 char *strcat(char *, const char *);
 int strcmp(const char *, const char *);

 char buf[80];
 strcat(strcat(buf, "alpha"), "bet");

 strcat(strcat(strcat(buf, "alpha"), "bet"), " soup") ; 

 // scmp.C - string comparisons for three or more character strings
 #include <iostream.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>

 int main()
 {
  bool scmp(int, ...);   // variable arg list prototype
  char *s1 = "one";
  char *s2 = "two";
  char *s3 = "three";
  char *s4 = "four";

  cout << (scmp(3, s1, s2, s3)? "same" : "different")
     << " strings" << endl;
  cout << (scmp(4, s1, s2, s3, s4)? "same" : "different")
     << " strings" << endl;
  cout << (scmp(4, s1, s1, s1, s1)? "same" : "different")
     << " strings" << endl;
  return 0;
 }

 bool scmp(int num, ...) {
  va_list args;       // argument list
  va_start(args, num);   // init argument list, get number
  const char *s, *t;
  bool rval = true;         // return value
  s = va_arg(args, const char *);    // get first string

  while(--num) {
    t = va_arg(args, const char *);  // get next string
    if (strcmp(s, t)) {        // are they the same?
     rval = false;          // strings are different
     break;
    }
  }
  va_end(args);             // cleanup argument list
  return rval;             // return result
 }

 $ scmp
 different strings
 different strings
 same strings