Magyar oldal English site

Oldaltérkép
2024-08-15 21:49:20 (Eredeti megjelenés dátuma: 2013-01-18)
Programozás>> C/C++

C++ standard függvénytár

A standard C++ könyvtár egy objektum-orientált könyvtár. Ebben a nagy részben ismertetem a főbb osztályait. Ezek a standard C++ dolgok, mindahányan az std névtérben vannak definiálva. Ezért a C++ forráskódoknak szinte elengedhetetlen része egy using namespace std; sor.

A C++ standard függvénytár hatalmas, már a tartalomjegyzéken is jelentős idő végiggörgetni...

Szerk: Közben lett C++11, 14, 17, 20 és nem sokára 23 is lesz. Ezeket nem tartalmazza az alábbi írás, mert még azelőtt írtam mielőtt azok elterjedtek volna. Javaslom a Cpp Reference-t használni, hogy a legfrissebb dolgokat is elérd.

Tartalomjegyzék

C standard könyvtár C++ megfelelői

Mindegyik C fejléc elérhető a C++-ban is, viszont van nekik egy C++-osított változata. A következő módon: stdio.h -ből lesz a cstdio Azaz elé teszünk egy c-t, és kiterjesztés nélkül.

A kettő között az a különbség, hogy az C++-os változat mindent egy std nevű névtérben definiál.

IOStream objektumkönyvtár

Ezzel lehet mindenféle I/O műveletet végezni C++ módon. A következő listában foglalom össze az ebben található objektumokat. A leszármazottakat bentebb kezdve.

ios_base (ios fejléc)

Fő ősosztály.

ios : ios_base (ios fejléc)

Stream-ek fő ősosztálya.

istream : ios (istream fejléc)

A bemeneti adatfolyamokhoz használatos. Egy fontos példánya a cin, amely standard inputról való olvasásra használatos (az iostream fejlécben van).

iostream : istream, ostream (istream fejléc)

Olyan adatfolyamokhoz használatos, amely inputot és outputot is támogat.

fstream : iostream (fstream fejléc)
Fájlok írására és olvasására használatos.
stringstream : iostream (sstream fejléc)
Karakterláncok írására és olvasására használatos.
ifstream : istream (fstream fejléc)
Fájlok olvasására használatos
istringstream : istream (sstream fejléc)
Karakterláncok input adatfolyamként való használatára való.
ostream : ios (ostream fejléc)

Output adatfolyamokhoz használatos. Fontos példányai a cout, cerr és clog, ezek rendre a standard outputra, hibaeszközre és naplóeszközre írnak (ezek is az iostream fejlécben vannak).

iostream : istream, ostream (istream fejléc)

(lásd korábban)

ofstream : iostream (fstream fejléc)
Fájlok írására használatos.
ostringstream : iostream (sstream fejléc)
Karakterlánc írására használatos.
streambuf (streambuf fejléc), absztrakt osztály

Puffer funkcionalitást biztosít.

filebuf : streambuf (fstream fejléc)
A streambuf funkcionalitását implementálja, fájlokra.
stringbuf : streambuf (sstream fejléc)
A streambuf funkcionalitását implementálja, karakterláncokra.

Definiált objektumai

extern istream cin
A standard inputról (billentyűzet, stdin) olvas. A cout-hoz van kötve.
extern ostream cout
A standard outputra (terminál, stdout) írhatunk a segítségével.
extern ostream cerr
A standard hibaeszközre (terminál, stderr), írhatunk a segítségével. Ez nincs pufferelve, így a hibaüzenet azonnal a képernyőn lesz.
extern ostream clog
A standard hibaeszközre (terminál, stderr), írhatunk a segítségével. Ez pufferelve van, így naplózáskor és sok szöveg kiírásakor gyorsabb lehet, mint a cerr.

Definiált típusai

template <class stateT> class fpos
Stream-ekben a pozíció típusa. Ez egy általános típus.
streamoff
Stream-ekben az eltolás típusa. Implementációfüggő, hogy micsoda, de általában egy számtípus, legalább is van egy paraméteres konstruktora, amely elfogad számot.
streampos
Stream-ekben az eltolás típusa. Implementációfüggő, hogy micsoda, de általában egy számtípus, legalább is van egy paraméteres konstruktora, amely elfogad számot. Lényegében typedef fpos<mbstate_t> streampos.
streamsize
Általánosan használt egész szám típus a méretek jelzésére, valószínűleg egy size_t.

ios_base osztály tagjai

Az ios_base minden osztály alapja. Az összes adatfolyam tőle örököl. Ez egy absztrakt osztály, tehát nem példányosítható közvetlenül.

Belső típusok

event

Ez egy enum a lehetséges esemény típusokkal:

copyfmt_event
Az ios::copyfmt hívásakor történik.
erase_event
A destruktor hívásakor történik, illetve az ios::copyfmt hívásának az elején
imbue_event
Az imbue metódus hívásakor történik.
event_callback

Ez egy függvény mutató típus, a következő megadással: 

    typedef void (*event_callback) (event ev, ios_base& obj, int index);
ev
Az esemény típusa
obj
Az objektum amelyen regisztrálva van ez a függvény
index
Az az index, amely az eseménykezelő regisztrálásakor regisztrálva lett a függvényhez.

Ezeket a függvényeket az ios_base osztály hívogatja bizonyos események bekövetkeztekor A register_callback metódusával lehet ezeket az eseménykezelőket regisztrálni.

fmtflags

Ez egy egész típus, melyekben különféle jelzőbiteket tárol az osztály. A bináris számon belül egyes jelzőbitek mezőkbe vannak összerakva. Ezekről fogok külön is írni, ha odaérünk.

A következő jelzőbitek léteznek:

Független jelzőbitek:

boolalpha
Beolvasáskor és kiíráskor a logikai értékeket szövegként olvassa illetve írja ("true" és "false"), ha nincs beállítva, akkor számként kezeli őket (1 és 0).
showbase
Kiíráskor megjeleníti a számrendszer alapját (10-es számrendszer: 123, 8-as: 0123, 16-os: 0x123)
showpos
Pozitív és nulla számok elé kiírja a + jelet.
skipws
Figyelmen kívül hagyja a kezdeti whitespace karaktereket beolvasáskor.
unitbuf
Minden egyes írás után kiüríti a kimenetre az adatfolyam pufferét.
uppercase
Nagybetűvel ír ki egyes dolgokat. Példa az hexadecimális 0x-et.

A basefield mezőben a következő jelzőbitek bitjei egyesek, ezekkel jelzőbitekkel a kiírandó, illetve a beolvasandó szám számrendszerét lehet megadni:

dec
Tízes számrendszer.
hex
16-os számrendszer.
oct
8-as számrendszer.

A floatfield mezőben a következő jelzőbitek bitjei egyesek, ezekkel a lebegőpontos számok kezelési módját lehet megadni:

