std::istream::ignore

Angol

Főnév

std::istream::ignore (tsz. std::istream::ignores)

(informatika) A std::istream::ignore függvény a C++ standard könyvtárban egy bemeneti adatfolyamból (std::istream) karaktereket hagy figyelmen kívül. Ez különösen hasznos, amikor az előző bemeneti műveletek után maradt nem kívánt karaktereket, például újsor (\n) vagy egyéb elválasztókat kell eltávolítani.

1. Szintaxis

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

Paraméterek:

n: Az ignorálni kívánt karakterek száma. Alapértelmezett értéke 1.
delim: Egy határoló karakter, amelyig az ignorálás történik. Ha ezt a karaktert találja, az ignore leáll. Alapértelmezett értéke EOF (fájl vége karakter).

Visszatérési érték:

A std::istream referencia (*this), így láncolható más műveletekkel.

2. Alapvető Használat

Egyszerű példa:

#include <iostream>

int main() {
    char c;
    std::cout << "Adj meg egy karaktert és nyomj Entert: ";
    std::cin >> c;

    std::cin.ignore();  // Az Enter (newline) karakter eltávolítása

    std::cout << "Adj meg egy másik karaktert: ";
    std::cin >> c;

    std::cout << "Második karakter: " << c << std::endl;

    return 0;
}

Magyarázat:

Az első std::cin >> c; egy karaktert olvas be, de az Enter (\n) a pufferben marad.
std::cin.ignore(); eltávolítja ezt az újsor karaktert.
A második std::cin >> c; már egy új karaktert vár a felhasználótól.

3. Több karakter ignorálása

A std::istream::ignore használható nagyobb mennyiségű karakter kihagyására.

std::cin.ignore(100, '\n');

Ez azt jelenti, hogy a következő 100 karaktert hagyja figyelmen kívül, vagy a következő '\n' karakterig.

Példa több karakter kihagyására:

#include <iostream>

int main() {
    char str[10];

    std::cout << "Adj meg egy hosszú szöveget: ";
    std::cin.get(str, 10);  // Csak 9 karaktert olvas be

    std::cin.ignore(100, '\n');  // Az extra karaktereket és az Entert eldobjuk

    std::cout << "Beolvasott szöveg: " << str << std::endl;

    return 0;
}

Mi történik itt? - A std::cin.get(str, 10); maximum 9 karaktert olvas be (10 - 1 a nullterminátor miatt). - Ha a felhasználó ennél hosszabb szöveget adott meg, akkor a maradék a pufferben marad. - A std::cin.ignore(100, '\n'); eltávolítja a maradék karaktereket, hogy az új bemenet tiszta legyen.

4. Használat std::getline előtt

Ha std::cin >> valami; után std::getline(std::cin, szoveg); következik, akkor a std::cin.ignore(); fontos, mert különben a getline az előző cin után maradt újsor karaktert (\n) olvassa be.

Helytelen kód (hiba van benne)

#include <iostream>
#include <string>

int main() {
    int szam;
    std::string nev;

    std::cout << "Adj meg egy számot: ";
    std::cin >> szam;

    std::cout << "Add meg a neved: ";
    std::getline(std::cin, nev);  // Hibás lesz, mert az előző cin után ott maradt egy '\n'

    std::cout << "Név: " << nev << std::endl;

    return 0;
}

Megoldás:

#include <iostream>
#include <string>

int main() {
    int szam;
    std::string nev;

    std::cout << "Adj meg egy számot: ";
    std::cin >> szam;
    std::cin.ignore();  // Eltávolítja az Entert

    std::cout << "Add meg a neved: ";
    std::getline(std::cin, nev);  // Most már helyesen működik

    std::cout << "Név: " << nev << std::endl;

    return 0;
}

5. Fájlkezelésnél is hasznos

A std::istream::ignore fájlból történő olvasáskor is jól jön, például amikor egy bizonyos karakterig vagy egy teljes sorig szeretnénk kihagyni a bemenetet.

Példa fájlkezelésre

#include <iostream>
#include <fstream>

int main() {
    std::ifstream fajl("adatok.txt");

    if (!fajl) {
        std::cerr << "Hiba: Nem sikerült megnyitni a fájlt!" << std::endl;
        return 1;
    }

    std::string sor;
    std::getline(fajl, sor); // Beolvassa az első sort
    fajl.ignore(1000, '\n'); // A következő 1000 karaktert figyelmen kívül hagyja vagy a következő sortörésig

    std::getline(fajl, sor); // Most egy újabb sort olvasunk

    std::cout << "Második sor a fájlból: " << sor << std::endl;

    fajl.close();
    return 0;
}

Miért fontos itt az ignore? - Ha az első sor tartalmaz sok karaktert, és nem akarjuk az összeset feldolgozni, az ignore segít kihagyni a maradékot.

6. Tipikus hibák

Nem használod ignore()-t cin >> és getline() között.
- Megoldás: std::cin.ignore(); használata.
Túl kevés karaktert ignorálsz.
- Ha például sok felesleges karakter van a pufferben, egy egyszerű std::cin.ignore(); nem mindig elég. Használj nagyobb értéket, például std::cin.ignore(1000, '\n');.
Túl sok karaktert ignorálsz.
- Ha egy érzékeny formázott bemenetben túl sok karaktert dobsz el, lehet, hogy fontos adatot is elveszítesz.

Összegzés

A std::istream::ignore() egy hasznos eszköz a bemeneti puffer tisztítására.
Különösen fontos std::cin >> és std::getline() együtt használatakor.
Használható fájlok olvasásánál is.
Alapértelmezettként 1 karaktert hagy figyelmen kívül, de nagyobb értéket is megadhatunk (n).
Egy delim karakterig is ignorálhatunk (std::cin.ignore(100, '\n');).

Ha helyesen használod, elkerülheted a bemeneti hibákat, és programod stabilabbá válik! 🚀

További információk

std::istream::ignore - Szótár.net (en-hu)
std::istream::ignore - Sztaki (en-hu)
std::istream::ignore - Merriam–Webster
std::istream::ignore - Cambridge
std::istream::ignore - WordNet
std::istream::ignore - Яндекс (en-ru)
std::istream::ignore - Google (en-hu)
std::istream::ignore - Wikidata
std::istream::ignore - Wikipédia (angol)