Template based programming

Introduction

As we already know of inheritance, it is a good way of reusing your code. However, Visual C++ provides another way of reusing your code. We can do this through templates. With templates you can make the 'type' parameter. Let me explain. When you had this class that shows all processor information. The class is huge, and it uses all integers. What if, in time, the integer wouldn't be able to store the information of the processor (just because it's out of range for the integer). Now you'll need to review all your code and change the integers to longs. Or when you have this class that handles int arrays, and someday you'll need the exact same class, only you want it to handle floats.

Details

For these problems we have templates. Let me show you some code:

class CMyIntArray
{ 
public: 
    int GetSize();//gets the size of the array int 
    SetSize();//sets the size of the array 
    void Add(int Value);//adds a value to the array etc...
}

As it becomes clear from this code, you cannot handle floats with this class. A float class would look like this:

class CMyFloatArray
{ 
public: 
    int GetSize();//gets the size of the array int 
    SetSize();//sets the size of the array 
    void Add(float Value);//adds a value to the array etc...
}

Ok, we can handle this little bit of change.. but what if you had lots of functions, and what if we needed them same class for short, char etc...

You might now the old C macros (#define), template based programming is just like that (in a way). But, type macros aren't type safe, templates are. If you want to know how to create a template please look at the code below:

//Use of templates in Visual C++ by Clemens Timmermans (maxcode.com)
template <typename Type>
class CMyArray
{ 
public:
    void Add(Type Value);
    int GetSize();
    int SetSize();
};

That wasn't so hard? right? Now lets see how we can USE this template, by the following code snippet:

...
// USING CMyArray
CMyArray <int> iArray;
iArray.Add(100);
////////////////////
CMyArray<float> fArray;
fArray.Add(10.2);
/////////////////////
...
//you got the point of basic template use!

No, finally, we may also use the Templates as containers. Checkout the following code:

class CMercedes
{
public:
    int GetMaxSpeed();//this gets the max speed of the car
    void SpeedUp();
    CMercedes();
    virtual ~CMercedes();
}

in template based programming we would make it look like this, no matter what the brand is.

//what if we want to create a template class 
//which needs to take any valid car

template <typename MyCar>
class CTemplateCar
{
private:
    MyCar theCar;
public:
    CTemplateCar(){}
    virtual ~CTemplateCar(){}
    void SpeedUpWhateverCarWeLike()
    {
        theCar.SpeedUp();
    }
}

now, as we want to use the template.. use this code to use it!

...
CTemplateCar<CMercedes>  car;
car.SpeedUpWhateverCarWeLike();
CTemplateCar<CFerrari>  car2;
car2.SpeedUpWhateverCarWeLike();
...

I hope this article has helped you understand the meaning of template based programming, but above all, how to use it and why use it.