Generic
Programming
Generic Programming
• Generic programming in C++ is a paradigm that allows you to write
code in a way that is abstracted from any specific type. This allows for
the creation of flexible and reusable components. The primary
mechanism for generic programming in C++ is through the use of
templates.
Generic Programming
• The method of Generic Programming is implemented to increase
the efficiency of the code. Generic Programming enables the
programmer to write a general algorithm which will work with
all data types. It eliminates the need to create different
algorithms if the data type is an integer, string or a character.
The advantages of Generic
Programming are
1.Code Reusability
2.Avoid Function Overloading
3.Once written it can be used for multiple times and
cases.
Templates in C++
• Templates is simple yet very powerful tool in C++.
• Templates are the foundation of generic programming, which involves writing code in
a way that is independent of any particular type.
• A template is a blueprint or formula for creating generic function or class`.
Two Types of Templates are:
a) Function Template
b) Class Template
Function Overloading
int add(int x,int y)
{
return(x+y);
}
double add(double x,double y)
{
return(x+y);
}
int main()
{
cout<<add(2,3)<<endl;
cout<<add(5.6,3.3);
}
Function Overloading
int great(int x,int y)
{
return(x>y?x:y);
}
float great(double x,double y)
{
return(x>y?x:y);
}
int main()
{
cout<<great(2,3)<<endl;
cout<<great(5.6,3.3);
}
Syntax to declare Template
template <class identifier> function_declaration;
// or
template <typename identifier> function_declaration;
• Either we use the class keyword or typename. Both
approaches are the same.
Template
template <class T>
T num(T a, T b)
{
return (a > b ? a : b);
}
int main()
{
int x = 5, y = 2;
float a = 4.5, b = 1.3;
cout << num(x, y) << "\n";
cout << num(a, b);
}
Macros vs Templates
Macros and templates are both mechanisms in C++ for achieving generic
Macros
programming. Templates
Macros operate purely on text and offer no type safety Templates provide strong type safety because they are type-
guarantees. aware and checked by the compiler.
Macros, being text substitutions, can obscure debugging and Templates produce more readable and maintainable code
make code harder to understand. because they are part of the C++ language syntax and benefit
from compiler error messages.
Macros are global and can potentially pollute the global Templates respect C++ scoping rules and can be confined
namespace. within namespaces and classes, enhancing encapsulation and
reducing name clashes.
Macros are typically used for simple text substitutions or Templates are suitable for most generic programming needs
when compatibility with older codebases or languages (like C) in modern C++, providing better safety and flexibility.
is necessary.
Macros vs Templates
#define Square(x) ((x) * (x)) template <typename T>
T Square(T x)
int main() {
{ return x * x;
int a = 5; }
int result = Square(a++); // int main()
Expands to: ((a++) * (a++)), leads to {
undefined behavior int a = 5;
} int result = Square(a); // Calls
Square<int>(5)
}
Macros vs Templates
#define Max(x,y) (x>y?x:y)
int main()
{
int a=3,b=7;
cout<<Max(a,b)<<endl;
cout<<Max(a++,b++)<<endl;
cout<<Max(a,b);
}
Macros vs Templates
template <typename T>
T Max(T x,T y)
{
return(x>y?x:y);
}
int main()
{
int a=3,b=7;
cout<<Max(a,b)<<endl;
cout<<Max(a++,b++)<<endl;
cout<<Max(a,b);
}
Function with two generic types
template<typename T1, typename T2>
void print(T1 first, T2 second)
{
cout<<first<<" "<<second;
}
int main()
{
print(42, "Hello, World!");
print(3.14, 42);
print("Template", 123.456);
}
Explicitly overloading a generic function
// Generic template function
template<typename T>
int main() {
T print(T x)
print(42); // Calls the int specialization
{ cout << endl;
cout << x; print(3.14); // Calls the generic template
} cout << endl;
print("Hello, world!"); // Calls the generic template
// Explicit specialization for int cout << endl;
template<> print(std::string("Hello")); // Calls the generic
int print(int x) template
cout << endl;
{
cout << " (integer)"; return 0;
cout << x; }
}
Explicitly overloading a generic function
template <class T>
void display(T t1)
{ int main()
cout << "Displaying Template: "
<< t1 << "\n"; {
} display(200);
template<> display(12.40);
int display(int t1)
{
display('G'); return 0;
cout << "Explicitly display: " }
<< t1 << "\n";
}
Explicitly overloading a generic function
#include <iostream>
// Generic function
template <typename T>
void print(T value)
{ int main()
cout << value << endl;
} {
template<>
void print(int value)
print(42);
{ print(3.14);
cout << "Integer: " << value << endl;
} print("Hello");
template<> }
void print(double value)
{
cout << "Double: " << value << endl;
}
Using standard parameters with template functions
template<typename T>
T fun(T r, double pi=3.14) int main()
{ {
double area=pi*r*r; fun(4,5);
cout<<"Area of circle is fun(10);
"<<area; }
}
Using standard parameters with template functions
template <typename T>
T power(T base, int exponent = 2)
int main()
{
{
T result = 1;
cout << "Power of 5 with exponent 3: " <<
for (int i = 0; i < exponent; ++i)
power(5, 3) << endl;
{
cout << "Power of 3.5 with default exponent (2): "
result = result*base;
<< power(3.5) <<endl;
}
}
return result;
}
Using standard parameters with template functions
template<class X>
void tab(X data, int tab=1)
{
int main()
for(; tab; tab--) {
for(int i=0; i<8; i++) tabo("This is a test");
{ tabo(100, 1);
cout << ' ‘; tabo('X', 2);
} tabo(10/3, 3);
cout << data << "\n";
}
}
Generic function restrictions in C++
1. Not all operations are generic:
• Generic functions work well for operations that are
independent of specific data types. For example, finding the
maximum of two values can be done for integers, doubles, or
even custom types with a proper > operator overload.
• However, operations that rely on specific properties of a data
type might not be suitable for generics. For instance, you
cannot write a generic function to convert an integer to a
string because the conversion logic depends on the specific
string representation used.
Generic function restrictions in C++
2. No virtual functions in templates:
Template functions cannot have virtual functions. Virtual functions are used for
polymorphism, which relies on runtime type information. Since templates are
resolved at compile time, virtual functions wouldn't work in this context.
Generic function restrictions in C++
3. Limited friend functions with templates:
Friend functions can be declared with templates, but they lose the ability to
access private members of the templated class. This is to prevent unintended
access and maintain encapsulation.
4. Performance considerations:
While generics offer code reuse, in some cases, compiling a generic function for
different types might lead to slightly less efficient code compared to a
specifically written function. This is because the compiler might need to
generate multiple versions of the function for different types.