fixed
Fixpontos mód azaz extra nullák ki lesznek írva. (123.456 => 123.456000
scientific
Tudományos mód, exponenciálisan lesznek kiírva a dolgok. (123.456 => 1.234560E+02)
(Egyik sem)
Ha egyik sincs beállítva, akkor automatikusan választ a kettő közül, a túl nagy számokat tudományos, a túl kicsi számokat pedig fixpontos alakban írja ki, extra nullák nélkül.

Az adjustfield mezőben a következő jelzőbitek bitjei egyesek. Ezekkel lehet beállítani, hogy balra vagy jobbra igazítsa-e a kimenetet a megadott mezőben (ios_base::width-tel állítható be). A fennmaradó helyeket a megadott kitöltő karakterrel tölti ki (az alapértelmezett a szóköz, beállítható az ios::fill metódusával).

left
Balra igazít.
right
Jobbra igazít.
internal
A kiírandó dolog előjele, előtagja balra, az érték jobbra lesz igazítva, pl. hexadecimális számoknál a 0x bal oldalon lesz a szám pedig jobb oldalon. Előjel, előtag nélküli dolgoknál jobbra igazítást csinál.
iostate

Egy egész szám típus, melyben az adatfolyam állapotát lehet tárolni. A következő jelzőbitek lehetnek benne (összevagyolva):

eofbit
Be van állítva, ha a fájl végére értünk. Általában a fájl végére való érkezéskor a failbit is beállítódik.
failbit
Be van állítva, ha az előző input művelet sikertelen volt (pl. helytelen formátum, vagy a fájl végére értünk közben). A adatfolyam használható marad a művelet után.
badbit
Be van állítva, ha az előző input/output művelet sikertelen volt, és a hiba mélyebbről származik (pl. meg telt a lemez). Ez egy fatális hiba, azt jelenti, hogy adatfolyam többé nem használható.
goodbit
0. Az előzőek egyike sincs beállítva.
openmode

A adatfolyam megnyitási módjait tartalmazó adattípus. Értéke a következők összekombinálásából (vagy operátort alkalmazunk rájuk) áll:

app
(append) Hozzáfűzési mód: Minden egyes írási művelet a fájl végére történik.
ate
(at end) Megnyitáskor a fájl végére teszi a fájlmutatót.
binary
Bináris tartalomként kezeli a fájlt.
in
Engedélyezett a fájlból való beolvasás.
out
Engedélyezett a fájlba való írás.
trunc
Kitöröl mindent a fájlból megnyitáskor és egy üres fájlt nyit meg.
seekdir

Ez egy enum, amely tartalmazza a lehetséges fájlmutató-pozicionálási viszonyítási pontokat:

beg
Fájl elejétől.
cur
Az aktuális pozíciótól.
end
A fájl végétől.
failure

Az std::exception osztályból származik, ezt az osztályt dobják bizonyos műveletek kivételként.

Init

Inicializáló objektum, melynek létrehozása biztosítja, hogy a standard adatfolyam objektumok (cout, cin, cerr, clog), létrejönnek, mielőtt használnánk őket.

Konstruktorok és = operátor

    protected: ios_base ();
    private: ios_base (const ios_base&);
    private: ios_base& operator= (const ios_base&);

Ezek a konstruktorok kívülről nem elérhetők, így nem készíthető ezekből az osztályokból példány, csak a leszármazottaiból. Privát másoló konstruktora és = operátora miatt, az osztály példányai nem másolhatóak.

Destruktor

    virtual ~ios_base();

A megsemmisülés előtt, a register_callback metódusával regisztrált függvényeket meghívja az erase_event eseménnyel.

flags – formátum jelzőbitek lekérdezése, beállítása

    public:
        ios_base::fmtflags flags() const;
        ios_base::fmtflags flags(ios_base::fmtflags fmtfl);

A formátum jelzőbiteket lehet vele lekérdezni, illetve beállítani. A jelzőbitekről korábban volt szó. Visszatérési értéke a jelzőbitek a beállítás előtt.

setf metódus – egyes jelzőbitek bekapcsolása

    public:
        ios_base::fmtflags setf(ios_base::fmtflags fmtfl);
        ios_base::fmtflags setf(ios_base::fmtflags fmtfl, ios_base::fmtflags mask);

Az első verzió beállítja 1-re azokat a jelzőbiteket, amelyek a paraméterben megadott jelzőben egyesek, a többit úgy hagyja (lényegében: uj = elozo | fmtfl). A második verzió beállítja azokat azokat a jelzőbit, a megadott maszkban egyesek voltak, a paraméterben megadott jelző megfelelő bitjeire. (lényegében: uj = elozo | (fmtfl & mask) & (fmtfl & ~mask)).

Visszatérési értéke a jelzőbitek a beállítás előtt.

Példa:

    cout.setf(ios_base::hex, ios_base::basefield);

Beállítja a kiírás módját hexadecimálisra.

unsetf – egyes jelzőbitek törlése

Nullázza a biteket a formátum jelzőbitek közül, ahol a megadott maszk bitjei egyesek. Szintaxis: 

    public:
        void unsetf(fmtflags maszk);

precision – Értékes számjegyek számának a beállítása

Lebegőpontos számok kiírásakor az értékes számjegyek számát állítja be. 

    public:
        streamsize precision() const;
        streamsize precision(streamsize precizio);

A visszatérési értéke a korábbi pontosság.

Alapértelmezett lebegőpontos módban ténylegesen az értékes jegyekre vonatkozik. Fixpontos vagy tudományos módban A tizedes pont után megjelenítendő számok számára (ha kell nullákkal kiegészítve).

width – mezőszélesség beállítása

A soron következő output művelet mezőszélességét állítja be. Szintaxis: 

    public:
        streamsize width() const;
        streamsize width(streamsize wide);

Az első változat lekérdezi az aktuális szélességet, a második, pedig beállítja azt. Ezután setf-elni lehet a left, right, internal igazítást, ha igazítani akarunk.

Visszatérési értéke a beállítás előtti érték.

imbue – locale beállítása.

Beállítja a megadott std::locale-t (nyelvi beállítást) az adatfolyamon. Szintaxis: 

    public:
        locale imbue(const locale& loc);

Visszatérési értéke a beállítást megelőző locale.

getloc – aktuális locale lekérdezése

Lekérdezi az aktuális locale-t. 

    public:
        locale getloc() const;

xalloc – hely foglalása felhasználói adatnak

Lefoglal egy elemet az adatfolyam belső tömbjében. Szintaxis: 

    public:
        int xalloc();

Visszatérési értéke a tömbindex.

Ez a belső tömb egy általános célú dolog, amelyben felhasználói adatokat lehet tárolni.

iword – felhasználói adatterület elérése (számokhoz)

Lekéri a belső tömb adott indexű elemének a referenciáját. Szintaxis: 

    public:
        long& iword(int idx);

Ha nincs elég elem ebben a tömbben, akkor lefoglal annyit, hogy legyen. Hiba esetén is egy érvényes referenciával tér vissza, mely a 0 értéket tartalmazza.

pword – felhasználói adatterület elérése (mutatókhoz)

Lekéri a belső tömb adott indexű elemének a referenciáját. Szintaxis: 

    public:
        void*& pword(int idx);

Ha nincs elég elem ebben a tömbben, akkor lefoglal annyit, hogy legyen. Hiba esetén is egy érvényes referenciával tér vissza, mely a 0 értéket tartalmazza. Ez a függvény mutató értékként kezeli az adott tömb elemet (tehát saját dolgok címét tárolhatjuk benne).

register_callback – saját eseménykezelő regisztrálása

Saját eseménykezelőket regisztrálhatunk ezzel a metódussal. Szintaxis: 

    public:
        void register_callback(event_callback fn, int index);
fn
Az eseménykezelő függvény.
index
Egy szám, amit majd az objektum által az eseménykezelő függvénynek, amikor az hívódik.

sync_with_stdio – szinkronizálás a C stdio-val

Beállítja, hogy szinkronizálva legyen-e C++ IOStream függvénytár a standard C stdio-val. Ennek akkor van értelme, ha a két függvénytár együtt van használva. Szintaxis: 

    public:
        static bool sync_with_stdio ( bool sync = true );
sync
Ha igaz, akkor be van kapcsolva a szinkronizáció, hamis esetén ki van kapcsolva.

Visszatérési értéke a beállítás előtti érték.

Az ios osztály tagjai

Ez az ősosztálya az összes adatfolyam osztálynak, örökli az ios_base minden funkcióját, elemét, belső típusát és konstansait.

Konstruktorok

    public:
        explicit ios(streambuf *sb);

Ez inicializálja az objektumot az init(sb) függvény hívásával. Azaz hozzárendeli a megadott adatfolyam puffert. 

    protected: 
        ios();

Az alapértelmezett konstruktor nem inicializálja az objektumot, a leszármazottnak kell az init függvényt hívni.

Destruktor

    public:
        virtual ~ios();

Felszabadítja a dolgokat. De a hozzárendelt adatfolyam puffert nem törli.

good – hibaállapotban vagyunk-e

    public:
        bool good() const;

Igazzal tér vissza, hogy ha minden minden hibabit nulla az adatfolyamon. (eof, fail, bad).

eof – adatfolyam végén vagyunk-e

    public:
        bool eof() const;

Az eof bit értékével tér vissza (azaz az adatfolyam végén vagyunk)

fail – sikertelen volt-e az előző művelet

    public:
        bool fail() const;

A fail bit értékével tér vissza. Általában akkor van beállítva, ha valamilyen beolvasási művelet sikertelen volt (pl. számot várt, és mi valami hülyeséget írtunk be). A fail egy enyhébb hiba, az adatfolyam továbbra is használható.

bad – hibás-e az adatfolyam

    public:
        bool bad() const;

A bad bit értékével tér vissza. Általában akkor történik, hogy ha valami objektumtól független hiba történik (nincs elég hely a lemezen, nincs meg a fájl, stb.) Ha értéke igaz, akkor az adatfolyam nem használható tovább.

! operátor – hiba történt-e?

    public:
        bool operator !() const;

Igazzal tér vissza, ha az bad vagy a fail bit be van állítva az objektumon. Szóval egy !stream kifejezéssel eldönthetjük, hogy valami rossz történt.

A void*-ra típuskényszerítő operátor – hiba esetén NULL

    public:
        operator void*() const;

Ha a bad vagy a fail bit be van állítva, akkor értéke NULL, különben egy más érték. Ez azért van, hogy az if (stream) ... jellegű dolgok is működjenek, ne csak a !.

rdstate – státuszlekérés

    public:
        iostate rdstate() const;

Lekérdezi a státusz biteket.

setstate – státuszbeállítás

    public:
        void setstate(iostate state );

Beállítja a státusz biteket. Ez a függvény a korábbi státusz bitekkel összekombinálja (OR művelet) megadott paramétert.

clear – státuszbitek törlése vagy beállítása

    void clear(iostate state = goodbit);

Beállítja státusz biteket, a régi értéket lecseréli az újjal. Paraméterek nélkül hívva törli az összes bitet.

copyfmt – formátum jelzőbitek átvétele

    ios& copyfmt(const ios &rhs);

Átveszi az összes formátum jelzőbitet a megadott adatfolyamtól. Visszatérési értéke a *this.

fill – kitöltő karakter beállítása

    char fill() const;
    char fill(char fillch);

Lekérdezi vagy beállítja a kitöltő karaktert. Mezőben való kiíráskor ezzel a karakterrel tölti ki az üres helyeket. Visszatérési értéke a beállítás előtti érték.

exceptions – kivételdobás beállítása

    iostate exceptions() const;
    void exceptions(iostate except);

Lekérdezi illetve beállítja, hogy mely státusz bitek beállításakor dobjon fel az osztály ios_base::failure kivételt. (Több lehetőséget is összevagyolhatunk).

imbue – locale beállítása

    public:
        locale imbue(const locale& loc);

Beállítja a locale-t az adatfolyamon és a hozzárendelt pufferen is. Azaz hív egy ios_base::imblue(loc)-ot, majd a hozzárendelt pufferen is streambuf::pubimbue(loc)-ot. Visszatérési értéke a korábbi locale lesz.

tie – kimeneti adatfolyam kötése az aktuális adatfolyamhoz

    public:
        ostream* tie() const;
        ostream* tie(ostream* tiestr);

Kimeneti adatfolyamot köt az adatfolyamhoz, illetve lekérdezi azt. A művelet visszatérési értéke a korábban hozzákötött adatfolyam. A kötött adatfolyam mindig meghívódik a flush metódus, mielőtt az aktuális objektumon I/O műveletet végzünk.

A standard adatfolyamok cin, clog, cerr a cout-ot kötik alap esetben.

rdbuf – adatfolyam puffer beállítása vagy lekérdezése

    public:
        streambuf* rdbuf() const;
        streambuf* rdbuf(streambuf* sb);

Lekérdezi illetve beállítja az adatfolyamhoz rendelt adatfolyam puffert. A művelet visszatérési értéke a korábbi adatfolyam puffer címe.

narrow – nyelvspecifikus karakter fordítása a standardra

    public:
        char narrow(char c, char dfault) const;

Az aktuális objektumon beállított locale-beli karaktert fordít a standard változatára, ha nem lehet fordítani, akkor a dfault karakterrel tér vissza.

widen – standard karakter átalakítása nyelvspecifikusra

   char widen(char c) const;

Az aktuális objektumon beállított locale-ra fordítja át a megadott standard locale-beli karaktert.

Az istream osztály tagjai

Ez az osztály egy input adatfolyamot reprezentál, amelyből be lehet olvasni dolgokat. Az ios osztályból örököl mindent.

Belső típusok

sentry
    class istream::sentry 
    {
    public:
        explicit sentry ( istream& stream, bool nincs_szokoz_kihagyas = false );
        ~sentry();
        operator bool() const;
    private:
        sentry (const sentry&);             // nincs definiálva
        sentry& operator= (const sentry& ); // nincs definiálva
    };

Ezt az osztályt minden input művelet előtt példányosítja az istream osztály, ennek az osztálynak a konstruktora végzi az ellenőrzést az adatfolyamon (bitek jók, szinkronizálás a kötött outputtal megvolt, stb.) A destruktora semmit nem csinál. A bool operátor meg igazat ad, ha minden oké. (Csak azt nem értem, hogy miért kellett ehhez osztályt csinálni?)

Konstruktor

    public:
        explicit  istream(streambuf * sb);

Inicializálja az input adatfolyamot, adott adatfolyam pufferrel.

Destruktor

    public:
        virtual ~istream();

Megsemmisíti az objektumot, a hozzárendelt adatfolyam puffert békén hagyja.

A >> operátor – adatok olvasása az adatfolyamból

Tagfüggvények:

    public:
        istream& operator>> (bool& val );
        istream& operator>> (short& val );
        istream& operator>> (unsigned short& val );
        istream& operator>> (int& val );
        istream& operator>> (unsigned int& val );
        istream& operator>> (long& val );
        istream& operator>> (unsigned long& val );
        istream& operator>> (float& val );
        istream& operator>> (double& val );
        istream& operator>> (long double& val );
        istream& operator>> (void*& val );
         
        istream& operator>> (streambuf* sb );
         
        istream& operator>> (istream& ( *pf )(istream&));
        istream& operator>> (ios& ( *pf )(ios&));
        istream& operator>> (ios_base& ( *pf )(ios_base&));

Globális függvények

    istream& operator>> (istream& is, char& ch );
    istream& operator>> (istream& is, signed char& ch );
    istream& operator>> (istream& is, unsigned char& ch );
     
    istream& operator>> (istream& is, char* str );
    istream& operator>> (istream& is, signed char* str );
    istream& operator>> (istream& is, unsigned char* str );

Ezzel az operátorral lehet beolvasni formázott dolgokat, ha a billentyűzetről akarunk beolvasni, akkor a cin objektumot lehet használni. Mivel az operátor visszatérési értéke maga az objektum, ezért ezt lehet láncolni tetszőleges hosszban: 

    int a, b, c;
    // Beolvasás:
    cin >> a >> b >> c;

Persze nem csak változókba lehet beolvasni, lehet egy másik adatfolyam pufferbe, illetve lehet manipulátor függvényeket is használni. De ezekről majd később.

Ez a függvény beállítja a fail bitet, ha a beolvasott karakterek nem értelmezhetők az adott típusként.

gcount – hány karaktert olvastunk be?

    public:
        streamsize  gcount() const;

Visszatér a legutóbbi formázatlan input műveletkor beolvasott karakterek számával.

get – karakterek beolvasása az adatfolyamból

    public:
        int get();

Beolvas egyetlen karakter az adatfolyamból is visszatér vele. 

    public:
        istream& get(char& c);

Beolvas 1 karaktert és eltárolja a paraméterként megadott változóban. Visszatérési értéke az objektum maga. 

    public:
        istream& get(char* s, streamsize n);

Beolvas egy C karakterláncot a adatfolyamból, adott maximális hosszal. A függvény n-1 karaktert olvas be, majd a karakterláncot lezárja egy nullás byte-tal. Szintén megáll, hogy ha egy '\n' karakterhez ér, de azt már nem olvassa be, hanem az input pufferben marad. Úgyszintén megáll, ha adatfolyam végéhez ért. Visszatérési értéke az adatfolyam, amin hívták, így ezek a műveletek láncolhatók 

    public:
        istream& get(char* s, streamsize n, char delim);

Ugyanaz, mint előbb, csak itt saját elválasztót adhatunk az alapértelmezett '\n' helyett. 

    public:
        istream& get(streambuf& sb);
        istream& get(streambuf& sb, char delim);

Ugyanaz, mint az előző kettő, csak ez egy adatfolyam pufferbe írja a dolgokat.

getline – sor beolvasása az adatfolyamból

    public:
        istream& getline(char* s, streamsize n);
        istream& getline(char* s, streamsize n, char delim);

Beolvas egy sort az adatfolyamból az s C tömbbe, legfeljebb n karaktert, '\n'-t vagy delim karaktert sor végének használva. A függvény akkor áll meg, hogy ha beolvasott n-1 karaktert, ha sorvégjelet, vagy az adott elválasztót elérte (ekkor az elválasztót beolvassa, de nem adja hozzá a szöveghez), Vagy ha fájl végére ért. Bármely esetben lezárja a karakterláncot egy 0-ás byte-tal, és visszatérési értéke az objektum, amelyen hívták.

ignore – karakterek figyelmen kívül hagyása

    public:
        istream& ignore(streamsize n = 1, int delim = EOF);

Beolvas, és eldob megadott számú karaktert. Akkor áll meg, hogy ha már eldobott n db karaktert, vagy elérte a delim karaktert, mely alapértelmezésben negatív, tehát nincs. Természetesen akkor is megáll, hogy ha eléri az adatfolyam végét. Visszatérési értéke az adatfolyam, amelyen hívták, szóval láncolható ez a dolog.

peek – mi a soron következő karakter?

    public:
        int peek();

Megmondja az adatfolyamban a soron következő karaktert, de nem olvassa be.

read – byte-ok beolvasása adatfolyamból

    public:
        istream& read(char* s, streamsize n);

Beolvas egy blokkot az s tömbbe, legfeljebb n hosszan. A függvény akkor áll meg, ha beolvasta az n db karaktert, vagy ha elérte az adatfolyam végét (hogy mennyit sikerült olvasni, azt a gcount metódus mondja meg).

readsome – byte-ok beolvasása adatfolyamból, de csak a belső pufferből

    public:
        streamsize readsome(char* s, streamsize n);

Hasonlóképpen működik, mint a read csak ez a lokális pufferből olvas csak, így akkor sem valószínű, hogy eleget olvasunk, amikor még lenne mit olvasni. A függvény visszatérési értéke a kiolvasott karakterek száma. Ez akkor hasznos, amikor valamilyen aszinkron forrásból akarunk olvasni (pl. hálózat), mert ez a függvény azonnal visszatér, a read pedig minden esetben vár.

putback – visszatesz egy karaktert az adatfolyamba

    public:
        istream& putback(char c);

Visszatesz egy karaktert, így a következő karakter, amit beolvasunk a visszarakott karakter lesz. Visszatérési értéke az adatfolyam, amelyen a metódust hívták. Nincs garancia arra, hogy ez a függvény működik. Ha a belső puffer elején járunk, akkor nem lehet semmit se visszarakni, így a badbit beállítódik majd. Visszatérési értéke az adatfolyam, melyen hívták.

unget – visszateszi az előzőleg beolvasott karaktert

    public:
        istream& unget();

Ugyanaz, mint a putback metódus, csak ez az utoljára kiolvasott karaktert teszi vissza. Akár csak az az előzőnél, itt sincs garancia arra, hogy ez a függvény működik. Ha a belső puffer elején járunk, akkor nem lehet semmit se visszarakni, így a badbit beállítódik majd.

tellg – hol vagyunk az input adatfolyamban?

    public:
        streampos tellg();

Lekérdezi a pozíciót az adatfolyamban, amelyről a következő adatot olvassuk. Ha a művelet nincs értelmezve vagy hiba történt, akkor -1-gyel tér vissza.

seekg – adatfolyamban a bemeneti pozíció beállítása

    public:
        istream& seekg(streampos pos);
        istream& seekg(streamoff off, ios_base::seekdir dir);

Beállítja a pozíciót az adatfolyamban, ahonnét olvasunk majd. Az első változat abszolút pozíciót állít be. A második változat pedig egy relatívot a fájl elejéhez, végéhez vagy az aktuális pozícióhoz képest.

A fail bit beállítódik, ha a megadott pozíció nem érhető el, vagy az adatfolyam nem támogatja a pozicionálást.

Visszatérési értéke az adatfolyam, amelyen hívták.

sync – adatfolyam szinkronizálása az input forrással

    public:
        int sync();

Csak pufferelt adatfolyamok esetén használható, szinkronizálja az adatfolyam pufferét az input forrással, lényegében üríti a tartalmát. Hogy ez ténylegesen hogyan történik, az az adott input forrástól függ. Ha a művelet sikeres volt, 0-val, ha nincs pufferelve az adatfolyam, akkor -1-gyel tér vissza. Hiba esetén beállítódik a bad bit.

Az ostream osztály elemei

Ez egy kimeneti adatfolyam osztályt valósít meg, az ios osztályból örököl mindent.

Belső típusok

sentry
    class ostream::sentry {
    public:
      explicit sentry ( ostream& os );
      ~sentry();
      operator bool() const;
    private:
      sentry (const sentry&);             // nincs definiálva
      sentry& operator= (const sentry& ); // nincs definiálva
    };

Ugyanaz, mint az istream esetében, a műveletek előtt végez ellenőrzéseket, és igen, itt sem értem, hogy miért nem metódusként csinálták...

Konstruktor

    public:
        explicit ostream(streambuf *sb);

Létrehozza a kimeneti adatfolyamot és hozzárendeli a megadott adatfolyam puffert.

Destruktor

    virtual ~ostream();

Elvégzi a megsemmisülés előtti teendőket, a hozzárendelt streambuf-ot nem szabadítja fel.

<< operátor – adatok írása az adatfolyamba

Ezzel lehet adatot küldeni az adatfolyamba:

Metódusok:

    public:
        ostream& operator<<(bool val);
        ostream& operator<<(short val);
        ostream& operator<<(unsigned short val);
        ostream& operator<<(int val);
        ostream& operator<<(unsigned int val);
        ostream& operator<<(long val);
        ostream& operator<<(unsigned long val);
        ostream& operator<<(float val);
        ostream& operator<<(double val);
        ostream& operator<<(long double val);
        ostream& operator<<(const void* val);
         
        ostream& operator<<(streambuf* sb);
         
        ostream& operator<<(ostream& (*pf)(ostream&));
        ostream& operator<<(ios& (*pf)(ios&));
        ostream& operator<<(ios_base& (*pf)(ios_base&));

Globális függvények:

    public:
        ostream& operator<<(ostream& out, char c );
        ostream& operator<<(ostream& out, signed char c );
        ostream& operator<<(ostream& out, unsigned char c );
         
        ostream& operator<<(ostream& out, const char* s );
        ostream& operator<<(ostream& out, const signed char* s );
        ostream& operator<<(ostream& out, const unsigned char* s );

Ezzel adatokat lehet formázva kiírni, az összes alap adattípus kiírható vele. A adatfolyam pufferes a puffer teljes tartalmát beírja az adatfolyamba, a függvénymutatós változat pedig I/O manipulátorokhoz van (ezekről később). A globális változatok egyetlen karakterhez, illetve C karakterláncokhoz vannak.

Az operátorok visszatérési értéke az adatfolyam maga, így ezek láncolhatók. Egy gyakran használt kimeneti adatfolyam a cout, amely a standard kimenet. Példa: 

    cout << "Pi értéke: " << 3.1415926536

put – egyetlen karakter írása az adatfolyamba

    public:
        ostream& put(char c);

Beír egy karaktert az adatfolyamba, visszatérési értéke az adatfolyam, így több függvény is láncolható utána. Hiba esetén a bad bit lesz beállítva.

write – byte-ok írása adatfolyamba

    public:
        ostream& write(const char* s, streamsize n);

Beír az s területről n byte-ot az adatfolyamba. Visszatérési értéke az adatfolyam maga, szóval ez a dolog láncolható. Nyilván bináris ez az írás, szóval nem fog megállni holmi 0 byte-oknál.

tellp – a kimeneti pozíció lekérése

    public:
        streampos tellp();

Visszatér a pozícióval, ahova a kiírt dolgokat írja. Ha az adatfolyam esetén nem értelmezett a pozíció, vagy hiba történt, akkor -1-gyel tér vissza.

seekp – a kimeneti pozíció beállítása

    ostream& seekp(streampos pos);
    ostream& seekp(streamoff eltolas, ios_base::seekdir irany);

Hasonlóan Az istream seekg metódusához, ez is beállítja a pozíciót, ahová írunk. Az első abszolút pozíciót állít, a második az elejéhez, végéhez vagy az aktuális pozícióhoz relatívan. Visszatérési értéke az adatfolyam maga. A fail bit beállítódik, ha elérhetetlen helyre akarunk pozicionálni, minden más esetben a bad bit állítódik be.

flush – írás érvényesítése

    ostream& flush();

Üríti az adatfolyam pufferét, egy réteggel lentebb küldve a módosításokat.

Az iostream tagjai

Ez az osztály tulajdonképpen örökli az istream és az ostream mindenét: 

    class iostream : public istream, public ostream 
    {
    public:
        explicit iostream(streambuf *sb);
        virtual ~iostream();
    }

Olyan adatfolyamokhoz használatos, amelybe írni és olvasni is lehet. Nyilván viszonylag ritka, hogy egyszerre akarjuk használni mind a két funkciót.

A streambuf tagjai

Ez egy absztrakt osztály, az adatfolyamok háttérpufferét reprezentálja.

Konstruktor

    protected:
        streambuf();

Inicializálja az objektumot. Mivel védett, csak a leszármazottai hívhatják. Meg ahogy pár sorral fentebb írtam: absztrakt osztály.

Destruktor

    virtual ~streambuf();

Felszabadítási dolgokat végez.

pubimbue – nyelvi beállítás a pufferen

    public:
        locale pubimbue(const locale& loc);

Beállítja a megadott nyelvi beállítást az adatfolyam pufferen, a visszatérési értéke a beállítás előtti locale. A beállítás a védett imbue metódussal végezteti el.

getloc – nyelvi beállítás lekérdezése

    public:
        locale getloc() const;

Lekérdezi az adatfolyam pufferen beállított locale-t.

pubsetbuf – puffer terület beállítása

    public:
        streambuf* pubsetbuf(char* s, streamsize n);

A védett setbuf metódust hívja, mely beállítja a megadott n méretű s tömböt. Ha mindkettő paraméter nulla, akkor az objektum puffer nélküli lesz. Siker esetén a pufferrel magával tér vissza, különben NULL mutatóval.

pubseekoff – pozíció beállítása a pufferben

    public:
        streampos pubseekoff(
            streamoff eltolas, 
            ios_base::seekdir origo, 
            ios_base::openmode ezt = ios_base::in | ios_base::out
        );

Beállítja a pozíciót a pufferen eltolas helyre, origo relatív pozícióhoz képest, valamint, hogy az input vagy az output pozíciót (ezt ) kell-e beállítani. Visszatérési értéke a beállított pozíció. A védett seekoff metódust hívja.

pubseekpos – pozíció beállítása a pufferben

    public:
        streampos pubseekpos(
            streampos pos, 
            ios_base::openmode which = ios_base::in | ios_base::out 
        );

Ez is beállítja az adatfolyam pufferben az aktuális pozíciót, csak egy mindig abszolút pozícióra állítja. A védett seekpos metódust hívja. A többi paraméterei és visszatérési megegyezik az előző metóduséval.

pubsync – puffer szinkronizálása a kapcsolódó adatforrással

    public:
        int pubsync();

Meghívja a védett sync metódust. A feladata az, hogy szinkronizálja a puffert a kapcsolódó eszközzel, kimeneti puffer esetén pl. kiírja az eszközre a dolgokat, bemenetinél egyszerűen eldobja a tartalmát. Visszatérési értéke sikeres futás esetén 0, különben -1.

in_avail – mennyi beolvasható karakter van a pufferben?

    public:
        streamsize in_avail();

Visszatér a beolvasható karakterek számával (input műveletek esetén). Ez kétféleképpen történhet:

snextc – előreléptetés majd az ottani karakter kiolvasása

    public:
        int snextc();

Előrelépteti az olvasási pozíciót, majd visszatér az újonnan mutatott karakterrel. Ha nem tud karaktert olvasni, mert végig értünk az adatfolyamon, akkor az EOF konstans értékével tér vissza. Ez hívja az uflow védett metódust, ha a mutató a puffer végére ért.

sbumpc – aktuális karakter kiolvasása, majd előreléptetés

    public:
        int sbumpc();

Először kiolvassa az olvasási pozíció által mutatott karaktert, majd előre lépteti a mutatót. Ha nem tud karaktert olvasni, mert az olvasási mutató már az adatfolyam puffer végén áll, akkor az EOF konstans értékével tér vissza. Ez is hívja az uflowvédett metódust, ha a mutató a puffer végére ért.

sgetc – aktuális pozíción lévő karakter kiolvasása

    public:
        int sgetc();

Visszatér az olvasási mutató által mutatott karakterrel. Ha mutató a puffer végén áll, akkor az underflow védett metódust hívja, hogy újratöltse a puffert, ha ez nem sikerül, akkor az EOF karakterrel tér vissza. Ez a függvény nem mozgatja előre az olvasási pozíciót.

sgetn – byte-ok beolvasása a tömbbe 

    public:
        streamsize sgetn(char *s, streamsize n );

Beolvas n darab karaktert (byte-ot), az s által mutatott helyre. A beolvasást az xsgetn védett függvénnyel végzi. Visszatérési értéke a karakterek száma, amennyit sikerült beolvasni a pufferből. Ez lehet n vagy kevesebb.

sputbackc – visszateszi a megadott karaktert a pufferbe

    public:
        int sputbackc(char c);

Visszateszi a c karaktert a beolvasandó karakterek közé. Lényegében úgy, hogy eggyel visszalépteti a beolvasási mutatót, és arra a helyre beírja a c értékét. Ha a már ott lévő karakterrel nem egyezik meg az érték, vagy mutató már a puffer elején áll, a akkor a pbackfail függvényt hívja a c paraméterrel, amely vagy visszarakja a karaktert, vagy EOF-fal tér vissza.

A függvény visszatérési értéke a visszatett karakter, vagy EOF, ha nem sikerült visszatenni.

sungetc – legutóbb beolvasott karakter visszahelyezése

    public:
        int sungetc();

Újra elérhetővé teszi a legutóbb beolvasott karaktert, a pbackfail védett függvényt hívja, hogy ha a beolvasási mutató a puffer elején áll. A függvény visszatérési értéke a karakter, amit amit újra beolvashatunk, vagy EOF, ha a puffer elején vagyunk.

sputc – egy karakter írása a pufferbe majd pozíció előreléptetése

    public:
        int sputc(char c);

A megadott karaktert eltárolja az aktuális kiírási pozíción, majd előre lépteti a kiírási pozíciót. Ez meghívja az overflow védett függvényt, ha a kiírási mutató a kiírási puffer végére mutat. Sikeres kiírás esetén a kiírt karakterrel tér vissza, különben az EOF értékével.

sputn – byte-ok írása a pufferbe

    public:
        streamsize sputn(const char * s, streamsize n);

Az s helyről, n db karaktert ír a pufferbe a kiírási pozíciótól kezdve. Ezt a feladatot az xsputn védett függvénnyel végezteti el. A művelet úgy történik, mintha sok sputc függvényt hívtunk volna egymás után, amíg az első EOF-fal nem tér vissza. Visszatérési értéke a kiírt karakterek száma, mely n vagy annál kevesebb.

Az input puffer mutatóinak lekérése (eback, gptr, egptr metódusok)

    protected:
        char *eback() const;
        char *gptr() const;
        char *egptr() const;

Az eback az input puffer első byte-jára mutat. A gptr az aktuális olvasási pozícióra mutat. A egptr az input puffer vége utáni első byte-ra mutat.

Az olvasási pozíció nyilván az input pufferen belül, annak eleje és vége között van.

Az output puffer mutatóinak lekérése

    protected:
        char *pbase() const;
        char *pptr() const;
        char *epptr() const;

A pbase az output puffer első byte-jára mutat. A pptr az aktuális írási pozícióra mutat. A epptr az output puffer vége utáni első byte-ra mutat.

Az írási pozíció nyilván az output pufferen belül, annak eleje és vége között van.

gbump – olvasási mutató előreléptetése

    protected:
        void gbump(int n);

Megadott számú pozícióval előre lépteti az olvasási mutatót. A művelet nincs ellenőrizve (szóval simán lehet puffer túlcsordulás, ha nem figyelünk).

setg – input puffer és mutatók beállítása

    protected:
        void setg(char* eleje, char* kovetkezo, char* vege);

Beállítja az input puffer elejét eleje-re, a puffer végét vege-re, az aktuális olvasási pozíciót pedig kovetkezo-re.

pbump – írási mutató előreléptetése

    protected:
        void pbump(int n);

Megadott számú pozícióval előre lépteti az írási mutatót. A művelet nincs ellenőrizve (szóval simán lehet puffer túlcsordulás, ha nem figyelünk).

setp – kimeneti puffer beállítása

    protected:
        void setp(char* eleje, char* vege);

Beállítja az input puffer elejét eleje-re, a puffer végét vege-re. Hogy az írási pozíciót miért nem lehet ezzel beállítani, mint a setg-vel az olvasásit, nem tudom...

imbue – nyelvi beállítás beállításának a kezelője

    protected:
        virtual void imbue(const locale &loc);

A tényleges locale beállítást végzi, alapértelmezésben nem csinál semmit. A pubimbue hívja.

setbuf – a puffer beállítás kezelője

    protected:
        virtual streambuf *setbuf(char *s, streamsize n);

A pubsetbuf hívja ezt, hogy a tényleges hozzárendelést elvégezze. Beállítja az s tömböt, melynek hossza n. Siker esetén az adatfolyam pufferrel kell visszatérni, különben NULL-lal. Ha a két paramétere NULL, akkor adatfolyam puffer egy puffer nélküli dolog.

seekoff – Pozicionálás kezelője

    protected:
        virtual streampos seekoff(
            streamoff eltolas, 
            ios_base::seekdir innen, 
            ios_base::openmode ezt = ios_base::in | ios_base::out
        );

Ez végzi a pufferben való pozicionálást, a pubseekoff hívja ezt, hogy a pozicionálást elvégezze. Az ezt pufferpozíciót állítja be innen helytől, adott eltolas helyre. Visszatérési értéke a beállított pozíció, -1 ha nem sikerült a beállítás. Az alapértelmezett viselkedés az, hogy nem csinál semmit, és visszatér -1-gyel.

seekpos – fájlmutató beállítás kezelője

    protected:
        virtual streampos seekpos( 
            streampos sp, 
            ios_base::openmode which = ios_base::in | ios_base::out 
        );

Az abszolút pozícióra való beállítást végzi, a pubseekpos függvény hívja ezt. Paraméterezése ugyanaz, mint annak. Alapértelmezett viselkedési egyszerűen visszatér -1-gyel.

sync – szinkronizálás kezelője

    protected:
        virtual int sync();

A tényleges szinkronizálást végzi a külső input vagy output forrással. Siker esetén 0-val, különben más értékkel tér vissza. Az alapértelmezett viselkedése az, hogy visszatér nullával.

showmanyc

    protected:
        virtual streamsize showmanyc();

Megadja, hogy mennyi karakter lesz elérhető, miután az olvasási puffer végére értünk (és underflow állapotában vagyunk). Ezt az in_avail függvény hívja az ott említett esetekben. Az alapértelmezett viselkedése az, hogy egyszerűen visszatér 0-val.

xsgetn – karakterbeolvasásnak a kezelője

    protected:
        virtual streamsize xsgetn(char *s, streamsize n);

Az sgetn metódus hívja ezt. Beolvas s tömbbe n db karaktert, és visszatér a sikeresen beolvasott karakterek számával. Az alapértelmezett viselkedése az sbumpc-t hívogatja n-szer, és az első hibánál megáll, és visszatér a karakterek számával.

underflow – puffer elfogyásának a kezelője

    protected:
        virtual int underflow();

Karakter beolvasását végzi, amikor az az olvasási pozíció a puffer végére ért. Az sgetc hívja abban az esetben. Ilyenkor van lehetőség előreolvasni (újratölteni a puffert), és megmondani a soron következő karaktert. Ha nincs következő karakter, akkor a visszatérési értéke EOF. Az alapértelmezett viselkedése egyszerűen annyi, hogy visszatér EOF-fal.

uflow – puffer elfogyásának a kezelője 

    protected:
        virtual int uflow();

Ugyanazt csinálja, mint az underflow csak ez eggyel előrelépteti az olvasási pozíciót. Ez a metódus az sbumpc és az snextc függvény által hívódhat. Az alapértelmezett viselkedése az, hogy meghívja az underflow metódust, ha a hívás sikeres volt, akkor előrelépteti a mutatót és visszatér az visszatérési értékével, különben EOF konstans értékével tér vissza.

pbackfail – sikertelen karakter-visszarakás kezelője

    protected:
        virtual int pbackfail(int c = EOF);

Visszateszi a karaktert az adatfolyam pufferbe, hogyha az sputbackc vagy a sungetc hívásakor nincs hely az input pufferben, vagy az ott lévő karakter nem egyezik meg a legutóbb olvasottal. Ez a függvény eldönti, hogy ekkor mi a teendő, ha sikerült visszatennie az adott c karaktert, akkor visszatér egy EOF-tól különböző értékkel, ha nem, akkor EOF-fal. Ha a paraméter EOF, akkor az azt jelenti, hogy az utoljára olvasott karaktert szeretnénk újra visszatenni.

Az alapértelmezett viselkedés nem csinál semmit, egyszerűen visszatér EOF-fal.

xsputn – karakterkiírásnak a kezelője

    public:
        virtual streamsize xsputn(const char * s, streamsize n);

Az sputn hívja, hogy végezze el az s tömbből, n karakter kiírását az adatfolyam pufferbe. A visszatérési értéke a sikeresen kiírt karakterek száma. Az alapértelmezett viselkedése az, hogy az sputc-vel karakterenként végigmegy és kiírja a tömb elemeit, megállva, amikor az először EOF-ot kap, és visszatér A sikeresen kiírt karakterek számával (mely lehet n vagy kevesebb).

overflow – puffer megtelésének a kezelője

    protected:
        virtual int overflow(int c = EOF);

Ez a függvény akkor hívódik, amikor a karaktert akart akarunk írni a kimeneti pufferbe, mikor az már megtelt (az írási mutató a puffer végén áll). A függvény feladata az, hogy ebben az esetben is megoldja az írást (pl. szinkronizálja a puffert, a tényleges kimenettel, és kezdje az elejéről). Ha sikerült a szükséges előkészítés után kiírni a c-t, akkor a visszatér egy EOF-tól különböző értékkel, különben EOF-fal. Az alapértelmezett viselkedés az, hogy nem csinál semmit, csak visszatér EOF-fal.

Az ifstream, fstream és ostream osztály tagjai

Ezek az objektumok fájlokat reprezentálnak, melyek olvasásra, írásra esetleg mindkettőre meg vannak nyitva. Az objektumok között nagy hasonlóságok vannak, így nem szedem őket külön. Az ifstream az istream osztályból, az ofstream az ostream osztályból, az fstream az iostream osztályból örököl.

Konstruktorok

    public:
        ifstream::ifstream();
        explicit ifstream::ifstream(const char *fajlnev, ios_base::openmode mod = ios_base::in );
        
        ofstream::ofstream();
        explicit ofstream::ofstream(const char *fajlnev, ios_base::openmode mod = ios_base::out );
        
        fstream::fstream();
        explicit fstream::fstream(const char *fajlnev, ios_base::openmode mod = ios_base::in | ios_base::out);

Ezek inicializálják az objektumot. A paraméter nélküli konstruktor nem csinál semmit. A paraméteres pedig megnyitja a megadott nevű fájlt adott módban (alapértelmezésben az adatfolyam típusának megfelelően). A fail bit beállítódik, hogy ha a konstruktor futása sikertelennek bizonyul.

Destruktor

    public:
        virtual ifstream::~ifstream();
        virtual ofstream::~ofstream();
        virtual fstream::~fstream();

Ezen osztályok destruktorai bezárják a fájlt, ha korábban nem tettük volna meg a close metódussal.

rdbuf – fájlhoz tartozó puffer lekérése

    public:
        filebuf* rdbuf() const;

Lekéri a fájladatfolyamhoz rendelt fájl puffert.

is_open – megvan-e nyitva a fájl.

    public:
        bool is_open();

Igazzal tér vissza, ha a fájl meg van nyitva, különben hamissal.

open – fájl megnyitása

    public:
        void ifstream::open(const char *filename, ios_base::openmode mode = ios_base::in);
        void ofstream::open(const char *filename, ios_base::openmode mode = ios_base::out);
        void fstream::open(const char *filename, ios_base::openmode mode = ios_base::in | ios_base::out);

Megnyitja a megadott nevű fájlt, alapértelmezésben az adatfolyam típusnak megfelelő módban. Ha a megnyitás nem sikerül, akkor a fail bit beállítódik az adatfolyamon.

close – fájl bezárása

    public:
        void close();

Bezárja a fájlt, és lemezre ment mindent. Ha ez nem sikerül, akkor a fail bit beállítódik az adatfolyamon.

A filebuf osztály elemei

Ez az osztály örökli a streambuf funkcionalitását és alkalmazza fájlokra. Tulajdonképpen az összes fájl adatfolyam, ennek az objektumnak a szolgáltatásait használja.

Konstruktorok

    public:
        filebuf();

Inicializálja az objektumot.

Destruktor

    public:
        virtual ~filebuf ();

A destruktor lezárja az alárendelt fájlt, ha azt nem tettük volna meg korábban.

is_open – fájl megnyitása

    public:
        bool is_open();

Igazat ad vissza, hogy ha a hozzárendelt fájl meg van nyitva, különben hamisat.

open – fájl megnyitása

    public:
        filebuf *open(const char *filename, ios_base::openmode mode);

Megnyitja a megadott nevű fájlt a megadott módban. Siker esetén önmagának címével, különben NULL mutatóval tér vissza.

close – fájl bezárása

    public:
        filebuf *close();

Bezárja a pufferhez hozzárendelt fájlt. Siker esetén, önmaga címével, különben NULL mutatóval tér vissza.

A stringstream, istringstream, ostringstream osztályok tagjai

Ezek az osztályok tetszőleges hosszúságú karakterláncok összerakására szolgálnak. Ezen osztályokban sok a közös vonás, így nem veszem őket külön. Az istringstream az istream, az ostringstream az ostream, a stringstream pedig az iostream osztálytól örököl mindent.

Konstruktorok

    public:
        explicit istringstream::istringstream(openmode which = ios_base::in );
        explicit istringstream::istringstream(const string &str, openmode which = ios_base::in );
        
        explicit ostringstream::ostringstream(openmode which = ios_base::out );
        explicit ostringstream::ostringstream(const string &str, openmode which = ios_base::out );
        
        explicit stringstream::stringstream(openmode which = ios_base::in | ios_base::out );
        explicit stringstream::stringstream(const string & str, openmode which = ios_base::in | ios_base::out );

Inicializálja az objektumot és a tárolt karakterláncpuffert, a megadott módban, illetve van lehetőség arra, hogy megadjuk egy kezdő karakterláncot neki.

Destruktorok

    public:
        virtual istringstream::~istringstream();
        virtual ostringstream::~ostringstream();
        virtual stringstream::~stringstream();

Ezek a destruktorok semmi extrát nem csinálnak, felszabadítja az adatfolyam tartalmát, és az alárendelt puffert.

rdbuf – a karakterláncpuffer lekérése

    public:
        stringbuf* rdbuf() const;

Visszatér az adatfolyam alá rendelt karakterlánc pufferrel.

str – a tárolt karakterlánc lekérdezése

    public:
        string str() const;
        void str(const string &s);

A karakterlánc pufferben tárolt karakterláncot adja vissza, illetve állítja be.

A stringbuf osztály tagjai

Ez az osztály az előbb említett karakterlánc adatfolyam osztályok puffere, a streambuf osztályból örököl mindent.

Konstruktorok

    public:
        explicit stringbuf(ios_base::openmode which = ios_base::in | ios_base::out );
        explicit stringbuf(const string &str, ios_base::openmode which = ios_base::in | ios_base::out );

Beállítja a puffer írási módját (írás vagy olvasás), illetve beállíthat egy kezdő karakterláncot benne, tulajdonképpen a stringstream és társai ennek direktben átadják a paramétereket.

str – tárolt karakterlánc visszaadása

    public:
        void str(const string &s);
        string str() const;

A karakterlánc pufferben tárolt karakterláncot adja vissza, illetve állítja be. Tulajdonképpen a stringstream és társai ezt a függvényt hívják, amikor az str metódust hívjuk rajta.

I/O manipulátorok

Ezeket a << illetve a >> operátorokkal lehet adatfolyamokba küldeni, így a kiírási láncba lehet belerakni az egyes formázásokat. Ebben a részben ismertetem őket. Ezek az <iomanip> fejlécben vannak deklarálva.

Példa:

    cout << "Tizenhatos számrendszerben írja ki: " << hex << 234 << endl;
    cout << "Nyolcas számrendszerben írja ki: " << oct << 123 << endl;
    cout << "Tízes számrendszerben írja ki: " << dec << 123 << endl;

A példában a dec, hex, oct és endl is egy I/O manipulátor, az adatfolyamba küldve beállítják a számrendszer, az endl pedig sort emel, és kiüríti a pufferét.

Ezek a manipulátorok tulajdonképpen függvények, de mivel így kell őket használni, ezért nem írom le, hogy hogyan lehetne meghívni őket amúgy. A következőkben (IN/OUT), (IN) és (OUT)-tal jelölöm, hogy kimeneti vagy bemenetiként használható-e az adott manipulátor.

Kapcsoló jelzőbitek

A boolalpha manipulátor (IN/OUT)

Beállítja, hogy a logikai értékeket betűvel írja ki (tehát true és false), alapértelmezésben számmal írja ki. A noboolalpha pedig kikapcsolja ezt.

A showbase manipulátor (IN/OUT)

Bekapcsolja a számrendszer alapjának jelölését. (Nyolcas esetén "0", 16-os esetén "0x"-et ír a szám elé.) Beolvasáskor pedig elvárja, hogy azok ott legyenek. (Alapértelmezésben kikapcsolva). Kikapcsolni a noshowbase-szel lehet.

A showpoint manipulátor (IN/OUT)

Bekapcsolja, hogy kiírja a tizedespontot, hogy ha a szám egész érték. (alapértelmezésben kikapcsolva). Kikapcsolni a noshowpoint-tal lehet.

A showpos manipulátor (IN/OUT)

Bekapcsolja, hogy kiírja a + jelet a pozitív számok elé. A noshowpos kapcsolja ki ezt. Alapértelmezésben kikapcsolva.

A skipws manipulátor (IN/OUT)

Beolvasás elején figyelmen kívül hagyja a szóközöket és a többi whitespace karaktert. Kikapcsolni a noskipws-sel lehet. Alapértelmezésben be van kapcsolva.

Az uppercase manipulátor (IN/OUT)

Nagybetűket használ a kiíráskor, mindenre, ami nem karakterlánc vagy karakter, tehát a hexadecimális számokban a 0x-re és a 10 feletti, betű számjegyekre, illetve a true és false szövegre. Kikapcsolni a nouppercase-szel lehet. Alapértelmezésben kikapcsolva.

Az unitbuf manipulátor (IN/OUT)

Minden egyes művelet után kiüríti illetve, szinkronizálja a puffert, kikapcsolni a nounitbuf-fal lehet. Alapértelmezésben kikapcsolva.

Számrendszert állító jelzőbitek

A dec manipulátor (IN/OUT)

Tízes számrendszerbe kapcsolja a számok kiírását/értelmezését.

A hex manipulátor (IN/OUT)

Tizenhatos számrendszerbe kapcsolja a számok kiírását/értelmezését.

A oct manipulátor (IN/OUT)

Nyolcas számrendszerbe kapcsolja a számok kiírását/értelmezését.

A setbase manipulátor (IN/OUT)
    smanip setbase(int base);

Beállítja a számrendszert számmal, az értékek, amit elfogad: 8, 10, 16. (Nem értem, hogy miért... Elvileg pont az lenne a lényeg, hogy bármilyen számrendszerben tudjon kiírni.)

Igazítással kapcsolatos manipulátorok

A setw manipulátor (OUT)
    smanip setw(int base);

Beállítja a mezőszélességet csak a következő kiíráshoz.

A left manipulátor (OUT)

A megadott mezőben balra igazítja a kimenetet. A jobbra igazítás az alapértelmezett.

A right manipulátor (OUT)

A megadott mezőben jobbra igazítja a kimenetet. A jobbra igazítás az alapértelmezett.

A internal manipulátor (OUT)

A megadott mezőben balra igazítja a prefixumot (előjel, 0x, stb.)és jobbra kimenetet. A jobbra igazítás az alapértelmezett.

A setfill manipulátor (OUT)
    smanip setfill(char c);

Beállítja a kitöltő karaktert, ezt a karaktert fogja kiírni a mezőben üresen maradó helyekre.

Lebegőpontos manipulátorok

A fixed manipulátor (OUT)

Fixpontos módba kapcsolja a lebegőpontos számok kiírását értelmezését. Ekkor tizedestörtként írja ki a dolgokat: (123.3456 => 123.345600) Alapértelmezésben nincs beállítva lebegőpontos jelzőbit (ios_base::unsetf-fel törölhető)

A scientific manipulátor (OUT)

Tudományos módba kapcsolja a lebegőpontos számok kiírását értelmezését. Ekkor normálalakban írja ki a dolgokat: (123.3456 => 1.233456e+02) Alapértelmezésben nincs beállítva lebegőpontos jelzőbit (ios_base::unsetf-fel törölhető)

A setprecision manipulátor (OUT)
    smanip setprecision(int n);

Beállítja a pontosságot, ez alapértelmezett módban a maximális értékes jegyek száma, fixpontos és tudományos módban a tizedestört-jegyek száma.

Karakterlánc manipulátorok

Az endl manipulátor (OUT)

Sort emel, és kiüríti a puffert. Ha nem akarunk kiüríteni egyszerűen írjunk ki egy "\n"-t.

Az ends manipulátor (OUT)

Egy NUL karaktert (nullás byte-ot), szúr az adatfolyamba.

A ws manipulátor (IN)

Beolvasáskor annyi whitespace karaktert hagy ki, amennyit csak tud. Nyilván ennek akkor van értelme, hogy ha a skipws ki van kapcsolva.

Egyéb manipulátorok

A flush manipulátor (OUT)

Kiüríti a kimeneti puffert (azaz, kiírja az eddig ki nem írt dolgokat a fájlba vagy a képernyőre.)

A setiosflags manipulátor (IN/OUT)
    smanip setiosflags(ios_base::fmtflags mask);

Beállít jelzőbiteket. Az ios_base::setf-fel egyenértékű.

A resetiosflags manipulátor (IN/OUT)
    smanip resetiosflags(ios_base::fmtflags mask);

Töröl jelzőbiteket. Az ios_base::unsetf-fel egyenértékű.

Standard sablonkönyvtár adatszerkezetei

Ebben a részben C++ által definiált adatszerkezetekről lesz szó. Ezek kivétel nélkül osztálysablonok, így lehetővé teszik tetszőleges típusú adat tárolását. Minden adatszerkezetnek megvan az előnye és a hátránya.

Bejárók

Az bejáró adattípus (osztály) egy mutatókkal analóg dolog: tehát az adatszerkezet egy elemére mutat, és emellett lehetővé teszi az adatszerkezetben való lépkedést, támogatja az összehasonlító operátorokat is, hogy megállapíthassuk, hogy két bejáró azonos elemre mutat-e. A működésük nagyon hasonlít a mutatókéra: implementálják a * operátort, amellyel az adott elem elérhető. A ++ és a -- operátorral lehet előre és hátra lépegetni. A != és a == operátorokkal lehet összehasonlítást végezni.

Nagyon sok hasonlósága van a mutatókkal.

A következő táblázat foglalja össze az egyes bejáró kategóriák tulajdonságait:

Kategória Jellemző Példa
Mindegyik Másolható X i2(i);
i2 = i;
Léptethető iter++;
++iter;
Tetszőleges elérésű Kétirányú Egyirányú Bemeneti Egyenlőségre tesztelhető a == b
a != b;
Konstans mutatóként viselkedik. *iter
iter->mutatott_struktura_eleme
Kimeneti Normál mutatóként viselkedik az * operátor lvalue-t eredményez. *iter = érték; iter->mutatott_struktura_eleme = érték;
Alapértelmezett konstruktora van. Iterator iter;
Hátrafelé is lehet vele lépni iter--;
--iter;
Támogatja az aritmetikai operátorokat. iter + szam
iter - szam
szam + iter
szam - iter
iter1 + iter2
iter1 - iter2
Támogatja a relációs operátorokat iter < iter2
iter <= iter2
iter > iter2
iter >= iter2
Támogatja a += operátorokat iter += szam
iter -= szam
Támogatja a [] operátort iter[index]

Az adatszerkezetek használata közben gyakran fogunk bejárókkal találkozni. Az bejárók pontos leírásáról később.

A vektor adatszerkezet

A vektor egy dinamikusan növelhető tömb adatszerkezet. Úgy működik, hogy lefoglal egy folytonos területet a memóriában, amely ha megtelt lefoglal egy nagyobbat, és átmásolja oda a tartalmat. Garantálja, hogy az elemei egymást követő helyeken vannak a memóriában. A <vector> fejlécben található.

Megadása

    template <class T, class Allocator = allocator<T> > class vector;

Egyetlen kötelező paramétere az elemtípus, a memóriahely-foglalót (2. argumentum) csak akkor kell megadni, hogy ha nem az alapértelmezettet akarjuk használni.

Műveleteinek időbonyolultsága

Elem törlése
O(n). Mivel az első elem törlésekor az összes felette lévő elemet eggyel visszább kell másolni.
Elem beszúrása
O(n). Mivel ha az első helyre szúrunk be, akkor az összes utána lévő elemet eggyel előrébb kell tolni.
Elem hozzáadása a végén
O(1), amíg nem kell új helyre másolni az egészet.
Elem törlése a végén
O(1), mivel nem kell előbbre másolni az egészet.
Elem elérése index alapján.
O(1), az elem helyét a tömb elejétől mért távolsága adja meg, ez mindig azonos idő alatt számolható.
Keresés
O(n), egy érték megtalálásához végig kell nézni az egész tömböt.

Belső típusok

iterator

Egy közvetlen elérésű bejáró.

const_iterator

Egy tetszőleges elérésű bejáró, viszont rajta keresztül nem módosítható a mutatott elem.

reverse_iterator

Egy tetszőleges elérésű bejáró, csak ezzel visszafelé lehet menni.

const_reverse_iterator

Egy tetszőleges elérésű bejáró, csak ezzel visszafelé lehet lépkedni, és rajta keresztül nem módosítható a mutatott elem.

size_type

Egy előjel nélküli egész szám típus, valószínűleg egy size_t

reference

Referenciatípus az elemekre. Lényegében: 

    typedef T& reference;
const_reference

Konstans referenciatípus az elemekre. Lényegében: 

    typedef const T& reference;
allocator_type

A sablon Allocator paraméterének a típusa.

Konstruktorai

    public:
        explicit vector(const Allocator& = Allocator());

Alapértelmezett konstruktor, létrehoz egy üres tömböt, alapértelmezett beállításokkal. Megadott memóriafoglalóval. Ha nem adunk meg memóriafoglalót, akkor az alapértelmezett konstruktorával létrehoz egyet. 

    public:
        explicit vector(size_type n, const T& value=T(), const Allocator& = Allocator());

Egy n elemű tömböt hoz létre, value elemekkel feltöltve. Ha nem adunk meg értéket, annak alapértelmezett konstruktorát használja, a létrehozáshoz. 

    public:
        template <class InputIterator>
             vector(InputIterator eleje, InputIterator vege, const Allocator& = Allocator());

Bejárók alapján hozza létre a tömböt. A eleje bemeneti bejárót használva lépeget a végig egy adott adatszerkezeten, átemelve belőle az elemeket, amíg a vege bejárót el nem éri. Az bejárók egy félig nyított tartományt határoznak meg. 

    public:
        vector(const vector<T,Allocator>& x);

Ez pedig a másoló konstruktor, amely egy másik vektort teljesen lemásol.

Destruktor

    public:
        ~vector();

Az összes elem destruktorát hívja, majd felszabadítja a tömböt.

Az = operátor

    public:
        vector<T,Allocator>& operator=(const vector<T,Allocator>& x);

Értékadás két vektor között, tulajdonképpen lemásolja az egész tömböt.

begin – bejáró a tömb elejére

    public:
        iterator begin();
        const_iterator begin() const;

Visszatér egy tetszőleges elérésű bejáróval az első elemre.

end – bejáró a tömb végére

    public:
        iterator end();
        const_iterator end() const;

Visszatér egy tetszőleges elérésű bejáróval az utolsó utáni helyre. Mi ez a tömb után mutat, ezért ezen az bejárón nem érhetünk el elemet, arra használatos, hogy lássuk, végigértünk-e a tömbön.

rbegin – fordított bejáró a tömb végére

    public:
        reverse_iterator rbegin();
        const_reverse_iterator rbegin() const;

Visszatér egy tetszőleges elérésű fordított bejáróval az utolsó elemre.

rend – fordított bejáró a tömb első eleme elé

    public:
        reverse_iterator rend();
        const_reverse_iterator rend() const;

Visszatér egy tetszőleges elérésű fordított bejáróval az első előtti helyre. Mi ez a tömb elé mutat, ezért ezen az bejárón nem érhetünk el elemet, arra használatos, hogy lássuk, végigértünk-e a tömbön.

size – tömb elemeinek a száma

    public:
        size_type size() const;

Visszatér a tömb elemeinek a számával.

max_size – elvben lehetséges maximális elemszám

    public:
        size_type max_size() const;

Visszatér a maximális lehetséges elemszámmal, amely . Ez lényegében a size_t típus maximális értéke, osztva a tömb elemtípusának a méretével.

resize – tömb átméretezése

    public:
        void resize(size_type sz, T c = T());

Átméretezi a tömböt. Ha az sz értéke kisebb, mint a jelenlegi méret, akkor eldobja a felső indexű elemeket (destruktorukat hívja). Ha nagyobb, akkor új elemeket hoz létre adott c értékekkel. Az átméretezés művelete érvényteleníti az elemekre mutató bejárókat és mutatókat.

capacity – az lefoglalt elemek száma

    public:
        size_type capacity() const;

Visszatér az lefoglalt elemek számával. (Ez általában több, mint a tömbben lévő elemek száma).

empty – üres-e a tömb?

    public:
        bool empty() const;

Igazzal tér vissza, hogy ha a tömb üres.

reserve – megadott számú elem lefoglalása

    public:
        void reserve(size_type n);

Megváltoztatja a tömb méretét úgy, hogy legalább n elférjen benne. Az átméretezés művelete érvényteleníti az elemekre mutató bejárókat és mutatókat.

[] operátor – elem elérése

    public:
        reference operator[](size_type index);
        const_reference operator[](size_type index) const;

Eléri a megadott indexű elemet. Fontos tudni, hogy semmi indexhatár ellenőrzés nincs, szóval ha rossz helyre indexelsz, a programod elszállhat, akárcsak a hagyományos tömbök esetén.

Természetesen az indexelés, akárcsak a tömböknél 0-tól kezdődik.

at – elem elérése (ellenőrzött)

    public:
        const_reference at(size_type n) const;
        reference at(size_type n);

Ez ugyanazt csinálja, mint a [] operátor, csak ez std::out_of_range kivételt dob.

front – referencia az első elemre

    public:
        reference front();
        const_reference front() const;

Az első elemre mutató referenciát adja vissza. Ha a tömb üres, akkor a referencia érvénytelen lesz. (Tehát használata előtt meg kell győződni egy empty hívással).

back – referencia az utolsó elemre

    public:
        reference back();
        const_reference back() const;

Az utolsó elemre mutató referenciát adja vissza. Ha a tömb üres, akkor a referencia érvénytelen lesz. (Tehát használata előtt meg kell győződni egy empty hívással).

assign – tartalom hozzárendelése a tömbhöz

    public:
        template <class InputIterator>
            void assign ( InputIterator eleje, InputIterator vege );
        void assign ( size_type n, const T& u );

Új tartalmat rendel hozzá a tömbhöz. A működésük lényegében ugyanaz, mint amit a konstruktorainál is említettünk már. A művelet után a korábbi elemekre mutató bejárók és mutatók érvénytelenek lesznek.

push_back – elem hozzáadása a tömb végén

    public:
        void push_back(const T& x);

Elemet ad hozzá a tömb végén. Ha kell át is méretezi nagyobbra, hogy elférjen. (Az egyik leggyakrabban használt metódusa.) Az művelet érvénytelenítheti az elemekre mutató bejárókat és mutatókat, ha átméretezésre kerülne sor.

pop_back – elem elvétele a tömb végéről

    public:
        void pop_back();

Törli az utolsó elemet tömbből, csökkentve a tömb méretét. A törlendő elem destruktorát hívja. Az művelet érvénytelenítheti az elemekre mutató bejárókat és mutatókat, ha átméretezésre kerülne sor.

insert – elem beszúrása

Elemet szúr be a tömbbe a ide bejáró által mutatott elem elé. 

    public:
        iterator insert(iterator ide, const T& x);

Ez a legegyszerűbb változat beszúrja az x értékű elemet a megadott elem elé. 

    public:
        void insert(iterator ide, size_type n, const T& x);

Ez n darab x értékű elemet szúr be a megadott elem elé. 

    public:
        template <class InputIterator>
            void insert(iterator ide, InputIterator eleje, InputIterator vege);

Ez a eleje és a vege bemeneti bejárók által megadott tartományon tárolt értékeket szúrja be a tömbbe (a eleje által mutatottat igen, a vege által mutatottat már nem).

Az művelet érvénytelenítheti az elemekre mutató bejárókat és mutatókat, ha átméretezésre kerülne sor.

erase – elem törlése a tömbből

Elemet töröl a tömbből

    public:
        iterator erase(iterator ezt);

Egy megadott elemre mutató bejáró alapján törli az elemet. Visszatérési érték egy tetszőleges elérésű bejáró ezt bejárót követő elemre. 

    public:
        iterator erase(iterator eleje, iterator vege);

Egy első és egy utolsó félig nyitott tartomány által kijelölt tartományt töröl a tömbből. A függvény visszatérési értéke az vege iterator.

Az művelet érvénytelenítheti az elemekre mutató bejárókat és mutatókat, ha átméretezésre kerülne sor. A törölt elemek bejárói nyilvánvalóan érvénytelenek lesznek.

swap – két vektor tartalmának a cseréje

    void swap(vector<T,Allocator>& vec);

Megcseréli két vektor tartalmát. Az bejárók és mutatók az elemekre érvényesek maradnak.

clear – elemek törlése a vektorból

    public:
        void clear();

Törli az összes elemet a tömbből (destruktoruk hívása után). Minden elemre mutató bejáró érvénytelen lesz.

get_allocator – memóriafoglaló lekérdezése

    public:
        allocator_type get_allocator() const;

Lekérdezi az adatszerkezet memóriafoglalóját.

A deque adatszerkezet

Ez egy két végű sor, melynek az elejére és a végére is lehet gyorsan elemeket tenni. Nagyban hasonlít a vector adatszerkezetre, de ez nem garantálja, hogy az elemek pontosan egymás mellett vannak.

Egy lehetséges implementációja az, amikor egy lefoglalt memória terület elején és a végén is van szabad hely. Az elején beszúrt elemek az eleje felé, a végén beszúrt elemek a vége felé bővítik tömböt, ha valamelyik irányban betelik, akkor mozgatja a területen belül, vagy másik, nagyobb területre másolja át. A <deque> fejlécben található.

Műveleteinek időbonyolultsága

Elem törlése
O(n). Mivel az első elem törlésekor az összes felette lévő elemet eggyel visszább kell másolni.
Elem beszúrása
O(n). Mivel ha a közepére szúrunk be, akkor az összes utána lévő elemet eggyel előrébb kell tolni.
Elem hozzáadása a végén
O(1), amíg nem kell új helyre másolni az egészet.
Elem hozzáadása a elején
O(1), amíg nem kell új helyre másolni az egészet.
Elem törlése az elején
O(1)
Elem törlése a végén
O(1)
Elem elérése index alapján.
O(1), az elem helyét a tömb elejétől mért távolsága adja meg, ez mindig azonos idő alatt számolható.
Keresés
O(n), egy érték megtalálásához végig kell nézni az egész tömböt.

Megadása

A következő sablonként van megadva: 

    template <class T, class Allocator = allocator<T> > class deque;

Működése nagyban hasonló a vector osztályhoz így csak a különbségeket részletezem, minden más helyen a vector osztályra utalok.

Konstruktorai

    public:
        explicit deque(const Allocator& = Allocator());
        explicit deque(size_type n, const T& value= T(), const Allocator& = Allocator());
        template <class InputIterator>
                 deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
        deque(const deque<T,Allocator>& x);

A vektoréval analóg módon működik.

Destruktorai

    public:
        ~deque();

Meghívja minden elem destruktorát, és felszabadítja az adatszerkezetet.

Az = operátor

    public:
        deque<T,Allocator>& operator=(const deque<T,Allocator>& x);

Felülírja egy az adatszerkezet tartalmát egy másikkal. Visszatérési értéke az objektum maga.

Metódusok, amelyek ugyanúgy működnek, mint a vektornál

push_front – elem beszúrása a sor elején

    public:
        void push_front(const T& x);

Az adatszerkezet elejére tesz egy elemet. A művelet miatt esetleg az elemekre mutató bejárók érvénytelenné válhatnak.

pop_front – elem törlése a sor elejéről

    public:
        void pop_front();

Az adatszerkezet elejéről töröl elemet.

A list adatszerkezet

A list osztály egy két irányban láncolt listát valósít meg. Viszont ennek a láncolt listának a hátránya, hogy az elemeihez nem biztosít tetszőleges elérést, mindig az elejétől kell lépkedni, hogy elérjünk egy adott elemet, erre mondjuk megoldás lehet az, hogy a fontos elemekre mutató bejárókat eltároljuk. Az bejárói kétirányúak. A <list> fejlécben található.

Megadása

A következő sablonnal adják meg az osztályt: 

    template < class T, class Allocator = allocator<T> > class list;

Lényegében az összes adatszerkezetet ez a sablon adja meg.

A list műveleteinek időbonyolultsága

Elem beszúrása bárhová:
O(1): mivel csak a szomszédos elemek mutatóit kell állítani.
Elem törlése bárhonnan:
O(1): mivel csak a szomszédos elemek mutatóit kell átírni.
Egy adott értéke keresése:
O(n): mivel végig kell járni az egész listát.
Elem elérése adott helyen:
O(n): mivel az elejétől lépkedni kell.

Konstruktor

    public:
        explicit list ( const Allocator& = Allocator() );
        explicit list ( size_type n, const T& value = T(), const Allocator& = Allocator() );
        template < class InputIterator >
                 list ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
        list ( const list<T,Allocator>& x );

Inicializálják az adatszerkezetet, hasonlóképpen működnek, mint amint a vector-nál említettem.

Destruktor

    public:
        ~list();

Minden elem destruktorát hívja, és felszabadítja őket.

Az = operátor

    public:
        list<T,Allocator>& operator=(const list<T,Allocator>& x);

Felülírja a lista tartalmát egy másik listával. Minden bejáró érvénytelen lesz.

A közös metódusok

A következő metódusok hasonlóképpen működnek mint a korábban említett adatszerkezeteknél. Részletezve a vector és a deque osztályoknál vannak. Ne felejtsük el, hogy a list adatszerkezet bejárói kétirányúak (tehát nem tetszőleges elérésűek):

splice – elemek átmozgatása egy másik listából

Egy másik listából mozgat elemeket az aktuális objektumba. 

    public:
        void splice(iterator ide, list<T,Allocator>& ezt);

A teljes ezt lista elemeit átmozgatja a ide bejáró által mutatott elem elé. 

    public:
        void splice(iterator ide, list<T,Allocator>& ebbol, iterator innen);

Az ebbol lista innen bejáró által mutatott elemét mozgatja át. 

    public:
        void splice(iterator ide, list<T,Allocator>& ebbol, iterator innen, iterator idaig);

Az ebbol lista innen és idaig bejárója által bezárt félig nyílt tartományt mozgatja át.

Az eltávolított (átmozgatott) elemekre mutató bejárók érvénytelenné válnak a művelet után.

remove – megadott értékű elemek törlése a listából

    void remove(const T& ertek);

Eltávolítja a megadott értékű elemeket a listából. Az eltávolított elemekre mutató bejárók érvénytelenné válnak.

remove_if – adott feltételnek eleget tevő elemek törlése a listából

    public:
        template <class Predicate>
            void remove_if(Predicate pred);

Eltávolítja az elemeket a listából, amelyek a megadott feltételnek megfelelnek. A pred általában egy függvénymutató, valami ilyesmi: 

    bool (*pred)(const T &elem);

Szóval egy, a lista elemtípusával egyező, paramétere van és logikai értékkel tér vissza. A metódus minden elemmel meghívja ezt a függvényt, és ha igazzal tér vissza, akkor az adott elemet törli.

Természetesen a generikusság miatt nem muszáj, hogy függvénymutató legyen, lehet egy objektumtípus is, amely felülbírálta a () operátort.

unique – egymás melletti azonos értékű elemek közül 1db meghagyása

    public:
        void unique();
        template <class BinaryPredicate>
            void unique(BinaryPredicate feltetel);

Egymás melletti azonos értékű elemeket távolít el a listából (és 1-et hagy meg csak), emiatt első sorban rendezett listák esetén hasznos. Az első változata egyszerűen az == operátort használva működik. A második változata pedig egy felhasználó által megadott függvény segítségével működik, melynek a formája valami ilyesmi: 

    bool (*feltetel)(const T &p1, const T &p2);

Ennek a függvénynek igazat kell visszaadnia, ha a két értéket egyezőnek tekintjük, akkor az egyiket el kell távolítani a listából.

merge – két rendezett lista összefésülése

    public:
        void merge(list<T,Allocator>& ezt);
        template <class Compare>
            void merge(list<T,Allocator>& ezt, Compare kisebbE);

Egy rendezett listát fésül bele az aktuális listába, ahhoz, hogy működjön, mind az aktuális és az ezt-nek is rendezettnek kell lennie. A művelet után ezt üres lesz, mivel az elemeket átmozgattuk, az elemeire mutató bejárók érvénytelenek lesznek.

Az első metódus az alapértelmezett < összehasonlító operátort használja, a másik pedig egy saját összehasonlító függvény segítségével, melynek a formája valami ilyesmi: 

    bool (*kisebbE)(const T& a, const T& b);

Ennek a függvénynek igazzal kell visszatérnie, ha a<b, különben hamissal.

sort – lista sorba rendezése

    public:
        void sort();
        template <class Compare>
            void sort(Compare kisebbE);

Rendezi a listát. Az első függvény az alap összehasonlító operátort (<) használja, a másik egy saját összehasonlító függvényt (lásd előbb). Az bejárók és elemekre mutató mutatók érvényesek maradnak.

A művelet időbonyolultsága O(n²).

reverse – megfordítja az elemek sorrendjét a listában.

    void reverse();

Megfordítja a listában az elemek sorrendjét. Az bejárók és a mutatók az elemekre érvényesek maradnak. Időbonyolultsága O(n).

A set adatszerkezet

Ez az adatszerkezet egy halmazt valósít meg, melybe gyorsan lehet elemet beszúrni, törölni és keresni, viszont a beszúrt elemek nem módosíthatók. Az elemek mindig rendezetten vannak benne. Egy elem nem szerepelhet benne kétszer. A megvalósítása általában önmagát egyensúlyozó bináris keresőfával, vagy B-fával történik. Bejárói kétirányúak, és konstans bejárók, tehát nem módosítható rajta keresztül az érték. A <set> fejlécben van.

A set műveleteinek időbonyolultsága

Elemek beszúrása:
O(log n)
Elem keresése:
O(log n)
Elem törlése:
O(log n)

Megadása

A következő sablonnal van megadva: 

    template 
    < 
        class Key, 
        class Compare = less<Key>,
        class Allocator = allocator<Key> 
    > class set;

A Key a tárolt elemek típusa. A Compare az elemeket összehasonlító objektum alapértelmezésben a < használata. Az Allocator továbbra is a memóriaterület lefoglalásához használt memóriafoglaló.

Belső típusok

Itt csak azokat sorolom fel, amelyekről korábban még nem volt szó. (Ugyanazok a dolgai ennek megvannak, mint a vector adatszerkezetnek.)

key_type, value_type

A sablonban használt elemtípus, a kettő ugyanaz.

key_compare, value_compare

A sablonban használt Compare paraméter, a kettő ugyanaz.

Konstruktorai

    public:
        explicit set(const Compare& comp = Compare(), const Allocator& = Allocator());
        template <class InputIterator>
            set(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
        set(const set<Key,Compare,Allocator>& x);

A konstruktorai hasonlóak az eddig említett adatszerkezetek konstruktoraihoz. Így különösebb részletezésre nem szorul.

Destruktor

    public:
        ~set();

Hívja az összes elem destruktorát és felszabadítja az elemeket.

Az = operátor

    public:
        set<Key,Compare,Allocator>&
            operator=(const set<Key,Compare,Allocator>& x);

Felülírja az objektumot egy másik halmazzal.

Közös metódusok a többi adatszerkezettel

A következő metódusok ugyanúgy működnek, mint a többi adatszerkezet esetében:

Mivel ez az adatszerkezet rendezett, ezért a begin metódus mindig a legkisebbre, az rbegin pedig a legnagyobb elemre ad bejárót. Az bejárók konstans bejárók, nem módosítható rajtuk keresztül az elem.

insert – elem hozzáadása a halmazhoz

Elemet szúr be a halmazba. 

    public:
        pair<iterator,bool> insert(const value_type& x);

Beszúrja az adott értékű elemet a halmazba. Visszatér egy párral melynek az első eleme egy bejáró a beszúrt új elemre, vagy egy bejáró a már meglévő elemre, a pár második eleme egy logikai érték, ha igaz, akkor új elemet szúrtunk be, ha hamis, akkor már volt egy ilyen elem a halmazban korábban. 

    public:
        iterator insert(iterator ide, const value_type& x);

Beszúrja az elemet egy megadott elemet kiindulásul választva (ide). Természetesen mivel sorba van rendezve a halmaz, ezért nem ott fog kikötni, hanem a helyén. Ha jól választjuk ki az elemet, akkor nagyon gyors beszúrást érhetünk el. A visszatérési érték egy bejáró a beszúrt elemre, vagy a halmazban már meglévő elemre. 

    public:
        template <class InputIterator>
            void insert(InputIterator innen, InputIterator idaig);

A innen és a idaig bejárók által meghatározott félig nyitott tartományból szúr be elemeket a halmazba.

erase – elemek törlése a halmazból

Elemeket töröl a halmazból

    public:
        void erase(iterator ezt);

Törli a megadott bejáró által mutatott elemet. 

    public:
        size_type erase(const key_type& ertek);

Törli a megadott értékű elemeket, és visszatér a törölt elemek számával, amely ezen set típus esetén 1, ha benne volt; 0, ha nem. 

    public:
        void erase(iterator innen, iterator idaig);

Megadott innen és idaig bejáró által megadott félig nyílt tartományt törli a halmazból.

swap – két halmaz elemeinek a megcserélése

    public:
        void swap(set<Key,Compare,Allocator>& ezzel);

Megcseréli az elemeket a másik halmazzal, az bejárók érvényesek maradnak.

key_comp – érték összehasonlító lekérdezése

    public:
        key_compare key_comp() const;

Lekérdezi a objektum Compare típusú összehasonlító objektumát.

A value_comp – érték összehasonlító lekérdezése

    public:
        value_compare value_comp() const;

Lekérdezi a objektum Compare típusú összehasonlító objektumát.

find – adott értékű elem keresése

    public:
        iterator find(const key_type& x) const;

Megkeresi az adott értékű elemet, és visszatér az bejárójával, ha nincs meg, akkor az end metódus által visszaadott bejáróval tér vissza.

count – adott értékű elemek megszámolása

    public:
        size_type count(const key_type& x) const;

Megszámolja az adott értékű elemeket. Ha megvan, akkor 1, különben 0. Nyilván multiset esetén lehet 1-nél nagyobb érték is.

lower_bound – adott értékhez felülről legközelebb álló érték keresése

    public:
        iterator lower_bound(const key_type& x) const;

Visszatér egy bejáróval a legkisebb elemre, melynek értéke nem kisebb, mint x. Ha nincs ilyen, akkor az end bejáróval. A multiset esetén azonos elemek esetén az elsővel tér vissza. A upper_bound metódussal együtt használva azonos értékű elemek tartományát kaphatjuk meg.

upper_bound – adott értékhez felülről legközelebb álló, vele nem egyenlő érték keresése

    public:
        iterator upper_bound(const key_type& x) const;

Visszatér egy bejáróval a legkisebb elemre, melynek értéke épp nagyobb, mint x. Ha nincs ilyen, akkor az end bejáróval. A lower_bound metódussal együtt használva azonos értékű elemek tartományát kaphatjuk meg multiset esetén.

equal_range – azonos értékű elemek tartományának keresése

    public:
        pair<iterator,iterator> equal_range(const key_type& x) const;

Visszatér az azonos értékű elemek tartományával. A visszatérési érték egy pár, melynek első eleme bejárója az elejére mutat; a második elemének az bejárója az utolsó után mutat (félig nyitott tartomány). Ha nincs meg az x a halmazban, akkor a pár két bejárója megegyezik, és egy x közeli értékre mutat. A set esetén ez a tartomány mindig 1 elemű, ha találat van. A multiset esetén hosszabb tartomány is lehet.

A multiset adatszerkezet

Ez teljesen ugyanolyan, mint a set adatszerkezet, csak ez lehetővé teszi, hogy több azonos elemet beletegyünk. Nyilván ezzel kapcsolatban pár metódus leírását is értelemszerűen máshogy kell olvasni, pl.: equal_range, count. A <set> fejlécben van.

Pár különbség azért van a metódusokban is:

A map adatszerkezet

Szintén a set-hez hasonló adatszerkezet, csak ez nem csak értékeket tárol egy halmazban, hanem kulcs-érték párokat. A kulcsok továbbra sem módosíthatók, viszont az értékek igen. A <map> fejlécben található.

Műveleteinek időbonyolultsága

A kulcsokkal kapcsolatos műveletek ugyanolyan gyorsak, mint a set esetében. De ha értékekre akarunk keresni, vagy érték alapján törölni, ahhoz végig kell nyalni az egész adatszerkezetet (O(n)) időben.

Megadása

A következő négy paraméteres sablonnal lehet megadni: 

    public:
        template <class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key,T> > > class map;

Gyakorlatban csak az első két paraméter a fontos: a kulcstípus és az értéktípus.

Belső típusai

Ugyanazok a típusai megvannak, mint a set típusnak, és a többi adatszerkezetnek. Néhány adattípusa viszont más:

key_type
A key sablonparaméter.
mapped_type
A T sablonparaméter.
value_type
Egy pár, lényegében: pair<Key, T>. Fontos, hogy az adatszerkezet bejárói is ilyen párokra mutatnak.

Metódusai

Ugyanazok a metódusai vannak, mint set adatszerkezetnek, csak konkrét értékek helyett párokat lehet beszúrni (ld. value_type). Törölni pedig a kulcs alapján lehet (mivel az erase függvény key_type-t kér).

Viszont egyetlen extra dolog van, amivel ez az adatszerkezet többet tud a set-nél, van [] operátora:

Az [] operátor
    public:
        T& operator[](const key_type& x);

Ez megkeresi az adott értéket a kulcs alapján, és visszatér a rámutató referenciával. Ha nincs meg az elem, akkor létrehozza azt (annak a paraméter nélküli konstruktora alapján), és az újonnan létrehozott elem referenciájával tér vissza, ha megvan, akkor a meglévő elemével.

Ily módon ez az adatszerkezet úgy használható, mint egy tömb.

A multimap adatszerkezet

Ez olyan, mint a map vagy a multiset, csak több azonos kulcsú érték is lehet benne, valamint ennek nincs [] operátora sem, mivel nem lehet egyértelműen azonosítani az értéket a kulcs alapján. Így az elemek (kulcs-érték párok) beszúrásának is az egyetlen módja az insert, elérésüknek, keresésünknek pedig a find vagy az equal_range. Egyébként minden más ugyanúgy van, mint a map-nál. A <map> fejlécben van deklarálva.

A bitset adatszerkezet

Ez egy bitekből álló tömb adatszerkezet. Azaz egy olyan tömb, amely csak logikai értékeket tárol. Viszont nem 1 egész byte-ot pazarol el egy értékre, hanem csak egy bitet, azaz 1 byte-on 8 értéket tárol. Mellesleg a vector<bool> is ilyen elven működik.

Megadása

A következő sablonnal adhatjuk meg, hogy hány elemű bithalmazt akarunk: 

    template <size_t N> class bitset;

Belső típusai

reference
    class bitset::reference 
    {
        friend class bitset;
        reference();           // Nem hozható létre csak úgy.                      
    public:
        ~reference();
        operator bool () const;                      
        reference& operator=(bool x);             
        reference& operator=(const reference& x); 
        reference& flip();                           
        bool operator~() const;                      
    };

Ez egy belső osztály. Mivel nincs adattípus, ami tárolni tudna 1 bitet. Ez úgy viselkedik, mintha 1 bit lenne. Konvertálható bool-lá, átbillenthető a másik bitbe, a flip metódussal, és lekérhető az ellentettje.

Konstruktorai

    public:
        bitset();

Minden bitet 0-ra inicializál. 

    public:
        bitset(unsigned long val);

A megadott egész szám bitjeivel inicializálja a bittömb bitjeit. 

    public:
        template<class charT, class traits, class Allocator>
            explicit bitset
            (
                const basic_string<charT,traits,Allocator>& str,
               typename basic_string<charT,traits,Allocator>::size_type pos = 0,
               typename basic_string<charT,traits,Allocator>::size_type n = basic_string<charT,traits,Allocator>::npos
           );

Egy bináris karakterlánc ('1' -es és '0'-ás karaktereket tartalmazó), alapján inicializálja a tömböt. A második és a harmadik paramétere arról szól, hogy a karakterlánc mely részét kívánjuk felhasználni (kezdet, és onnan számolva a karakterek száma). Alapértelmezésben az egész karakterláncot felhasználja. Ha nem odaillő karaktert talál, akkor invalid_argument kivételt dob.

Operátorai

Tagfüggvényként:

    public:
        bitset<N>& operator&= (const bitset<N>& rhs);
        bitset<N>& operator|= (const bitset<N>& rhs);
        bitset<N>& operator^= (const bitset<N>& rhs);
        bitset<N>& operator<<= (size_t pos);
        bitset<N>& operator>>= (size_t pos);
        bitset<N> operator~() const;
        bitset<N> operator<<(size_t pos) const;
        bitset<N> operator>>(size_t pos) const;
        bool operator== (const bitset<N>& rhs) const;
        bool operator!= (const bitset<N>& rhs) const;

Globális operátorok:

    public:
        template<size_t N>
            bitset<N> operator& (const bitset<N>& lhs, const bitset<N>& rhs);
        template<size_t N>
            bitset<N> operator| (const bitset<N>& lhs, const bitset<N>& rhs);
        template<size_t N>
            bitset<N> operator^ (const bitset<N>& lhs, const bitset<N>& rhs);

Az IOStream-be való íráshoz globális operátorok

    public:
        template<class charT, class traits, size_t N> basic_istream<charT, traits>&
            operator>> (basic_istream<charT,traits>& is, bitset<N>& rhs);
        template<class charT, class traits, size_t N> basic_ostream<charT, traits>&
            operator<< (basic_ostream<charT,traits>& os, bitset<N>& rhs);

Amint látható a bitműveletek ugyanúgy működnek, mint bármely más egész számon. Valamint van lehetőségünk az adatfolyamokba küldeni őket, vagy onnan beolvasni őket.

[] operátor – adott helyen álló bit lekérése

    public:
        bool operator[](size_t pos) const;
        reference operator[](size_t pos);

Lekérdezi az adott pozíción lévő bitet. Nincs ellenőrizve az indexhatár.

set – adott helyen lévő bit 1-re állítása

    public:
        bitset<N>& set();
        bitset<N>& set(size_t pos, bool val = true);

Beállítja a biteket, az első változat minden bitet 1-esre állít, a második változat egy adott helyen lévő bitet állítja be. Visszatérési értéke a egy referencia az objektumra magára.

reset – adott helyen lévő bit 0-ra állítása

    public:
        bitset<N>& reset();
        bitset<N>& reset(size_t pos);

Biteket nulláz, a paraméter nélküli változata, az összes bitet nullázza. A második egy megadott bitet nulláz le.

flip – adott helyen álló bit átfordítása

    public:
        bitset<N>& flip();
        bitset<N>& flip(size_t pos);

Biteket fordít át, a paraméter nélküli változata minden bitet átfordít, a paraméteres egy megadott helyen lévő bitet.

to_unlong – unsigned longgá való átalakítás

    public:
        unsigned long to_ulong() const;

A bitekből összeállítható unsigned long értékkel tér vissza.

to_string – karakterlánccá alakítás

    public:
        template <class charT, class traits, class Allocator>
            basic_string<charT,traits,Allocator> to_string() const;

Egyesekből és nullákból álló karakterlánccá alakítja a biteket.

count – egyesen álló bitek számának a lekérése

    public:
        size_t count();

Visszatér az egyesen álló bitek számával.

size – bitek száma (tulajdonképpen az N sablonparaméter)

    public:
        size_t size() const;

Visszatér a bitek számával a halmazban. Ez tulajdonképpen az N sablonparaméter.

test – 1-es-e a megadott helyen álló bit?

    public:
        bool test(size_t pos) const;

Megadott helyen pozíción lévő bit értékét kérdezi le. Végez indexhatár ellenőrzést is. Ha nincs kívül esik az index, akkor out_of_range kivételt dob.

any – van-e egyes bit beállítva

    public:
        bool any() const;

Igazzal tér vissza legalább 1 bit be van állítva 1-re.

none – minden bit nulla?

    public:
        bool none() const;

Igazzal tér vissza, ha minden bit 0.

Adatszerkezet adapterek

Ezek nem adatszerkezetek, hanem valamilyen adatszerkezetet tárolnak, hogy aztán veremként, sorként vagy fontossági sorként használjuk őket. Ebben a részben ismertetem ezeket.

A stack adapter

Ez egy vermet valósít meg, tehát amit utoljára betettünk azt vesszük ki először.

Megadása
    public:
        template <class T, class Container = deque<T> > class stack;

Alapértelmezett adatszerkezet, amit ez használ a deque, bármilyen adatszerkezet megteszi, amelynek van size, back, push_back és pop_back metódusa.

Belső típusai
size_type

Egy pozitív egész típus, valószínűleg size_t

value_type

A T sablon paraméter.

Konstruktora
    public:
        explicit stack(const Container& ctnr = Container());

Inicializálja a vermet egy adott adatszerkezettel, vagy üresen.

empty – üres-e?
    public:
        bool empty() const;

Igazzal tér vissza, ha a verem üres.

size – mennyi elem van benne?
    public:
        size_type size() const;

Visszatér a veremben lévő elemek számával.

top – legfelső elem lekérése
    public:
        value_type& top();
        const value_type& top() const;

Visszatér egy referenciával a verem tetején lévő elemre. Ha üres a verem, akkor egy érvénytelen referenciával tér vissza, ezért érdemes megnézni, hogy a verem üres-e.

push – elem behelyezése
    public:
        void push(const T& x);

Betesz egy elemet a verembe.

pop – elem kivétele
    public:
        void pop();

Leveszi a verem tetején lévő elemet. Üres verem esetén hívva nincs specifikálva, hogy mi fog történni, (szóval ellenőrizzünk hogy üres-e.)

A queue adapter

Ez egy sor adatszerkezetet valósít meg, azaz, az vehetjük ki először, ami először betettünk.

Megadása
    template < class T, class Container = deque<T> > class queue;

Hasonlóképpen van megadva, mint a stack esetében. Bármilyen adatszerkezet megfelel, amelynek van size, front, back, push_back és push_front metódusa.

Konstruktor
    public:
        explicit queue(const Container& ctnr = Container());

Inicializálja az adapter egy üres adatszerkezettel vagy a paraméterként megadottal.

Közös metódusok

Ezek ugyanúgy működnek, mint a stack esetében:

front – elején lévő elem lekérése
    public:
        value_type& front();
        const value_type& front() const;

Visszatér a soron következő elemre mutató referenciával. Üres sor esetén érvénytelen lesz a referencia.

back – végén lévő elem lekérése
    public:
        value_type& back();
        const value_type& back() const;

Visszatér a legutóbb berakott elemre mutató referenciával. Üres sor esetén érvénytelen lesz a referencia.

push – elem berakása a sor végén
    public:
        void push(const T& x);

Elemet tesz a sorba.

pop – elem levétele a sor elejéről
    public:
        void pop();

Kiveszi a legrégebben berakott elemet.

A priority_queue adapter

Ez egy fontossági sorrend adapter, azaz egy olyan sor, ahol mindig a legmagasabb értékű elem van az elején.

Megadása
    template < class T, class Container = vector<T>, class Compare = less<typename Container::value_type> > class priority_queue;

Alapértelmezésben szüksége van egy elemtípusra, de megadható, hogy milyen adatszerkezetet használjon, illetve, hogy milyen módon hasonlítsa össze a dolgokat. Bármilyen adatszerkezet megteszi, amelynek van front, push_back, pop_back és size metódusa, valamint az bejárói tetszőleges elérésűek.

Konstruktorai
    public:
        explicit priority_queue ( const Compare& x = Compare(), const Container& y = Container() );

Inicializálja az adaptert, és a benne lévő adatszerkezetet, és összehasonlítót. 

    public:
        template <class InputIterator> priority_queue 
        (
            InputIterator first, 
            InputIterator last, 
            const Compare& x = Compare(), const Container& y = Container()
        );

Inicializálja az adaptert, két bejáró által meghatározott félig nyílt tartomány alapján.

Közös metódusok a többi adapterrel

Ezekkel lehet megnézni, hogy hány elem van benne, és hogy üres-e.

top – a sor elején álló (legnagyobb) elem.
    public:
        const value_type& top() const;

Lekérdezi a sor elején álló (legnagyobb) elemet. Mivel konstans referenciával tér vissza, így az az elem nem módosítható.

pop – a sor elején álló elem levétele
    public:
        void pop();

Kiveszi a legnagyobb értékű elemet.

push – elem behelyezése a fontossági sorba
    public:
        void push(const T& x);

Beleteszi az elemet a fontossági sorba (átrendezve azt).

A karakterlánc függvénytár

Ez a függvénytár, amint a nevéből is látszik karakterláncok kezelésére való.

A string osztály tagjai

Ez az osztály egy karakterláncot reprezentál. Nagyban hasonlít a korábban bemutatott STL tároló osztályokra elsősorban a vector osztályra. Bejárói tetszőleges hozzáférésűek. Az osztály a <string> fejlécben van.

Konstruktorai

    public:
        string();

Egy üres karakterláncot inicializál. 

    public:
        string(const string& ebbol);

Másoló konstruktor. 

    public:
        string(const string& ebbol, size_t innen, size_t ennyit = npos);

Inicializálja az objektumot egy másik karakterláncból kivágott darabbal. A innen az első karakter, ahol kezdődik, majd onnét számolva legfeljebb ennyit darab karaktert vesz. Ha karakterlánc vége hamarabb jön, akkor kevesebbet. (Az npos egy konstans, mely egy nagy számot jelent, így alapértelmezés az, hogy a megadott pozíciótól a karakterlánc végéig számító darabot vágja ki.) 

    public:
        string(const char *s, size_t n);

Karaktertömb első n eleme alapján inicializálja az objektumot. 

    public:
        string(const char *s);

C karakterlánc (nullás byte-tal lezárt karakterlánc) alapján inicializálja az objektumot. 

    public:
        string(size_t n, char c);

A karakterláncot n db c karakterből álló szöveggel inicializálja. 

    template<class InputIterator> string(InputIterator begin, InputIterator end);

Két bejáró alapján meghatározott félig nyitott tartomány alapján inicializálja a karakterláncot.

= operátor

    public:
        string& operator=(const string& str);
        string& operator=(const char* s);
        string& operator=(char c);

Az értékadó operátornak különféle változatai létetnek. Ennek az objektumnak adhatunk értéket, másik karakterláncból, hagyományos C karakterláncból, illetve beállíthatjuk, hogy egyetlen egy karaktert tartalmazzon.

Tárolóosztályokkal közös metódusok

A következő metódusok úgy működnek, mint az STL tárolóosztályok esetében:

length – karakterlánc hossza.

    public:
        size_t length() const;

Ugyanaz, mint a size metódus, visszatér a karakterlánc hosszával.

+= operátor – hozzáfűzés a karakterlánchoz

    public:
        string& operator+=(const string& str);
        string& operator+=(const char* s);
        string& operator+=(char c);

Karakterláncot fűz hozzá az objektumhoz, értelemszerűen hozzá tud fűzni egy karaktert, C karakterláncot és egy másik string objektum tartalmát.

append – hozzáfűzés a karakterlánchoz

Hozzáfűz az aktuális karakterlánchoz. 

    public:
        string& append(const string& str);

Egy másik karakterlánc tartalmát fűzi hozzá. 

    public:
        string& append(const string& str, size_t innen, size_t ennyit);

A megadott karakterlánc egy részét fűzi hozzá (innen-től kezdve, ennyit darab karaktert max). Ha a innen a karakterláncon kívül van, akkor out_of_range kivételt dob. 

    public:
        string& append(const char* s, size_t n);

Megadott C karakterlánc első n karakterét fűzi hozzá. 

    public:
        string& append(const char* s);

Megadott teljes C karakterláncot fűzi hozzá (C karakterláncok egy nullás byte-tal vannak lezárva.) 

    public:
        template <class InputIterator>
            string& append(InputIterator first, InputIterator last);

Adott bejárók által meghatározott félig nyitott tartományban lévő karaktereket fűzi hozzá.

A függvények visszatérési értéke a karakterlánc maga.

assign – értékadás

Lecseréli a karakterlánc korábbi értékét egy újjal. Tulajdonképpen egy az = operátor metódusos változata. 

    public:
        string& assign(const string& str);

Egy másik karakterlánccal cseréli le a tartalmat. 

    public:
        string& assign(const string& str, size_t innen, size_t ennyit);

Egy másik karakterlánc részével cseréli le a részkarakterlánc innen pozícióban kezdődik, és onnan számítva legfeljebb ennyit karaktert vesz át. 

    public:
        string& assign(const char* s, size_t n);

Megadott C string első n karakterével cseréli le. 

    public:
        string& assign(const char* s);

Megadott C karakterlánccal értékével cseréli le a tartalmat. 

    public:
        string& assign(size_t n, char c);

n darab c karakterrel cseréli le a tartalmat. 

    public:
        template <class InputIterator>
            string& assign(InputIterator first, InputIterator last);

Adott bejárók által meghatározott félig nyitott tartomány alapján cseréli le a tartalmat.

A függvények visszatérési értéke a karakterlánc maga.

insert – karakterlánc beszúrása az aktuális objektumba

    public:
        string& insert(size_t pos, const string& str); //Egész karakterláncot
        string& insert(size_t pos, const string& str, size_t start, size_t n); //Rész karakterláncot
        string& insert(size_t pos, const char* s, size_t n); //C karakterlánc elejét
        string& insert(size_t pos, const char* s); //C karakterláncot
        string& insert(size_t pos, size_t n, char c);  //n darab c karaktert
        iterator insert(iterator p, char c); //Egyetlen karaktert
        void insert(iterator p, size_t n, char c);  //n darab c karaktert
        template<class InputIterator>
            void insert(iterator p, InputIterator first, InputIterator last);  //Félig nyitott tartomány által meghatározott karakterláncot.

Karakterláncot szúr be az aktuális objektumba, adott helyen lévő karakter elé. Ezt a helyet megadhatjuk pozícióval vagy bejáróval. Nem részletezem ismét, hogy a különféle overloadok paramétereit hogyan kell értelmezni, megtettem már az előző két függvényben.

A visszatérési érték az objektum maga, vagy egy bejáró a beszúrási pozícióra.

erase – részkarakterlánc törlése

Töröl a karakterláncból. 

    public:
        string& erase(size_t pos = 0, size_t n = npos);

Adott pozíciótól kezdve n karaktert töröl a karakterláncból. Alapértelmezésben a nullázza.

    public:
        iterator erase(iterator position);

Egyetlen karaktert töröl az bejárónál

    public:
        iterator erase(iterator first, iterator last);

Bejárók által meghatározott félig nyitott tartományt töröl a karakterláncból.

replace – a karakterlánc egy részét vagy egészét cseréli le 

    public:
        string& replace(size_t pos1, size_t n1,   const string& str); //egész karakterlánc objektum tartalmával
        string& replace(iterator i1, iterator i2, const string& str);

        string& replace(size_t pos1, size_t n1, const string& str, size_t pos2, size_t n2); //rész karakterlánccal

        string& replace(size_t pos1, size_t n1,   const char* s, size_t n2); //C karakterlánc elejével
        string& replace(iterator i1, iterator i2, const char* s, size_t n2);

        string& replace(size_t pos1, size_t n1,   const char* s); //Egész C karakterlánccal
        string& replace(iterator i1, iterator i2, const char* s);

        string& replace(size_t pos1, size_t n1,   size_t n2, char c); //ismétlődő karaktersorozattal
        string& replace(iterator i1, iterator i2, size_t n2, char c);

        template<class InputIterator>
           string& replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2); //félig nyitott tartománnyal.

Karakterlánc egy részét cseréli le egy másikkal. A lecserélendő rész megadható kezdő pozícióval post1 és hosszal n1 vagy bejárókkal megadott félig nyílt tartományokkal (i1 és i2). A helyére beszúrandó karakterláncot pedig a korábban említett sokféle módon lehet megadni.

c_str – C karakterlánc kinyerése

    public:
        const char* c_str() const;

Visszatér a C karakterlánc tartalmával a C++ karakterláncnak. A mutató a következő módosító karakterlánc műveletig vagy az objektum megsemmisüléséig érvényes.

data – tárolt bináris adattal való visszatérés

    public:
        const char* data() const;

Visszatér a karakterláncban tárolt adattal, a c_str-rel ellentétben ez nem tesz a karakterlánc végére 0-ás byte-ot, így az adat nem használható C karakterláncként.

copy – C tömbbe való másolás karakterláncból

    public:
        size_t copy(char* s, size_t n, size_t pos = 0) const;

Kimásol legfeljebb n darab karaktert a pos helyről kezdve az s által mutatott helyre. Visszatérési értéke a másolt karakterek száma, mely lehet n vagy kevesebb, ha kevesebb karakter volt a karakterlánc végéig.

find – keresés karakterláncban

    public:
        size_t find(const string& str, size_t pos = 0) const;
        size_t find(const char* s, size_t pos, size_t n) const;
        size_t find(const char* s, size_t pos = 0) const;
        size_t find(char c, size_t pos = 0) const;

Megkeresi a megadott karakterlánc első előfordulási helyét, adott pozíciótól, az aktuális objektumban. A keresés a pos pozíciótól kezdődik. A keresendő karakterláncot sokféleképpen lehet megadni. Lehet egy másik karakterlánc objektum (str), egy C karakterlánc (s), vagy annak az első n karaktere. De lehet egyetlen egy karakter is, amit keresünk (c). A megvan a keresendő karakterlánc, akkor visszatér azzal a pozícióval, ahol kezdődik, különben npos konstans értékével (ami egy nagy szám).

rfind – keresés a karakterlánc végétől visszafelé

    public:
        size_t rfind(const string& str, size_t pos = npos) const;
        size_t rfind(const char* s, size_t pos, size_t n) const;
        size_t rfind(const char* s, size_t pos = npos) const;
        size_t rfind(char c, size_t pos = npos) const;

Ugyanaz, mint a find csak ez visszafelé keres, tehát a megadott pozíciótól visszafelé számolva az utolsó találatot keresi meg.

find_first_of – adott karakterlánc karaktereinek a keresése

    public:
        size_t find_first_of(const string& str, size_t pos = 0) const;
        size_t find_first_of(const char* s, size_t pos, size_t n) const;
        size_t find_first_of(const char* s, size_t pos = 0) const;
        size_t find_first_of(char c, size_t pos = 0) const;

Adott karakterlánc bármely karakterének első előfordulását keresti az aktuális objektumban, pos pozíciótól kezdve. Visszatér a hellyel ahol az első karaktert megtalálta, különben az npos értékével tér vissza. A paraméterek értelmezését a find metódusnál írtam le.

find_last_of – adott karakterlánc karaktereinek a keresése visszafelé

    public:
        size_t find_last_of(const string& str, size_t pos = npos) const;
        size_t find_last_of(const char* s, size_t pos, size_t n) const;
        size_t find_last_of(const char* s, size_t pos = npos) const;
        size_t find_last_of(char c, size_t pos = npos) const;

Ugyanaz, mint a find_first_of csak ez az adott pozíciótól visszafelé keres.

find_first_not_of – adott karakterlánc karaktereitől különböző karakterek keresése

    public:
        size_t find_first_not_of(const string& str, size_t pos = 0) const;
        size_t find_first_not_of(const char* s, size_t pos, size_t n) const;
        size_t find_first_not_of(const char* s, size_t pos = 0) const;
        size_t find_first_not_of(char c, size_t pos = 0) const;

A find_first_of logikai ellentéte: visszatér az első pozícióval, melyen lévő karakter nem egyezik meg a karakterláncban lévőkkel.

find_last_not_of – adott karakterlánc karaktereitől különböző karakterek keresése hátulról

    public:
        size_t find_last_not_of(const string& str, size_t pos = npos) const;
        size_t find_last_not_of(const char* s, size_t pos, size_t n) const;
        size_t find_last_not_of(const char* s, size_t pos = npos) const;
        size_t find_last_not_of(char c, size_t pos = npos) const;

A find_last_of logikai ellentéte: visszatér az első pozícióval, melyen lévő karakter nem egyezik meg a karakterláncban lévőkkel.

substr – részkarakterlánc képzése

    public:
        string substr(size_t pos = 0, size_t n = npos) const;

A karakterlánc egy részéből képez egy új karakterláncot, a rész a pos helyen kezdődik, legfeljebb n karakterből áll (vagy kevesebből, ha karakterlánc vége előbb jön). Ha a pos a karakterláncon kívülre mutat, akkor out_of_range kivételt dob.

compare – két karakterlánc összehasonlítása

    public:
        int compare(const string& str) const;
        int compare(const char* s) const;
        int compare(size_t pos1, size_t n1, const string& str) const;
        int compare(size_t pos1, size_t n1, const char* s) const;
        int compare(size_t pos1, size_t n1, const string& str, size_t pos2, size_t n2) const;
        int compare(size_t pos1, size_t n1, const char* s, size_t n2) const

Összehasonlítja az aktuális objektum karakterláncot (vagy annak részét) egy másik karakterlánccal. Az első kettő egy másik karakterlánc objektummal vagy C karakterlánccal hasonlítja össze az objektumot. A többi a pos1 és n1 által kijelölt részkarakterláncot hasonlítja össze a megadott másik karakterlánc objektummal vagy annak pos2 és n2 által kijelölt részével, vagy egy C karakterlánccal, vagy annak első n2 karakterével. Ha pos1 vagy pos2 az adott karakterláncok kívül mutat, a metódus out_of_range kivételt dob.

Visszatérési értéke 0, ha az összehasonlított karaktersorozatok megegyeznek; negatív érték, ha az aktuális objektumban lévő karaktersorozat a betűrendben előbb van; pozitív értéket, hogy ha hátrébb.

A char_traits sablon

Ez egy sablon, mellyel karakterjellemzőket lehet megadni. Ezt a string és más osztályok használhatják a műveleteikhez. Sablonspecializációval készíthetünk saját karakterjellemzőt bármilyen típushoz.

Megadása

A következő sablon adja meg: 

    template <class charT> struct char_traits;

Előredefiniált specializációi

A char és wchar_t típusra alapból létezik specializáció, ezeket használja sok objektum: 

    template <> struct char_traits<char>
    template <> struct char_traits<wchar_t>

Belső típusai

char_type

Ez a CharT sablonparaméter. A két specializációban egy char, illetve wchar_t.

int_type

Egy olyan típus, melynek értékkészlete tartalmazza a teljes char_type értékkészletét és még az EOF karaktert. A két specializációban ez int, illetve wint_t.

off_type

Az eltolás adattípus, olyan mint a streamoff az iostream típus esetén. A két specializáció esetén ez a streamoff.

pos_type

Pozíció adattípus, olyan mint a streampos az iostream típus esetén. A két specializáció esetén ez a típus a streampos.

state_type

Egy állapot típus, karakter konverzió állapotához. A két specializáció esetén mbstate_t.

Szükséges metódusok

A következő részben sorolom fel, hogy egy char_traits specializációnak milyen metódusokat kell tartalmaznia.

assign – értékadás
    static void assign(char_type& c1, char_type& c2);

Értékadás művelete: c1=c2.

eq – egyenlőség
    static bool eq(const char_type& c1, const char_type& c2);

Egyenlőség művelete: c1 == c2

lt – kisebb-e
    static bool lt(const char_type& c1, const char_type& c2);

Összehasonlítás művelete: c1 < c2

compare – karakterlánc-összehasonlítás
    static int compare(const char_type* s1, const char_type* s2, size_t n);

karakterlánc-összehasonlítás, az strncmp-vel analóg.

length – karakterlánchossz
    static size_t length(const char_type* s);

Karakterlánchossz, az strlen függvénnyel analóg.

find – karakterkeresés karakterláncban
    static const char_type* find(const char_type* s, size_t n, const char_type& a);

Az a karakter keresése az s karakterlánc első n karakterében. Visszatérési érték egy mutató az első találat helyére.

move – részkarakterlánc mozgatása
    static char_type* move(char_type* s1, const char_type* s2, size_t n);

n karakter mozgatása s2 helyről s1 helyre. A memmove függvénnyel analóg.

copy – részkarakterlánc másolása
    static char_type* copy(char_type* s1, const char_type* s2, size_t n);

n karakter másolása s2 helyről s1 helyre. A memcpy függvénnyel analóg.

assign – tömb feltöltése adott karakterrel
    static char_type* assign(char_type* s, size_t n, char_type a);

s által mutatott területre, n darab a karakter másolása. Visszatérési értéke s. A memset függvénnyel analóg.

eof – a fájlvég jel értéke
    static int_type eof();

A fájlvég jelnek használt érték. A két specializáció esetén EOF (valami negatív szám).

not_eof – fájlvég-e a karakter
    static int_type not_eof(const int_type& c);

Visszatér c-vel, ha az nem az eof, különben valami más nem-eof értékkel.

to_char_type – egészből karakterré konvertál
    static char_type to_char_type(const int_type& c);

char_type-pá konvertálja, ha megadott int_type értéket, ha lehet. Ha nem lehet, akkor a visszatérési érték nincs specifikálva (azaz bármi lehet).

to_int_type – karakterből intté konvertál
    static int_type to_int_type(const char_type& c);

int_type-pá konvertálja a megadott char_type-ot.

eq_int_type – két egész számot hasonlít össze
    static bool eq_int_type(const int_type& c1, const int_type& c2);

Igazzal tér vissza, hogy ha c1 és c2 értékét megkaphatjuk a to_int_type függvény értékeként, és ha mindkettő értéke az eof() függvény által visszaadott érték, különben hamissal.

Globális operátorok és függvények

A függvénytár definiál globális függvényeket és operátorokat a karakterláncokhoz

A + operátor – karakterláncok összefűzése

    string operator+(const string& lhs, const string& rhs);
    string operator+(const char* lhs, const string& rhs);
    string operator+(char lhs, const string& rhs);
    string operator+(const string& lhs, const char* rhs);
    string operator+(const string& lhs, char rhs);

Ezzel lehet string objektumokat összeadni, illetve hozzájuk adni C karakterláncot vagy karakter. Az eredmény a kettő összefűzöttje lesz.

Összehasonlító operátorok

    bool operator==(const string& lhs, const string& rhs);
    bool operator==(const char* lhs, const string& rhs);
    bool operator==(const string& lhs, const char* rhs);

    bool operator!=(const string& lhs, const string& rhs);
    bool operator!=(const char* lhs, const string& rhs);
    bool operator!=(const string& lhs, const char* rhs);

    bool operator<(const string& lhs, const string& rhs);
    bool operator<(const char* lhs, const string& rhs);
    bool operator<(const string& lhs, const char* rhs);

    bool operator>(const string& lhs, const string& rhs);
    bool operator>(const char* lhs, const string& rhs);
    bool operator>(const string& lhs, const char* rhs);

    bool operator<=(const string& lhs, const string& rhs);
    bool operator<=(const char* lhs, const string& rhs);
    bool operator<=(const string& lhs, const char* rhs);

    bool operator>=(const string& lhs, const string& rhs);
    bool operator>=(const char* lhs, const string& rhs);
    bool operator>=(const string& lhs, const char* rhs);

Ezek az összehasonlító operátorok betűrendi összehasonlítást végeznek (az angol ábécé, illetve az ASCII kódtábla szerint).

A << és >> operátor – karakterlánc objektumok adatfolyamba íratása

    ostream& operator<<(ostream& os, const string& str);
    istream& operator>>(istream& is, string& str);

Ezeket az operátorok azért vannak, hogy a karakterláncot be lehessen szúrni adatfolyamokba vagy beolvasni onnan.

swap függvény – két karakterlánc tartalmának felcserélése

    void swap(string& lhs, string& rhs);

Felcseréli a két karakterlánc tartalmát.

getline függvény – getline metódus karakterlánc beolvasására adatfolyamból

    istream& getline(istream& is, string& str, char delim);
    istream& getline(istream& is, string& str);

Adott input adatfolyamból (is) beolvas egy sort és eltárolja az str karakterláncba. Az alapértelmezett elválasztó a '\n' karakter, de ha megadjuk a delim paramétert, akkor más is lehet. Az elválasztó is be lesz olvasva, de nem lesz része a karakterláncnak.

Algoritmus függvénytár

Ebben a részben az STL algoritmusairól lesz szó, ezek függvénysablonok. Melyek paraméterezhetők mindenféle függvénnyel. Általában adatszerkezeteken, bejárókkal, félig nyílt tartományokon működnek. Az egyszerűbbeket a rövid kódjukkal együtt közlöm az összetettekről csak leírást adok.

Sablonparaméterek

Ezek az algoritmus függvények csupán függvény sablonok, a paramétereik a következő típusokat jelentik:

InputIterator
Egy bemeneti bejáró
OutputIterator
Egy kimeneti bejáró
BidirectionalIterator
Egy kétirányú bejáró típus
ForwardIterator
Egyirányú bejáró típus
RandomAccessIterator
Egy közvetlen elérésű bejáró.
UnaryOperator
Egy függvénymutató-típus, lényegében valami ilyesmi: OutputIterator::value_type (*UnaryOperator)(const InputIterator::reference x). Az bejáró típusok általában adottak sablonparaméterként. Nem muszáj, hogy függvénytípus legyen, lehet objektum is, amely az () operátort írja felül.
BinaryOperator
Egy függvénymutató-típus, lényegében valami ilyesmi: OutputIterator::value_type (*BinaryOperator)(const InputIterator1::reference x, const InputIterator::reference y). Az bejáró típusok általában adottak sablonparaméterként. Nem muszáj, hogy függvénytípus legyen, lehet objektum is, amely az () operátort írja felül.
Predicate
Egy függvénymutató-típus, lényegében a következő: bool (*Predicate)(const InputIterator::reference x). Ennek a függvénynek igazat kell visszaadnia, hogy ha a paramétere valamilyen tulajdonságokkal rendelkezik. Természetesen lehet objektum is, amely egy felülbírált () operátorral rendelkezik.
BinaryPredicate
Egy függvénymutató-típus, lényegében a következő: bool (*BinaryPredicate)(const InputIterator1::reference a, const InputInterator2::reference b). Ennek a függvénynek igazat kell visszaadnia, hogy ha a két paramétere egyenlőnek tekintendő. Természetesen lehet objektumtípus is, amely egy felülbírált () operátorral rendelkezik.
RandomNumberGenerator
Véletlenszám-generátor függvény, lényegében a következő: iterator_traits<RandomAccessIterator>::difference_type (*RandomNumberGenerator)(iterator_traits<RandomAccessIterator>::difference_type dt); Ez a függvény 0 és megadott dt között generál véletlen számot. Természetesen lehet objektumtípus is, amely egy felülbírált () operátorral rendelkezik.
Generator
Egy tetszőleges paraméter nélküli függvény, amely a művelethez megfelelő típusú értékkel tér vissza. Természetesen lehet objektumtípus is, amely egy felülbírált () operátorral rendelkezik.
Compare
Komparátor függvény, lényegében a következő: bool (*Compare)(iterator_traits<RandomAccessIterator>::difference_type p1, iterator_traits<RandomAccessIterator>::difference_type p2);. Igazat ad, ha az első argumentuma kisebb, mint a második, különben hamisat.

Nem módosító algoritmusok

Ezek az algoritmusok nem módosítják az adatszerkezetet, amelyen elindítottuk őket.

for_each – adott lista minden elemén elvégzi a megadott műveletet

    template<class InputIterator, class Function>
        Function for_each(InputIterator eleje, InputIterator vege, Function f)
        {
            for (; eleje!=vege; ++eleje) 
            {
                f(*eleje);
            }
            return f;
        }

Végigmegy a két bejáró által meghatározott félig nyílt tartományban, és minden elemre meghívja az f függvényt, visszatérési értéke az f függvény. Az f függvény egy egyparaméteres függvény, amely az bejáró által mutatott típusú adatra mutat.

O(n) időbonyolultságú.

find – érték keresése

    template<class InputIterator, class T>
        InputIterator find(InputIterator eleje, InputIterator vege, const T& ertek)
        {
            for (; eleje!=vege; eleje++) 
            {
                if (*eleje==ertek) break;
            }
            return eleje;
        }

Az bejárók által meghatározott félig nyílt tartományban megkeresi a megadott értéket. Ha megtalálta, akkor visszatér az bejáróval rá, ha nem, akkor a vege bejáróval tér vissza.

O(n) időbonyolultságú.

find_if – keresés feltétel alapján

    template<class InputIterator, class Predicate>
        InputIterator find_if(InputIterator eleje, InputIterator vege, Predicate feltetel)
        {
            for (; eleje!=vege; eleje++) 
            {
                if (feltetel(*eleje)) break;
            }
            return eleje;
        }

Megkeresi a megadott tulajdonságú elemet az bejárók által meghatározott tartományban. A feltetel olyan függvény, amely bool értékkel tér vissza, és az bejárók által mutatott típusú adatot fogad el paraméterként. A függvény találat esetén visszatér a találatra mutató bejáróval, különben a vege paraméter értékével tér vissza.

O(n) időbonyolultságú.

find_end – egyik lista utolsó előfordulásának megkeresése a másikban

    template <class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 find_end
        (
            ForwardIterator1 eleje1, ForwardIterator1 vege1,
            ForwardIterator2 eleje2, ForwardIterator2 vege2
        );

    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
        ForwardIterator1 find_end
        (
            ForwardIterator1 eleje1, ForwardIterator1 vege1,
            ForwardIterator2 eleje2, ForwardIterator2 vege2,
            BinaryPredicate feltetel
        );

Megkeresi a eleje1 és vege1 által meghatározott félig nyilt tartományban megkeresi a eleje2 és vege2 félig nyílt tartomány elemeit (ebben a sorrendben). Visszatér az bejáróval az utolsó előfordulásának a kezdetére, ha nincs meg, akkor a last1 bejáróval tér vissza.

Pl.: [1 2 3 4 1 2 3 1 2 3 4 5] tartományban az [1 2 3] keresésekor az bejáró 8. elemre mutat.

A feltetel egy függvény, mely bool értékkel tér vissza, két paramétere van, típusuk az egyik és másik bejáró által mutatott dolog típusa. Visszatérési értéke igaz, ha a kettő érték egyezőnek tekinthető. A 3. paraméter nélküli változatnál egyszerűen az == operátort használja.

O(mn) időbonyolultságú.

find_first_of – adott elemek közül az első megkeresése a listában

    template <class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 find_first_of
    (
        ForwardIterator1 eleje1, ForwardIterator1 vege1,
        ForwardIterator2 eleje2, ForwardIterator2 vege2
    );

    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
        ForwardIterator1 find_first_of
        (
            ForwardIterator1 eleje1, ForwardIterator1 vege1,
            ForwardIterator2 eleje2, ForwardIterator2 vege2,
            BinaryPredicate feltetel
        );

A eleje1 és vege1 kijelöl egy félig nyitott tartományt, melyben keresünk. A eleje2 és a vege2 bejárókkal jelölt félig nyílt tartomány egy halmazt határoz meg, melynek elemeit megkeressük az előbbiben. A függvény visszatér egy bejáróval az első elemre a tartományban, amely benne van a megadott halmazban. Ha nincs ilyen elem, akkor a vege1 bejáróval tér vissza.

A feltetel itt is egy függvény, amely bool típusú értéket ad vissza, amely igaz, ha a két paraméterében megadott érték egyezőnek tekintendő, a paraméterek típusa az bejárók típusának megfelelő típus. A predikátum nélküli változatok esetén == operátort használja.

O(n) időbonyolultságú.

adjacent_find – azonos értékű elemek megkeresése

    template <class ForwardIterator>
        ForwardIterator adjacent_find
        (
            ForwardIterator eleje, ForwardIterator vege
        );

    template <class ForwardIterator, class BinaryPredicate>
        ForwardIterator adjacent_find
        (
            ForwardIterator eleje, ForwardIterator vege,
            BinaryPredicate pred
        );

Két egymás melletti azonos értékű elemet keres meg a tartományban. Az összehasonlítás a megadott == operátorral illetve predikátummal történik. Visszatér egy bejáróval az azonos értékű elempár első elemére, ha nincs ilyen, akkor a eleje bejáróval tér vissza.

count – megszámolja az adott értékű elemeket a megadott listában

    template <class InputIterator, class T>
        typename iterator_traits<InputIterator>::difference_type
            count(ForwardIterator eleje, ForwardIterator vege, const T& ertek);

Megszámolja a megadott tartományban az adott értékű elemeket. Az iterator_traits<T>::difference_type a csúnya neve ellenére egy egész szám.

O(n) időbonyolultságú.

count_if – adott feltételnek megfelelő elemek megszámolása

    template <class InputIterator, class Predicate>
        typename iterator_traits<InputIterator>::difference_type
            count_if(ForwardIterator eleje, ForwardIterator vege, Predicate feltetel);

A megadott tartományban megszámolja azokat az elemeket, amelyekre a feltetel függvény igazat ad vissza.

O(n) időbonyolultságú.

mismatch – a különbség helyének a megkeresése

    template <class InputIterator1, class InputIterator2>
        pair<InputIterator1, InputIterator2>
            mismatch
            (
                InputIterator1 eleje1, InputIterator1 vege1,
                InputIterator2 eleje2 
            );

    template <class InputIterator1, class InputIterator2, class BinaryPredicate>
        pair<InputIterator1, InputIterator2>
            mismatch
            (
                InputIterator1 eleje1, InputIterator1 vege1,
                InputIterator2 eleje2, 
                BinaryPredicate feltetel 
            );

Két félig nyílt tartományt hasonlít össze, az elsőt a eleje1, vege1 jelzi, a eleje2 a másik tartomány kezdetét jelzi, a vége nincs megadva, mert feltételezi, hogy azonos hosszúságúak. Megadható egy predikátum is az összehasonlításhoz feltetel, alapértelmezésben az == operátort használja. Visszatér két bejáróval a különböző elempárra, ha megegyezik a két tartomány, akkor pár első-első eleme a vege1 bejáró lesz.

O(n) időbonyolultságú.

equal – összehasonlít két listát

    template <class InputIterator1, class InputIterator2>
        bool equal
        (
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2 
        );

    template <class InputIterator1, class InputIterator2, class BinaryPredicate>
        bool equal 
        (
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, 
            BinaryPredicate feltetel 
        );

Két félig nyílt tartományt hasonlít össze. A paraméterezés ugyanaz, mint előbb. Visszatérési értéke igaz, ha a két tartomány megegyezik, hamis, ha nem.

O(n) időbonyolultságú. 

    template <class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 search 
        ( 
            ForwardIterator1 eleje1, ForwardIterator1 vege1,
            ForwardIterator2 eleje2, ForwardIterator2 vege2 
        );

    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
        ForwardIterator1 search 
        ( 
            ForwardIterator1 eleje1, ForwardIterator1 vege1,
            ForwardIterator2 eleje2, ForwardIterator2 vege2.
            BinaryPredicate feltetel 
        );

A eleje1 és vege1 bejárók által kijelölt félig nyílt tartományban keresi a másik eleje2 és vege2 által kijelölt félig nyílt tartomány első előfordulását. Ha megtalálta, akkor visszatér egy bejáróval az első illeszkedő elemre, különben a vege1 bejáróval tér vissza. Megadott predikátummal vagy az == operátorral végzi az összehasonlítást. Úgy működik, mint a find_end csak ez az első illeszkedő tartományt keresi meg.

O(n) időbonyolultságú.

search_n – n egymás mellett lévő elem megkeresése

    template <class ForwardIterator, class Size, class T>
        ForwardIterator search_n 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Size ennyit, 
            const T& ertek 
        );

    template <class ForwardIterator, class Size, class T, class BinaryPredicate>
        ForwardIterator search_n 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Size ennyit, 
            const T& ertek, 
            BinaryPredicate feltetel 
        );

