char sum_char(char a, char b)
{
    char c;
    c = a + b;
    return c;
}
 
int sum_int(int a, int b)
{
    int c;
    c = a + b;
    return c;
}  

A call to sum_char involves the following operations:

1. Convert the second parameter into an int by sign extension (C and C++ push parameters in reverse)
2. Push the sign extended parameter on the stack as b.
3. Convert the first parameter into an int by sign extension.
4. Push the sign extended parameter on to the stack as a.
5. The called function adds a and b
6. The result is cast to a char.
7. The result is stored in char c.
8. c is again sign extended
9. Sign extended c is copied into the return value register and function returns to caller.
10. The caller now converts again from int to char.
11. The result is stored.

A call to sum_int involves the following operations:

1. Push int b on stack
2. Push int a on stack
3. Called function adds a and b
4. Result is stored in int c
5. c is copied into the return value register and function returns to caller.
6. The called function stores the returned value.

Thus we can conclude that int should be used for all interger variables unless storage requirements force us to use a char or short. When char and short have to be used, consider the impact of byte alignment and ordering to see if you would really save space. (Many processors align structure elements at 16 byte boundaries) 

Define lightweight constructors

As far as possible, keep the constructor light weight. The constructor will be invoked for every object creation. Keep in mind that many times the compiler might be creating temporary object over and above the explicit object creations in your program. Thus optimizing the constructor might give you a big boost in performance. If you have an array of objects, the default constructor for the object should be optimized first as the constructor gets invoked for every object in the array.

Prefer initialization over assignment

Consider the following example of a complex number::

void foo()
{
    Complex c;
    c = (Complex)5;
}
 
void foo_optimized()
{
    Complex c = 5;
}   

In the function foo, the complex number c is being initialized first by the instantiation and then by the assignment. In foo_optimized, c is being initialized directly to the final value, thus saving a call to the default constructor of Complex.

Use constructor initialization lists

Use constructor initialization lists to initialize the embedded variables to the final initialization values. Assignments within the constructor body will result in lower performance as the default constructor for the embedded objects would have been invoked anyway. Using constructor initialization lists will directly result in invoking the right constructor, thus saving the overhead of default constructor invocation.  

In the example given below, the optimized version of the Employee constructor saves the default constructor calls for m_name and m_designation strings.

Employee::Employee(String name, String designation)
{
    m_name = name;
    m_designation = designation;
}

/* === Optimized Version === */
 
Employee::Employee(String name, String designation): m_name(name), m_destignation (designation)
{  
}   

Do not declare "just in case" virtual functions

Virtual function calls are more expensive than regular function calls so do not make functions virtual "just in case" somebody needs to override the default behavior. If the need arises, the developer can just as well edit the additional base class header file to change the declaration to virtual.

In-line 1 to 3 line functions

Converting small functions (1 to 3 lines) into in-line will give you big improvements in throughput. In-lining will remove the overhead of a function call and associated parameter passing. But using this technique for bigger functions can have negative impact on performance due to the associated code bloat. Also keep in mind that making a method inline should not increase the dependencies by requiring a explicit header file inclusion when you could have managed by just using a forward reference in the non-inline version. (See the article on header file include patterns for more details).

---