26.x — Rozdział 26, podsumowanie i quiz

Szablony pozwalają nam pisać funkcje lub klasy przy użyciu symboli zastępczych typy, dzięki czemu możemy narysować identyczne wersje funkcji lub klasy przy użyciu różnych typów. Funkcja lub klasa, która została utworzona, nazywana jest instancją funkcji lub klasy.

Wszystkie funkcje lub klasy szablonowe muszą zaczynać się od deklaracji parametru szablonu, która informuje kompilator, że następująca funkcja lub klasa jest funkcją lub klasą szablonu. W deklaracji parametrów szablonu określone są parametry typu szablonu lub parametry wyrażenia. Parametry typu szablonu to po prostu typy zastępcze, zwykle nazywane T, T1, T2 lub innymi nazwami składającymi się z pojedynczych liter (np. S). Parametry wyrażeń są zwykle typami całkowitymi, ale mogą być wskaźnikiem lub odwołaniem do funkcji, obiektu klasy lub funkcji składowej.

Dzielenie definicji klasy szablonowej i definicji funkcji składowych nie działa jak normalne klasy — nie można umieścić definicji klasy w nagłówku, a definicji funkcji składowych w pliku .cpp. Zwykle najlepiej jest przechowywać je wszystkie w pliku nagłówkowym, a definicje funkcji składowych znajdują się pod klasą.

Specjalizacji szablonów można użyć, gdy chcemy zastąpić domyślne zachowanie funkcji lub klasy z szablonem dla określonego typu. Jeśli wszystkie typy zostaną zastąpione, nazywa się to pełną specjalizacją. Klasy obsługują również częściową specjalizację, w której specjalizowane są tylko niektóre parametry szablonu. Funkcje nie mogą być częściowo wyspecjalizowane.

Wiele klas w standardowej bibliotece C++ używa szablonów, w tym std::array i std::vector. Szablony są często używane do implementowania klas kontenerów, więc kontener można zapisać raz i używać z dowolnym odpowiednim typem.

Czas quizu

1. Czasami przydatne jest zdefiniowanie danych przesyłanych parami. Napisz klasę z szablonem o nazwie Pair1, która umożliwia użytkownikowi zdefiniowanie jednego typu szablonu, który będzie używany dla obu wartości w parze. Powinna zadziałać następująca funkcja:

int main()
{
	Pair1<int> p1 { 5, 8 };
	std::cout << "Pair: " << p1.first() << ' ' << p1.second() << '\n';

	const Pair1<double> p2 { 2.3, 4.5 };
	std::cout << "Pair: " << p2.first() << ' ' << p2.second() << '\n';

	return 0;
}

i wydrukuj:

Pair: 5 8
Pair: 2.3 4.5

Pokaż rozwiązanie

#include <iostream>

template <typename T>
class Pair1
{
private:
	T m_x {};
	T m_y {};

public:
	Pair1(const T& x, const T& y)
		: m_x{ x }, m_y{ y }
	{
	}

	T& first() { return m_x; }
	T& second() { return m_y; }
	const T& first() const { return m_x; }
	const T& second() const { return m_y; }
};

int main()
{
	Pair1<int> p1 { 5, 8 };
	std::cout << "Pair: " << p1.first() << ' ' << p1.second() << '\n';

	const Pair1<double> p2 { 2.3, 4.5 };
	std::cout << "Pair: " << p2.first() << ' ' << p2.second() << '\n';

	return 0;
}

2. Napisz klasę Pair, która pozwoli Ci określić osobne typy dla każdej z dwóch wartości w parze.

Uwaga: Nadajemy tej klasie inną nazwę niż poprzednia, ponieważ C++ obecnie nie pozwala na „przeciążanie” klas, które różnią się jedynie liczbą lub rodzajem parametrów szablonu.

Następujący program powinien działać:

int main()
{
	Pair<int, double> p1 { 5, 6.7 };
	std::cout << "Pair: " << p1.first() << ' ' << p1.second() << '\n';

	const Pair<double, int> p2 { 2.3, 4 };
	std::cout << "Pair: " << p2.first() << ' ' << p2.second() << '\n';

	return 0;
}

i wydrukuj:

Pair: 5 6.7
Pair: 2.3 4

Wskazówka: Aby zdefiniować szablon używający dwóch różnych typów, oddziel oba typy przecinkiem w deklaracji parametru szablonu. Więcej informacji można znaleźć w lekcji 11.8 -- Szablony funkcji z wieloma typami szablonów .

Pokaż rozwiązanie

#include <iostream>

template <typename T, typename S>
class Pair
{
private:
	T m_x;
	S m_y;

public:
	Pair(const T& x, const S& y)
		: m_x{x}, m_y{y}
	{
	}

	T& first() { return m_x; }
	S& second() { return m_y; }
	const T& first() const { return m_x; }
	const S& second() const { return m_y; }
};

int main()
{
	Pair<int, double> p1 { 5, 6.7 };
	std::cout << "Pair: " << p1.first() << ' ' << p1.second() << '\n';

	const Pair<double, int> p2 { 2.3, 4 };
	std::cout << "Pair: " << p2.first() << ' ' << p2.second() << '\n';

	return 0;
}

3. Para ciąg-wartość to specjalny typ pary, w którym pierwsza wartość jest zawsze typu łańcuchowego, a druga wartość może być dowolnego typu. Napisz klasę szablonową o nazwie StringValuePair, która dziedziczy po częściowo wyspecjalizowanej klasie Pair (używając std::string jako pierwszego typu i pozwalając użytkownikowi na określenie drugiego typu).

Powinien uruchomić się następujący program:

int main()
{
	StringValuePair<int> svp { "Hello", 5 };
	std::cout << "Pair: " << svp.first() << ' ' << svp.second() << '\n';

	return 0;
}

i wydrukuj:

Pair: Hello 5

Wskazówka: Kiedy wywołujesz konstruktor Pair z konstruktora StringValuePair, nie zapomnij uwzględnić parametrów szablonu jako części nazwy klasy Pair.

Pokaż rozwiązanie

#include <iostream>
#include <string>
#include <string_view>

template <typename T, typename S>
class Pair
{
private:
	T m_x{};
	S m_y{};

public:
	Pair(const T& x, const S& y)
		: m_x{ x }, m_y{ y }
	{
	}

	T& first() { return m_x; }
	S& second() { return m_y; }
	const T& first() const { return m_x; }
	const S& second() const { return m_y; }
};

template <typename S>
class StringValuePair : public Pair<std::string, S>
{
public:
	StringValuePair(std::string_view key, const S& value)
                // a std::string_view won't implicitly convert to a std::string, we must be explicit
		: Pair<std::string, S>{ static_cast<std::string>(key), value }
	{
	}
};

int main()
{
	StringValuePair<int> svp{ "Hello", 5 };
	std::cout << "Pair: " << svp.first() << ' ' << svp.second() << '\n';

	return 0;
}