A megadott tartományban (eleje..vege) keres ennyit darab egymás mellett lévő ertek értéket. Visszatér egy bejáróval a szekvencia első elemére, vagy a vege bejáróval, hogy nincs olyan szekvencia.

O(n) időbonyolultságú.

Módosító algoritmusok

Ezek az algoritmusok módosítják az adatszerkezeteket.

copy – lista másolása

    template<class InputIterator, class OutputIterator>
        OutputIterator copy(InputIterator eleje, InputIterator vege, OutputIterator kimenet)
        {
            while (eleje!=vege) *kimenet++ = *eleje++;
            return kimenet;
        }

A két bemeneti bejáró alapján megadott félig nyílt tartományt, másolja a kimeneti bejáró által mutatott helytől kezdve. Visszatérési értéke egy bejáró a célterületre az utolsó másolt elem után.

O(n) időbonyolultságú.

copy_backward – lista másolása visszafelé

    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 copy_backward 
        ( 
            BidirectionalIterator1 eleje, BidirectionalIterator1 vege,
            BidirectionalIterator2 kimenet 
        )
        {
            while (vege!=eleje) *(--kimenet) = *(--vege);
            return kimenet;
        }

A két bejáró (eleje, vege) által megadott félig nyílt tartomány másolja az kimenet bejárótól kezdve visszafelé, a vege-1 lesz az első elem, ami a kimenet-1 helyre kerül. Visszatérési értéke egy bejáró az átmásolt első elemre.

