C++ templates enable writing generic code that works with different data types without rewriting the entire code for each type. They are broadly categorized into function templates and class templates.

Function Templates

Function templates provide a mechanism to define a generic function that can operate on different data types. The compiler generates specific function instances based on the types provided during a call.

Template Syntax

To define a function template, the template keyword is used, followed by a list of template parameters enclosed in angle brackets. typename or class can be used for type parameters.

#include <iostream>
#include <string>

template <typename TParam>
void swapValues(TParam& valA, TParam& valB) {
    TParam temporary = valA;
    valA = valB;
    valB = temporary;
}

int main() {
    int num1 = 10;
    int num2 = 20;

    // Automatic type deduction by the compiler
    swapValues(num1, num2);
    std::cout << "After swap (auto-deduced): num1=" << num1 << ", num2=" << num2 << std::endl;

    // Explicit type specification
    double dbl1 = 15.5;
    double dbl2 = 25.5;
    swapValues<double>(dbl1, dbl2);
    std::cout << "After swap (explicit double): dbl1=" << dbl1 << ", dbl2=" << dbl2 << std::endl;

    // This will not compile without explicit type due to mismatched types
    // char charVal = 'C';
    // swapValues(num1, charVal); // Error: Type deduction fails for TParam

    // But with explicit type, implicit conversion might occur if safe
    char charVal = 'C';
    swapValues<int>(num1, reinterpret_cast<int&>(charVal)); // Dangerous, but demonstrates type fix
    // A safer explicit call with potential conversion for value parameters would be:
    // int intVal = num1;
    // swapValues<int>(intVal, static_cast<int>(charVal)); // If parameters were by value

    system("pause");
    return 0;
}

Considerations for Function Templates

• Type Consistency for Automatic Deduction: When the compiler automatically deduces template types, all arguments corresponding to a single type parameter TParam must resolve to the same concrete type. If types are inconsistent (e.g., swapValues(int_var, char_var)), deduction fails.
• Type Resolution: A template's type parameters must be explicitly or implicitly resolved before the template can be used. An empty template function requires explicit instantiation.

#include <iostream>

template <typename TGeneric>
void processEmpty() {
    // This function does nothing specific with TGeneric
    std::cout << "Processing empty template with type: " << typeid(TGeneric).name() << std::endl;
}

int main() {
    // Must explicitly specify the type argument for an empty template function
    processEmpty<int>();
    processEmpty<double>();
    system("pause");
    return 0;
}

Template Functions vs. Non-Template Functions

There are key differences in how regular (non-template) functions and function templates behave, especially concerning type conversions during function calls:

• Implicit Type Conversion: Ordinary functions allow standard implicit type conversions (e.g., char to int).
• Automatic Deduction with Templates: When using automatic type deduction, function templates generally do not permit implicit type conversions for the template type parameters themselves. All deduced types for a single TParam must match exactly.
• Explicit Type Specification with Templates: If you explicitly specify the template argument (e.g., swapValues<int>(val1, val2)), then implicit conversions can occur for the function arguments themselves, as long as they are compatible with the explicitly specified template type.

#include <iostream>

template <typename TGeneric>
void performGenericSwap(TGeneric argA, TGeneric argB) {
    TGeneric temp = argA;
    argA = argB;
    argB = temp;
    std::cout << "Generic swap: A=" << argA << ", B=" << argB << std::endl;
}

void performSpecificSwap(int argA, int argB) {
    int temp = argA;
    argA = argB;
    argB = temp;
    std::cout << "Specific swap: A=" << argA << ", B=" << argB << std::endl;
}

int main() {
    int iVal = 10;
    char cVal = 'x'; // ASCII 120

    // performGenericSwap(iVal, cVal); // ERROR: Automatic deduction fails as TGeneric cannot be both int and char

    // Explicitly specifying <int> allows char to implicitly convert to int for the parameter
    performGenericSwap<int>(iVal, cVal); // Calls template, char 'x' converts to 120

    // Non-template function allows implicit conversion directly
    performSpecificSwap(iVal, cVal); // Calls non-template, char 'x' converts to 120

    system("pause");
    return 0;
}

Function Template Overload Resolution Rules

When both non-template functions and function templates exist with similar signatures, the C++ compiler follows specific rules to determine which function to call:

