Adott az alábbi sztring osztály, amely most az egyszerűség kedvéért nem használ dinamikus memóriakezelést:
class String {
private:
char data[100];
public:
String() {
data[0] = 0;
}
String(char const *init) {
strcpy(data, init);
}
bool operator==(String const &rhs) {
String const &lhs = *this;
size_t i;
for (i = 0; lhs.data[i] != 0 && rhs.data[i] != 0; ++i)
if (lhs.data[i] != rhs.data[i])
return false;
return lhs.data[i] == 0 && rhs.data[i] == 0;
}
};
int main() {
String s1 = "hello", s2 = "HeLLo";
std::cout << (s1 == s2);
}Ezen a sztring osztályon több dolgot is lehetne általánosítani. Például a karakter típusa az egybájtos char-on
túl lehetne másféle is, pl. char16_t vagy char32_t az Unicode kódolású szövegek tárolásához. Továbbá,
az összehasonlítást nem feltétlenül kellene az == operátorral végezni. Lehetne pl. úgy is, hogy figyelmen kívül
hagyjuk a kisbetű–nagybetű különbségeket.
Ezek sablonparaméterek lehetnének. Hogy ne legyen túl sok sablonparamétere a String osztálynak, érdemes
ezeket egy külön osztályba tenni. Például a fenti viselkedés leírásához a CharTraits osztályban kell lennie egy
belső típusnak, és egy statikus függvénynek, CharTraits::type és CharTraits::equal():
struct CharTraits {
using Type = char;
static bool equal(char c1, char c2) { return c1 == c2; }
};Feladatok
- Írd át úgy a fenti
Stringosztályt, hogy a sablonparamétere egy ilyen viselkedésosztály legyen! Használják az osztály függvényei a sablonparaméterből vett típust és az onnan vett karakterösszehasonlító függvényt! Figyelj arra, hogy ehhez astrcpy()függvényhívást is át kell írnod, mert az csakchar*-okon működik. - Példányosítsd az új
Stringsablonod a fentiCharTraitsosztállyal, és teszteld a működését! - Hozz létre egy olyan karakterosztályt is, amelynek karakterei érzéketlenek a kisbetű–nagybetű különbségre! Teszteld ezt is!
Mi történik, ha összehasonlítasz az == operátorral két sztringet, amelyek karakterosztálya eltérő? Miért?
Tipp
Ha sablon osztályból kell egy belső típust hivatkozni, elé kell írni, hogy typename:
template <typename SABLONOSZTALY> // sablon kódon belül vagyunk
void f() {
typename SABLONOSZTALY::BelsoTipus x;
}Ennek okairól itt olvashatsz bővebben.
Megoldás
#include <iostream>
template <typename CHAR_TRAITS>
class String {
private:
using CharType = typename CHAR_TRAITS::Type;
CharType data[100];
public:
String() {
data[0] = 0;
}
String(CharType const *init) {
size_t i;
for (i = 0; init[i] != 0; ++i)
data[i] = init[i];
data[i] = 0;
}
bool operator==(String const &rhs) {
String const &lhs = *this;
size_t i;
for (i = 0; lhs.data[i] != 0 && rhs.data[i] != 0; ++i)
if (!CHAR_TRAITS::equal(lhs.data[i], rhs.data[i]))
return false;
return lhs.data[i] == 0 && rhs.data[i] == 0;
}
};
struct CharTraits {
using Type = char;
static bool equal(char c1, char c2) {
return c1 == c2;
}
};
struct CharTraitsCaseInsensitive: public CharTraits {
static bool equal(char c1, char c2) {
return toupper(c1) == toupper(c2);
}
};
int main() {
String<CharTraits> s1 = "hello", s2 = "hEllo";
std::cout << (s1 == s2) << std::endl;
String<CharTraitsCaseInsensitive> s3 = "hello", s4 = "hEllo";
std::cout << (s3 == s4) << std::endl;
}A CharTraitsCaseInsensitive osztály származtatható a CharTraits osztályból, így megörökli
a Type belső típust. Ennek a származtatásnak akkor jönne ki igazán az előnye, ha több belső függvény lenne, mert
csak egyet szeretnénk felülírni. Bár az equal() függvény statikus, és így nem lehet virtuális, mégis felüldefiniálható
a leszármazásban, mert a sablonoknál fordítási időben a megfelelő típus látszik!
Az eltérő viselkedésosztályból példányosított sztring objektumok nem hasonlíthatók össze, mert különböző típusúnak számítanak. Ez az összehasonlításnál nem is baj, amúgy sem lehet eldönteni, hogy egy kisbetű–nagybetűre érzéketlen és egy arra érzékeny sztringet hogyan kellene összehasonlítani.
Az std::basic_string és az std::char_traits ugyanígy működnek; std::string ==
std::basic_string<char, std::char_traits<char>>, illetve std::char_traits<char>::char_type
és std::char_traits<char>::eq().
Szorgalmi feladat: Nézz utána a szabványos std::basic_string, std::basic_ostream,
és az std::char_traits osztályoknak, és hasonlítsd össze őket a most megírt programoddal!
Ez a feladat a GotW #29 alapján készült.