Chapter II. Modular programming in C++

In the language C++ parameters can be grouped in two categories on the basis of how they are passed. There are input parameters passed by value and variable parameters  passed by reference.

double enumber(int n) {
    double f = 1;
    double eseq = 1;
    for (int i=2; i<=n; i++) {
        eseq += 1.0 / f;
        f *= i;
    }
    return eseq;
}

int main(){
    long x =1000;
    cout << enumber(x)<< endl;
    cout << enumber(123) << endl;
    cout << enumber(x + 12.34) << endl;
    cout << enumber(&x) << endl;
}

cout << enumber((int)&x) << endl;

void pswap(double *p, double *q) {
    double c = *p;
    *p = *q;
    *q = c;
}
 
int main(){
    double a = 12, b =23;
    pswap(&a, &b);
    cout << a << ", " << b<< endl; // 23, 12
}

void rswap(double & a, double & b) {
    double c = a;
    a = b;
    b = c;
}
 
int main(){
    double x = 12, y =23;
    rswap(x, y);
    cout << x << ", " << y << endl; // 23, 12
}

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
struct svector {
    int size;
    int a[1000];
};
 
void MinMax(const svector & sv, int & mi, int & ma) {
mi = ma = sv.a[0];
for (int i=1; i<sv.size; i++) {
        if (sv.a[i]>ma)
            ma = sv.a[i];
        if (sv.a[i]<mi)
            mi = sv.a[i];
}
}
 
int main() {
    const int maxn = 1000;
    srand(unsigned(time(0)));
    svector v;
    v.size=maxn;
    for (int i=0; i<maxn; i++) {
        v.a[i]=rand() % 102 + (rand() % 2012);
    }
    int min, max;
    MinMax(v, min, max);
    cout << min << endl;
    cout << max << endl;
}

int Gcd(const int & a, const int & b ) {
    int min = a<b ? a : b, gcd = 0;  
    for (int n=min; n>0; n--)
        if ( (a % n == 0) && (b % n) == 0) {
            gcd = n;
            break;
        }
    return gcd;
}
 
int main() {
    cout << Gcd(24, 32) <<endl; // 8
}

The following subchapters will broaden our knowledge about parameters for different types with the help of examples. In the examples of this subchapter, the definition of functions is followed by the presentation of the function call after a dotted line. Of course, we give the whole program code for more complicated cases.

void PrintOutF(double data, int field, int precision) {
    cout.width(field);
    cout.precision(precision);
    cout << fixed << data << endl;
}
...
PrintOutF(123.456789, 10, 4);  //  123.4568

long Product(int a, int b) {
   return long(a) * b;
}
...
cout << Product(12, 23) <<endl; // 276

void Cube(double a, double & surface_area, double & volume, 
          double & diagonal) {
    surface_area = 6 * a * a;
    volume = a * a * a;
    diagonal = a * sqrt(3.0);
}
...
double f, v, d;
Cube(10, f, v, d);

struct complex {
           double re, im;
       };

void CSum1(const complex*pa, const complex*pb, complex *pc){
  pc->re = pa->re + pb->re;
  pc->im = pa->im + pb->im;
}

complex CSum2(complex a, complex b) {
  complex c;
  c.re = a.re + b.re;
  c.im = a.im + b.im;
  return c;
}

complex Csum3(const complex & a, const complex & b) {
  complex c;
  c.re = a.re + b.re;
  c.im = a.im + b.im;
  return c;
}

int main() {
    complex c1 = {10, 2}, c2 = {7, 12}, c3;
    
    // all the three arguments are pointers
    CSum1(&c1, &c2, &c3); 
    
    c3 = CSum2(c1, c2);   // arguments are structures
    
    // arguments are structure references
    c3 = CSum3(c1, c2);  
}

long VectorSum1 (const int vector[], int n) {
  long sum = 0;
  for (int i = 0; i < n; i++) {
     sum+=vector[i];   // or sum+=*(vector+i);
  }
  return sum;
}
...
int v[7] = { 10, 2, 11, 30, 12, 7, 23};
cout <<VectorSum1(v, 7)<< endl;  // 95
cout <<VectorSum1(v, 3)<< endl;  // 23

long VectorSum2 (const int * const vector, int n) {
  long sum = 0;
  for (int i = 0; i < n; i++) {
     sum+=vector[i];   // or sum+=*(vector+i);
  }
  return sum;
}

void Sort(double v[], int n) {
    double temp;
    for (int i = 0; i < n-1; i++) 
        for (int j=i+1; j<n; j++)
            if (v[i]>v[j]) {
                temp = v[i];
                v[i] = v[j];
                v[j] = temp;
            }
}
 
int main() {
    const int size=7;
    double v[size]={10.2, 2.10, 11, 30, 12.23, 7.29, 23.};
    Sort(v, size);
    for (int i = 0; i < size; i++) 
        cout << v[i]<< '\t';
    cout << endl;
}

long VectorSum3 (const int (&vector)[6]) {
  long sum = 0;
  for (int i = 0; i < 6; i++) {
     sum+=vector[i];   // or sum+=*(vector+i);
  }
  return sum;
}
...
int v[6] = { 10, 2, 11, 30, 12, 7};
cout << VectorSum3(v) << endl;

int m[2][3];

