inline function : Demo

Inline expansion, or inlining, is  compiler optimization that replaces a function call site with the body of the callee. This optimization may improve time and space usage at runtime, at the possible cost of increasing the final size of the program (i.e. the binary file size).

#include <iostream>

using namespace std;

inline int square(int n)
{
   return  n*n;
}

int main()
{
   int x = 5, sq;
   sq = square(x);
   //
   //  At this call, x*x is replaced by compiler.
   //

   cout << sq << endl;

   return 0;
}

"inline" is just a hint or request to compiler to expand the body of function at its call.
Compiler may decline this request, often in following cases:
1. Function returning a value, contains loop, switch or goto.
2. Function not returning value, has a return statement.
3. Function contains a static variable.
4. Function is recursive.

Function overloading : _Z10Everything _Z4that _Z5looks _Z6simple, _Z2is _Z3not_Z8 actually _Z2so !

#include <iostream>
using namespace std;

int add (int a, int b);
float add (float a, float b);

int main()
{
  int a = 6;
  int b = 3;

  float c = 5.46;
  float d = 7.887987;

  cout << a << "+" << b << "=" << add(a,b) << endl;
  cout << c << "+" << d << "=" << add(c,d) << endl;

  return 0;
}

int add(int a, int b)
{
   return a+b;
}

float add(float a, float b)
{
   return a+b;
}

Naming decoration aka Name mangling :

Why?
In early days, C++ compilers used to convert C++ source into C code.
C does not support two functions with same names, hence names have to be decorated in order to conform them to 'C' identifier rules.
Even after development of compilers that can translate C++ source to machine code or assembly directly, system linkers did not support C++ symbols. So mangling still required.

The C++ language does not define a standard decoration scheme, so each compiler uses its own.