1. Prefer Non-Template Overloads: If a non-template function provides an exact match for the arguments, it will be preferred over a function template.

   #include <iostream>
   
   void displayInfo(int x, int y) {
       std::cout << "Calling non-template displayInfo(int, int)" << std::endl;
   }
   
   template <typename T>
   void displayInfo(T x, T y) {
       std::cout << "Calling function template displayInfo(T, T)" << std::endl;
   }
   
   void executeTest1() {
       int i = 5;
       int j = 10;
       displayInfo(i, j); // Calls non-template displayInfo(int, int)
   }
   
   int main() {
       executeTest1();
       system("pause");
       return 0;
   }
   

   Note: If the non-template function is only declared but not defined, the compiler will attempt to link to it. If it's not found, a linker error occurs, even if a suitable template exists.

2. Force Template Instantiation: To explicitly force the compiler to use a function template even when a non-template overload exists, an empty template argument list <> can be used.

   #include <iostream>
   
   void displayInfo(int x, int y) {
       std::cout << "Calling non-template displayInfo(int, int)" << std::endl;
   }
   
   template <typename T>
   void displayInfo(T x, T y) {
       std::cout << "Calling function template displayInfo(T, T)" << std::endl;
   }
   
   void executeTest2() {
       int i = 5;
       int j = 10;
       displayInfo<>(i, j); // Forces calling function template displayInfo(T, T)
   }
   
   int main() {
       executeTest2();
       system("pause");
       return 0;
   }
   

3. Function Overloading: Function templates can also be overloaded, just like regular functions, provided they signatures differ (either in the number of parameters or the types of parameters).

4. Better Match Preference: If no non-template function is an exact match, but a function template can provide a better or exact match after type deduction (e.g., fewer implicit conversions required), the template will be chosen.

   #include <iostream>
   
   void displayInfo(int x, int y) {
       std::cout << "Calling non-template displayInfo(int, int)" << std::endl;
   }
   
   template <typename T>
   void displayInfo(T x, T y) {
       std::cout << "Calling function template displayInfo(T, T)" << std::endl;
   }
   
   void executeTest3() {
       char c1 = 'A';
       char c2 = 'B';
       // The template provides an exact match for (char, char),
       // whereas the non-template requires (char->int, char->int) conversion.
       displayInfo(c1, c2); // Calls function template displayInfo(T, T)
   }
   
   int main() {
       executeTest3();
       system("pause");
       return 0;
   }
   

Template Limitations and Specialization

Function templates assume that the operations performed within them are valid for the template type T. This assumption can break down for custom data types that do not define these operations (e.g., comparison operators like ==).

Consider a Coordinate class:

#include <iostream>
#include <string>

class Coordinate {
public:
    std::string name;
    int x, y;

    Coordinate(std::string n, int x_coord, int y_coord) : name(n), x(x_coord), y(y_coord) {}
};

template <typename T>
bool areEqual(T val1, T val2) {
    if (val1 == val2) { // This comparison might not be defined for custom types
        return true;
    }
    return false;
}

void testCoordinateComparison() {
    Coordinate p1("Origin", 0, 0);
    Coordinate p2("Origin", 0, 0);
    // areEqual(p1, p2); // COMPILE ERROR: No 'operator==' defined for Coordinate
}

int main() {
    testCoordinateComparison();
    system("pause");
    return 0;
}

To resolve this, two common approaches are used:

1. Operator Overloading: Define the required operator(s) for the custom type.

   // ... (Coordinate class definition as above)
   
   // Overload the equality operator for Coordinate objects
   bool operator==(const Coordinate& c1, const Coordinate& c2) {
       return c1.name == c2.name && c1.x == c2.x && c1.y == c2.y;
   }
   
   void testCoordinateComparisonWithOperatorOverload() {
       Coordinate p1("PointA", 1, 2);
       Coordinate p2("PointA", 1, 2);
       Coordinate p3("PointB", 3, 4);
   
       if (areEqual(p1, p2)) {
           std::cout << "P1 and P2 are equal." << std::endl;
       } else {
           std::cout << "P1 and P2 are not equal." << std::endl;
       }
   
       if (areEqual(p1, p3)) {
           std::cout << "P1 and P3 are equal." << std::endl;
       } else {
           std::cout << "P1 and P3 are not equal." << std::endl;
       }
   }
   
   // int main() (from previous block)
   // testCoordinateComparisonWithOperatorOverload();
   // system("pause");
   // return 0;
   