O(n) időbonyolultságú.

swap – két elem értékének cseréje

    template <class T> void swap(T& a, T& b)
    {
        T c(a); a=b; b=c;
    }

Megcseréli a két változó értékét.

swap_ranges – két lista tartalmának megcserélése

template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator2 swap_ranges 
    ( 
        ForwardIterator1 eleje1, ForwardIterator1 vege1,
        ForwardIterator2 eleje2 
    )
    {
        while (eleje1!=vege1) swap(*eleje1++, *eleje2++);
        return eleje2;
    }

Két félig nyílt tartomány elemeit cseréli meg, at első tartomány eleje és vége adott, a másodiknak csak az eleje. Visszatér a második tartomány utolsó eleme utánra mutató bejáróval.

O(n) időbonyolultságú.

iter_swap – két bejáró által mutatott érték cseréje

    template <class ForwardIterator1, class ForwardIterator2>
        void iter_swap(ForwardIterator1 a, ForwardIterator2 b)
        {
            swap (*a, *b);
        }

Két bejáró által mutatott értéket cserél meg.

transform – egy vagy két lista transzformálása

    template < class InputIterator, class OutputIterator, class UnaryOperator >
        OutputIterator transform 
        ( 
            InputIterator eleje1, InputIterator vege1,
            OutputIterator eredmeny, 
            UnaryOperator op 
        );

    template < class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperator >
        OutputIterator transform 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, 
            OutputIterator eredmeny,
            BinaryOperator binary_op 
        );

