Utility (C ++) - Utility (C++)

C ++ standardní knihovna
Kontejnery
C standardní knihovna

nástroj je hlavičkový soubor v C ++ standardní knihovna. Tento soubor má dvě klíčové komponenty:

  • rel_ops, a jmenný prostor obsahující sadu šablon, které definují výchozí chování pro relační operátoři !=, >, <=, a >= mezi objekty stejného typu na základě uživatelem definovaných operátorů == a <.
  • pár, šablona kontejneru, která obsahuje dva členské objekty (za prvé a druhý) libovolného typu (typů). Navíc záhlaví definuje výchozí relační operátory pro párkteré mají oba typy společné.

rel_ops

GCC Implementace deklaruje rel_ops jmenný prostor (vnořený uvnitř jmenný prostor std) následujícím způsobem:[1]

jmenný prostor rel_ops {	šablona <třída _Tp> v souladu bool operátor !=(konst _Tp& __X, konst _Tp& __y) { vrátit se !(__X == __y); }	šablona <třída _Tp> v souladu bool operátor  >(konst _Tp& __X, konst _Tp& __y) { vrátit se   __y < __X;   }	šablona <třída _Tp> v souladu bool operátor <=(konst _Tp& __X, konst _Tp& __y) { vrátit se !(__y < __X);  }	šablona <třída _Tp> v souladu bool operátor >=(konst _Tp& __X, konst _Tp& __y) { vrátit se !(__X < __y);  }	}

Zvažte následující prohlášení o třída A, který definuje rovnost a méně než operátory pro srovnání s jinými objekty stejného typu:

třída A {	int budova;	int pokoj, místnost;veřejnost:	bool operátor ==(konst A& jiný) konst {		vrátit se (budova == jiný.budova) && (pokoj, místnost == jiný.pokoj, místnost);		}	bool operátor <(konst A& jiný) konst {		vrátit se (budova < jiný.budova) ||		   (!(jiný.budova < budova) && (pokoj, místnost < jiný.pokoj, místnost));		}	};prázdnota f1(konst A& a1, konst A& a2) {	bool rovnat se = (a1 == a2);       // používá == definováno ve třídě A	bool not_equal = (a1 != a2);       // chyba: žádná shoda pro „operator! =“ v „a1! = a2“	bool méně = (a1 < a2);         // používá 	bool větší = (a1 > a2);          // error: no match for ‘operator>‘ in ‘a1> a2	bool less_equal = (a1 <= a2);      // chyba: žádná shoda pro „operátor <=“ v „a1 <= a2“	bool greater_equal = (a1 >= a2);   // chyba: žádná shoda pro „operator> =“ v „a1> = a2“	}

Vyvoláním rel_ops šablon, lze zbývajícím relačním operátorům přiřadit výchozí význam. Pokud však v aktuálním oboru existuje podobný typově specifický (tj. Nešablonový) operátor, dokonce i mimo definici třídy, kompilátor jej místo toho upřednostní.

// (pokračování shora)#zahrnout <utility>použitím jmenný prostor std::rel_ops;// níže operátor nahrazuje rel_opsbool operátor >=(konst A& a1, konst A& a2) {	do_something_else();      // provést určitý rozlišující vedlejší účinek	vrátit se !(a1 < a2);             // ale jinak použijte stejný postup jako rel_ops	};prázdnota f2(konst A& a1, konst A& a2) {	bool rovnat se = (a1 == a2);         // používá operátor == definovaný ve třídě A	bool not_equal = (a1 != a2);        // používá! (a1 == a2) na rel_ops	bool méně = (a1 < a2);           // používá operátor 	bool větší = (a1 > a2);           // použití (a2 	bool less_equal = (a1 <= a2);       // používá! (a2 	bool greater_equal = (a1 >= a2); // používá globální operátor> = definovaný výše	}

Dalo by se samozřejmě deklarovat následující ve tandemu s rel_ops, což umožňuje odvození všech relačních operátorů z <:

šablona <třída _Tp> v souladu bool operátor ==(konst _Tp& __X, konst _Tp& __y) { vrátit se !(__X < __y || __y < __X);  }

pár

Objekt deklarovaný například jako std::pár<int, plovák> bude obsahovat dva členy, int za prvé; a plovák druhý;plus tři funkce konstruktoru.

První (výchozí) konstruktor inicializuje oba členy s výchozími hodnotami 0 a 0.0, zatímco druhý přijímá jeden parametr každého typu. Třetí je konstruktor kopírování šablon, který bude akceptovat všechny std::pár<_U1, _U2>, za předpokladu, že typy _U1 a _U2 jsou schopni implicitní převod na int a plovák resp.

Implementace GCC definuje pár mechanismus následovně.[2]

šablona<třída _T1, třída _T2> struktur pár {	typedef _T1 first_type;	typedef _T2 druhý_typ;	_T1 za prvé;	_T2 druhý;	pár(): za prvé(), druhý() { }	pár(konst _T1& __A, konst _T2& __b): za prvé(__A), druhý(__b) { }	šablona<třída _U1, třída _U2> pár(konst pár<_U1, _U2>& __p) : za prvé(__p.za prvé), druhý(__p.druhý) { }	};

Navíc tato hlavička definuje všech šest relačních operátorů pro pár instance s oběma typy společnými. Ty definují přísné slabé řazení pro objekty typu std::pár<_T1, _T2>, založeno na za prvé prvky a poté na druhý prvky pouze tehdy, když za prvé jsou si rovni. 

// pokračovalo shorašablona<třída _T1, třída _T2> v souladu bool operátor ==(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se __X.za prvé == __y.za prvé && __X.druhý == __y.druhý; }šablona<třída _T1, třída _T2> v souladu bool operátor  <(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se __X.za prvé < __y.za prvé || (!(__y.za prvé < __X.za prvé) && __X.druhý < __y.druhý); }šablona<třída _T1, třída _T2> v souladu bool operátor !=(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se !(__X == __y); }šablona<třída _T1, třída _T2> v souladu bool operátor >(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se __y < __X; }šablona<třída _T1, třída _T2> v souladu bool operátor<=(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se !(__y < __X); }šablona<třída _T1, třída _T2> v souladu bool operátor>=(konst pár<_T1, _T2>& __X, konst pár<_T1, _T2>& __y)	{ vrátit se !(__X < __y); }

Záhlaví dále obsahuje funkci šablony make_pair () který odvozuje svůj návratový typ na základě parametrů:

// pokračovalo shorašablona<třída _T1, třída _T2> v souladu pár<_T1, _T2> make_pair(_T1 __X, _T2 __y)	{ vrátit se pár<_T1, _T2>(__X, __y); }

Reference

  1. ^ Copyright (C) 2001, 2002, 2004, 2005, 2008 Free Software Foundation, Inc .; k dispozici pod GNU General Public License, verze 3 a novější. Dokumentace je k dispozici online na <https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.4/a00897.html >
  2. ^ Id., <https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.4/a00894.html >
  • ISO / IEC 14882: 2011 návrh specifikace (PDF). str. 508, § 20.

externí odkazy

Viz také