2. Template Specialization: Provide a specific implementation of the template function for a particular type. This completely overrides the generic template for that type.

   #include <iostream>
   #include <string>
   
   class MyPoint {
   public:
       std::string label;
       int posX, posY;
   
       MyPoint(std::string lbl, int x_coord, int y_coord) : label(lbl), posX(x_coord), posY(y_coord) {}
   };
   
   // Generic template for comparison
   template <typename T>
   

bool compareItems(T item1, T item2) { std::cout << "Generic comparison." << std::endl; return item1 == item2; }

// Explicit specialization for MyPoint
template <>

bool compareItems<MyPoint>(MyPoint item1, MyPoint item2) { std::cout << "Specialized comparison for MyPoint." << std::endl; return (item1.label == item2.label && item1.posX == item2.posX && item1.posY == item2.posY); }

void testItemComparison() {
    int a = 10, b = 10, c = 20;
    std::cout << "Comparing ints: " << compareItems(a, b) << std::endl; // Uses generic
    std::cout << "Comparing ints: " << compareItems(a, c) << std::endl; // Uses generic

    MyPoint pta("Start", 0, 0);
    MyPoint ptb("Start", 0, 0);
    MyPoint ptc("End", 1, 1);

    std::cout << "Comparing MyPoints: " << compareItems(pta, ptb) << std::endl; // Uses specialization
    std::cout << "Comparing MyPoints: " << compareItems(pta, ptc) << std::endl; // Uses specialization
}

int main() {
    testItemComparison();
    system("pause");
    return 0;
}
```

A crucial point with specialization is that the *primary template* (the generic version) must be declared or defined before any explicit specialization for it. Without the primary template, the specialized version is essentially defining a non-template function, which might lead to errors or unexpected behavior if the compiler expects a template.

Class Templates

Class templates allow defining a generic class where member variables, return types of member functions, or function parameters can be specified by template parameters. This enables creating data structures and classes that can work with any type.

Template Syntax and Constructors

A class template is defined similarly to a function template. Template parameters are used as placeholders for types within the class definition.

#include <iostream>
#include <string>

template <class TValue>
class DynamicContainer {
public:
    TValue data;

    // Template constructor using TValue
    DynamicContainer(TValue initialData) : data(initialData) {
        std::cout << "DynamicContainer (template type) constructor called." << std::endl;
    }

    // Non-template constructor (can coexist if parameters differ sufficiently)
    DynamicContainer(int specificInt) : data(static_cast<TValue>(specificInt)) {
        std::cout << "DynamicContainer (specific int) constructor called." << std::endl;
    }

    void display() const {
        std::cout << "Contained data: " << data << std::endl;
    }
};

int main() {
    // Must specify type explicitly for class templates
    DynamicContainer<std::string> stringContainer("Hello Template");
    stringContainer.display();

    DynamicContainer<double> doubleContainer(123.45);
    doubleContainer.display();

    // Calling the specific int constructor (if TValue is compatible)
    DynamicContainer<float> floatContainer(99);
    floatContainer.display();

    system("pause");
    return 0;
}

Nested Templates and Dependent Types

Class templates can contain members that are themselves template instances, potentially with partially specified template arguments.

#include <iostream>
#include <string>
#include <typeinfo>

template <class First, class Second>
struct PairData {
    First valOne;
    Second valTwo;
};

template <class MainType, class AuxType>
class ComplexProcessor {
public:
    // A nested templated struct, with one type fixed to int, the other dependent on AuxType
    PairData<int, AuxType> internalStructure;

    ComplexProcessor() {
        std::cout << "ComplexProcessor instantiated with MainType: " << typeid(MainType).name()
                  << ", AuxType: " << typeid(AuxType).name() << std::endl;
    }
};

int main() {
    // When instantiating ComplexProcessor, we specify MainType and AuxType.
    // The internalStructure's types are then resolved: PairData<int, std::string>.
    ComplexProcessor<float, std::string> processorInstance;
    processorInstance.internalStructure.valOne = 100;
    processorInstance.internalStructure.valTwo = "Nested String";

    std::cout << "Internal valOne: " << processorInstance.internalStructure.valOne << std::endl;
    std::cout << "Internal valTwo: " << processorInstance.internalStructure.valTwo << std::endl;
    std::cout << "Type of internalStructure.valTwo: " << typeid(processorInstance.internalStructure.valTwo).name() << std::endl;

    system("pause");
    return 0;
}

Distinctions: Class Templates vs. Function Templates

1. Type Deduction: Class templates do not support automatic type deduction. When instantiating a class template, all template arguments must be explicitly specified (e.g., MyClass<int, std::string> obj;).
2. Default Arguments: Class template parameters can have default values (e.g., template <class T = int> class MyClass { ... };). Function template parameters can also have default arguments in C++11 and later.

Instantiation of Class Template Member Functions

Unlike ordinary classes, where all member functions are effectively 'created' when the class definition is compiled, member functions of a class template are instantiated only when they are called. This 'just-in-time' instantiation has implications:

#include <iostream>

class SpecificOperationA {
public:
    void executeA() { std::cout << "Executing operation A." << std::endl; }
};

class SpecificOperationB {
public:
    void executeB() { std::cout << "Executing operation B." << std::endl; }
};

template <class TAction>
class ActionPerformer {
public:
    TAction performerObj;

    void callExecuteA() {
        performerObj.executeA(); // This line is compiled only if callExecuteA is invoked.
    }

    void callExecuteB() {
        performerObj.executeB(); // This line is compiled only if callExecuteB is invoked.
    }
};

int main() {
    ActionPerformer<SpecificOperationA> performer1;
    performer1.callExecuteA(); // executeA() is instantiated and called.
    // performer1.callExecuteB(); // COMPILE ERROR: SpecificOperationA does not have executeB()
                                 // This error occurs only when callExecuteB() is actually called.

    ActionPerformer<SpecificOperationB> performer2;
    performer2.callExecuteB(); // executeB() is instantiated and called.

    system("pause");
    return 0;
}

This behavior means that a class template can define member functions that are only valid for a subset of its possible template argument types. The compiler will only report an error if an invalid member function is actually invoked.

Passing Class Template Objects to Functions

When a class template object needs to be passed to another function, there are three common patterns:

1. Explicitly Specifying Types: The function parameter explicitly lists the concrete types of the class template.

   template<class TName, class TAge>
   class UserProfile {
   public:
       TName userName;
       TAge userAge;
       UserProfile(TName name, TAge age) : userName(name), userAge(age) {}
       void displayProfile() const {
           std::cout << "Name: " << userName << ", Age: " << userAge << std::endl;
       }
   };
   
   // Method 1: Specify concrete types
   void processUser1(UserProfile<std::string, int>& profile) {
       std::cout << "Processing user via Method 1: ";
       profile.displayProfile();
   }
   // Usage:
   // UserProfile<std::string, int> userA("Alice", 30);
   // processUser1(userA);
   

2. Templating the Receiving Function: The function itself is a template, with its own template parameters used to deduce the types of the class template object.

   // Method 2: Template the receiving function
   template<class NameType, class AgeType>
   void processUser2(UserProfile<NameType, AgeType>& profile) {
       std::cout << "Processing user via Method 2: ";
       profile.displayProfile();
       std::cout << "  (Name type: " << typeid(NameType).name() << ", Age type: " << typeid(AgeType).name() << ")" << std::endl;
   }
   // Usage:
   // UserProfile<std::string, int> userB("Bob", 25);
   // processUser2(userB);
   

3. Generic Templated Parameter: The function takes a generic template parameter TObj that can be any type, including a class template instance. This defers type checking to TObj's methods.

   // Method 3: Generic templated parameter
   template<class TObj>
   void processUser3(TObj& profileObject) {
       std::cout << "Processing user via Method 3: ";
       profileObject.displayProfile(); // Assumes TObj has a displayProfile method
       std::cout << "  (Object type: " << typeid(TObj).name() << ")" << std::endl;
   }
   // Usage:
   // UserProfile<std::string, int> userC("Charlie", 35);
   // processUser3(userC);
   

   #include <iostream>
   #include <string>
   #include <typeinfo>
   
   template<class TName, class TAge>
   class UserProfile {
   public:
       TName userName;
       TAge userAge;
       UserProfile(TName name, TAge age) : userName(name), userAge(age) {}
       void displayProfile() const {
           std::cout << "Name: " << userName << ", Age: " << userAge << std::endl;
       }
   };
   
   // Method 1: Specify concrete types
   void processUser1(UserProfile<std::string, int>& profile) {
       std::cout << "Processing user via Method 1: ";
       profile.displayProfile();
   }
   
   // Method 2: Template the receiving function
   template<class NameType, class AgeType>
   void processUser2(UserProfile<NameType, AgeType>& profile) {
       std::cout << "Processing user via Method 2: ";
       profile.displayProfile();
       std::cout << "  (Name type: " << typeid(NameType).name() << ", Age type: " << typeid(AgeType).name() << ")" << std::endl;
   }
   
   // Method 3: Generic templated parameter
   template<class TObj>
   void processUser3(TObj& profileObject) {
       std::cout << "Processing user via Method 3: ";
       profileObject.displayProfile(); // Assumes TObj has a displayProfile method
       std::cout << "  (Object type: " << typeid(TObj).name() << ")" << std::endl;
   }
   
   int main() {
       UserProfile<std::string, int> userA("Alice", 30);
       processUser1(userA);
   
       UserProfile<std::string, int> userB("Bob", 25);
       processUser2(userB);
   
       UserProfile<std::string, int> userC("Charlie", 35);
       processUser3(userC);
   
       system("pause");
       return 0;
   }
   

Class Templates and Inheritance

When a class template is involved in an inheritance hierarchy, special considerations apply:

1. Derived Class Must Specify Base Template Types: If a derived class inherits from a base class template, it must provide concrete types for the base template's parameters during its definition.

   template<class TBaseData>
   class BaseContainer {
   protected:
       TBaseData baseValue_;
   public:
       BaseContainer(TBaseData val = TBaseData()) : baseValue_(val) {}
       void showBaseValue() const { std::cout << "Base value: " << baseValue_ << std::endl; }
   };
   
   // Incorrect: 'BaseContainer' is a template; its template parameters must be specified.
   // class SpecificDerived : public BaseContainer {
   //     // ...
   // };
   
   // Correct: SpecificDerived inherits from BaseContainer<int>
   class SpecificDerived : public BaseContainer<int> {
   public:
       SpecificDerived(int val) : BaseContainer<int>(val) {}
       void customDerivedMethod() {
           std::cout << "Derived class using base int value: " << baseValue_ << std::endl;
       }
   };
   
   int main() {
       SpecificDerived sd(42);
       sd.showBaseValue();
       sd.customDerivedMethod();
       system("pause");
       return 0;
   }
   

2. Derived Class as a Template: To maintain flexibility and allow the derived class to also be generic (i.e., its base class's types can vary), the derived class itself must be a class template. Its template parameters can then be used to specify the base class template's types.

   #include <iostream>
   #include <string>
   #include <typeinfo>
   
   template<class TBaseData>
   class BaseContainer {
   protected:
       TBaseData baseValue_;
   public:
       BaseContainer(TBaseData val = TBaseData()) : baseValue_(val) {}
       void showBaseValue() const { std::cout << "Base value: " << baseValue_ << std::endl; }
   };
   
   // Derived class is also a template, allowing flexible base class types
   template<class TDerivedSpecific, class TBaseSpecific>
   class FlexibleDerived : public BaseContainer<TBaseSpecific> {
   public:
       TDerivedSpecific derivedMember_;
       FlexibleDerived(TDerivedSpecific dm, TBaseSpecific bm) 
           : BaseContainer<TBaseSpecific>(bm), derivedMember_(dm) {}
   
       void showTypes() const {
           std::cout << "TDerivedSpecific type: " << typeid(TDerivedSpecific).name() << std::endl;
           std::cout << "TBaseSpecific type: " << typeid(TBaseSpecific).name() << std::endl;
           std::cout << "Derived member: " << derivedMember_ << std::endl;
       }
   };
   
   int main() {
       FlexibleDerived<std::string, double> fd("Hello", 3.14);
       fd.showTypes();
       fd.showBaseValue(); // Inherited method
   
       FlexibleDerived<int, char> fd2(123, 'Z');
       fd2.showTypes();
       fd2.showBaseValue();
       system("pause");
       return 0;
   }
   

Out-of-Class Definition for Class Template Member Functions

Defining member functions of a class template outside its definition requires specifying the template parameters for both the class and the functon itself.

#include <iostream>

template <class T>
class DataProcessor {
public:
    T value_;
    DataProcessor(T val);
    void processAndDisplay();
};

// Constructor definition outside the class
template <class T>
DataProcessor<T>::DataProcessor(T val) : value_(val) {
    std::cout << "DataProcessor constructor for type " << typeid(T).name() << std::endl;
}

// Member function definition outside the class
template <class T>
void DataProcessor<T>::processAndDisplay() {
    std::cout << "Processing value: " << value_ << std::endl;
}

int main() {
    DataProcessor<int> intProc(100);
    intProc.processAndDisplay();

    DataProcessor<double> dblProc(200.5);
    dblProc.processAndDisplay();
    system("pause");
    return 0;
}

Class Template Separate Compilation Issues

Templates are typically compiled using a