Végigmegy a megadott tartomány (eleje1, vege1) vagy két tartomány (eleje2-től kezdve) elemein. Elvégzi rajtuk az UnaryOperator műveletét vagy a BinaryOperator műveletét. Az eredményt pedig az eredmeny bejárótól kezdve írja. Visszatérési értéke egy bejáró az utolsó eredmény elem után.

O(n) időbonyolultságú.

replace – elemek keresése és cseréje

    template < class ForwardIterator, class T >
        void replace 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& regi, 
            const T& uj
        )
        {
            for (; eleje != vege; ++eleje)
            if (*eleje == regi) *eleje=uj;
        }

A megadott tartományban (eleje..vege), adott értékű elemeket (regi), lecseréli egy új értékkel (uj).

O(n) időbonyolultságú.

replace_if – megadott feltételnek eleget tevő elemek cseréje

    template < class ForwardIterator, class Predicate, class T >
        void replace_if 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Predicate feltetel, 
            const T& uj 
        )
        {
            for (; eleje != vege; ++eleje)
            if (feltetel(*eleje)) *eleje = uj;
        }

Megadott tartományban (eleje..vege) lecseréli azon elemeket, amelyre a feltétel igaz.

O(n) időbonyolultságú.

replace_copy – megadott tartomány másolása, miközben adott értékű elemeket lecserélik

