template<class T>
T max(const T& a, const T& b)
{
	return a > b ? a : b;
}

int main()
{
	int a = 7, b = 5;
	double d1 = 2.0, d2 = 3.0;
	cout << max(a, b) << endl;
	cout << max(d1, d2) << endl;
	return 0;
}

ניתן לחשוב על מה שקורה פה כהמהדר יוצר מלא ההעמסות עבור הפונקציה $max$.

איך אנו יודעים כי עבור $T$ יש את הפעולה $>$? ובכן, זוהי הבעיה הגדולה עם $templates$ כי ל-$C++$ לא איכפת ⇐ לא יתקמפל.
("ב-$C++23$ הוסיפו קונספט בשם קונספט" - גל ללוש (הקונספט מאפשר להגביל את $T$ אבל לא נלמד עליו בקרוס הזה או, ככל הנראה, באף קורס בטכניון כרגע))

template<class T>
T maxElement(const T* arr, int size)
{
	T result = arr[0];
	for (int i = 0; i < size; ++i)
		reult = max(result, arr[i]); // from the earlier example
	return result
}

המהדר לא יבחר בעצמו את הפונקציה המתאימה רק על בסיס ערך ההחזרה.

template<class T, class S>
T convert(const S& s)
{
	return T(s);
}

int main()
{
	int n = 7;
	double d1 = convert(n); // ERROR
	double d2 = convert<double>(n);
	double d3 = convert<double, int>(n);
}

$Array<\!int\!>$ הוא לא אותה מחלקה כמו $Array<\! double\!>$.
הן מתנהגות כמחלקות שונות לגמרי שאינן קשורות.

template<class T>
const T* Set<T>::Iterator::operator->() const
{
	if (index < 0 || index >= set->getSize())
		throw out_of_range("Bad index");
	return &(set->data[index]);
}

כאשר אנו לוקחים אובייקט $T$ אשר אין לו את כל הפונקציות הדרושות, המהדר פשוט לא ייצר חלק מהפונקציות - אלו שמשתמשות בפונקציות שאין.
הפונקציות שלא משתמשות בפונקציות שאין יווצרו ונוכל להשתמש בהן.

מחלקה שמיישמת את האופרטור $operator()$ נקרא אובייקט פונקציה.

class DividesBy
{
	int n;
public:
	DividesBy(int n) : n(n) {}
	bool operator()(int number) const
	{
		return number % n == 0;
	}
};

int main()
{
	DividesBy isEven(2); // constructor call
	
	// checking if things are divided by 2
	cout << isEven(9) << endl; // operator()
	cout << isEven(8) << endl;
	
	// checking if things are divided by 3
	DividesBy isTriple(3);
	
	cout << isTriple(9) << endl;
	cout << isTriple(8) << endl;
	
	return 0;
}

לפני כן נראה עוד מחלקת עזר נחמדה:

class Between
{
	int min, max;
public:
	Between(int min, int max) : min(min), max(max) { }
	
	bool operator()(int val) const
	{
		return min <= val && val <= max;
	}
};

כעת נוכל לבנות לתוך קבוצה $filter$ שכזה שאנו יכולים להפעיל עם כל פונקציה על מנת למיין איברים מהקבוצה.

template <class T>
class Set
{
public:
	// ...
	
	template<class Condition>
	Set filter(const Condition& c) const;
};

template<class T>
template<class Condition>
Set<T> Set<T>::filter(Condition c) const
{
	Set result;
	for (const T& elem : *this)
	{
		if (c(elem))
		{
			result.add(elem);
		}
	}
	return result;
}

כעת נוכל לראות את השימוש:

void test(const Set<int>& s)
{
	DividesBy isEven(2);
	cout << s.filter(isEven) << endl;
	
	int x1, x2;
	cin >> x1 >> x2;
	cout << s.filter(Between(x1, x2)) << endl;
}

פונקציית למדה מוגדרת כך:

[<capture-list>] (parameters) -> <return-type> { <code> }

זה יוצר פונקציה זמנית ללא שם.

אם הלמדה מכילה רק שורת החזרה, סוג ההחזרה לא נדרש.

cout << s.filter( [x1,x2](int i) -> bool { return x1 <= i && i <= x2; } ) << endl; // not needed
cout << s.filter( [x1,x2](int i) { return x1 <= i && i <= x2; } ) << endl; // great

ניתן ללכוד משתנה גם כרפרנס או פויינטר ולשנות אותו כך:

int sum = 0;
std::for_each(s.begin(), s.end(), [&sum](int n) { sum += n; });

את זה צריך לעשות בזהירות שכן אנו צריכים להיות בטוחים ש-$sum$ קיים כאשר הלמדה נקראת באמת.

ניתן לתת למהדר להתאמץ ולמצוא את מה שהוא צריך באמצעות $[=]$ כך:

double a, b, c;
// ...
double result = integrate(0.0, 1.0, [=] (double x) { return a*x*x + b*x + c; });
result = integrate(0.0, 1.0, [&] (double x) { return a*x*x + b*x + c; });

זה מאפשר לנו לשלוח לפונקציה את כל מה שאנחנו צריכים מבלי לדעת מה אנחנו צריכים.
כל המשתנים ב-$=$ מועברים $by\; value$ וב-$[\&]$ כל המשתנים מועברים $by\;refrence$.

בפונקציות למדה בתוך פונקציות מחלקה, ניתן לתפוס את שדות המחלקה.

class Polynomial
{
	double a, b, c;
public:
	doubel integrate(double xmin, double xmax) const
	{
		return numerics::integrate(xmin, xmax,
			[this] (double x) { return a*x*x + b*x + c; }
		);
	}
};