verktyg (C++)
| C++ standardbibliotek |
|---|
| Behållare |
| C standardbibliotek |
utility är en rubrikfil i C++ Standard Library . Den här filen har två nyckelkomponenter:
-
rel_ops, ett namnområde som innehåller uppsättning mallar som definierar standardbeteende för relationsoperatorerna!=,>,<=och>=mellan objekt av samma typ, baserat på användardefinierade operatorer==och<. -
pair, en behållarmall som innehåller två medlemsobjekt (förstaochandra) av godtycklig(a) typ(er). Dessutom definierar rubriken standardrelationsoperatorer förparsom har båda typerna gemensamma.
rel_ops
GCC :s implementering deklarerar namnområdet rel_ops (kapslade i namnområdet std ) på följande sätt:
namnutrymme rel_ops { mall < class _Tp > inline bool- operator != ( const _Tp & __x , const _Tp & __y ) { retur ! ( __x == __y ); } mall < class _Tp > inline bool operator > ( const _Tp & __x , const _Tp & __y ) { return __y < __x ; } mall < class _Tp > inline booloperator < = ( const _Tp & __x , const _Tp & __y ) { return ! ( __y < __x ); } mall < class _Tp > inline booloperator > = ( const _Tp & __x , const _Tp & __y ) { return ! ( __x < __y ); } }
Betrakta följande deklaration av klass A , som definierar likhet och mindre-än-operatorer för jämförelse med andra objekt av samma typ:
klass A { int byggnad ; int rum ; public : bool operator == ( const A & other ) const { return ( building == other . building ) && ( room == other . room ); } bool operator < ( const A & other ) const { return ( building < other . building ) || ( ! ( annan . byggnad < byggnad ) && ( rum < annan . rum )); } }; void f1 ( const A & a1 , const A & a2 ) { bool lika = ( a1 == a2 ); // använder == definierad inom klass A bool not_equal = ( a1 != a2 ); // fel: ingen matchning för 'operator!=' i 'a1 != a2' bool less = ( a1 < a2 ); // använder < definierad inom klass A bool larger = ( a1 > a2 ); // fel: ingen matchning för 'operator >' i 'a1 > a2' bool less_equal = ( a1 <= a2 ); // fel: ingen matchning för 'operator<=' i 'a1 <= a2' bool greater_equal = ( a1 >= a2 ); // fel: ingen matchning för 'operator>=' i 'a1 >= a2' }
Genom att anropa rel_ops -mallarna kan man tilldela en standardbetydelse till de återstående relationsoperatorerna. Men om en liknande typspecifik (dvs. icke-mall) operatör finns i det aktuella omfånget, även utanför klassdefinitionen, kommer kompilatorn att föredra det istället.
// (fortsättning från ovan) #include <utility> med namnutrymme std :: rel_ops ; // under operator ersätter rel_ops bool operator >= ( const A & a1 , const A & a2 ) { do_something_else (); // utföra några särskiljande biverkningar returnera ! ( al < a2 ); // men använd i övrigt samma procedur som rel_ops }; void f2 ( const A & a1 , const A & a2 ) { bool lika = ( a1 == a2 ); // använder operator == definierad inom klass A bool not_equal = ( a1 != a2 ); // använder !(a1 == a2) per rel_ops bool less = ( a1 < a2 ); // använder operator < definierad inom klass A bool larger = ( a1 > a2 ); // använder (a2 < a1) per rel_ops bool less_equal = ( a1 <= a2 ); // använder !(a2 < a1) per rel_ops bool greater_equal = ( a1 >= a2 ); // använder global operator >= definierad ovan }
Man skulle naturligtvis kunna deklarera följande tillsammans med rel_ops , vilket tillåter härledning av alla relationsoperatorer från < :
mall < class _Tp > inline booloperator == ( const _Tp & __x , const _Tp & __y ) { retur ! _ ( __x < __y || __y < __x ); }
par
Ett objekt som till exempel deklareras som std :: pair < int , float > kommer att innehålla två medlemmar, int first ; och flyta tvåa ; , plus tre konstruktorfunktioner.
0 Den första (standard) konstruktorn initierar båda medlemmarna med standardvärdena och 0.0 , medan den andra accepterar en parameter av varje typ. Den tredje är en mallkopieringskonstruktor som accepterar alla std :: par < _U1 , _U2 > , förutsatt att typerna _U1 och _U2 kan implicit omvandla till int respektive float .
GCC:s implementering definierar parmekanismen enligt följande.
mall < klass _T1 , klass _T2 > struct par { typedef _T1 first_type ; typedef _T2 andra_typ ; _T1 först ; _T2 sekund ; par () : första (), andra () { } par ( const _T1 & __a , const _T2 & __b ) : första ( __a ), andra ( __b ) { } mall < klass _U1 , klass _U2 > par ( const par < _U1 , _U2 >& __p ) : första ( __p . första ), andra ( __p . andra ) { } };
Dessutom definierar denna rubrik alla sex relationsoperatorer för parinstanser med båda typerna gemensamma. Dessa definierar en strikt svag ordning för objekt av typen std :: par < _T1 , _T2 > , baserat på de första elementen och sedan på de andra elementen endast när de första är lika.
// fortsättning från ovan mall < class _T1 , class _T2 > inline bool operator == ( const pair < _T1 , _T2 >& __x , const pair < _T1 , _T2 >& __y ) { return __x . först == __y . först && __x . andra == __y . andra ; } mall < klass _T1 , klass _T2 > inline booloperator < ( const pair < _T1 , _T2 > & __x , const pair < _T1 , _T2 >& __y ) { return __x . först < __y . först || ( ! ( __y . first < __x . first ) && __x . second < __y . second ); } mall < class _T1 , class _T2 > inline bool operator != ( const pair < _T1 , _T2 >& __x , const pair < _T1 , _T2 >& __y ) { return ! ( __x == __y ); } mall < klass _T1 , klass _T2 > inline bool operator > ( const pair < _T1 , _T2 >& __x , const pair < _T1 , _T2 >& __y ) { return __y < __x ; } mall < klass _T1 , klass _T2 > inline booloperator <= ( const par < _T1 , _T2 > & __x , const par < _T1 , _T2 >& __y ) { return ! ( __y < __x ); } mall < klass _T1 , klass _T2 > inline booloperator >= ( const par < _T1 , _T2 >& __x , const par < _T1 , _T2 > & __y ) { return ! ( __x < __y ); }
Dessutom innehåller rubriken en mallfunktion make_pair() som härleder dess returtyp baserat på parametrar:
// fortsättning från ovan mall < klass _T1 , klass _T2 > inline par < _T1 , _T2 > make_pair ( _T1 __x , _T2 __y ) { return par < _T1 , _T2 > ( __x , __y ); }
Se även
- ISO/IEC 14882:2011 utkast till specifikation (PDF) . sid. 508, 20 §.