template < class InputIterator, class OutputIterator, class T >
    OutputIterator replace_copy 
    ( 
        InputIterator eleje, InputIterator vege,
        OutputIterator eredmeny_hely, 
        const T& regi, 
        const T& uj 
    )
    {
        for (; eleje != vege; ++eleje, ++eredmeny_hely)
            *result = (*eleje==regi) ? uj: *eleje;
        return eredmeny_hely;
    }

Megadott tartományt (eleje..vege) másol egy másik helyre (eredmeny_hely), miközben lecseréli a megadott értékű elemeket (regi) egy másik értékre (uj).

O(n) időbonyolultságú.

replace_copy_if – megadott tartomány másolása, miközben a megadott feltételnek eleget tevő elemeket cseréljük

template < class InputIterator, class OutputIterator, class Predicate, class T >
    OutputIterator replace_copy_if 
    ( 
        InputIterator eleje, InputIterator vege,
        OutputIterator eredmeny_hely, 
        Predicate feltetel,
        const T& uj 
    )
    {
        for (; eleje != vege; ++eleje, ++eredmeny_hely)
            *eredmeny_hely = (feltetel(*eleje))? uj: *eleje;
        return eredmeny_hely;
    }

Megadott tartományt (eleje..vege) másol egy másik helyre (eredmeny_hely), miközben lecseréli az adott tulajdonságnak megfelelő elemeket (regi) egy másik értékre (uj).

O(n) időbonyolultságú.

fill – terület feltöltése adott értékkel

    template < class ForwardIterator, class T >
        void fill(ForwardIterator eleje, ForwardIterator vege, const T& ertek)
        {
            while (eleje != vege) *eleje++ = ertek;
        }

Feltölti a megadott tartományt a megadott értékkel.

fill_n – n elem feltöltése adott értékkel, adott kezdőhelytől kezdve

    template < class OutputIterator, class Size, class T >
        void fill_n(OutputIterator eleje, Size n, const T& ertek)
        {
            for (; n>0; --n)  *eleje++ = ertek;
        }

Megadott bejárótól kezdve az első n elemet beállítja megadott értékre.

generate – terület feltöltése függvény által generált értékekkel

    template <class ForwardIterator, class Generator>
        void generate(ForwardIterator eleje, ForwardIterator vege, Generator generator)
        {
            while (eleje != vege)  *eleje++ = generator();
        }

Megadott tartományt feltölti értékekkel, amellyel a generátorfüggvény vagy funktor tér vissza.

O(n) időbonyolultságú.

generate_n – adott kezdőponttól kezdve n db elem beállítása és feltöltése értékekkel

    template <class OutputIterator, class Size, class Generator>
        void generate_n
        ( 
            OutputIterator eleje, 
            Size n, 
            Generator generator 
        )
        {
            for (; n>0; --n)  *eleje++ = generator();
        }

Megadott bejárótól kezdve n darab elemet ír, melyek értékét a generátor adja.

O(n) időbonyolultságú.

remove – adott értékű elemek törlése a tartományból

    template < class ForwardIterator, class T >
        ForwardIterator remove
        (
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek 
        );

Megadott tartományból kitörli azokat az elemeket, amelyek értéke megegyezik a megadottal. Az utánuk lévőket előre másolgatja. Visszatérési értéke egy mutató a tartomány új végére. A régi vége és az új vége közötti elemek megmaradnak, csak az értékük nincs meghatározva.

O(n) időbonyolultságú.

remove_if – adott feltételnek megfelelő értékek törlése a tartományból

    template < class ForwardIterator, class Predicate >
        ForwardIterator remove_if 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Predicate feltetel 
        );

Megadott tartományból kitörli azokat az elemeket, amelyekre a megadott feltétel igaz. Visszatérési értéke egy mutató a tartomány új végére. A régi vége és az új vége közötti elemek megmaradnak, csak az értékük nincs meghatározva.

O(n) időbonyolultságú.

remove_copy – tartomány másolása adott értékek nélkül

    template <class InputIterator, class OutputIterator, class T>
        OutputIterator remove_copy 
        ( 
            InputIterator eleje, InputIterator vege,
            OutputIterator kimenet, 
            const T& ertek 
        );

A megadott tartományt (eleje..vege) átmásolja a megadott kimeneti bejáróhoz (kimenet) a megadott értékű elemek nélkül. Visszatérési értéke egy bejáró az átmásolt tartomány végére

O(n) időbonyolultságú.

remove_copy_if – tartomány másolása adott feltételnek eleget tevő elemek nélkül

    template <class InputIterator, class OutputIterator, class Predicate>
        OutputIterator remove_copy_if 
        ( 
            InputIterator eleje, InputIterator vege,
            OutputIterator kimenet, 
            Predicate feltetel 
        );

A megadott tartományt (eleje..vege) átmásolja a megadott kimeneti bejáróhoz (kimenet) a megadott feltételnek eleget tevő elemek nélkül. Visszatérési értéke egy bejáró az átmásolt tartomány végére.

O(n) időbonyolultságú.

unique – egymás lévő elemek közül 1 db meghagyása, a többi törlése

    template <class ForwardIterator>
        ForwardIterator unique 
        ( 
            ForwardIterator eleje, ForwardIterator vege 
        );

    template <class ForwardIterator, class BinaryPredicate>
        ForwardIterator unique 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            BinaryPredicate feltetel 
        );

Megadott félig nyitott tartományból (eleje..vege) törli az egymás mellett lévő azonos értékű elemeket. Az összehasonlítás az == operátorral vagy a feltetel predikátummal történik. Visszatér egy bejáróval az átalakított tartomány végére.

O(n) időbonyolultságú.

unique_copy – másolás, miközben az egymás mellett lévő elemek közül 1 db meghagyása, a többi törlése

    template <class InputIterator, class OutputIterator>
        OutputIterator unique_copy 
        ( 
            InputIterator eleje, InputIterator vege,
            OutputIterator kimenet 
        );

    template <class InputIterator, class OutputIterator, class BinaryPredicate>
        OutputIterator unique_copy 
        ( 
            InputIterator eleje, InputIterator vege,
            OutputIterator kimenet, 
            BinaryPredicate feltetel 
        );

A megadott félig nyílt tartományt (eleje..vege), másolja egy másik helyre a kimenet bejáró által mutatott helyre, miközben az egymás mellett lévő azonos értékű elemeket eltávolítja. Az eltávolítás történhet az == operátorral, vagy a megadott feltétellel. Visszatérési értéke egy bejáró az átmásolt terület végére.

O(n) időbonyolultságú.

reverse – elemek sorrendjének a megfordítása

template <class BidirectionalIterator>
    void reverse 
    ( 
        BidirectionalIterator eleje, BidirectionalIterator vege
    )
    {
        while ((eleje!=vege)&&(eleje!=--vege))
            swap (*eleje++,*vege);
    }

A megadott félig nyitott tartomány elemeinek a sorrendjét megfordítja.

O(n) időbonyolultságú.

reverse_copy – elemek másolása fordított sorrendben

    template <class BidirectionalIterator, class OutputIterator>
        OutputIterator reverse_copy 
        ( 
            BidirectionalIterator eleje, BidirectionalIterator vege, 
            OutputIterator kimenet 
        )
        {
            while (eleje!=vege) 
                *kimenet++ = *--vege;
            return kimenet;
        }

A megadott félig nyitott tartománynak (eleje..vege) az elemeit megfordítva kiírja a kimenetnek megadott bejáróhoz.

O(n) időbonyolultságú.

rotate – tartomány forgatása, amíg az adott elem adott helyre nem kerül

    template <class ForwardIterator>
        void rotate 
        ( 
            ForwardIterator eleje, 
            ForwardIterator kozepe,
            ForwardIterator vege 
        )
        {
            ForwardIterator kovetkezo = kozepe;
            while (eleje != kovetkezo)
            {
                swap (*eleje++,*kovetkezo++);
                if (kovetkezo == vege) kovetkezo = kozepe;
                else if (eleje == kozepe) kozepe = kovetkezo;
            }
        }

A megadott félig nyílt tartományt (eleje..vege) addig forgatja, amíg a benne lévő megadott elem (kozepe) az elejére nem kerül.

O(n) időbonyolultságú.

rotate_copy – másolás, közben tartomány forgatása, amíg az adott elem adott helyre nem kerül

    template <class ForwardIterator, class OutputIterator>
        OutputIterator rotate_copy 
        ( 
            ForwardIterator eleje, 
            ForwardIterator kozepe,
            ForwardIterator vege, 
            OutputIterator kimenet 
        )
        {
            kimenet=copy (kozepe,vege,kimenet);
            return copy (eleje,kozepe,kimenet);
        }

Ugyanazt csinálja, mint az előző rotate függvény, csak ez a megadott bejáróhoz odamásolja a forgatott eredményt. Visszatérési értéke egy bejáró a másolt tartomány végére.

O(n) időbonyolultságú.

random_shuffle – tartomány összekeverése

    template <class RandomAccessIterator>
        void random_shuffle 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege 
        );

    template <class RandomAccessIterator, class RandomNumberGenerator>
        void random_shuffle 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege,
            RandomNumberGenerator& veletlen_generator 
        );

A megadott félig nyílt tartomány elemeit összekeveri: minden elem értékét megcseréli egy véletlenszerűen kiválasztott elem értékével. A keverés történhet valamilyen gyári függvénnyel vagy egy megadott függvénnyel.

O(n) időbonyolultságú.

partition – adott tulajdonságú elemek előre rendezése

    template <class BidirectionalIterator, class Predicate>
        BidirectionalIterator partition 
        ( 
            BidirectionalIterator eleje, BidirectionalIterator vege, 
            Predicate feltetel 
        );

Átrendezi a megadott tartományt úgy, hogy azon elemeket, melyre a feltétel igaz azok elé teszi, amelyre nem igaz. Visszatérési értéke egy bejáró az első elemre, amelyre a feltétel nem igaz.

Következő példában a páratlan számokat rendezzük a párosak elé: [1, 2, 3, 4, 5, 6, 7, 8, 9] => [1, 9, 3, 7, 5, 6, 4, 8, 2]. A sorrend nem garantált, csak az, hogy azon elemek, melyre a feltétel igaz volt, előre lesznek téve. A stable_partition a sorrendet is garantálja.

O(n) időbonyolultságú.

stable_partition – adott tulajdonságú elemek előre rendezése, sorrendjüket megtartva

    template <class BidirectionalIterator, class Predicate>
        BidirectionalIterator stable_partition 
        ( 
            BidirectionalIterator eleje, BidirectionalIterator vege,
            Predicate feltetel 
        );

Átrendezi a megadott tartományt úgy, hogy azon elemeket, melyre a feltétel igaz azok elé teszi, amelyre nem igaz. Az adott elemek tartományon belüli sorrendjét megtartva. Visszatérési értéke egy bejáró az első elemre, amelyre a feltétel nem igaz.

Következő példában a páratlan számokat rendezzük a párosak elé: [1, 2, 3, 4, 5, 6, 7, 8, 9] => [1, 3, 5, 7, 9, 2, 4, 6, 8].

O(n) időbonyolultságú.

Rendező algoritmusok

Ezekkel lehet tartományokat különféle sorrendbe rendezni.

sort – rendezi a megadott tartományt

    template <class RandomAccessIterator>
        void sort(RandomAccessIterator eleje, RandomAccessIterator vege);

    template <class RandomAccessIterator, class Compare>
        void sort(RandomAccessIterator eleje, RandomAccessIterator vege, Compare komparator);

sorba rendezi a megadott tartományt. Az összehasonlításhoz használhatja a < operátort, vagy a megadott összehasonlító függvényt.

Időbonyolultsága lehet O(n log(n)) vagy O(n2), implementációtól függően.

stable_sort – sorba rendezi a tartományt, azonos értékű elemek 

    template <class RandomAccessIterator>
        void stable_sort 
        ( 
            RandomAccessIterator first, RandomAccessIterator last 
        );

    template <class RandomAccessIterator, class Compare>
        void stable_sort 
        ( 
            RandomAccessIterator first, RandomAccessIterator last,
            Compare comp 
        );

sorba rendezi a megadott tartományt. Az összehasonlításhoz használhatja a < operátort, vagy a megadott összehasonlító függvényt. Az azonos értékű elemek egymáshoz viszonyított sorrendjét megtartja.

Időbonyolultsága lehet O(n log(n)) vagy O(n2), implementációtól függően.

partial_sort – rendezés, amíg az adott elem a végleges helyére nem kerül

    template <class RandomAccessIterator>
        void partial_sort 
        ( 
            RandomAccessIterator eleje, 
            RandomAccessIterator kozepe,
            RandomAccessIterator vege 
        );

    template <class RandomAccessIterator, class Compare>
        void partial_sort 
        (
            RandomAccessIterator eleje, 
            RandomAccessIterator kozepe,
            RandomAccessIterator vege, 
            Compare komparator 
        );

Részlegesen rendezi a megadott tartományt (eleje..vege), úgy, hogy a kiválasztott elemnél kozepe kisebbek a tartomány elejére lesznek rendezve, az utána lévők pedig nem lesznek rendezve. Az összehasonlításhoz használhatja a < operátort, vagy a megadott összehasonlító függvényt.

Időbonyolultsága O(n2). Minél kisebb elemet választunk ki, annál gyorsabban végez.

partial_sort_copy – másol, közben rendezés, amíg az adott elem a végleges helyére nem kerül

    template <class InputIterator, class RandomAccessIterator>
    RandomAccessIterator partial_sort_copy 
    ( 
        InputIterator eleje, InputIterator vege,
        RandomAccessIterator ki_eleje, RandomAccessIterator ki_vege 
    );

    template <class InputIterator, class RandomAccessIterator, class Compare>
        RandomAccessIterator
        partial_sort_copy 
        (
            InputIterator eleje, InputIterator vege,
            RandomAccessIterator ki_eleje, RandomAccessIterator ki_vege, 
            Compare vege 
        );

A megadott tartomány (eleje..vege) legkisebb elemeit rendezve átmásolja a megadott másik tartományhoz (ki_eleje..ki_vege). Az összehasonlításhoz használhatja a < operátort, vagy a megadott összehasonlító függvényt. Visszatérési értéke egy bejáró a rendezett tartomány végére.

Időbonyolultsága O(nm).

nth_element – rendezett sorozatban helyére teszi az n. elemet

    template <class RandomAccessIterator>
        void nth_element
        ( 
            RandomAccessIterator eleje, 
            RandomAccessIterator n_edik,
            RandomAccessIterator vege 
        );

    template <class RandomAccessIterator, class Compare>
        void nth_element 
        ( 
            RandomAccessIterator eleje, 
            RandomAccessIterator n_edik,
            RandomAccessIterator vege, 
            Compare comp 
        );

Részben átrendezi a megadott tartományt (eleje..vege) úgy, hogy megadott helyen lévő elem (n_edik) a helyén legyen, tehát minden nála kisebb elem előtte, minden nagyobb, pedig mögé kerül, csak a megadott elem lesz a helyén, a többi nem garantált, hogy rendezve lesz.

Például vegyük ezt a tömböt: [1, 2, 3, 9, 8, 5, 7, 4, 6]. Szeretnénk a helyére tenni a leendő rendezett sorozat hatodik elemét, akkor az algoritmus lefutása után valami ilyesmit kapunk: [3, 1, 4, 2, 5, 6, 9, 7, 8]

Időbonyolultsága O(n).

Bináris keresés

Ezzel a keresési lehetőséggel egy már rendezett tartományban kereshetünk elemeket. 

    template <class ForwardIterator, class T>
        bool binary_search 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek 
        );

    template <class ForwardIterator, class T, class Compare>
        bool binary_search
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek, 
            Compare komparator 
        );

Bináris kereséssel megkeresi a megadott értékű elemet a megadott rendezett tartományban. Igazzal tér vissza, ha megtalálta, különben hamissal.

Időbonyolultsága O(log n).

lower_bound – azonos értékű elemek tartományának az elejével tér vissza

    template <class ForwardIterator, class T>
        ForwardIterator lower_bound 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek 
        );

    template <class ForwardIterator, class T, class Compare>
        ForwardIterator lower_bound 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek, 
            Compare komparator 
        );

Bináris kereséssel megkeresi az első elemet az adott rendezett tartományban, amelynek értéke egyezik a keresettnél vagy nagyobb nála, ha a keresett elem minden más elemnél nagyobb, akkor a vege bejáróval tér vissza.

Példa: ebben a tömbben: [1, 2, 3, 4, 5, 5, 5, 6, 7] az 5 keresése egy bejáróval tér vissza a 5. elemre.

Időbonyolultsága O(log n).

upper_bound – azonos értékű elemek tartományának a végével tér vissza

    template <class ForwardIterator, class T>
        ForwardIterator upper_bound 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek 
        );

    template <class ForwardIterator, class T, class Compare>
        ForwardIterator upper_bound 
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            const T& ertek, 
            Compare komparator 
        );

Bináris kereséssel megkeresi az első elemet az adott rendezett tartományban, melynek az értéke nagyobb, mint a keresett.

Példa: ebben a tömbben: [1, 2, 3, 4, 5, 5, 5, 6, 7] az 5 keresése egy bejáróval tér vissza a 8. elemre.

Időbonyolultsága O(log n).

equal_range – azonos értékű elemek tartományának a lekérdezése

    template <class ForwardIterator, class T>
        pair<ForwardIterator,ForwardIterator> equal_range 
        ( 
            ForwardIterator eleje, ForwardIterator vege, 
            const T& ertek 
        );

    template <class ForwardIterator, class T, class Compare>
        pair<ForwardIterator,ForwardIterator> equal_range 
        ( 
            ForwardIterator eleje, ForwardIterator vege, 
            const T& ertek,
            Compare komparator 
        );

Visszatér egy bejárópárral az azonos értékű elemeket tartalmazó tartományra a megadott rendezett tartományban.

Időbonyolultsága O(log n).

Halmazműveletek rendezett tartományokon

Ezek az algoritmusok rendezett tartományokon végeznek különféle halmazműveleteket.

merge – két rendezett sorozat összefésülése

    template <class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator merge 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet 
        );

    template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
        OutputIterator merge 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet, 
            Compare komparator 
        );

