Syntax och parametrar för funktionen Seekg() i C++
Seekg() kan implementeras med två syntaxer:
1. Streampos Syntax
ström & sökkg ( streampos inlägg ) ;Denna syntax tar bara en parameter, position, som representerar markörens position i strömbufferten. Det representerar ett 'int'-värde och av typen streampos.
2. Offset- och riktningssyntax
ström & sökkg ( strömma av ofta , ios_base :: söka är smuts ) ;Denna syntax tar två parametrar som indata: offset och riktning. Parametern 'ofst' är ett heltal av typen streamoff som indikerar offset i strömmens buffert. Parametern 'smuts' söker riktning.
- ios_base::beg: Offset från början av strömmens buffert.
- ios_base::cur: Offset från den aktuella positionen i strömmens buffert.
- ios_base::end: Offset från den sista av strömmens buffert.
Seekg()-funktionen i C++ manipulerar filpekaren, vilket gör att programmeraren kan placera den på en specifik plats i filen. Den returnerar modifieringen av 'istream'-objektet (*detta) och justerar filpekaren därefter.
Fel- och undantagshantering i C++ Seekg()-funktionen
Seekg()-funktionen i C++ säkerställer den grundläggande garantin för undantagshantering och bibehåller objektets giltighet om ett undantag inträffar. Det kan kasta 'fel'-undantag när feltillståndsflaggan saknar information, och funktionen fångar och hanterar dessa undantag på ett ansvarsfullt sätt, och kastar dem om en dålig bit sattes i det senaste anropet.
Dessutom uppstår ett vanligt problem med seekg() när den når slutet av filen (EOF), vilket gör att pekaren förblir inställd och utlöser ett fel. Metoden clear() används för att återställa pekaren och lösa de EOF-relaterade felen för att åtgärda detta. Dessutom kan seekg() riskera att ändra ett strömobjekt i en miljö med flera trådar, vilket kräver försiktighet och implementering av synkroniseringsmekanismer för att mildra de potentiella 'ofstream'-objektändringarna.
Exempel 1: Grunderna i Seekg()
I det första exemplet kommer vi att förklara grunderna för funktionen seekg() i C++. Koden för ett C++-program ges i det följande. Ta en titt på det först och sedan går vi vidare till förklaringen av varje avsnitt i koden.
#inkludera
#include
använder namnutrymme std ;
int huvud ( int argc , röding ** argv ) {
fstream sgFile ( 'seekgFile.txt' , ios :: i | ios :: ut | ios :: trunk ) ;
sgFile << 'sekg() funktion' ;
sgFile. sökkg ( 8 , ios :: be ) ;
röding sgArray [ 8 ] ;
sgFile. läsa ( sgArray , 8 ) ;
sgArray [ 8 ] = 0 ;
cout << sgArray << endl ;
sgFile. stänga ( ) ;
}
Programmet innehåller två nödvändiga header-filer –
fstream sgFile(“seekgFile.txt”, ios::in | ios::out | ios::trunk); – Här skapas 'sgFile', ett objekt i klassen 'fstream', som representerar en filström. Filen med namnet 'seekgFile.txt' är associerad med filströmmen. Filströmmen öppnas för input (ios::in) utmatning (ios::out). Om filen finns trunkeras dess innehåll (ios::trunc).
sgFile << 'seekg() funktion'; – Strängen 'seekg() function' skrivs till filen med operatorn '<<'.
sgFile.seekg(8, ios::beg); – Seekg()-funktionen används för att ställa in get-pekaren på den 8:e positionen från början (ios::beg) av filen.
sgFile.read(sgArray, 8); – 'Read'-funktionen används för att läsa åtta tecken från den aktuella positionen för get-pekaren till 'sgArray'.
sgArray[8] = 0; – Null avslutar teckenmatrisen för att säkerställa en korrekt stränghantering.
cout << sgArray << endl; – Innehållet i 'sgArray' (de 8 tecknen som läses från filen) visas på konsolen med cout.
sgFile.close(); – Close()-funktionen används för att stänga filströmmen.
Utdata från detta program förväntas vara 'funktion'. Låt oss kontrollera det i följande utdatautdrag:
Koden skapar en filström som är associerad med filen 'seekgFile.txt' skriver en sträng till filen, söker den åttonde positionen från början, läser åtta tecken och matar ut det lästa innehållet. Slutligen stängs filströmmen.
Exempel 2: Dynamisk navigering
Tänk på ett scenario där du dynamiskt måste beräkna seekg() offset. Låt oss förstå hur man dynamiskt beräknar offset med hjälp av ett kodexempel.
#include#inkludera
använder namnutrymme std ;
int huvud ( ) {
ifstream sgFile ( 'seekgFile.txt' ) ;
int offset = 8 ;
sgFile. sökkg ( offset , ios :: sätta ) ;
röding buffert [ 8 ] ;
sgFile. läsa ( buffert , 8 ) ;
cout << 'Innehåll: ' << buffert << endl ;
sgFile. stänga ( ) ;
lämna tillbaka 0 ;
}
Som du kan se läser vi innehållet från samma fil som vi skapade i föregående exempel, 'seekgFile.txt'. Seekg()-funktionen sätter get-pekaren vid den aktuella positionen (ios::cur) i filen, och den flyttas av den beräknade offseten (8 tecken). Read()-funktionen läser åtta tecken från den aktuella positionen för get-pekaren till bufferten.
Med tanke på innehållet i filen 'seekg() function' och förskjutningen av åtta tecken, kommer programmet att mata ut delsträngen som börjar från det nionde tecknet i filen. Därför är det förväntade resultatet av programmet 'funktion'. Låt oss bekräfta det i följande givna utdata:
Det här exemplet visar flexibiliteten hos seekg() genom att dynamiskt beräkna offseten.
Exempel 3: Navigera från slutet
I det här exemplet kommer vi att visa hur man läser data i en fil från slutet av filen. Här används seekg() för att navigera från slutet av filen. Den negativa offseten indikerar en position som är relativt slutet. Se följande givna kod:
#include#inkludera
använder namnutrymme std ;
int huvud ( ) {
ifstream sgFile ( 'seekgFile.txt' ) ;
sgFile. sökkg ( - 4 , ios :: slutet ) ;
röding buffert [ 8 ] ;
sgFile. läsa ( buffert , 8 ) ;
cout << 'Innehåll: ' << buffert << endl ;
sgFile. stänga ( ) ;
lämna tillbaka 0 ;
}
Detta C++-program öppnar en fil med namnet 'seekgFile.txt' som flyttar get-pekaren på fyra tecken bakåt från slutet av filen med sgFile.seekg(-4, ios::end), läser de nästa åtta tecknen från den positionen till en buffert och skriver sedan ut innehållet i bufferten till konsolen. Med tanke på innehållet i filen som 'seekg() funktion', är den förväntade utdata 'ction'. Låt oss matcha utgången i skärmdumpen av följande utgång:
Slutsats
Sammanfattningsvis framstår seekg() som en värdefull tillgång för att navigera i filströmmarna med precision. Genom sin förmåga att söka godtyckliga positioner, dynamiskt beräkna offseten och navigera från olika punkter i en fil, ger seekg() utvecklarna möjlighet att hantera filoperationerna effektivt. Som vi har sett i exemplen förbättrar mastering seekg() din kontroll och flexibilitet när du arbetar med filströmmar i C++. Det kräver dock en noggrann övervägande av undantagshantering och potentiella datarace-scenarier för att säkerställa robusta och felfria filoperationer i C++.