Wczytywanie z pliku txt

Mam taką funkcję która ma wczytać linie z pliku, ale jeśli odpalę ją w pętli to zaczyna czytać od początku a nie od miejsca gdzie skończyła. Funkcja by miała wczytać plik potem wypisać w konsoli co wczytała i znowu wczytać plik ale za drugim razem wczytuje od początku. Da się jakoś zrobić żeby ominąć pierwsze 6 linijek w pliku, potem 12 itd czy jakoś tak? Plik wygląda tak:

1. Ile to 2+2
A. 1
B. 2
C. 3
D. 4
d
1. Ile to 2-2
A. 0
B. 2
C. 3
D. 4
a
1. Ile to 2*2
A. 0
B. 2
C. 3
D. 4
d

itd.

Zależy mi żeby funkcja czytała pojedynczo każde pytanie, 4 odpowiedzi i poprawną a nie cały plik na raz bo tak to wiem jak zrobić. Dzięki za pomoc.

nr_linii=1;
void Pytanie::wczytaj()
{
    fstream plik;
    string linia;
    plik.open("quiz.txt", ios::in);

    if(plik.good()==false)
    {
        cout<<"Nie ma pliku";
        exit(0);
    }

    while(getline(plik,linia))
    {
        switch(nr_linii)
        {
        case 1: tresc=linia; break;
        case 2: a=linia; break;
        case 3: b=linia; break;
        case 4: c=linia; break;
        case 5: d=linia; break;
        case 6: poprawna=linia; break;
        }
    nr_linii++;
    if(nr_linii==7) {nr_linii=1; break;}
    }
    plik.close();
}

/////////////////////////////////////////////////

void Pytanie::zadaj()
{
    cout<<tresc<<endl<<endl;
    cout<<a<<endl;
    cout<<b<<endl;
    cout<<c<<endl;
    cout<<d<<endl;
    cin>>odp;
}