Két rendezett tartományt fésüli össze egy rendezett tartománnyá a kimeneten, az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

O(n + m) időbonyolultságú.

inplace_merge – két rendezett sorozat összefésülése helyben

    template <class BidirectionalIterator>
        void inplace_merge
        ( 
            BidirectionalIterator eleje, 
            BidirectionalIterator kozepe,
            BidirectionalIterator vege 
         );

    template <class BidirectionalIterator, class Compare>
        void inplace_merge 
        ( 
            BidirectionalIterator eleje, 
            BidirectionalIterator kozepe,
            BidirectionalIterator vege, 
            Compare komparator 
        );

Két egymás után lévő rendezett tartományt (eleje..kozepe és kozepe..vege), helyben összefésül. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

O(n + m) időbonyolultságú.

includes – részhalmaz függvény

    template <class InputIterator1, class InputIterator2>
        bool includes 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2 
        );

    template <class InputIterator1, class InputIterator2, class Compare>
        bool includes 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2, 
            Compare komparator 
        );

Igazzal tér vissza ha az eleje2..vege2 rendezett tartomány minden eleme benne van a eleje1..vege1 rendezett tartományban. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

O(n + m) időbonyolultságú.

set_union – halmaz unió

    template <class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_union 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet 
        );

    template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
        OutputIterator set_union 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet, 
            Compare komparator 
        );

A két megadott rendezett tartományt összefésüli a kimeneti bejáróhoz úgy, hogy az azonos értékű elemeket csak egyszer szerepelteti (kivéve, ha az egyik tartományban alapból több van belőle). Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal. Visszatérési értéke egy bejáró az átmásolt tartomány végére.

O(n + m) időbonyolultságú.

set_intersection – halmaz metszet.

    template <class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_intersection 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet 
        );

    template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
        OutputIterator set_intersection 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet, 
            Compare komparator 
        );

A két megadott rendezett tartomány közös elemeit másolja át a kimenetre. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal. Visszatérési értéke egy bejáró az átmásolt tartomány végére.

set_difference – halmazok különbsége

    template <class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_difference 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet 
        );

    template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
        OutputIterator set_difference 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet, 
            Compare komparator 
        );

Két megadott rendezett tartományból azon elemeket másolja a kimeneti bejáróhoz, amelyek benne vannak az első tartományban (eleje1..vege1) , de nincsenek benne a másodikban (eleje2..vege2) . Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal. Visszatérési értéke egy bejáró az átmásolt tartomány végére.

O(n + m) időbonyolultságú.

set_symmetric_difference – halmazok szimmetrikus különbsége

    template <class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_symmetric_difference 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            OutputIterator kimenet 
        );

    template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
    OutputIterator set_symmetric_difference 
    (
        InputIterator1 eleje1, InputIterator1 vege1,
        InputIterator2 eleje2, InputIterator2 vege2,
        OutputIterator kimenet, 
        Compare komparator 
    );

Két megadott rendezett tartományból azon elemeket másolja a kimeneti bejáróhoz, amelyek vagy benne vannak az egyik tartományban, vagy a másikban, de nem mindkettőben. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal. Visszatérési értéke egy bejáró az átmásolt tartomány végére.

O(n + m) időbonyolultságú.

Kupac műveletek

Ebben a részben a kupac adatszerkezettel kapcsolatos műveletek. Ez tulajdonképpen a priority_queue adatszerkezethez hasonlóan működik.

make_heap – kupaccá rendezi az adatszerkezetet, a legnagyobb elem lesz elöl

    template <class RandomAccessIterator>
        void make_heap ( RandomAccessIterator eleje, RandomAccessIterator vege );

    template <class RandomAccessIterator, class Compare>
        void make_heap 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege,
            Compare komparator 
        );

Átrendezi a megadott tartományt egy kupac adatszerkezetbe, hogy a legnagyobb eleme legyen az első. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

push_heap – elem beszúrása a kupacba

    template <class RandomAccessIterator>
        void push_heap 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege 
        );

    template <class RandomAccessIterator, class Compare>
        void push_heap 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege,
            Compare komparator 
        );

Az eleje..vege-1 félig nyílt tartományban lévő kupacba beszúrja a vege-1 helyen lévő elemet. Az eleje..vege-1 tartománynak kupacnak kell lennie (make_heap-pel létrehozva). Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

Időbonyolultsága O(log(n)).

pop_heap – legnagyobb elem kivétele a kupacból

    template <class RandomAccessIterator>
        void pop_heap ( RandomAccessIterator eleje, RandomAccessIterator vege );

    template <class RandomAccessIterator, class Compare>
        void pop_heap 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege,
            Compare komparator 
        );

Megadott kupac tartományból legnagyobb elemet (a legelső) kiveszi, és az utolsó elem helyére (vege-1) teszi. Így az első helyen a második legnagyobb lesz. A művelet után már csak az eleje..vege-1 tartomány lesz kupac. Az elemek összehasonlítását végezheti a < operátorral vagy saját predikátummal.

Időbonyolultsága O(log(n)).

sort_heap – kupac rendezése

    template <class RandomAccessIterator>
        void sort_heap ( RandomAccessIterator eleje, RandomAccessIterator vege );

    template <class RandomAccessIterator, class Compare>
        void sort_heap 
        ( 
            RandomAccessIterator eleje, RandomAccessIterator vege,
            Compare komparator 
        );

A megadott kupac tartományt növekvő sorrendbe rendezi. A rendezés után a tartomány már nem minősül kupacnak.

O(n log n) időbonyolultságú.

Egyéb algoritmusok

min

    template <class T> const T& min(const T& a, const T& b);
    template <class T, class Compare>
        const T& min(const T& a, const T& b, Compare komparator);

A két paramétere közül visszatér a kisebbel. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

max

    template <class T> const T& max(const T& a, const T& b);
    template <class T, class Compare>
        const T& max(const T& a, const T& b, Compare komparator);

A két paramétere közül visszatér a nagyobbal. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

min_element – legkisebb elemre mutató bejáró lekérdezése

    template <class ForwardIterator>
        ForwardIterator min_element
        ( 
            ForwardIterator eleje, ForwardIterator vege 
        );

    template <class ForwardIterator, class Compare>
        ForwardIterator min_element
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Compare komparator 
        );

Megadott tartományból visszatér a legkisebb elemre mutató bejáróval. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

max_element – legnagyobb elemre mutató bejáró lekérdezése

    template <class ForwardIterator>
        ForwardIterator max_element
        ( 
            ForwardIterator eleje, ForwardIterator vege 
        );

    template <class ForwardIterator, class Compare>
        ForwardIterator max_element
        ( 
            ForwardIterator eleje, ForwardIterator vege,
            Compare komparator 
        );

Megadott tartományból visszatér a legnagyobb elemre mutató bejáróval. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

lexicographical_compare – lexikális összehasonlítás

    template <class InputIterator1, class InputIterator2>
        bool lexicographical_compare 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2 
        );

    template <class InputIterator1, class InputIterator2, class Compare>
        bool lexicographical_compare 
        ( 
            InputIterator1 eleje1, InputIterator1 vege1,
            InputIterator2 eleje2, InputIterator2 vege2,
            Compare komparator 
        );

Lexikális összehasonlítást végez két tartomány között. A két tartomány elemei rendre összehasonlítja. Az első különböző értékű elempár esetén, ha az első tartományban kisebb volt az elem, igazzal tér vissza, különben hamissal. Ha nincs különböző elem, és az első tartományon hamarabb ér végig, akkor is igazzal tér vissza, különben hamissal. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

O(n) időbonyolultságú.

next_permutation – egy számsor következő permutációját állítja elő

    template <class BidirectionalIterator>
        bool next_permutation 
        (
            BidirectionalIterator eleje,
            BidirectionalIterator vege 
        );

    template <class BidirectionalIterator, class Compare>
        bool next_permutation
        (
            BidirectionalIterator eleje, BidirectionalIterator vege, 
            Compare comp
        );

Átalakítja a megadott tartományt a következő lexikografikusan eggyel nagyobb permutációra. Igazzal tér vissza, ha az átalakítás elvégezhető, hamissal, ha a tartomány már a legnagyobb lehetséges permutáció. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

Példa: [1 2 3] => [1 3 2], [1 5 4 3 2] => [2 1 3 4 5]

O(n) időbonyolultságú.

prev_permutation – egy számsor előző permutációját állítja elő

    template <class BidirectionalIterator>
        bool prev_permutation 
        (
            BidirectionalIterator eleje,
            BidirectionalIterator vege 
        );

    template <class BidirectionalIterator, class Compare>
        bool prev_permutation
        (
            BidirectionalIterator eleje, BidirectionalIterator vege, 
            Compare comp
        );

Átalakítja a megadott tartományt a következő lexikografikusan eggyel kisebb permutációra. Igazzal tér vissza, ha az átalakítás elvégezhető, hamissal, ha a tartomány már a legkisebb lehetséges permutáció. Az összehasonlítást végezheti a < operátorral vagy saját predikátummal.

Példa: [1 3 2] => [1 2 3], [2 1 3 4 5] => [1 5 4 3 2]

O(n) időbonyolultságú.

Egyéb adattípusok és függvények

Egyéb standard C++ típusokról lesz szó itt:

complex osztály

A complex fejlécben van. Ez egy komplex számot reprezentáló osztály vagyis sablon. A komplex számok x + yi alakban vannak megadva, ahol definíció szerint i² = -1. A sablon fejléce: 

    template <class T> class complex;

Típusai

value_type

A sablonparaméter-típus.

Konstruktorai

    public:
        complex(const T& valos = T(), const T& kepzetes = T());
        complex(const complex& cmplx);
        template<class X>
            complex(const complex<X>& cmplx);

Ezek az alap konstruktorok és a másoló konstruktorok.

imag metódus

    T imag() const;

Lekérdezi a képzetes részét a komplex számnak.

real metódus

    T real() const;

Lekérdezi a valós részét a komplex számnak.

Operátorai

Minden operátorral rendelkezik, amellyel egy aritmetikai típusnak rendelkeznie kell. Inkább nem sorolom fel őket.

Kivételekkel kapcsolatos osztályok és függvények

Az exception osztály

Ez az az osztály, amelynek leszármazottait az standard függvénytár függvényei és metódusai dobják, hiba esetén.

Megadása

    class exception 
    {
    public:
        exception();
        exception(const exception&);
        exception& operator= (const exception&);
        virtual ~exception();
        virtual const char* what() const;
    }

Az egyetlen értelmes metódusa a what, amely egy nullával lezárt karakterláncként adja vissza, hogy miről is van szó.

bad_exception osztály

Ez egy speciális kivétel, amelyet akkor dobnak, hogyha a függvény olyan kivételt dob, amely nincs felsorolva kivételspecifikációk között. Természetesen ahhoz, hogy el lehessen kapni, ezt a kivételt is fel kell sorolni a kivételspecifikációba.

unexpected_handler, terminate_handler
    typedef void (*unexpected_handler)();
    typedef void (*terminate_handler)();

Ezek paraméter és visszatérési érték nélküli függvénymutató típusok. Kontextustól függ, hogy melyiket használjuk.

set_unexpected – váratlan kivétel esetén hívódó függvény beállítása

    unexpected_handler set_unexpected(unexpected_handler f);

Beállít egy függvényt, amely akkor hívódik, ha egy függvény olyan kivételt dob, amely nincs a kivétel specifikációjában. Az alapértelmezett függvény egyszerűen meghívja a terminate függvényt. Visszatérési értéke a korábbi függvény címe lesz.

unexpected – váratlan kivétel esetén hívódik

    void unexpected();

Ez a függvény hívódik, amikor egy függvény olyan kivételt dob, amely nincs a kivétel specifikációjában.

set_terminate függvény – kezeletlen kivétel esetén hívandó függvényt állít be

    terminate_handler set_terminate (terminate_handler f)

Beállítja a függvényt, amely a terminate hívásakor hívódik. Az alapértelmezett a standard abort függvény.

terminate – kezeletlen kivétel esetén hívódik

    void terminate();

Akkor hívódik, amikor egy kivételt nem kezelünk le.

uncaught_exception – igazzal tér vissza, ha épp van feldobva kivétel, különben hamis

    bool uncaught_exception()

Igazzal tér vissza, ha van feldobva kivétel, de még nem kapták el, hamis különben. Kivétel feldobása és elkapása között csak destruktorok futhatnak le, így ez a függvény csak ott adhat vissza igaz értéket.

Standard funktorok

A functional fejlécben van. A funktorok olyan osztályok, amelyek felülbírálják a () operátort, így függvényként használhatók. Gyakran sablonparaméterként szerepelnek, főleg a less.

unary_function – egyparaméteres függvény

Az egyparaméteres funktorok őse, csak egy struktúra mely két belső típust definiál. 

    template <class Arg, class Result>
        struct unary_function 
        {
            typedef Arg argument_type;
            typedef Result result_type;
        };

binary_function – kétparaméteres függvény

Ez a kétparaméteres funktorok őse: 

    template <class Arg1, class Arg2, class Result>
        struct binary_function 
        {
            typedef Arg1 first_argument_type;
            typedef Arg2 second_argument_type;
            typedef Result result_type;
        };

Operátoroknak megfelelő funktor objektumok

A következő táblázatban foglalom össze az operátorokat és a neki megfelelő functorokat. Különösebb magyarázatra nem szorulnak, értelemszerűen annyi paraméterük van amennyi az operátornak, és a visszatérési értékük is az operátornak megfelelő.

Ezek mindahányan sablonok, melyeknek egyetlen típusparamétere az operandusok típusa.

Operátor Funktor
+ plus
- minus
* multiplies
/ divides
% modulus
- negate
== equal_to
!= not_equal_to
> greater
< less
>= greater_equal
<= less_equal
&& logical_and
|| logical_or
! logical_not

Negátorok

A negátor egy olyan funktor, amely egyparaméteres vagy kétparaméteres funktor ellentettjét hozza létre. Kettő van belőle. Gyakorlatilag a ! operátort alkalmazza a megadott funktoron.

unary_negate – egyparaméteres funktor ellentettjének előállítása

Ez egy részleges sablonspecializáció, egyparaméteres funktorok negálására. Így néz ki: 

    template <class Predicate> class unary_negate
        : public unary_function <typename Predicate::argument_type,bool>
    {
    protected:
        Predicate fn;
    public:
        explicit unary_negate ( const Predicate& pred ) : fn (pred) {}
        bool operator() (const typename Predicate::argument_type& x) const
        { 
            return !fn(x); 
        }
    };

A not1 függvénnyel lehet ennek egy példányát megkapni: 

    template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
binary_negate – kétparaméteres funktor ellentettjének előállítása

