Forwarding functions

Sometimes it is required to seperate the interface from implementation and 'forwarding functions' can be useful. The interface class can forward the work to the implementation keeping the interface clean and minimal.

The following is a simple example where function f() forwards its work to function g():

//g.h
#pragma once

bool g(int x)
{
  if (x%2 == 0)
    return true;
  else
    return false;
}


//f.h
#pragma once

bool f(int x);


//f.cpp
#include<iostream>

#include "f.h"
#include "g.h"

bool f(int x)
{
  return g(x);
}


//main.cpp
//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
#include<iostream>

#include "f.h"

using namespace std;

int main()
{
  if(f(20))
    cout<<"TRUE"<<endl;
  else
    cout<<"FALSE"<<endl;

  return 0;
}

There are couple of things to keep in mind when writing them. See here.

You can read more about seperating Interface and Implementation here.

Using constants with functions

There always seems to be confusion in using const with functions. I am not referring to const functions that have const after the function name, that is straightforward. Also, the way functions behave when you have const before them is different than the built-in types. I have earlier provided a table for that.

Here is a simple program that shows different types of const with functions.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
#include<iostream>
#include<string>

using namespace std;

class A
{
public:
  int x;
};

class B
{
public:
  string y;
};

A* const createA()
{
  return (new A);
}

const B* createB()
{
  return (new B);
}

int main()
{
  A* a = NULL;
  a = createA();
  a->x = 100;
  cout<<"a.x = "<<a->x<<endl;
  delete a;

  const B* b = NULL;
  b = createB();
  //b->y = "Hello"; - Compilation error because b is constant
  (const_cast<B*>(b))->y = "Hello";
  cout<<"b.y = "<<b->y<<endl;
  delete b;

  A* const a2 = NULL;
  //a2 = createA(); - Compilation Error: 
                   // you cannot assign to a variable that is const

  A* const a3 = new A; //not possible to change what a3 points to now
  a3->x = 23456;
  cout<<"a3.x = "<<a3->x<<endl;
  delete a3;
  
  return 0;
}

The output is as follows:

Passing Variable arguments in functions

Sometimes it becomes necessary to have variable number of arguments in the function. One way is to overload the function but that may be unnecessary for simple logic. We can use access variable-argument lists macros in the functions. Here is a simple example:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Program to show how to use variable number of arguments

#include<iostream>
#include <stdarg.h> //needed for va_ macros
using namespace std;

//List Should be terminated by -1 in our case
int Add(int a,...)
{
  int total = a;
  int l_ParamVal=0;

  //Declare a va_list macro and initialize it with va_start
  va_list l_Arg;
  va_start(l_Arg,a);

  while((l_ParamVal = va_arg(l_Arg,int)) != -1)
  {
    total+= l_ParamVal;
  }

  va_end(l_Arg);
  return total;
}

int main()
{
  cout<<"Result of Add(2) = "<<Add(2, -1)<<endl;
  cout<<"Result of Add(2, 3) = "<<Add(2, 3, -1)<<endl;
  cout<<"Result of Add(2, 3, 31) = "<<Add(2, 3, 31, -1)<<endl;
  cout<<"Result of Add(2, 3, 31, 77) = "<<Add(2, 3, 31, 77, -1)<<endl;

  cout<<endl;
  return 0;
}

These type of functions that take variable number of arguments are also referred to as 'Variadic Functions'. See more details here.

The output is as follows:

Passing unnamed arguments in functions

It is possible to pass an unnamed argument in C++ function. The unnamed argument indicates that argument is unused. Typically unnamed arguments arise from the simplification of code or from planning ahead for extensions. In either case, leaving the argument in place, although unused, ensures that the callers are not affected by the change. Simple example as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Simple example of unnamed arguments
#include<iostream>

using namespace std;

void someFunc(int a, int)
{
  cout<<"Only a is defined to "<<a<<endl;
  cout<<"The second argument is dummy"<<endl;
}

int main()
{
  someFunc(15, 100); //100 is dummy

  cout<<endl;
  return 0;
}

The output is as follows:

Advanced features of C++ functions

There are 3 advanced features of C++ functions as compared to C. They are Call by Reference, Function Overloading and Default Arguments. You can read more about them here.

A simple program showing all the three features as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Example of pointer to const and const pointer
#include<iostream>

using namespace std;

//Call by reference
void swap(int& a, int &b)
{
  int temp = a;
  a = b;
  b = temp;
}

//Overloaded function: Call by reference (pointers)
void swap(int *a, int *b)
{
  int temp = *a;
  *a = *b;
  *b = temp;
}

//Pass by value with Default arguments
void doSwap(int a, int b = 1)
{
  swap(a,b);
  cout<<"After Local Swap: a = "<< a <<" b = "<< b <<endl;
}

int main()
{
  int a = 10, b = 17;
  cout<<"Before Swap : a = "<< a <<" b = "<< b <<endl;
  swap(a, b);
  cout<<"After Swap 1: a = "<< a <<" b = "<< b <<endl;
  swap(&a, &b);
  cout<<"After Swap 2: a = "<< a <<" b = "<< b <<endl;
  doSwap(a, b);
  doSwap(a);
  cout<<"After DoSwap: a = "<< a <<" b = "<< b <<endl;

  return 0;
}

The output is as follows:

Difference between procedures and functions in C++

In very simple terms in C++ a procedure is a function with return type as void.

Generally speaking we use the term procedure to refer to a routine, like the ones above, that simply carries out some task (in C++ its definition begins with void). A function is like a procedure but it returns a value; its definition begins with a type name, e.g. int or double indicating the type of value it returns. Procedure calls are statements that get executed, whereas function calls are expressions that get evaluated.

A simple program to show the difference as follows:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//This program shows difference between functions and procedures
#include<iostream>

using namespace std;

//function
bool checkIfPositive(int x)
{
  if(x >= 0)
    return true;
  return false;
}

//procedure
void printIfPositive(int x)
{
  bool isPositive = checkIfPositive(x);
  if(isPositive)
    cout<<"x is positive and its value is "<<x<<endl;
}

int main()
{
  printIfPositive(3);
  printIfPositive(-54);
  printIfPositive(710);
  return 0;
}

The output is as follows: