Ας υποθέσουμε ότι θέλουμε να φτιάξουμε μία συνάρτηση η οποία να βρίσκει το μέγιστο μεταξύ δύο τιμών. Η συνάρτηση θα μπορούσε να είναι η εξής:

int maximum(int a, int b) { return (a>b?a:b); }

Αντίστοιχα εάν θέλουμε να βρούμε το μέγιστο μεταξύ δύο αριθμών κινητής υποδιαστολής θα καλούμαστε να γράψουμε

double maximum(double a, double b) { return (a>b?a:b); }

Το ερώτημα είναι εάν θα μπορούσαμε να αποφύγουμε τις παραπάνω δηλώσεις και αντ' αυτού να φτιάξουμε μία συνάρτηση που να είναι αρκετά γενική ώστε να “καλύπτει” όλες τις περιπτώσεις. Προκειμένου να ικανοποιηθεί η παραπάνω ανάγκη, η C++ παρέχει τα templates συναρτήσεων.

Η παραπάνω συνάρτηση θα μπορούσε να γραφεί με τη βοήθεια template ως εξής:

template <typename T>
T maximum(T a, T b) { return (a>b?a:b); }

Το Τ μπορεί να είναι οποιοσδήποτε τύπος, επομένως και κάποιος τύπος που περιγράφεται από κλάση. Προκειμένου να μην γίνονται σημαντικές αντιγραφές κατά την κλήση των παραμέτρων με τιμή, προτιμούμε την παρακάτω ισοδύναμη, αλλά υπολογιστικά πιο “φθηνή” εκδοχή

template <typename T>
T& maximum(T& a, T& b) { return (a>b?a:b); }

Ας προσπαθήσουμε να χρησιμοποιήσουμε την παραπάνω συνάρτηση.

maximum1.cpp

template <typename T>
T& maximum(T& a, T& b) { return (a>b?a:b); }
 
#include <iostream>
using namespace std;
 
int main() {
  int a = 5, b = 10;
  double d = 5.5, f=3.3;
  cout << "max(5,10): " << maximum<int>(a,b) << endl;
  cout << "max(5.5,3.3): " << maximum<double>(d,f) << endl;
}

Ας υποθέσουμε ότι θέλουμε να κάνουμε χρήση της παραπάνω συνάρτηση maximum προκειμένου να βρούμε το μέγιστο μεταξύ δύο φοιτητών. Η κλάση του φοιτητή δίνεται παρακάτω:

Student.hpp

#include<cstring>
 
class Student {
  char *name;
  int aem;
 
public:
  Student(const char *name, int aem);
  Student();
  Student(const Student& );
  Student(const Student* );
  ~Student();
  char *getName() const;
  int getAEM() const;
  void setName(const char *name);
  void setAEM(int aem);
  friend std::ostream& operator<<(std::ostream& out, const Student & st);
  bool operator>(const Student& st) const;
  Student& operator=(const Student& st);
};
 
Student::Student(const char *name, int aem) {
  this->name = new char [strlen(name) + 1];
  strcpy(this->name, name);
  this->aem = aem;
}
 
Student::Student(const Student& st) {
  name = new char [strlen(st.name) + 1];
  strcpy(name, st.name);
  aem = st.aem;
}
 
Student::Student(const Student* st) {
  name = new char [strlen(st->name) + 1];
  strcpy(name, st->name);
  aem = st->aem;
}
 
Student::Student() {
  this->name = nullptr;
  this->aem = 0;
}
 
Student::~Student() {
  if(name != nullptr)
    delete []name;
}
 
char* Student::getName() const {
  return name;
}
 
int Student::getAEM() const {
  return aem;
}
 
void Student::setName(const char *name) {
  if(this->name != nullptr)
    delete this->name;
  this->name = new char [strlen(name) + 1];
  strcpy(this->name, name);
}
 
void Student::setAEM(int aem) {
  this->aem = aem;
}
 
Student& Student::operator=(const Student& st) {
  if(name != nullptr)
    delete name;
  name = new char [strlen(st.name) + 1];
  strcpy(name, st.name);
  aem = st.aem;
  return *this;
}
 
std::ostream& operator<<(std::ostream& out, const Student& st) {
  out << st.name << " " << st.aem;
  return out;
}
 
bool Student::operator>(const Student& st) const {
  if(aem > st.aem)
    return true;
  return false;
}

O κώδικας που κάνει χρήση της παραπάνω κλάσης είναι ο εξής:

maximum2.cpp

template <typename T>
T& maximum(T& a, T& b) { return (a>b?a:b); }
 
#include <iostream>
using namespace std;
 
#include "Student.hpp"
 
int main() {
  Student george("George", 1234), kate("Kate", 12345); 
  cout << "max('George','Kate'): " << maximum(george, kate) << endl;
}

Εάν προσπαθήσουμε να μεταγλωττίσουμε, το πρόγραμμα βγάζει αρκετά μηνύματα λάθους τα οποία συμπυκνώνονται στο ότι ο μεταγλωττιστής δεν ξέρει πως να διαχειριστεί την ανισότητα μεταξύ δύο αντικειμένων τύπου Student. Για τον λόγο αυτό θα πρέπει να υπερφορτώσουμε τον τελεστή < για την κλάση Student ως εξής:

// σύγκριση δύο μαθητών με βάση το ΑΕΜ τους
bool Student::operator<(const Student& st) const {
  if(aem < st.aem)
    return true;
  return false;
}

Εφόσον προσθέσουμε την παραπάνω συνάρτηση υπεφόρτωσης του τελεστή <το πρόγραμμα εκτυπώνει τα εξής:

max('George','Kate'): Kate 12345

Ας υποθέσουμε τώρα ότι θέλουμε να βρούμε το μέγιστο μεταξύ περισσότερων των δύο αριθμητικών τιμών οι οποίες έχουν αποθηκευτεί σε ένα πίνακα. Σε αυτή την περίπτωση η συνάρτηση maximum θα μπορούσε να γραφεί ως εξής:

template <typename T, int size>
T& maximum(T a[]) {
  T& max = a[0];
  for(int i=1; i<size; i++)
    if(a[i]>max)
      max = a[i];
  return max;
}

Παρατηρήστε ότι η συνάρτηση λαμβάνει μία επιπλέον ακέραια τιμή ως παράμετρο που αντιπροσωπεύει το μέγεθος του πίνακα.

Ο κώδικας χρήσης της παραπάνω συνάρτησης θα μπορούσε να είναι ο εξής:

maximum3.cpp

#include <iostream>
using namespace std;
 
template <typename T, int size>
T& maximum(T a[]) {
  T& max = a[0];
  for(int i=1; i<size; i++)
    if(a[i]>max)
      max = a[i];
  return max;
}
 
#include "Student.hpp"
 
int main() {
  Student george("George", 1234), kate("Kate", 12345), mary("Mary", 12346);
  Student students[] = { george, kate, mary };
  cout << "max('George','Kate', 'Mary'): " << maximum<Student,3>(students) << endl;
}