Ez egy részleges sablonspecializáció, kétparaméteres funktorok negálására. Így néz ki: 

    template <class Predicate> class binary_negate
       :public binary_function <typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>
    {
    protected:
        Predicate fn;
    public:
        explicit binary_negate ( const Predicate& pred ) : fn (pred) {}
        bool operator() (const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const
        { 
            return !fn(x,y); 
        }
    };

A not2 függvénnyel lehet ezeknek egy példányát megkapni: 

    template <class Predicate> binary_negate<Predicate> not2 (const Predicate& pred);

Paraméterkötő funktorok

Ezzel kétparaméteres funktorok egyik paraméterét egy értékhez köthetjük, egyparaméteressé téve azt. Két fajtája van: az egyik az első, a másik a második paramétert köti.

binder1st – kétparaméteres funktor első paraméterét köti
    template <class Operation> class binder1st
        : public unary_function <typename Operation::second_argument_type, typename Operation::result_type>
    {
    protected:
        Operation op;
        typename Operation::first_argument_type value;
    public:
        binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op (x), value(y) {}
        typename Operation::result_type
        operator() (const typename Operation::second_argument_type& x) const
        { 
            return op(value,x); 
        }
    };

Ennek egy példányát a bind1st függvénnyel lehet létrehozni: 

    template <class Operation, class T> binder1st<Operation> bind1st (const Operation& op, const T& x);
binder2nd – kétparaméteres funktor második paraméterét köti
    template <class Operation> class binder2nd
    : public unary_function <typename Operation::first_argument_type, typename Operation::result_type>
    {
    protected:
        Operation op;
        typename Operation::second_argument_type value;
    public:
        binder2nd ( const Operation& x, const typename Operation::second_argument_type& y) : op (x), value(y) {}
        typename Operation::result_type
        operator() (const typename Operation::first_argument_type& x) const
        { 
            return op(x,value); 
        }
    };

Ennek egy példányát a bind2nd függvénnyel lehet létrehozni: 

    template <class Operation, class T> binder2nd<Operation> bind2nd (const Operation& op, const T& x);

Függvénymutatóból funktor

ptr_fun
    template <class Arg, class Result>
        pointer_to_unary_function<Arg,Result> ptr_fun (Result (*f)(Arg));

    template <class Arg1, class Arg2, class Result>
        pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun (Result (*f)(Arg1,Arg2));

Egyparaméteres, illetve kétparaméteres függvényből csinál egy funktort. A visszatérési érték típusa az unary_function és a binary_function típusból vannak származtatva, értelemszerűen.

mem_fun, const_mem_fun
    template <class S, class T> mem_fun_t<S,T> mem_fun (S (T::*f)());
    template <class S, class T, class A> mem_fun1_t<S,T,A> mem_fun (S (T::*f)(A));
    template <class S, class T> const_mem_fun_t<S,T> mem_fun (S (T::*f)() const);
    template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun (S (T::*f)(A) const);

Tagfüggvénymutatót lehet vele funktorrá alakítani. A tagfüggvény lehet paraméter nélküli vagy egyparaméteres. A visszatérési érték típus a paraméter nélküli esetén az unary_function, egyparaméteres esetben pedig a binary_function függvényből származik.

Ezen funktorok első paramétere egy mutató az objektumra, amelyen a tagfüggvény hívódik.

mem_fun_ref
    template <class S, class T> mem_fun_ref_t<S,T> mem_fun_ref (S (T::*f)());
    template <class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref (S (T::*f)(A));
    template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref (S (T::*f)() const);
    template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref (S (T::*f)(A) const);

Tagfüggvénymutatót lehet vele funktorrá alakítani. A tagfüggvény lehet paraméter nélküli vagy egyparaméteres. A visszatérési érték típus a paraméter nélküli esetén az unary_function, egyparaméteres esetben pedig a binary_function függvényből származik.

Ezen funktorok első paramétere egy referencia az objektumra, amelyen a tagfüggvény hívódik.

bejáró osztályok

Az iterator fejlécben van. Korábban már volt szó az bejárókról, most itt leírom, hogy milyen osztályokkal valósítódnak meg.

bejáró struktúrák

iterator ősosztály

Ez egy típussablon, semmi értelme adatmezője, se metódusa nincs, így néz ki: 

template <class Category, class T, class Distance = ptrdiff_t, class Pointer = T*, class Reference = T&>
  struct iterator {
    typedef T         value_type;
    typedef Distance  difference_type;
    typedef Pointer   pointer;
    typedef Reference reference;
    typedef Category  iterator_category;
  };

Csak a kategória és a mutatót érték típusa, ami kötelező. A kategóriák a következők lehetnek:

input_iterator_tag
Bemeneti bejáró
output_iterator_tag
Kimeneti bejáró
forward_iterator_tag
Egyirányú bejáró
bidirectional_iterator_tag
Kétirányú bejáró
random_access_iterator_tag
Közvetlen elérésű bejáró
iterator_traits

Ez egy olyan sablon, amely egy bejáró szerepű típust (ez lehet egy mutató vagy akár egy egész szám is akár) vár sablonparaméternek. Ez felfogható egyfajta metastruktúrának, amely egy bejáró tulajdonságait írja le. Megadása ilyen: 

    template <class Iterator> struct iterator_traits 
    {
        typedef typename Iterator::difference_type difference_type;
        typedef typename Iterator::value_type value_type;
        typedef typename Iterator::pointer pointer;
        typedef typename Iterator::reference reference;
        typedef typename Iterator::iterator_category iterator_category;
    };

Illetve van két sablonspecializácója mutatókra: 

    template <class T> struct iterator_traits<T*> 
    {
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef T* pointer;
        typedef T& reference;
        typedef random_access_iterator_tag iterator_category;
    }

    template <class T> struct iterator_traits<const T*> 
    {
        typedef ptrdiff_t difference_type;
        typedef T value_type;
        typedef const T* pointer;
        typedef const T& reference;
        typedef random_access_iterator_tag iterator_category;
    }

bejáró függvények

advance függvény – bejáró léptetése

bejárók megadott értékkel való előreléptetésére használható. 

    template <class InputIterator, class Distance> void advance(InputIterator& i, Distance n);

Előrelépteti az bejárót a megadott lépésszámmal. Tetszőleges elérésű bejáró esetén a + és - operátorokat használja. Más bejárók esetén a ismétlődően hívogatja a ++ és -- bejárókat.

i
Az bejáró, amit előre kellene léptetni.
n
Valamilyen numerikus típus (valószínűleg valami iterator_traits<InputIterator>::difference_type), amellyel megadhatjuk, hogy mennyivel kell előreléptetni az bejárót. Csak tetszőleges elérésű és kétirányú bejáró esetén lehet az értéke negatív.

Visszatérési értéke az előreléptetett bejáró.

distance függvény – két bejáró távolsága
    template<class InputIterator> typename iterator_traits<InputIterator>::difference_type distance(InputIterator eleje, InputIterator vege);

Két bejáró közötti távolságot adja vissza. Tetszőleges elérésű bejáró esetén a - operátort használja, Más bejárók esetén a ++ operátorral növeli a eleje bejárót addig, amíg el nem éri a vege értékét.

Beszúrók

Ezek olyan kimeneti bejárók, amelyek beszúrnak elemeket az adatszerkezetbe, ahelyett, hogy meglévőket írnának felül.

back_insert_iterator – ez az adatszerkezet végére szúr be elemeket

Ez egy olyan beszúró bejáró, amely egy adatszerkezet végéhez tud elemeket beszúrni. A következő függvény használatával lehet ilyet kapni: 

    template <class Container> back_insert_iterator<Container> back_inserter(Container& x);

A definíciója pedig így néz ki: 

    template <class Container> class back_insert_iterator : public iterator<output_iterator_tag,void,void,void,void>
    {
    protected:
        Container* container;

    public:
        typedef Container container_type;
        explicit back_insert_iterator (Container& x) : container(&x) {}
        back_insert_iterator<Container>& operator= (typename Container::const_reference value)
        { 
            container->push_back(value); return *this; 
        }
        back_insert_iterator<Container>& operator* ()
        { 
            return *this; 
        }
        back_insert_iterator<Container>& operator++ ()
        {
            return *this; 
        }
        back_insert_iterator<Container> operator++ (int)
        { 
            return *this; 
        }
    };

Ez azt jelenti, hogy egy ilyen bejárón az = operátor elemet szúr be a hozzárendelt adatszerkezetbe, még akkor is ha a * operátoron keresztül elemet érünk el rajta. Az is látható, hogy a mutatott adatszerkezetnek támogatnia kell a push_back metódust.

front_insert_iterator – ez az elejére szúr be elemeket

Ez egy olyan beszúró bejáró, amellyel az adatszerkezet elejére lehet beszúrni elemeket. A következő függvénnyel kaphatunk ilyen bejárót. 

    template <class Container> front_insert_iterator<Container> front_inserter(Container& x);

Definíciója pedig így néz ki: 

    template <class Container> class front_insert_iterator : public iterator<output_iterator_tag,void,void,void,void>
    {
    protected:
        Container* container;

    public:
        typedef Container container_type;
        explicit front_insert_iterator (Container& x) : container(&x) {}
        front_insert_iterator<Container>& operator= (typename Container::const_reference value)
        { 
            container->push_front(value); return *this; 
        }
        front_insert_iterator<Container>& operator* ()
        { 
            return *this; 
        }
        front_insert_iterator<Container>& operator++ ()
        { 
            return *this; 
        }
        front_insert_iterator<Container> operator++ (int)
        { 
            return *this; 
        }
    };

Hasonlóképpen működik, mint a végére beszúró bejáró, csak ez az adatszerkezet elejére szúr be dolgokat.

insert_iterator – ez az általános beszúró bejáró

Ez az általános beszúró bejáró, amely bárhova képes elemeket beszúrni a megadott adatszerkezetben. A következő függvény használatával kaphatunk egy ilyet: 

    template <class Container, class Inserter> insert_iterator<Container> inserter (Container& x, Inserter i);

Megadása az előző beszúrókhoz hasonló: 

    template <class Container> class insert_iterator : public iterator<output_iterator_tag,void,void,void,void>
    {
    protected:
        Container* container;
        typename Container::iterator iter;

    public:
        typedef Container container_type;
        explicit insert_iterator (Container& x, typename Container::iterator i)
        : container(&x), iter(i) {}
        insert_iterator<Container>& operator= (typename Container::const_reference value)
        { 
            iter=container->insert(iter,value); ++iter; return *this; 
        }
        insert_iterator<Container>& operator*()
        { 
            return *this; 
        }
        insert_iterator<Container>& operator++()
        { 
            return *this; 
        }
        insert_iterator<Container> operator++(int)
        { 
            return *this; 
        }
    };

Előredefiniált bejárók

Ezeket használják az adatstruktúrák is (többnyire).

reverse_iterator – megfordítja az bejárót
    template <class Iterator> class reverse_iterator;

Ez a sablon egy fordított bejárót hoz létre egy meglévő bejáróból. Csak kétirányú és tetszőleges elérésű bejárókra működik. Ez az bejáró fordítva működik. Az előre művelete hátra léptet, a hátra művelete pedig előre.

Az általa csomagolt bejáró az Iterator base() const; metódussal érhető el. Az bejáró és a belső bejáró különböző elemre mutat. (A belső bejáró eggyel előrébb).

istream_iterator – bejáró bemeneti adatfolyamhoz
    template <class T, class charT=char, class traits=char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator;

Ez egy bemeneti bejáró, mellyel egy bemeneti adatfolyamból lehet T típusú adatot olvasni. Egyparaméteres konstruktora egy istream típusú paramétert vár. Az alapértelmezett konstruktora egy adatfolyamvég bejárót csinál, amely használható annak eldöntésére, hogy az bejáró az adatfolyam végén áll.

ostream_iterator – bejáró kimeneti adatfolyamhoz
    template <class T, class charT=char, class traits=char_traits<charT>, class Distance = ptrdiff_t> class ostream_iterator;

Ez egy kimeneti bejáró, mellyel egy kimeneti adatfolyamba lehet T típusú adatot írni. Egyparaméteres konstruktora egy ostream típusú paramétert vár. Az alapértelmezett konstruktora egy adatfolyamvég bejárót csinál, amely használható annak eldöntésére, hogy az bejáró az adatfolyam végén áll.

istreambuf_iterator – bejáró bemeneti streambuf-hoz
    template <class charT, class traits=char_traits<charT> > class istreambuf_iterator;

Ez egy bemeneti bejáró, amelyből charT típusú karaktereket lehet olvasgatni. Egyparaméteres konstruktora tud bejárót csinálni egy streambuf és egy istream típusú objektumból is. Az alapértelmezett konstruktora egy puffervég bejárót csinál, amely használható annak eldöntésére, hogy az bejáró az adatfolyam végén áll.

ostreambuf_iterator
    template <class charT, class traits=char_traits<charT> > class ostreambuf_iterator;

Ez egy kimeneti bejáró, amellyel charT típusú karaktereket lehet írogatni. Egyparaméteres konstruktora tud bejárót csinálni egy streambuf és egy ostream típusú objektumból is. Az alapértelmezett konstruktora egy puffervég bejárót csinál, amely használható annak eldöntésére, hogy az bejáró az adatfolyam végén áll (összehasonlítással).

limits fejléc

Típusok értékhatárainak eléréséhez szolgáló sablon van bele.

numeric_limits

A numeric_limits sablon a következőképpen van megadva: 

    template <class T> class numeric_limits 
    {
    public:
        static const bool is_specialized = false; // Igaz minden specializációra.
        static T min() throw(); // A típus által ábrázolható legkisebb véges érték
        static T max() throw(); // A típus által ábrázolható legnagyobb véges érték.
        static const int  digits = 0; // Egész számok esetén az értékes számjegyek bitszáma (előjelbit nélkül), valós számok esetén a mantissza bitszáma.
        static const int  digits10 = 0; // Ábrázolható értékes számjegyek maximális száma (tízes számrendszerben).
        static const bool is_signed = false; // Előjeles számokra igaz.
        static const bool is_integer = false; // Egész számokra igaz
        static const bool is_exact = false; // Igaz, ha egzakt reprezentációt használ (egész számokra igaz, valósra hamis).
        static const int radix = 0; // Ábrázoláshoz használt számrendszer alapja (2).
        static T epsilon() throw(); // Különbség 1 és hozzá legközelebbi, de nála nagyobb szám között. 
        static T round_error() throw(); // A legnagyobb kerekítési hiba mértéke.

        static const int  min_exponent = 0; // Minimális nagyságrend (kettes számrendszerben)
        static const int  min_exponent10 = 0; // Minimális nagyságrend (10-es számrendszerben)
        static const int  max_exponent = 0; // Maximális nagyságrend (kettes számrendszerben)
        static const int  max_exponent10 = 0; // Maximális nagyságrend (10-es számrendszerben)

        static const bool has_infinity = false; // Igaz, ha értelmezi a végtelen fogalmát.
        static const bool has_quiet_NaN = false; // Igaz, ha értelmezi a csendes „nem szám” fogalmát.
        static const bool has_signaling_NaN = false; // Igaz, ha értelmezi a jelző generáló „nem szám” fogalmát.
        static const float_denorm_style has_denorm = denorm_absent; // Támogatja-e a normálatlan értékeket. Lehetséges értékei: denorm_indeterminate, denorm_absent, denorm_present
        static const bool has_denorm_loss = false; // Igaz, ha a típus tudja érzékelni a normálatlan veszteséget.
        static T infinity() throw(); // A pozitív végtelen értéke
        static T quiet_NaN() throw(); // Csendes „nem szám”
        static T signaling_NaN() throw(); // Jelző „nem szám”
        static T denorm_min() throw(); // Legkisebb értékű normálatlan szám.

        static const bool is_iec559 = false; // Igaz, ha a típus IEC559 szabványt követ.
        static const bool is_bounded = false; // Igaz, ha a típus által felvehető értékek száma véges. (Szerintem mindig igaz)
        static const bool is_modulo = false; // Igaz, ha a típus értéke átfordul egy bizonyos érték meghaladása után.

        static const bool traps = false; // Igaz, ha a típus értékkészletében van legalább egy olyan érték, amely valamelyik aritmetikai műveletnél alkalmazva hibát generál. (egész számok nullával való osztás).
        static const bool tinyness_before = false; // Igaz, ha kerekítés előtt érzékeli a rendszer, hogy a szám túl kicsi (normálatlan).
        static const float_round_style round_style = round_toward_zero; // A kerekítés módját határozza meg: round_indeterminate, round_toward_zero, round_to_nearest, round_toward_infinity, round_toward_neg_infinity.
    }

Minden egyes alap számtípusra létezik specializációja.

A locale függvénytár

A <locale> fejlécben van. Ezzel nyelvspecifikus dolgokat állíthatunk be (dátum, számformátum, pénzformátum, stb). Ez egy elég nagy téma, részletesen nem megyek bele inkább.

Memóriakezelő dolgok

A <memory> fejlécben van. A standard függvénytárban van egy pár memóriakezelő függvény (és annál több típus), amelyek elég hasznosak.

Az allocator sablon

Ez az alapértelmezett memóriafoglaló, amelyet minden használ, ha nem adunk meg mást.

A sablon megadása. 

    template < class T > class allocator;

Ahol T az objektum típusa, amit lefoglalni szeretnénk. Lehet készíteni hozzá specializációt.

Belső típusai

A következő belső típusai vannak:

value_type
T
pointer
T*
reference
T&
const_pointer
const T*
const_reference
const T&
size_type
size_t
difference_type
ptrdiff_t
Konstruktorok
    allocator() throw();
    allocator(const allocator&) throw();
    template <class U> allocator(const allocator<U>&) throw();

Ezek a standard memóriafoglaló esetén semmi extrát nem csinálnak.

Destruktor
    ~allocator() throw();

Nem csinál semmit.

address metódus – &x
    pointer address(reference x) const;
    const_pointer address(const_reference x) const;

Visszatér a paraméter címével. Standard memóriafoglaló esetén ez lényegében &x.

allocate metódus – new
    pointer allocate(size_type n, allocator<void>::const_pointer hint=0);

Megadott számú (n) elemet foglal le és visszatér a blokk címével. Az memóriafoglalónak lehet tippet adni egy korábban lefoglalt blokkal, hogy merrefelé foglaljon blokkot. A standard memóriafoglaló a new operátort használja az allokációhoz.

deallocate metódus – delete
    void deallocate(pointer p, size_type n);

Megadott mutató által mutatott területről felszabadít n elemet. Az n-nek pont annyi elemnek kell lennie, mint amennyit lefoglaltunk.

Standard memóriafoglaló esetén a delete operátorral lesz felszabadítva a blokk. Az egyes elemekre nem hívódik destruktor!

max_size – az elméletileg legnagyobb lefoglalható blokk mérete
    size_type max_size() const throw();

Visszatér az elméletben lehetségesen lefoglalható legtöbb elem számával. A függvénynek nem sok haszna van, mert nem garantálja, hogy a visszatérési értékként kapott számú elemet le is lehet foglalni.

construct – másoló konstruktor hívása az a megadott mutatónál
    void construct(pointer p, const_reference val);

A p mutatón lévő területen, hívja a másoló konstruktort val értékkel. Standard memóriafoglaló esetében ez lényegében a következő helyi new operátor hívása: new ((void*)p) T (val);

destroy – destruktor hívása
    void destroy (pointer p);

Meghívja a destruktort a megadott mutatón. Standard memóriafoglaló esetében ez lényegében egy destruktorhívás: ((T*)p)->~T();.

auto_ptr

    template <class X> class auto_ptr;

Ez egy olyan objektum, amely magába zár a mutatót, és felszabadítja azt a delete operátorral, amikor az objektum megsemmisül.

Konstruktorai
    explicit auto_ptr (X* p=0) throw();
    auto_ptr (auto_ptr& a) throw();
    template<class Y> auto_ptr (auto_ptr<Y>& a) throw();
    auto_ptr (auto_ptr_ref<X> r) throw();

A p egy mutató, amelyet az objektum átvesz. Az a egy másik auto_ptr, amelytől átveszi a mutatót az éppen készített objektum (szóval az már nem tárolja azt.) Az r egy auto_ptr_ref amely egy referencia egy auto_ptr osztályra.

Destruktor
    ~auto_ptr() throw();

Felszabadítja a memóriát, melyre a tárolt mutató mutat (egy delete operátorral).

get metódus
    X* get() const throw();

Lekérdezi a tárolt mutató értékét.

A * operátor
    X& operator*() const throw();

Hagyományos mutatókhoz hasonlóan használható a * operátor ezen osztály példányain.

A -> operátor
    X* operator->() const throw();

A -> operátor is használható ezen az osztályon ugyanúgy, mint sima mutatókon.

Az = operátor
    auto_ptr& operator= (auto_ptr& a) throw();
    template <class Y> auto_ptr& operator= (auto_ptr<Y>& a) throw();
    auto_ptr& operator= (auto_ptr_ref<X> r) throw();

Ez az operátor nem másol, hanem mozgat, a jobb oldalán álló auto_ptr-ben lévő mutató nullázva lesz, miután át lett másolva a bal oldalon állóba. Ha a baloldalon álló objektum már tárol egy mutatót, akkor az fel lesz szabadítva a delete operátorral.

release metódus – tárolt mutató elengedése
    X* release() throw();

Elengedi a tárolt mutatót, és visszatér vele. A művelet után a tárolt mutató értéke NULL lesz. A mutatott objektum nem fog felszabadulni.

reset metódus – tárolt mutatón tárolt adat felszabadítása
    void reset (X* p=0) throw();

Felszabadítja a tárolt mutató által mutatott objektumot a delete operátorral, és lecseréli a p mutatóra.

Konvertáló operátorok
    template <class Y> operator auto_ptr_ref<Y>() throw();
    template <class Y> operator auto_ptr<Y>() throw();

Ezek a konvertáló operátorok arra jók, hogy egy olyan auto_ptr vagy auto_ptr_ref objektumot csináljuk, amely más típusú adatra mutat.

auto_ptr_ref osztály

    template <class Y> struct auto_ptr_ref;

Ebben semmi érdekes nincs, ez csak egy osztály, amelyben auto_ptr-re mutató referenciát lehet tárolni.

Inicializálatlan memória kezelése

raw_storage_iterator osztály
template <class OutputIterator, class T>
  class raw_storage_iterator :
    public iterator<output_iterator_tag,void,void,void,void>
{
    protected:
        OutputIterator iter;

    public:
    explicit raw_storage_iterator (OutputIterator x) : iter(x) {}
    raw_storage_iterator<OutputIterator,T>& operator* ()
    { 
        return *this; 
    }
    raw_storage_iterator<OutputIterator,T>& operator= (const T& element)
    { 
        new (static_cast<void*>(&*iter)) T (element); 
        return *this; 
    }
    raw_storage_iterator<OutputIterator,T>& operator++ ()
    { 
        ++iter; 
        return *this; 
    }
    raw_storage_iterator<OutputIterator,T> operator++ (int)
    { 
        raw_storage_iterator<OutputIterator,T> tmp = *this; 
        ++iter; 
        return tmp; 
    }
};

Ez egy OutputIterator (kimeneti bejáró), amely inicializálatlan területen működik: íráskor ott helyben konstruálja meg az objektumokat. A hagyományos kimeneti bejáró már létező objektumokon működik.

Ideiglenes pufferek függvényei

get_temporary_buffer függvény – lényegében malloc
    template <class T> pair <T*,ptrdiff_t> get_temporary_buffer ( ptrdiff_t n );

Egyfajta C++-os malloc, mellyel megadott számú és típusú elemnek foglalhatunk memóriát. Ha sikerül a lefoglalás egy pair-rel tér vissza, melynek első eleme egy mutató a lefoglalt bufferre, a második pedig a ténylegesen lefoglalt elemeknek a száma. Ha nem sikerül a lefoglalás, akkor NULL-ra lesz állítva a mutató, és 0-ra a lefoglalt elemek száma. Semmi inicializálást nem csinál.

return_temporary_buffer függvény – lényegében free
    template <class T> void return_temporary_buffer (T* p);

Egyfajta C++-os free. A get_temporary_buffer függvénnyel kapott memória visszaadása.

Specializált algoritmusok

uninitialized_copy függvény – másolás inicializálatlan területre
    template <class InputIterator, class ForwardIterator> 
        ForwardIterator uninitialized_copy 
        ( 
            InputIterator first, InputIterator last,
            ForwardIterator result
        );

Lényegében ugyanazt csinálja, mint a sima copy, csak ez ott helyben konstruálja meg az objektumokat (másoló konstruktorral), ahelyett hogy az egészet csak úgy átmásolná (az = operátorral). Nyilván ez működik inicializálatlan területen is, a sima copy nem.

uninitialized_fill függvény – inicializálatlan terület kitöltése
    template <class ForwardIterator, class T>
        void uninitialized_fill 
        (
            ForwardIterator first, ForwardIterator last, const T& x
        );

Ugyanazt csinálja, mint a fill algoritmus, csak ez inicializálatlan területen másoló konstruktorral hozza létre az objektumokat, a sima fill az = operátor segítségével.

uninitialized_fill_n függvény
    template <class ForwardIterator, class Size, class T> void uninitialized_fill_n (ForwardIterator first, Size n, const T& x);

Ugyanazt csinálja, mint a fill_n algoritmus, csak ez inicializálatlan területen másoló konstruktorral hozza létre az objektumokat, a sima fill_n az = operátor segítségével.

A <new> fejléc

Ez a fejléc írja le a new operátorral kapcsolatos dolgokat. Fontos tudni, hogy a new, new[], delete és delete[] operátorok ezen fejléc beszúrása nélkül is működik, viszont a kapcsolódó dolgok eléréséhez be kell szúrni ezt a fejlécet.

Típusok

bad_alloc

Ez egy kivétel, amely az exception osztályból származik, akkor dobják, ha az lefoglalás sikertelen volt.

new_handler
    typedef void (*new_handler)();

Egy paraméter és visszatérési érték nélküli függvénytípus.

nothrow_t

Segédtípus, egy üres struktúra

Konstansok

nothrow
    extern const nothrow_t nothrow;

Ez a konstans a kivételt nem dobó new operátorhoz van, amelyet valahogy így kell használni: 

    new (nothrow) Típus(paraméterek)

Ez a new operátor NULL mutatóval tér vissza, és nem fog kivételt dobni, ha sikertelen az allokáció.

Függvények

set_new_handler – sikertelen new operátor hívása esetén hívódik
    new_handler set_new_handler (new_handler new_p) throw();

Beállít egy handlert, amely akkor hívódik, amikor a standard new vagy new[] operátor nem tudott sikeresen lefutni. Visszatér a korábbi kezelőre mutató mutatóval.

Számsorozatokra alkalmazható algoritmusok

Ezek a <numeric> fejlécben vannak. Számokat tartalmazó tartományokra alkalmazhatók.

accumulate – elemek összegzése

    template <class InputIterator, class T>
       T accumulate(InputIterator eleje, InputIterator vege, T kezdo);
    template <class InputIterator, class T, class BinaryOperation>
       T accumulate(InputIterator eleje, InputIterator vege, T kezdo, BinaryOperation binaris_muvelet);

Megadott tartomány elemeit összegzi, megadott kezdőértéktől kezdve (kezdo). Az alapértelmezett algoritmus a + operátort használja, de megadhatunk saját kétoperandusú műveletet is.

adjacent_difference – szomszédos elemek különbsége

    template <class InputIterator, class OutputIterator>
        OutputIterator adjacent_difference 
        ( 
           InputIterator eleje, 
           InputIterator vege,
           OutputIterator eredmeny 
        );

    template <class InputIterator, class OutputIterator, class BinaryOperation>
        OutputIterator adjacent_difference 
        ( 
            InputIterator eleje, 
            InputIterator vege,
            OutputIterator eredmeny, 
            BinaryOperation binary_op 
        );

A megadott tartomány szomszédos elemeinek a különbségét számolja ki, és az eredményt a megadott kimeneti bejáróhoz írja. Az eredmény első eleme a kiindulási tartomány első eleme, a többi érték a tartomány adott eleme, és az azt megelőző elem különbsége. Alapértelmezésben a - operátort használja, de megadhatunk saját operátort is.

Példa: [1, 2, 4, 7, 11, 16] => [1, 1, 2, 3, 4, 5]

inner_product – skaláris szorzat, belső szorzat

    template <class InputIterator1, class InputIterator2, class T>
        T inner_product 
        ( 
            InputIterator1 eleje1, 
            InputIterator1 vege1,
            InputIterator2 eleje2, 
            T init 
        );

    template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
        T inner_product 
        ( 
            InputIterator1 eleje1, 
            InputIterator1 vege1,
            InputIterator2 eleje2, 
            T init,
            BinaryOperation1 osszeadas,
            BinaryOperation2 szorzas
        );

Két azonos hosszúságú listának a belső szorzatát állítja elő (azaz összeszorozza elemeiket páronként, és összeadja az eredményeket). Az init-et használva kezdőértéknek. Alapértelmezésben a + és * műveletet használja, de lehet használni saját összeadás és szorzás műveleteket is.

Példa: [1, 2, 3] * [3, 4, 5] = 3 + 8 + 15 = 26

partial_sum – részösszegek listájának az előállítása

    template <class InputIterator, class OutputIterator>
        OutputIterator partial_sum 
        ( 
            InputIterator eleje, 
            InputIterator vege,
            OutputIterator eredmeny 
        );

    template <class InputIterator, class OutputIterator, class BinaryOperation>
        OutputIterator partial_sum 
        ( 
            InputIterator eleje, 
            InputIterator vege,
            OutputIterator eredmeny, 
            BinaryOperation muvelet
        );

A megadott tartomány elemeit összeadogatja a részeredményeket a megadott bejáróhoz írja ki. Alapértelmezésben a + műveletet használja, de megadhatunk sajátot is.

[1, 2, 3, 4] => [1, 3, 6, 10]

Standard kivételek

Ez az <stdexcept> fejlécben van. A szabvány a következő osztályhierarchiát definiálja a kivételekből:

Minden standard függvénynél adott, hogy milyen kivételeket dobhat.

Futás közbeni típusazonosítás

A <typeinfo> fejléc deklarálja azt a struktúrát, amelyet a typeid operátor állít elő. 

    class type_info 
    {
    public:
        virtual ~type_info();
        bool operator== (const type_info& rhs) const;
        bool operator!= (const type_info& rhs) const;
        bool before (const type_info& rhs) const;
        const char* name() const;
    private:
        type_info (const type_info& rhs);
        type_info& operator= (const type_info& rhs);
    };

A konstruktora és a másoló konstruktora privát, mert ezt csak a typeid operátor hozhatja létre.

A name metódusával lehet lekérdezni a típus nevét. A before metódus igazat ad, ha a típus illesztési sorrendben megelőz egy másik típust (ezt lehet használni < operátorként ha adatszerkezetben akarunk típusokat tárolni).

bad_cast kivétel

Ezt akkor dobja, amikor a dynamic_cast nem tudja átkonvertálni a referenciát (mutató esetén NULL-t ad az az operátor)

bad_typeid kivétel

Ezt akkor dobja, amikor a typeid operátor, ha NULL mutatót adunk neki.

Az utility fejléc

Pár hasznos apróság van ebben a fejlécben.

pair

Ezzel a sablonnal lehet két dolgot egybe pakolni, korábban már előkerült, megadása: 

    template <class T1, class T2> struct pair
    {
      typedef T1 first_type;
      typedef T2 second_type;

      T1 first;
      T2 second;
      pair() : first(T1()), second(T2()) {}
      pair(const T1& x, const T2& y) : first(x), second(y) {}
      template <class U, class V>
        pair (const pair<U,V> &p) : first(p.first), second(p.second) { }
    }

A globális összehasonlító operátorok is értelmezve vannak rajta: először az első értéket hasonlítja össze, ha az egyenlő, akkor a másodikat. Ha mindkettő egyenlő, akkor két pár egyenlőnek tekintendő.

make_pair függvény – pár gyártása

    template <class T1, class T2> pair<T1,T2> make_pair(T1 x, T2 y);

Egy pair példányt hoz létre. Semmi extra nincs benne, csak egyszerűbb make_pair(1, 2)-t írni, mint std::pair<int,int>(1, 2)-t.

rel_ops névtér

    namespace rel_ops 
    {
        template <class T> bool operator!= (const T&, const T&);
        template <class T> bool operator>  (const T&, const T&);
        template <class T> bool operator<= (const T&, const T&);
        template <class T> bool operator>= (const T&, const T&);
    }

Ebben a névtérben az == és az < operátor segítségével definiáljuk a többit, így saját típushoz elég csak ezt a kettőt definiálni. A többi ezen névtér használatával elérhetővé válik.

valarray

Ezt a <valarray> fejlécben találjuk. Ezt vektoros számítások elvégzésére találták ki, azonban nem nagyon használatos, illetve vannak jobb erre szakosodott függvénytárak is már erre.

Alap sablonok

A legtöbb iostream és más osztályoknak léteznek ún. alapsablonjaik melyekkel a funkcióik általánosíthatók más adattípusokra is, a következő táblázatban gyűjtöttem össze ezeket:

Alap sablon Példánya Példány kifejtve
basic_ios<charT, traits> ios basic_ios<char, char_traits<char> >
basic_istream<charT, traits> istream basic_istream<char, char_traits<char> >
basic_ostream<charT, traits> ostream basic_ostream<char, char_traits<char> >
basic_iostream<charT, traits> iostream basic_iostream<char, char_traits<char> >
basic_streambuf<charT, traits> streambuf basic_streambuf<char, char_traits<char> >
basic_ifstream<charT, traits> ifstream basic_ifstream<char, char_traits<char> >
basic_fstream<charT, traits> fstream basic_fstream<char, char_traits<char> >
basic_ofstream<charT, traits> ofstream basic_ofstream<char, char_traits<char> >
basic_filebuf<charT, traits> filebuf basic_filebuf<char, char_traits<char> >
basic_istringstream<charT, traits> istringstream basic_istringstream<char, char_traits<char> >
basic_ostringstream<charT, traits> ostringstream basic_ostringstream<char, char_traits<char> >
basic_stringstream<charT, traits> stringstream basic_stringstream<char, char_traits<char> >
basic_stringbuf<charT, traits> stringbuf basic_stringbuf<char, char_traits<char> >
basic_ios<charT, traits> wios basic_ios<char, char_traits<wchar_t> >
basic_istream<charT, traits> wistream basic_istream<char, char_traits<wchar_t> >
basic_ostream<charT, traits> wostream basic_ostream<char, char_traits<wchar_t> >
basic_iostream<charT, traits> wiostream basic_iostream<char, char_traits<wchar_t> >
basic_streambuf<charT, traits> wstreambuf basic_streambuf<char, char_traits<wchar_t> >
basic_ifstream<charT, traits> wifstream basic_ifstream<char, char_traits<wchar_t> >
basic_fstream<charT, traits> wfstream basic_fstream<char, char_traits<wchar_t> >
basic_ofstream<charT, traits> wofstream basic_ofstream<char, char_traits<wchar_t> >
basic_filebuf<charT, traits> wfilebuf basic_filebuf<char, char_traits<wchar_t> >
basic_istringstream<charT, traits> wistringstream basic_istringstream<char, char_traits<wchar_t> >
basic_ostringstream<charT, traits> wostringstream basic_ostringstream<char, char_traits<wchar_t> >
basic_stringstream<charT, traits> wstringstream basic_stringstream<char, char_traits<wchar_t> >
basic_stringbuf<charT, traits> wstringbuf basic_stringbuf<char, char_traits<wchar_t> >
basic_string<charT> string basic_string<char>
basic_string<charT> wstring basic_string<wchar_t>

Látható, hogy az ios_base kivételével az összes IOStream osztálynak van egy „basic_” előtagos változata, illetve a string osztálynak még.

Hasonlóan létezik wcin, wcout, wcerr, wclog, amelyek wchar_t-vel működnek a char helyett (ld. IOStream objektumok).

Ha hozzá akarsz szólni ehhez a poszthoz, oszd meg a közösségi médiában!
Nemrég frissült:
Rólam (2023-08-24)
Játékok (2021-12-11)
Tudomány>> Fizika>> Számolás elhanyagolhatóan pici dolgokkal (2021-12-11)
Tudomány>> Fizika>> 12. Mesterséges gravitáció (2021-12-11)
Tudomány>> Fizika>> 13. Helyzeti energia (2021-12-11)
Logo