For following compiler mangling details are below:
g++ (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5

For void add(int,int) Mangled name is _Z3addii
For void add(float,float) Mangled name is _Z3addff

In g++ generally,
All mangled symbols begin with _Z (note that an underscore followed by a capital is a reserved identifier in C and C++).
For nested names (including both namespaces and classes), this is followed by N. Then a series of pairs (the length being the length of the next identifier), and finally E. For example, 

namespace Earth
{
    class Man
    {
        void Born(float);
    }
}

The name Born is mangled as
_ZN5Earth3Man4BornEf
_Z        : mandatory
N         : says that namespace/class follows
5Earth : 5 characters in following dentifier "Earth"
3Man   : 3 characters in Man
4Born  : 4 characters in Born
E          : End of name
f           : Parameter is float

Only parameterized CTOR: Demo (along with error by g++)

#include <iostream>
using namespace std;

class SI
{
   float pple;
   float rate;
   float n;

   public:
     //
     // We have written only parameterized CTOR
     // In this case, C++ DOES NOT PROVIDE US WITH
     // default constructor.
     //
     SI(float rate, float n)
     {
        this->rate = rate;
        this->n = n;
     }
      void SetInput(float pple);
      void SetInput(float pple, float n, float r);
      float  CalculateSI();
};

void SI::SetInput(float pple)
{
   this->pple = pple;
}
void SI::SetInput(float pple, float n, float rate)
{
    this->pple = pple;
    this->rate = rate;
    this->n = n;
}

float SI::CalculateSI()
{
  return (pple *rate * n) /100;
}

int main()
{
  SI s1;
  s1.SetInput( 1000);
  s1.SetInput(1000, 6.7, 4);
 cout << endl <<"\t Simple intereset = "<< s1.CalculateSI()<< endl;

  return 0;
}
/*
ctor_only_param.cpp:44: error: no matching function for call to ‘SI::SI()’
ctor_only_param.cpp:16: note: candidates are: SI::SI(float, float)
ctor_only_param.cpp:5: note:                 SI::SI(const SI&)
*/

Parameterized constructor Demo

#include <iostream>
using namespace std;

class SI
{
   float pple;
   float rate;
   float n;

   public:
      SI()// This is default constructor
      {
         rate = 10;
         n = 3;
      }

      SI(float rate, float n)// This is parameterized constructor
      {
         this->rate = rate;
         this->n = n;
      }

      void SetInput(float pple);
      void SetInput(float pple, float n, float r);
      float  CalculateSI();
};

void SI::SetInput(float pple)
{
   this->pple = pple;
}
void SI::SetInput(float pple, float n, float rate)
{
    this->pple = pple;
    this->rate = rate;
    this->n = n;
}

float SI::CalculateSI()
{
  return (pple *rate * n) /100;
}

int main()
{
  SI s1;

  s1.SetInput( 1000);
  s1.SetInput(1000, 6.7, 4);
    cout << endl << "\t Simple intereset = "<< s1.CalculateSI()<< endl;
 
  SI s2(9.5, 5);
  s2.SetInput(5000);
  cout << "Simple interest = "<< s2.CalculateSI() << endl;

  return 0;
}

Compilation Process (C and C++ particular)

Compilation starts with preprocessor. Preprocessor expands our source code and often writes it into intermediate file.

There are two passes in compilation:
First pass parses pre-processed code i.e. breaks code into small units. For example if statement is “A+B” then elements are ‘A’,’+’,’B’. Global optimizer is used between first and second pass to produce smaller and faster code.

In second pass, code generator walks through parse tree, which is generated in first pass, and generates either assembly language code or machine code for nodes of tree.
For assembly code assembler should run.

Ultimate result of both cases is an object module (.o or .obj) (.o file generated here is different than finally generated a.out file)

Peephole optimizer used in second pass to look for redundant assembly language statement.

The linker combines a list of object modules into an executable program that and run by OS
Linker is useful when function of one object module makes reference to function or variable in another object module. These references are resolved by linker. Linker takes help of libraries to resolve these references.

Compiler performs type checking during first pass. As this type checking occurs during compile time, this is called as static type checking.

[Courtesy : Rajesh Deshpande]

Constructor and destructor

If baby takes birth and dies away immediately, then the "baby" (who belonged to MAN class) has performed two functions: "being born" and "dieing". Similarly there are TWO mercy functions for ANY C++ object:
1. constructor: After allocation of memory, initializes it.
and
2. destructor: Before deallocation of memory, de-initializes it.

Constructor gets called automatically when an object is created. and
destructor gets called automatically when an object is about to die (go out of scope).

#include <iostream>

using namespace std;

class Man
{
   float height;
   float weight;

public:
   Man()
   {
     cout << "Man born" << endl;
   }

   ~Man()
   {
      cout << "Man died" << endl;
   }
};

int main()
{
  Man Hritik;
  return 0;
}

Function with default arguments: Demo

#include 
using namespace std;

class SI
{
   float pple;
   float rate;
   float n;

   public:
      // Function with default arguments. (must be from right to left)
      void SetInput(float , float n = 3, float rate = 10);

      float  CalculateSI();
};


//
//   setInput: Function definition 
//   You may not write default argument values in definition
//
void SI::SetInput(float pple, float n, float rate)
{

//   This line is to test whether this contains address of caller object or not
//   cout << "this : <"<< this << ">"<< endl;

//
//  "this" is necessary here to resolve ambiguity,
//  Our class has the data members pple, rate, n and
//  we have the very same names as the parameters to this function
//
    this->pple = pple;
    this->rate = rate;
    this->n = n;
}

float SI::CalculateSI()
{
  return (pple *rate * n) /100;
}

int main()
{
  SI s1;
  s1.SetInput(1000,1);
  cout << endl << "\t Simple intereset = "<< s1.CalculateSI()<< endl;

//  This is to test whether "this" contains address of the caller object or not.
//  cout << "Address of s1 : <"<< &s1 << ">" << endl;

  SI s2;
  s2.SetInput(2000,4);
  cout << endl << "\t Simple intereset = "<< s2.CalculateSI()<< endl;

  SI s3;
  s3.SetInput(5000,3.5);
  cout << endl << "\t Simple intereset = "<< s3.CalculateSI()<< endl;

  SI s4;
  s4.SetInput(4538,9.32,5.7);
  cout << endl << "\t Simple intereset = "<< s4.CalculateSI()<< endl;

  SI s5;
  s5.SetInput(5000);
  cout << endl << "\t Simple intereset = "<< s5.CalculateSI()<< endl;

  return 0;
}