przyznam, że nie robiłem wczytywania pliku od miejsca w którym program zakończył czytanie (czy to z powodów wysypania się programu czy to przez przerwanie wczytywania na żądanie użytkownika czy to z założenia, że program ma na wstępie wczytać "dowolną ilość" linii.

Osobiście bym to zrobił tak (kroki mogą być bardzo ogólne gdyż piszę to na szybko)

Załóżmy, że założyłem sobie, że program po wskazaniu pliku do otwarcia wczytuje dowolną ilość linii które oddzielone są jakimś znakiem specjalnym, ponieważ nie jestem jednoznacznie stwierdzić czy rzeczywiście zawsze będę wczytywał 5 lub 10 linii (znak specjalny może być to zwykły "enter" po którym nie ma żadnych innych znaków

1. Wczytuję plik i program wczytuje "dowolną ilość" linii i przerywa wczytywanie w miejscu gdzie ustali użytkownik
2. Tam gdzie przerwało wczytywanie linii, ilość stanu wczytanych linii zapisuję do pliku (np wczytałem 15 linii to ich stan zapisuję do pliku jako liczba 15)
3. otwieram ponowne ten sam plik i program wczytuje plik do wczytania i plik "ze stanem linii" i zaczyna wczytywanie od momentu w którym poprzednio wczytywanie zostało przerwane

żadne tam kombinowanie z milionami getlinów, program po prostu musi jakoś pamiętać "ostatni stan" na którym skończył - lepszego sposobu na "zapisanie stanu" nie znam

A nie myślałeś, żeby po prostu uchwyt na plik był częścią klasy? Wówczas to "trzymanie pozycji" masz za darmo.

Nie lepiej do tego użyć bazy danych? Jeśli chcesz koniecznie wybierać pytania z pliku tekstowego, to może stwórz w pliku przed każdym pytaniem jakieś wyrażenie regularne połączone z numeracją, oznaczając w ten sposób kolejne pytania i sobie będziesz przeszukiwał plik dowolnie z niego wypisując fragmenty które chcesz, posługując się np. numeracją pytań. Nie wiem czy wystarczająco jasno napisałem co mam na myśli?

Zrobiłem na trochę pokrętny sposób może kiedyś jakiemuś początkującemu się przyda co robi pasje inf:
W skrócie przy 2 pytaniu odejmuje 6 od switcha i switch musi przejść przez te pierwsze 6 lini i nic z nimi nie robi, przy trzecim pytaniu odejmuje 12 itd. (chyba)

//main.cpp
#include <iostream>
#include "pytanie.h"

using namespace std;

int main()
{
    float suma=0;
    Pytanie p[5];
    for(int i=0;i<5;i++)
    {
        p[i].nr_pyt=i;
        p[i].wczytaj();
        p[i].zadaj();
        p[i].sprawdz();
        suma+=p[i].pkt;
        cout<<endl<<"Twoje punkty wynosza: "<<suma<<"/5";
        cout<<" A procent poprawnych odpowiedzi wynosi: "<<(suma/(i+1))*100<<"%"<<endl<<endl;
    }
    cout<<endl<<endl<<"KONIEC QUIZU"<<endl;

    return 0;
}

//pytanie.cpp
#include <iostream>
#include "pytanie.h"
#include <fstream>


using namespace std;

void Pytanie::wczytaj()
{
    fstream plik;
    string linia;
    plik.open("quiz.txt", ios::in);

    if(plik.good()==false)
    {
        cout<<"Nie ma pliku";
        exit(0);
    }
    int aktualny_nr=1;
    while(getline(plik,linia))
    {
        switch(aktualny_nr-(nr_pyt)*6)
        {
        case 1:
            tresc=linia;
            break;
        case 2:
            a=linia;
            break;
        case 3:
            b=linia;
            break;
        case 4:
            c=linia;
            break;
        case 5:
            d=linia;
            break;
        case 6:
            poprawna=linia;
            break;
        }
        aktualny_nr++;


    }
    plik.close();
}
void Pytanie::zadaj()
{
    cout<<tresc<<endl<<endl;
    cout<<a<<endl;
    cout<<b<<endl;
    cout<<c<<endl;
    cout<<d<<endl;
    cin>>odp;
}

void Pytanie::sprawdz()
{
    if(odp==poprawna)
    {
        cout<<endl<<"Dobrze"<<endl<<endl;
        pkt=1;
    }
    else
    {
        cout<<endl<<"Zle"<<endl<<endl;
    }
}

//pytanie.h
#include <iostream>

using namespace std;

class Pytanie
{
    public:

    string tresc;
    string a, b, c, d;
    string odp, poprawna;
    int nr_pyt=0, nr_linii, pkt=0, suma=0;

    void wczytaj(); //wczytuje dane z pliku
    void zadaj(); //zadaje pytanie
    void sprawdz(); //sprawdza

};

Zrobiłem na trochę pokrętny sposób

A nie lepiej zrobić to normalnie, bez switcha, otwierając strumień tylko raz?

std::istream& Pytanie::wczytaj(std::istream& is)
{
	std::getline(is, tresc);
	std::getline(is, a);
	std::getline(is, b);
	std::getline(is, c);
	std::getline(is, d);
	std::getline(is, poprawna);
	return is;
}

...

std::vector<Pytanie> pytania;

std::ifstream plik("quiz.txt");
Pytanie pytanie;

while(pytanie.wczytaj(plik))
	pytania.push_back(std::move(pytanie));

Ja bym poprawił tak:

std::istream& Pytanie::wczytaj(std::istream& is)
{
    std::getline(is, tresc);
    std::string odpowiedz;
    while (std::getline(is, odpowiedz) && !odpowiedz.empty()) {
         odpowiedzi.push_back(odpowiedz);
    }
    return is;
}

Gdzie std::vector<string> odpowiedzi; to pole klasy, a pierwszy element jest prawidłową odpowiedzią.
Podczas pokazywania pytania odpowiedzi wyświetlałbym w losowej kolejności. Odpowiedzi może być więcej niż jest potrzebne.
Łatwiej wtedy utrzymuje się dane wejściowe.

Krzysztof Miller napisał(a):

Mam taką funkcję która ma wczytać linie z pliku, ale jeśli odpalę ją w pętli to zaczyna czytać od początku a nie od miejsca gdzie skończyła. Funkcja by miała wczytać plik potem wypisać w konsoli co wczytała i znowu wczytać plik ale za drugim razem wczytuje od początku. Da się jakoś zrobić żeby ominąć pierwsze 6 linijek w pliku, potem 12 itd czy jakoś tak?

Pomysł chybiony. Wejście/wyjście jest z natury strumieniowe. A otwieranie tego samego pliku za każdym razem to marnotrawstwo.

Design też nie taki jak trzeba. Klasa nie musi mieć zakodowanej na stałe nazwy pliku, a funkcja wczytaj nie musi tworzyć strumienia. Twoja funkcja równie dobrze może przejmować strumień poprzez argument funkcji, ewentualnie argument konstruktora klasy. W ten sposób rozdzielasz odpowiedzialność tworzenie (otwierania) strumienia (pliku) od jego konsumpcji. Postaraj się nie tworzyć klas, które robią za dużo. Zasada pojedynczej odpowiedzialności.

A czym jest strumień - plikiem, standardowym wejście, czy stringiem z testu, jest bez znaczenia, ważne, że dostarcza on mechanizm pozwalający Ci odczytać dane. Zobacz kod @MarekR22 . Tak to powinno wyglądać.