void PrintMatrix23(const int matrix[2][3]) {
  for (int i=0; i<2; i++) {
     for (int j=0; j<3; j++)
       cout <<matrix[i][j] <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrix23(m);

10      2       12
23      7       29

void PrintMatrixN3(const int matrix[][3], int n) {
  for (int i=0; i<n; i++) {
     for (int j=0; j<3; j++)
       cout <<matrix[i][j] <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrixN3(m, 2);
cout << endl;
int m2[3][3] = { {1}, {0, 1}, {0, 0, 1} };
PrintMatrixN3(m2, 3);

10      2       12
23      7       29

1       0       0
0       1       0
0       0       1

void PrintMatrixNM(const void *pm, int n, int m) {
  for (int i=0; i<n; i++) {
     for (int j=0; j<m; j++)
        cout <<*((int *)pm+i*m+j) <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrixNM(m, 2, 3);
cout << endl;
int m2[4][4] = { {0,0,0,1}, {0,0,1}, {0,1}, {1} };
PrintMatrixNM(m2, 4, 4);

10     2      12
23     7      29

0      0      0      1
0      0      1      0
0      1      0      0
1      0      0      0

unsigned CountChC1(const char s[], char ch) {    
    unsigned cnt = 0;
    for (int i=0; s[i]; i++) {
        if (s[i] == ch) 
            cnt++;
    }
    return cnt;
}

unsigned CountChC2(const char *s, char ch) {    
    unsigned cnt = 0;
    while (*s) {
        if (*s++ == ch) 
            cnt++;
    }
    return cnt;
}

unsigned CountChCpp(const string & s, char ch) {    
    int cnt = -1, position = -1;
    do {
        cnt++;
        position = s.find(ch, position+1);
    } while (position != string::npos); 
    return cnt;
}

char s1[] = "C, C++, Java, C++/CLI / C#";
string s2 = s1;
cout<<CountChC1("C, C++, Java, C++/CLI / C#", 'C')<<endl;
cout<<CountChC2(s1, 'C')<<endl;

cout << CountChC2(s2.c_str(), 'C') << endl;
cout << CountChCpp(s2, 'C') << endl;

char * StrReverseC1(char s[]) {
    char ch;
    int length = -1; 
    while(s[++length]); // determining the string length
    for (int i = 0; i < length / 2; i++) {
        ch = s[i];
        s[i] = s[length-i-1];
        s[length-i-1] = ch;
    }
    return s;
}
 
char * StrReverseC2(char *s) {
    char *q, *p, ch;
    p = q = s; 
    while (*q) q++;     // going through the elements until byte 0 closing the string
    p--;            // p points to the first character of the string
    while (++p <= --q) {
        ch = *p;
        *p = *q;
        *q = ch;    
    }
    return s;
}
 
string& StrReverseCpp(string &s) {
    char ch;
    int length = s.size();
    for (int i = 0; i < length / 2; i++) {
        ch = s[i];
        s[i] = s[length-i-1];
        s[length-i-1] = ch;
    }
    return s;
}

int main() {
    char s1[] = "C++ programming";
    cout << StrReverseC1(s1) << endl;    // gnimmargorp ++C
    cout << StrReverseC2(s1) << endl;    // C++ programming
    string s2 = s1;
    cout << StrReverseCpp(s2) << endl;    // gnimmargorp ++C
    cout << StrReverseCpp(string(s1));    // gnimmargorp ++C
}

II.1.3.2.5. Functions as arguments

When developing mathematical applications, it is normal to expect that a well elaborated algorithm could be used in many functions. For that purpose, the function has to be passed as an argument to the function executing the algorithm.

II.1.3.2.5.1. Function types and typedef

With typedef, the type of a function can be indicated by a synonymous name. The function type declares the function that has the given number and type of parameters and returns the given data type. Let's have a look at the following example function that calculates the value of the third degree polynomial $f(x)=x^{\text{3}}-{\text{6x}}^{\text{2}}-x+\text{30}$ if x is given. The prototype and the definition of the function are:

double poly3(double);    // prototype 
 
double poly3(double x)    // definition
{
    return x*x*x - 6*x*x - x + 30;
}

Figure II.3. Graph of the third degree polynomial

Let's have a look at the prototype of the function and let's type typedef before it and replace the name poly3 with mathfunction.

        typedef double mathfunction(double);

If the type mathfunction is used, the prototype of the function poly3() is:

        mathfunction poly3;

II.1.3.2.5.2. Pointers to functions

In C++, function names can be used in two ways. A function name can be the left operand of a function call operator: in this case, it is a function call expression

        poly3(12.3)

the value of which is the value returned by the function. However, if the function name is used alone

        poly3

we get a pointer, the value of which is a memory address where the code of the function is (code pointer) and the type of which is that of the function.

Let's define a pointer to the function poly3(). This pointer can be assigned the address of the function poly3() as a value. The definition can be obtained easily if the name in the header of the function poly3 is replaced by the expression (*functionptr):

        double (*functionptr)(double);

functionptr is a pointer to a function that returns a double value and that has a parameter of type double.

However, this definition can be provided in a much more legible way if we use the type mathfunction created with typedef:

        mathfunction *functionptr;

When the pointer functionptr is initialised, the function poly3 can be called indirectly:

        functionptr = poly3;

        double y = (*functionptr)(12.3);

or

        double y = functionptr(12.3);

If we want to create a reference to this function, we have to follow the same steps. But in this case, the initial value has to be given already in the definition:

        double (&functionref)(double) = poly3;

or

        mathfunction &functionref = poly3;

Calling the function by using the reference:

        double y = functionref(12.3);

II.1.3.2.5.3. Examples for pointers to functions

On the basis of the things said above, the prototype of the Library function qsort () becomes more comprehensible:

void qsort(void *base, size_t n, size_t width,
           int (*fcmp)(const void *, const void *));

With qsort (), we can sort data stored in an array by using the Quicksort algorithm. This function makes it possible to sort an array starting at the address base, having n number of elements and each element being allocated width bytes. The comparator function called during sorting has to be provided by ourselves as the parameter fcmp.

The following example uses the function qsort () to sort integer and string arrays:

#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;
 
int icmp(const void *p, const void *q) {
 return *(int *)p-*(int *)q;
}
 
int scmp(const void *p, const void *q) {
 return strcmp((char *)p,(char *)q);
}
 
int main() {
    int m[8]={2, 10, 7, 12, 23, 29, 11, 30};
    char names[6][20]={"Dennis Ritchie", "Bjarne Stroustrup",
                       "Anders Hejlsberg","Patrick Naughton",
                       "James Gosling", "Mike Sheridan"};
 
    qsort(m, 8, sizeof(int), icmp);
    for (int i=0; i<8; i++)
      cout<<m[i]<<endl;
 
    qsort(names, 6, 20, scmp);
    for (int i=0; i<6; i++)
      cout<<names[i]<<endl;
}

The function named tabulate() in the following example codes can be used to print out in tabular form the values of any function having a parameter of type double and returning a double value. The parameters of the function tabulate() contains the two interval boundaries and the step value.

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
 
// Prototypes
void tabulate(double (*)(double), double, double, double);
double sqr(double); 
 
int main() {
    cout<<"\n\nThe values of the function sqr() ([-2,2] dx=0.5)"<<endl;
    tabulate(sqr, -2, 2, 0.5);
    cout<<"\n\nThe values of the function sqrt() ([0,2] dx=0.2)"<<endl;
    tabulate(sqrt, 0, 2, 0.2);
}
 
// The definition of the function tabulate()
void tabulate(double (*fp)(double), double a, double b,
              double step){
    for (double x=a; x<=b; x+=step) {
        cout.precision(4);
        cout<<setw(12)<<fixed<<x<< '\t';
        cout.precision(7);
        cout<<setw(12)<<fixed<<(*fp)(x)<< endl;
    }
}
 
// The definition of the function sqr()
double sqr(double x) {
    return x * x;
}

The results:

The values of the function sqr() ([-2,2] dx=0.5) -2.0000 4.0000000 -1.5000 2.2500000 -1.0000 1.0000000 -0.5000 0.2500000 0.0000 0.0000000 0.5000 0.2500000 1.0000 1.0000000 1.5000 2.2500000 2.0000 4.0000000 The values of the function sqrt() ([0,2] dx=0.2) 0.0000 0.0000000 0.2000 0.4472136 0.4000 0.6324555 0.6000 0.7745967 0.8000 0.8944272 1.0000 1.0000000 1.2000 1.0954451 1.4000 1.1832160 1.6000 1.2649111 1.8000 1.3416408 2.0000 1.4142136

// prototype
long SeqSum(int n = 10, int d = 1, int a0 = 1); 
 
long SeqSum(int n, int d, int a0) {  // definition 
    long sum = 0, ai;
    for(int i = 0; i < n; i++) {
        ai = a0 + d * i;
        cout << setw(5) << ai;
        sum += ai;
    }
    return sum;
}

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

char name[] = "Bjarne Stroustrup";
double a=12.3, b=23.4, c=a+b;
printf("C++ language\n");
printf("Name: %s \n", name);
printf("Result: %5.3f + %5.3f = %8.4f\n", a, b, c);

#include<iostream>
#include<cstdarg>
using namespace std;
 
double Average(int num, ... ) {
    va_list numbers; 
    // passing through the first (num) arguments
    va_start(numbers, num); 
    double sum = 0;
    for(int i = 0; i < num; ++i ) {
        // accessing the double arguments
        sum += va_arg(numbers, double);  
    }
    va_end(numbers);
    return (sum/num);
}
 
int main() {
    double avg = Average(7,1.2,2.3,3.4,4.5,5.6,6.7,7.8);
    cout << avg << endl;
}

II.1.3.2.8. Parameters and return value of the main() function

The interesting thing about the main () function is not only that program execution starts here but also that it can have many parameterizing options:

int main( )
 
int main( int argc) ( )
 
int main( int argc, char *argv[]) ( )

argv points to an array (a vector) of character pointers, argc gives the number of strings in the array. (The value of argc is at least 1 since argv[0] refers to the character sequence containing the name of the program.)

Figure II.4. The interpretation of the parameter argv

The return value of main (), which is of an int type according to the standard, can be provided within the main () function in a return statement or as an argument of the Standard Library function exit () that can be placed anywhere in a program. The header file cstdlib contains standard constants:

#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

These can be used as an exit code signalling whether the execution of the program was successful or not.

The main () function differs from other normal C++ functions in many ways: it cannot be declared as a static or inline function, it is not obligatory to use return in it and it cannot be overloaded. On the basis of the recommendations of C++ standards, it cannot be called within a program and its address cannot be obtained.

The following command1.cpp program prints out the number of arguments and then all of its arguments:

#include <iostream> 
using namespace std;
  
int main(int argc, char *argv[]) { 
    cout << "number of arguments: " << argc << endl;  
    for (int narg=0; narg < argc; narg++)   
        cout << narg << " " << argv[narg] << endl; 
    return 0; 
}

Command line arguments can be provided in the console window

C:\C++Book>command1 first 2nd third

or in the Visual Studio development environment (Figure II.5).

Figure II.5. Providing command line arguments

The results of executing command1.exe:

In a console window	In a development environment
C:\C++Book>command1 first 2nd third number of arguments: 4 0 command1 1 first 2 2nd 3 third C:\C++Book>	C:\C++Book>command1 first 2nd third number of arguments: 4 0 C:\C++Book\command1.exe 1 first 2 2nd 3 third C:\C++Book>

The next example code (command2.cpp) demonstrates a solution easy to use when creating utility software to test whether input arguments are well provided or not. The program only starts if it is called with two arguments. Otherwise, it sends an error message and prints out how to start the program from the command line properly.

#include <iostream>
#include <cstdlib>
using namespace std;
 
int main(int argc, char *argv[]) {
    if (argc !=3 ) {
        cerr<<"Wrong number of parameters!"<<endl;
        cerr<<"Usage: command2 arg1 arg2"<<endl;
        return EXIT_FAILURE;
    }
    cout<<"Correct number of parameters:"<<endl;
    cout<<"1. argument: "<<argv[1]<<endl;
    cout<<"2. argument: "<<argv[2]<<endl;
    return EXIT_SUCCESS;
}

The results of the execution of command2.exe:

Wrong number of parameters: command2	Correct number of parameters: command2 alfa beta
Wrong number of parameters! Usage: command2 arg1 arg2	Correct number of parameters: 1. argument: alfa 2. argument: beta

The solution of the problem above can be divided into parts that are logically independent of each other, more precisely:

The first four of the above mentioned activities will be realized by independent functions that communicate with each other and the main() function by shared (global) variables. Global variables should be provided outside function blocks and before the functions. (We should not forget about providing the prototypes!)

#include <iostream>
#include <cmath>
using namespace std;
 
// global variables
double a, b, c;
 
// prototypes
void ReadData();
bool TriangleInequality();
double Perimeter();
double Area();
 
int main() {
    ReadData();
    cout << "perimeter: " << Perimeter()<<endl;
    cout << "area: " << Area()<<endl;
}
 
void ReadData() {
    do {
        cout <<"a side: "; cin>>a;
        cout <<"b side: "; cin>>b;
        cout <<"c side: "; cin>>c;
    } while(!TriangleInequality() );
}
 
bool TriangleInequality() {
    if ((a<b+c) && (b<a+c) && (c<a+b))
        return true;
    else
        return false;
}
 
double Perimeter() {
    return a + b + c;
}
 
double Area() {
    double s = Perimeter()/2;
    return sqrt(s*(s-a)*(s-b)*(s-c));
}

It's clear that the code has become more legible; however, it still cannot benefit from a broader use. For example, if we want to store the data of other triangles as well and to reuse them later in other tasks, we have to make sure to set appropriately the global variables a, b and c.

int main() {
    double a1, b1, c1, a2, b2, c2;
    ReadData();
    a1 = a, b1 = b, c1 = c;
    ReadData();
    a2 = a, b2 = b, c2 = c;
    a = a1, b = b1, c = c1;
    cout << "perimeter: " << Perimeter()<<endl;
    cout << "area: " << Area()<<endl;
    a = a2, b = b2, c = c2;
    cout << "perimeter: " << Perimeter()<<endl;
    cout << "area: " << Area()<<endl;
}

Therefore, the solution would be better if the data of triangles are passed to the concerned functions as arguments.

Now we will not detail the following solutions since we have already presented the things to know about that in the previous sections.

#include <iostream>
#include <cmath>
using namespace std;
 
void ReadData(double &a, double &b, double &c);
bool TriangleInequality(double a, double b, double c);
double Perimeter(double a, double b, double c);
double Area(double a, double b, double c);
 
int main() {
    double x, y, z;
    ReadData(x , y , z);
    cout << "perimeter: " << Perimeter(x, y, z)<<endl;
    cout << "area: " << Area(x, y, z) <<endl;
}
 
void ReadData(double &a, double &b, double &c) {
    do {
        cout <<"a side: "; cin>>a;
        cout <<"b side: "; cin>>b;
        cout <<"c side: "; cin>>c;
    } while(!TriangleInequality(a, b, c) );
}
 
bool TriangleInequality(double a, double b, double c) {
    if ((a<b+c) && (b<a+c) && (c<a+b))
        return true;
    else
        return false;
}
 
double Perimeter(double a, double b, double c) {
    return a + b + c;
}
 
double Area(double a, double b, double c) {
    double s = Perimeter(a, b, c)/2;
    return sqrt(s*(s-a)*(s-b)*(s-c));
}

Now let's see the main () function if two triangles are to be dealt with.

int main() {
    double a1, b1, c1, a2, b2, c2;
    ReadData(a1, b1, c1);
    ReadData(a2, b2, c2);
    cout << "perimeter: " << Perimeter(a1, b1, c1)<<endl;
    cout << "area: " << Area(a1, b1, c1)<<endl;
    cout << "perimeter: " << Perimeter(a2, b2, c2)<<endl;
    cout << "area: " << Area(a2, b2, c2)<<endl;
}

When the two methods are compared with respect to speed, we could observe that global variables make programs run faster (and therefore they become more efficient) since arguments are not copied to the stack before a function is called. We have also seen the drawbacks of the solution, which do strongly prevent the reusability of the program code. How could we decrease the inconvenience of using a lot of arguments and of using long argument lists?

The following solution is much better and is more recommended than using global variables. Global variables and the parameters corresponding to them have to be collected in a structure or have to be passed to functions by reference or by constant reference.

#include <iostream>
#include <cmath>
using namespace std;
 
struct triangle {
    double a, b, c;
};
 
void ReadData(triangle &h);
bool TriangleInequality(const triangle &h);
double Perimeter(const triangle &h);
double Area(const triangle &h);
 
int main() {
    triangle h1, h2;
    ReadData(h1);
    ReadData(h2);
    cout << "perimeter: " << Perimeter(h1)<<endl;
    cout << "area: " << Area(h1)<<endl;
    cout << "perimeter: " << Perimeter(h2)<<endl;
    cout << "area: " << Area(h2)<<endl;
}
 
void ReadData(triangle &h) {
    do {
        cout <<"a side: "; cin>>h.a;
        cout <<"b side: "; cin>>h.b;
        cout <<"c side: "; cin>>h.c;
    } while(!TriangleInequality(h) );
}
 
bool TriangleInequality(const triangle &h) {
    if ((h.a<h.b+h.c) && (h.b<h.a+h.c) && (h.c<h.a+h.b))
        return true;
    else
        return false;
}
 
double Perimeter(const triangle &h) {
    return h.a + h.b + h.c;
}
 
double Area(const triangle &h) {
    double s = Perimeter(h)/2;
    return sqrt(s*(s-h.a)*(s-h.b)*(s-h.c));
}

Softwares with a text-based user interface can be controlled much better if it has a simple menu. To solve this problem, the menu entries are stored in a string array:

// Defintion of the menu
char * menu[] = {"\n1. Sides",
                 "2. Perimeter",
                 "3. Area",
                 "----------",
                 "0. Exit" , NULL };

Now let's transform the main () function of the previous example to handle the user’s menu selections:

int main() {
    triangle h = {3,4,5};
    char ch;
    do {
      // printing out the menu
      for (int i=0; menu[i]; i++)
          cout<<menu[i]<< endl;
    
      // Processing the answer
      cin>>ch; cin.get();
      switch (ch) {
        case '0': break;
        case '1': ReadData(h);
                  break;
        case '2': cout << "perimeter: ";
                   cout << Perimeter(h)<<endl;
                  break;
        case '3': cout << "area: " << Area(h)<<endl;
                  break;
        default:  cout<<'\a';
      }
    } while (ch != '0');
}

The window when the program runs

1. Sides
2. Perimeter
3. Area
----------
0. Exit
1
a side: 3
b side: 4
c side: 5
 
1. Sides
2. Perimeter
3. Area
----------
0. Exit
2
perimeter: 12
 
1. Sides
2. Perimeter
3. Area
----------
0. Exit
3
area: 6

In mathematics, there might be tasks that can be solved by producing certain data and states in a recursive way. In this case, we define data and states by providing a start state then a general state is determined with the help of the previous states of a finite set.

Now let's have a look at some well-known recursive definitions.

        factorial:

        $n!=\{\begin{array}{l}\mathrm{1,}\text{}ifn=0\\ n\cdot (n-1)!,\text{}ifn>0\end{array}$

        Fibonacci numbers:

        $Fibo(n)=\{\begin{array}{l}\mathrm{0,}ifn=0\\ \mathrm{1,}\text{}ifn=1\\ Fibo(n-1)+Fibo(n-2),\text{}ifn>1\end{array}$

        greatest common divisor (gcd):

        $\gcd (p,q)=\{\begin{array}{l}p,\text{}ifq=0\\ \gcd (q,p\%q),else\end{array}$

        binomial numbers:

        $B(n,k)=\{\begin{array}{l}\mathrm{1,}ifk=0\\ B(n,k-1)+B(n-\mathrm{1,}k-1),\text{}if0<k<n\\ \mathrm{1,}\text{}ifk=n\end{array}$

        $B(n,k)=\{\begin{array}{l}\mathrm{1,}ifk=0\\ B(n,k-1)\cdot \frac{n-k+1}{k},\text{}if0<k\le n\end{array}$

In programming, recursion means that an algorithm calls itself either directly (direct recursion) or via other functions it calls (indirect recursion). A classic example of recursion is calculating factorials.

On the basis of the recursive definition of calculating a factorial, 5! can be calculated in the following way:

5! = 5 * 4!
         4 * 3!
             3 * 2!
                 2 * 1! 
                     1 * 0!
                          1  = 5 * 4 * 3 * 2 * 1 * 1 = 120

The C++ function that realizes the calculating above:

unsigned long long Factorial(int n) 
{
    if (n == 0)
       return 1;
     else
       return n * Factorial(n-1);
}

Recursive functions solve problems elegantly but they are not efficient enough. Until a start state is reached, the allocated memory space (stack) can have a significant size because of multiple function calls, and the function call mechanism can take a lot of time.

That is why it is important to know that all recursive problems can be transformed into an iterative one (i. e. that uses loops), which is more difficult to elaborate but is more efficient. The non-recursive version of the function calculating factorials:

unsigned long long Factorial(int n)
{
    unsigned long long f=1;
    while (n != 0)
        f *= n--;
    return f;
}

Now, let's see how we can determine the nth element of a Fibonacci sequence.

0, 1, 1, 2, 3, 5, 8, 13, 21, ...

The following recursive rule can be used to calculate the nth element of the sequence :

Based on the recursive rule, we can now create the function that has completely the same structure as that of the mathematical definition:

unsigned long Fibonacci( int n ) {
   if (n<2)
      return n;
   else
      return Fibonacci(n-1) + Fibonacci(n-2);
}

Like in the preceding case, we recommend here using iterative structures in order to save time and memory:

unsigned long Fibonacci( int n ) {
   unsigned long f0 = 0, f1 = 1, f2 = n;
   while (n-- > 1) {
      f2 = f0 + f1;
      f0 = f1;
      f1 = f2;
   }
   return f2;
}

While the running time of the iterative solution increases linearly with n, that of the recursive solution increases exponentially ($\mathrm{0,5}{(\sqrt{2})}^2$).

The last part of this subchapter details only the recursive solution of the problems, so we entrust our readers with the iterative solutions.

The greatest common divisors of two natural numbers can be easily determined recursively:

int Gcd(int p, int q) {
    if (q == 0)
        return p;
    else
        return Gcd(q, p % q);
}

If binomial coefficients have to be calculated, we can choose between two recursive functions:

int Binom1(int n, int k)
{
    if (k == 0 || k == n)
        return 1;
    else
        return Binom1(n-1,k-1) + Binom1(n-1,k);
}
 
int Binom2(int n, int k)
{
    if (k==0)
        return 1;
    else
        return Binom2(n, k-1) * (n-k+1) / k;
}

From the two solutions, Binom2() is more efficient.

In the last example, we calculate a determinant recursively. The essential of the solution is that the calculation of a determinant of degree N is reduced to the problem of calculating N determinants of degree (N-1). And we do that until second degree determinants are reached. The solution is elegant and easy to understand but it is not very efficient. Function calls are stored in tree structures chained into each other, which require a lot of time and memory.

For example, if we want to calculate a determinant of size 4x4, the function Determinant() is called 17 times (once for a 4x4 matrix, four times for a 3x3 matrix and for 4 times 3 matrices of size 2x2) and the number of times the function is called increases to 5·17+1 = 86 for a fifth degree determinant. (It should be noted that in the case of a 12x12 matrix, the function Determinant() is called more than 300 million times, which may require many minutes.)

#include <iostream>
#include <iomanip>
using namespace std;
 
typedef double Matrix[12][12];
 
double Determinant(Matrix m, int n);
void PrintOutMatrix(Matrix m, int n);
 
int main() {
  Matrix m2 = {{1, 2},
               {2, 3}};
 
  Matrix m3 = {{1, 2, 3},
               {2, 1, 1},
               {1, 0, 1}};
 
  Matrix m4 = {{ 2, 0, 4, 3},
               {-1, 2, 6, 1},
               {10, 3, 4,-2},
               { 2, 1, 4, 0}};
 
  PrintOutMatrix(m2,2);
  cout << "Determinant(m2) = " << Determinant(m2,2) << endl;
 
  PrintOutMatrix(m3,3);
  cout << "Determinant(m3) = " << Determinant(m3,3) << endl;
 
  PrintOutMatrix(m4,4);
  cout << "Determinant(m4) = " << Determinant(m4,4) << endl;
 
  cin.get();
  return 0;
}
 
void PrintOutMatrix(Matrix m, int n)
{
   for (int i=0; i<n; i++) {
       for (int j=0; j<n; j++) {
         cout << setw(6) << setprecision(0) << fixed;
         cout << m[i][j];
       }
       cout << endl;
   }
}
 
double Determinant(Matrix m, int n)
{
  int q;
  Matrix x;
 
  if (n==2)
    return m[0][0]*m[1][1]-m[1][0]*m[0][1];
 
  double s = 0;
  for (int k=0; k<n; k++)  // n subdeterminants
  {
        // creating submatrices
        for (int i=1; i<n; i++)    // rows
        {
           q = -1;
           for (int j=0; j<n; j++) // columns
            if (j!=k)
              x[i-1][++q] = m[i][j];
        }
        s+=(k % 2 ? -1 : 1) * m[0][k] * Determinant(x, n-1);
  }
  return s;
}

The results:

     1     2
     2     3
Determinant(m2) = -1

     1     2     3
     2     1     1
     1     0     1
Determinant(m3) = -4

     2     0     4     3
    -1     2     6     1
    10     3     4    -2
     2     1     4     0
Determinant(m4) = 144

A template declaration starts with the keyword template, followed by the parameters of the template enclosed within the signs < and >. In most cases, these parameters are generic type names but they can contain variables as well. Generic type names should be preceded by the keyword class or typename.

When we create a function template, we should start from a working function in which the certain types should be replaced by generic types (TYPE). Afterwards, the compiler should be told which types should be replaced in the function template (template<class TYPE>). The first step to take in our function named Absolute():

inline TYPE Absolute(TYPE x) {
    return x < 0 ? -x : x;
}

Then the final version should be provided in two ways:

template <class TYPE>
inline TYPE Absolute(TYPE x) {
    return x < 0 ? -x : x;
}
 
template <typename TYPE>
inline TYPE Absolute(TYPE x) {
    return x < 0 ? -x : x;
}

From the function template that is now done, the compiler will create the needed function variant when the function is called. It should be noted that the template named Absolute() can only be used with numeric types among which the operations 'lower than' and 'changing the sign' can be interpreted.

When the function is called in a traditional way, the compiler determines, based on the type of the argument, which version of the function Absolute() it will create and compile.

cout << Absolute(123)<< endl;            // TYPE = int
cout << Absolute(123.45)<< endl;        // TYPE = double

Programmers themselves can carry out a function variant using the type-cast manually in the call:

cout << Absolute((float)123.45)<< endl;    // TYPE = float
cout << Absolute((int)123.45)<< endl;    // TYPE = int

The same result is achieved if the type name is provided within the signs < and > after the name of the function:

cout << Absolute<float>(123.45)<< endl;    // TYPE = float
cout << Absolute<int>(123.45)<< endl;    // TYPE = int

In a function template, more types can be replaced, as it can be seen in the following example:

template <typename T>
inline T Maximum(T a, T b) {
   return (a>b ? a : b);
}
 
int main() {
    int a = 12, b=23;
    float c = 7.29, d = 10.2;
 
    cout<<Maximum(a, b); // Maximum(int, int)
    cout<<Maximum(c, d); // Maximum(float, float)
  ↯ cout<<Maximum(a, c); // there is no Maximum(int, float)
    cout<<Maximum<int>(a,c);  
    // it is the function Maximum(int, int) that is called with type conversion
}

In order to use different types, more generic types should be provided in the function template header:

template <typename T1, typename T2>
inline T1 Maximum(T1 a, T2 b) {
   return (a>b ? a : b);
}
 
int main() {
    cout<<Maximum(5,4);       // Maximum(int, int)
    cout<<Maximum(5.6,4);     // Maximum(double, int)
    cout<<Maximum('A',66L);   // Maximum(char, long)
    cout<<Maximum<float, double>(5.6,4); 
                              // Maximum(float, double)
    cout<<Maximum<int, char>('A',66L);   
                              // Maximum(int, char)
}

When a C++ compiler first encounters a function template call, it creates an instance of the function with the given type(s). Each function instance is a specialised version of the function template with the given types. In the compiled program code, exactly one function instance belongs to each used type. The calls above were examples of the so-called implicit instantiation.

A function template can be instantiated in an explicit way as well if concrete types are provided in the template line containing the header of the function:

template inline int Absolute<int>(int);
template inline float Absolute(float);
template inline double Maximum(double, long);
template inline char Maximum<char, float>(char, float);

It should be noted that only one explicit instantiation can figure in the source code for (a) given type(s).

Since a C++ compiler processes function templates at compilation time, templates have to be available in the form of a source code in order that function variants could be created. It is recommended to place function templates in a header file to make sure that the header file can only be included once in C++ modules.

There are cases when it is not precisely the algorithm defined in the generic function template that has to be used for some types or type groups. In this case, the function template itself has to be overloaded (specialized) – explicit specialization.

The function template Swap() of the following example code exchanges the values of the passed arguments. In the case of pointers, the specialised version does not exchange pointers but the referenced values. The second specialised version can be used to swap strictly C-styled strings.

#include <iostream>
#include <cstring>
using namespace std;
 
// The basic template
template< typename T > void Swap(T& a, T& b) {
   T c(a);
   a = b;
   b = c;
}
 
// Template specialised for pointers
template<typename T> void Swap(T* a, T* b) {
   T c(*a);
   *a = *b;
   *b = c;
}
 
// Template specialised for C strings
template<> void Swap(char *a, char *b) {
   char buffer[123];
   strcpy(buffer, a);
   strcpy(a, b);
   strcpy(b, buffer);
}
 
int main() {
    int a=12, b=23;
    Swap(a, b);
    cout << a << "," << b << endl;     // 23,12
 
    Swap(&a, &b);
    cout << a << "," << b << endl;        // 12,23
 
    char *px = new char[32]; strcpy(px, "First");
    char *py = new char[32]; strcpy(py, "Second");
    Swap(px, py);
    cout << px << ", " << py << endl;    // Second, First
    delete px;
    delete py;
}

From among the different specialised versions, compilers first choose always the most specialised (concrete) template to compile the function call.

In order to sum up function templates, let's see some more complex examples. Let's start with making a generic version of the function VectorSum() of Section II.2.2. The function template can determine the sum of the elements of any one-dimensional numeric array:

#include <iostream>
using namespace std;
 
template<class TYPE>
TYPE VectorSum(TYPE a[], int n) {
   TYPE sum = 0;
   for (int i=0; i<n; i++)
      sum += a[i];
   return sum;
}
 
int main() {
   int       ai[]={1,1,2,3,5,8,13};
   const int ni=sizeof(ai) / sizeof(ai[0]);
   cout << "\nThe sum of the elements of the int array: "
        <<VectorSum(ai,ni);
 
   double    ad[]={1.2,2.3,3.4,4.5,5.6};
   const int nd=sizeof(ad) / sizeof(ad[0]);
   cout << "\nThe sum of the elements of the double array: "
        <<VectorSum(ad,nd);
 
   float     af[]={3, 2, 4, 5};
   const int nf=sizeof(af) / sizeof(af[0]);
   cout << "\nThe sum of the elements of the  float  array: "
        <<VectorSum(af,nf);
 
   long      al[]={1223, 19800729, 2004102};
   const int nl=sizeof(al) / sizeof(al[0]);
   cout << "\nThe sum of the elements of the  long   array: "
        <<VectorSum(al,nl);
}

The function template Sort() sorts the elements of any one-dimensional array of type Typ and of size Size in an ascending order. The function moves the elements within the array and the result is stored in the same array as well. Since this declaration contains an integer parameter (Size) besides the type parameter (Typ), the function has to be called in the extended version:

        Sort<int, size>(array);

The example code also calls the Swap() template from the the template Sort():

#include <iostream>
using namespace std;
 
template< typename T > void Swap(T& a, T& b) {
   T c(a);
   a = b;
   b = c;
}
 
template<class Typ, int Size> void Sort(Typ vector[]) {
   int j;
   for(int i = 1; i < Size; i++){
      j = i;
      while(0 < j && vector[j] < vector[j-1]){
          Swap<Typ>(vector[j], vector[j-1]);
          j--;
      }
   }
}
 
int main() {
    const int size = 6;
    int array[size] = {12, 29, 23, 2, 10, 7};
    Sort<int, size>(array);
    for (int i = 0; i < size; i++)
        cout << array[i] << " ";
    cout << endl;
}

Our last example also prints out the different variants of the function Function() used by the compiler when these functions are called. From the specialised variants, it is the generic template that is activated which prints out the elements of the complete function call with the help of the template PrintOut(). The name of the types is returned by the member name () of the object returned by the typeid operator. The function template Character() is used to print out characters enclosed in apostrophes. This little example code presents some ways function templates can be used.

#include <iostream>
#include <sstream>
#include <string>
#include <typeinfo>
#include <cctype>
using namespace std;
 
template <typename T> T Character(T a) { 
    return a; 
}
 
string Character(char c) {
    stringstream ss;
    if (isprint((unsigned char)c)) 
        ss << "'" << c << "'";
    else 
        ss << (int)c;
    return ss.str();
}
 
template <typename TA, typename TB> 
void PrintOut(TA a, TB b){
    cout << "Function<" << typeid(TA).name() << "," 
         << typeid(TB).name();
    cout << ">(" << Character(a) << ", " << Character(b)
         << ")\n";
}
 
template <typename TA, typename TB> 
void Function(TA a = 0, TB b = 0){
    PrintOut<TA, TB>(a,b);
}
 
template <typename TA> 
void Function(TA a = 0, double b = 0) {
    Function<TA, double>(a, b);
}
 
void Function(int a = 12, int b = 23) {
    Function<int, int>(a, b);
}
 
int main() {
        Function(1, 'c');
        Function(1.5); 
        Function<int>(); 
        Function<int, char>(); 
        Function('A', 'X');
        Function();
}

The results:

Function<int,char>(1, 'c')
Function<double,double>(1.5, 0)
Function<int,double>(0, 0)
Function<int,char>(0, 0)
Function<char,char>('A', 'X')
Function<int,int>(12, 23)

The notion of storage class is strongly related to that of variable accessibility and scope. Every identifier is visible only within its scope. There are three basic scope types: block level (local), file level and program level (global) scope (Figure II.7).

The accessibility of variables is determined by default by the place where they are defined in the source code. We can only create block level and program level variables in that way. However, we can also assign variables a storage class directly.

The notion of scope is similar to that of linkage but it is not completely equal to that. The same identifiers can be used to designate different variables in different scopes. However, the identifiers declared in different scopes or the identifiers declared more than once in the same scope can reference the same variable because of linkage. In C++, there are three types of linkage: internal, external and no linkage.

In a C++ source code, variables can have one of the following scopes:

File and program level scopes can be divided furthermore by namespaces presented later which introduce the notion of qualified identifiers.

Figure II.7. Variable scopes

A lifetime is a period of program execution where the given variable exists. On the basis of lifetime, identifiers can be divided into three groups: names of static, automatic and dynamic lifetime.

Variables that are defined within a function/program block or in the parameter list of functions are automatic (auto) by default. The keyword auto is not used in general. In addition, in the latest C++11 standard, this keyword has a new interpretation. Block level variables are often called local variables.

{
   definitions, declarations and
   statements
}

int main()
{
   double limit = 123.729;
   // the value of the double type variable limit is 123.729 
   {
      long limit = 41002L;
      // the value of the long type variable limit is 41002L 
   }
   // the value of the double type variable limit is 123.729
}

for (int i=12; i<23; i+=2)
   cout << i << endl;
↯ cout << i << endl; // compilation error: i is not defined

void Swap(register int &a, register int &b) {
   register int c = a;
                a = b;
                b = c;
}

long StrToLong(const string& str)
{
    register int index = 0;
    register long sign = 1, num = 0;
    // leaving out leading blanks
    for(index=0; index < str.size() 
                 && isspace(str[index]); ++index);
    // sign?
    if( index < str.size()) {
        if( str[index] == '+' ) { sign =  1; ++index; }
        if( str[index] == '-' ) { sign = -1; ++index; }
    }
    // digits
    for(; index < str.size() && isdigit(str[index]); ++index)
        num = num * 10 + (str[index] - '0');
    return sign * num;
}

#include <iostream>
using namespace std;
 
unsigned Fibo() {
    static unsigned a0 = 0, a1 = 1;
    unsigned a2 = a0 + a1;
    a0 = a1;
    a1 = a2;
    return a2;
}
 
int main() {
    for (register int i=2; i<10; i++)
        cout << Fibo() << endl;
}

Variables defined outside functions automatically have extern, i.e. program level scope. When software is developed from many modules (source files), it is not sufficient to use global variables in order that the principles of modular programming be observed. We might also need variables defined on module level: the access of these variables can be restricted to the source file (data hiding). This can be achieved by assigning extern variables a static storage class. If constants are defined outside functions, they have also internal linkage by default.

In the following program generating a Fibonacci sequence, the variables a0 and a1 were defined on a module level in order that their content remain accessible from another function (FiboInit()).

#include <iostream>
using namespace std;
 
const unsigned first = 0, second = 1;
static unsigned a0 = first, a1 = second;
 
void FiboInit() {
    a0 = first;
    a1 = second;
}
 
unsigned Fibo() {
    unsigned register a2 = a0 + a1;
    a0 = a1;
    a1 = a2;
    return a2;
}
 
int main() {
    for (register int i=2; i<5; i++)
        cout << Fibo() << endl;
    FiboInit();
    for (register int i=2; i<8; i++)
        cout << Fibo() << endl;
}

The initialization of static variables takes place only once: when the program is launched. In case we do not provide an initial value for them in their definition, then the compiler initializes these variables automatically to 0 (by filling up its memory space with 0 bytes). In C++, static variables can be initialized by any expression.

C++ standards recommend using anonymous namespaces instead of static external variables (see later).

Variables that are defined outside functions and to which a storage class is not assigned have an extern storage class by default. (Of course, the keyword extern can be used here, even if that is the default case.)

The lifetime of extern (global) variables begins with the launching and ends with the end of the program. However, there might be problems with visibility. A variable defined in a given module can only be accessed from another module, if the latter contains the declaration of that variable (for example by including its declaration file).

When using program level global variables, we have to pay attention whether we define or declare them. If a variable is used without a storage class specification outside functions, this means defining this variable (independently of the fact that it is provided an explicit initial value or not). On the contrary, assigning them extern explicitly can have two consequences: without initial value, they are declared , with initial value, they are defined . The following examples demonstrate what we have said so far:

It should be kept in mind that global variables can be declared anywhere in a program but the effects of these declarations start from the place of the declaration until the end of the given scope (block or module). It is a frequent solution to store declarations in header files for each module and to include them at the beginning of every source file.

The initialization of global variables takes place only once when the program starts. In case we do not provide any initial value to them, then the compiler initializes these variables automatically to 0. In C++, global variables can be initialised by any expression.

It should be kept in mind that global variables should only be used with caution and only if they are really needed. Even in the case of a bigger program, only some central extern variables are allowed.

C++ compilers complete the name we have given for a function in the object code with the letters of the types from the parameter list of the function. This solution named C++ linkage makes possible the possibilities presented earlier in this chapter (overloading, function template).

When C++ was born, C language had already existed for nearly ten years. It was rightful to claim that the algorithms of compiled object modules and Library functions developed for C programs would also be accessible from C++ programs. (Programs in C source code could therefore be implemented in C++ with slight modifications.) C compilers place function names without any modification in the object code (C linkage), so they are not accessible by the C++ declarations presented above.

To handle this problem, C++ contains the type modifier extern "C". If a function sqrt() coded in C is intended to be used from C++ source code, it should be declared as

extern "C" double sqrt(double a);

This modifier makes C++ compilers to use the habitual C name generation for the function sqrt(). As a consequence, C functions cannot be redefined (overloaded)!

In case more C functions are needed to be accessed from a C++ code, these functions should be grouped under one extern "C" :

extern "C" {
   double sin(double a);
   double cos(double a);
}

If the descriptions of the functions of a C library are contained in a separated declaration file, it should be worth the following method:

extern "C" {
   #include <rs232.h>
}

We should also use the extern "C" declaration if functions written and compiled in C++ are intended to be accessed from a C program code.

It is also worth mentioning here that the main () function also has extern "C" linkage.

In C language, variables and functions defined on the file level (as well as Standard library functions) can be found in the same common namespace. C++ enclose Standard library elements in the namespace called std whereas the other elements defined on a file level are contained within the global namespace.

In order to be able to refer the elements of a namespace, we have to know how to use the scope operator (::). We will talk more about the scope operator later in that book, so now we only show examples for two of its possible usages.

With the help of :: operator, we can refer names having file and program level scope (that is identifiers of the global namespace) from any block of a program.

#include <iostream>
using namespace std;
 
long a = 12;
static int b = 23;
 
int main() {
   double a = 3.14159265;
   double b = 2.71828182;
   {
      long a = 7, b;
      b = a * (::a + ::b);   
      // the value of b is 7*(12+23) = 245
      ::a = 7;
      ::b = 29;
   }
}

We also use the scope operator to access directly names defined in the namespace std :

#include <iostream>
int main() {
   std::cout<<"C++ language"<<std::endl;
   std::cin.get();
}

Bigger C++ source codes are in general developed by numerous programmers. The functionalities of C++ presented so far are not enough to avoid collision or conflict of global (program level) names. Introducing namespaces having a user-defined name gives a good solution for these problems.

namespace myOwnNamespace {
   definitions and declarations
}

#include <iostream>
#include <string>
 
// declarations
namespace nsexample {
    extern int value;
    extern std::string name;
    void ReadData(int & a, std::string & s);
    void PrintData();
}
 
// definitions
namespace nsexample {
    int value;
    std::string name;
    void PrintData() {
        std::cout << name << " = " << value << std::endl;
    }
}
 
void nsexample::ReadData(int & a, std::string & s) {
    std::cout << "name:   "; getline(std::cin, s);
    std::cout << "value: "; std::cin >> a;
}

int main() {
    nsexample::name = "Sum";
    nsexample::value = 123;
    nsexample::PrintData();
    nsexample::ReadData(nsexample::value, nsexample::name);
    nsexample::PrintData();
    std::cin.get();
}

using namespace nsexample;
int main() {
    name = "Sum";
    value = 123;
    PrintData();
    ReadData(value, name);
    PrintData();
    std::cin.get();
}

int PrintData() {
    std::cout << "Name conflict" << std::endl;
    return 1;
}
 
int main() {
    using nsexample::name;
    using nsexample::value;
    using nsexample::ReadData;
    name = "Sum";
    value = 123;
    nsexample::PrintData();
    ReadData(value, name);
    PrintData();
    std::cin.get();
}

namespace Project {
    typedef unsigned char byte;
    typedef unsigned short word;
 
    namespace Intel {
        word ToWord(byte lo, byte hi) {
            return lo + (hi<<8);
        }
    }
 
    namespace Motorola {
        word ToWord(byte lo, byte hi) {
            return hi + (lo<<8);
        }
    }
}

using namespace Project::Intel;
int main() {
    cout << hex;
    cout << ToWord(0xab,0x12)<< endl;             // 12ab
}
// -------------------------------------------------------
int main() {
    using Project::Motorola::ToWord;
    cout << hex;
    cout << ToWord(0xab,0x12)<< endl;            // ab12
}
// -------------------------------------------------------
using namespace Project;
int main() {
    cout << hex;
    cout << Intel::ToWord(0xab,0x12)<< endl;     // 12ab
    cout << Motorola::ToWord(0xab,0x12)<< endl;  // ab12
}
// -------------------------------------------------------
int main() {
    cout<<hex;
    cout<<Project::Intel::ToWord(0xab,0x12)<< endl;   // 12ab
    cout<<Project::Motorola::ToWord(0xab,0x12)<<endl; // ab12
}

namespace alias =externalNS::internalNS … ::most_internal_NS;

int main() {
    namespace ProcI = Project::Intel;
    namespace ProcM = Project::Motorola;
    cout << hex;
    cout << ProcI::ToWord(0xab,0x12)<< endl;     // 12ab
    cout << ProcM::ToWord(0xab,0x12)<< endl;     // ab12
}

#include <iostream>
#include <string>
using namespace std;
 
namespace {
    string password;
}
 
namespace {
    bool ChangePassword() {
        bool success = false;
        string old, new1, new2;
        cout << "Previous password: "; getline(cin, old);
        if (password == old) {
            cout << "New Password: "; getline(cin, new1);
            cout << "New Password: "; getline(cin, new2);
            if (new1==new2) {
                password = new1;
                success = true;
            }
        }
        return success;
    } // ChangePassword()
}
 
int main() {
    password = "qwerty";
    if (ChangePassword())
         cout << "Successful password change!" << endl;
    else
         cout << "Not a successful password change!" << endl;
}

Symbolic constants can be created by using the simple form of the #define directive:

#define  identifier
 
#define  identifier  replacement_text

Let's see some examples how to define and use symbolic constants.

#define SIZE 4
#define DEBUG
#define AND &&
#define VERSION "v1.2.3"
#define BYTE unsigned char
#define EOS '\0'
 
int main() {
    int v[SIZE];
    BYTE m = SIZE;
    if (m > 2 AND m < 5)
        cout << "2 < m < 5" << endl;
    #ifdef DEBUG
        cout << VERSION << endl;
    #endif
}

The source file after the preprocessing (replacements) is the following:

int main() {
    int v[4];
    unsigned char m = 4;
    if (m > 2 && m < 5)
        cout << "2 < m < 5" << endl;
        cout << "v1.2.3" << endl;
}

In the previous example, some symbolic constants can be replaced by identifiers of types const and typedef in C++:

#define DEBUG
#define AND &&
const int size = 4;
const string version = "v1.2.3";
const char eos = '\0';
typedef unsigned char byte;
 
int main() {
    int v[size];
    byte m = size;
    if (m > 2 AND m < 5)
        cout << "2 < m < 5" << endl;
    #ifdef DEBUG
        cout << version << endl;
    #endif
}

The macros can be efficiently used in much more cases if they are parameterized. The general form of a function-like parameterized macro:

#define  identifier(parameter_list)  replacement_text

Using (calling) a macro:

identifier(argument_list)

The number of the arguments in a macro call has to be identical with that of the parameters in the definition.

In order that parameterized macros work securely, the following two rules have to observed:

The following example code demonstrates some frequently used macro definitions and the way they can be called:

// determining the absolute value of x
#define ABS(x)   ( (x) < 0 ? (-(x)) : (x) )
 
// calculating the maximum value of a and b 
#define MAX(a,b) ( (a) > (b) ? (a) : (b) )
 
// calculating the square of X 
#define SQR(X)   ( (X) * (X) )
 
// generating a random number within a given interval
#define RANDOM(min, max) \
    ((rand()%(int)(((max) + 1)-(min)))+ (min))
 
int main() {
    int x = -5;
    x = ABS(x);
    cout << SQR(ABS(x));
    int a = RANDOM(0,100);
    cout << MAX(a, RANDOM(12,23));
}

The backslash (\) character at the end of the first line of the macro named RANDOM() indicates that the definition of that macro is continued in the next line. The content of the main () function cannot be qualified as legible at all after the preprocessing process:

int main() {
   int x = -5;
   x = ( (x) < 0 ? (-(x)) : (x) );
   cout << ( (( (x) < 0 ? (-(x)) : (x) )) * 
          (( (x) < 0 ? (-(x)) : (x) )) );
   int a = ((rand()%(int)(((100) + 1)-(0)))+ (0));
   cout << ( (a) > (((rand()%(int)(((23) + 1)-(12)))+ (12)))
        ? (a) : (((rand()%(int)(((23) + 1)-(12)))+ (12))) );
}

All advantages of macros (type-independence, faster code) can be achieved by using inline functions/function templates (instead of macros) while keeping the C++ code legible:

template <class tip> inline tip Abs(tip x) {
  return  x < 0 ? -x : x;
}
 
template <class tip> inline tip Max(tip a, tip b) {
  return a > b ? a : b;
}
 
template <class tip> inline tip Sqr(tip x) {
  return x * x;
}
 
inline int Random(int min, int max) {
  return rand() % (max + 1 - min) + min;
}
 
int main() {
    int x = -5;
    x = Abs(x);
    cout << Sqr(Abs(x));
    int a = Random(0,100);
    cout << Max(a, Random(12,23));
}

A macro can be undefined anytime and can be redefined again, even with a different content. It can be undefined by using the #undef directive. Before redefining a macro with a new content, the old definition always has to be undefined. The #undef statement does not signal an error if the macro to be undefined does not exist:

#undef identifier

The following example code traces the functioning of #define and #undef statements:

int main() {
    #define MACRO(x) (x) + 7
    int a = MACRO(12);
    #undef MACRO
    a = MACRO(12);
    #define MACRO 123
    a = MACRO
}

int main() {
 
    int a = (12) + 7;
 
    a = MACRO(12);
 
    a = 123
}

In our previous examples, replacement was carried out by the preprocessor only in case of separate parameters. There are cases where a parameter is a part of an identifier or where the value of an argument is to be reused as a string. If replacement has to be done in these cases as well, then the macro operators ## and # have to be used.

If the # character is placed before the parameter in a macro, the value of the parameter is replaced as enclosed within quotation marks (i.e. as a string). With this method, replacement can be carried out on strings as well, since the compiler will concatenate the string literals standing one after another into one string constant. The following code prints out the name and value of any variable by using the macro named INFO():

#include <iostream>
using namespace std;
 
#define INFO(variable) \
        cout << #variable " = " << variable <<endl;
 
int main() {
   unsigned  x = 23;
   double   pi = 3.14259265;
   string    s = "C++ language";
   INFO(x);
   INFO(s);
   INFO(pi);
}

x = 23
s = C++ language
pi = 3.14259

By using the ## operator, two syntactic units (tokens) can be concatenated. To achieve this, the ## operator has to be inserted between the parameters in the body of a macro.

In the following example, the macro named PERSON() populates the array named people with values of structure type:

#include <string>
using namespace std;
 
struct person {
    string name;
    string info;
};
 
string Ivan_Info ="K. Ivan, Budapest,  9";
string Alice_Info ="O. Alice, Budapest, 33";
 
#define PERSON(NAME) { #NAME, NAME ## _Info }
 
int main(){
    person people[] = {
        PERSON (Ivan),
        PERSON (Alice)
    };
}

The content of the main () function after preprocessing:

int main(){
    person people[] = {
        { "Ivan", Ivan_Info },
        { "Alice", Alice_Info }
    };
}

There are cases when one macro is not sufficient for a given purpose. In the following example, the version number is created by concatenating the given symbolic constants:

#define MAJOR 7
#define MINOR 29
 
#define VERSION(major, minor) VERSION_MINOR(major, minor)
#define VERSION_MINOR(major, minor) #major "." #minor
 
static char VERSION1[] = VERSION(MAJOR,MINOR);       // "7.29"
static char VERSION2[] = VERSION_MINOR(MAJOR,MINOR); //"MAJOR.MINOR"

ANSI C++ standard contains the following predefined macros. (Almost all identifiers start and end with a double underscore character.) The name of predefined macros cannot be used in #define and #undef statements. The value of predefined macros can be integrated into the text of a code but can also be used as a condition in conditional directives.

There are a lot of utility software that transforms a code written in a special programming language to a C++ source file (program generators).

The #line directive forces C++ compilers not to signal the error code in the C++ source text but in the original source file written in another special language. (The code and file name set by a #line statement are also present in the value of the symbols __LINE__ and __FILE__ .)

#line beginning_number
 
#line beginning_number "filename"

If it is inserted in a code, an #error directive can be used to print out a compilation error message which contains the text provided in the statement:

#error error_message

In the following example, compilation ends with an error message if we do not use the C++ mode:

#if !defined(__cplusplus)
    #error Compilation can only be carried out in C++ mode!
#endif

#pragma directives are used to control the compilation process in an implementation-dependent way. (There are not any standard solution for this directive.)

#pragma instruction

If the compiler encounters an unknown #pragma instruction, it does not consider that. Therefore the portability of computer programs is not endangered by this directive. For example, the alignment of structure members to different boundaries and disabling the printing out of warning compilation messages having a specific index can be done in the following way:

#pragma pack(8)
// aligned to 8 byte boundary
#pragma pack(push, 1)
// aligned to 1 byte boundary
#pragma pack(pop) 
// aligned again to 8 byte boundary
 
#pragma warning( disable : 2312 79 ) 

The empty directive (#) can also be used, but it does not affect preprocessing:

#