Binær fil-I/O
Læs og skriv rå bytes
Binær fil-I/O er en gratis C++ Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i C++ Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C++ Academy-kurset indeholder 4 lektioner i alt.
Tekst sammenlignet med binær
Teksttilstand skriver tegn, der kan læses af mennesker; binær tilstand skriver objekternes rå bytes præcis, som de ligger i hukommelsen. Åbn med std::ios::binary.
#include <iostream>
#include <fstream>
int main() {
int value = 12345;
std::ofstream out("v.bin", std::ios::binary);
out.write(reinterpret_cast<const char*>(&value), sizeof(value));
std::cout << "wrote " << sizeof(value) << " bytes\n";
return 0;
}write tager imod bytes
write(ptr, n) skriver n rå bytes fra ptr. Du konverterer objektadressens type til const char*.
#include <iostream>
#include <fstream>
int main() {
double d = 3.14;
std::ofstream out("d.bin", std::ios::binary);
out.write(reinterpret_cast<const char*>(&d), sizeof(d));
out.close();
std::cout << "saved a double\n";
return 0;
}read genskaber bytes
read(ptr, n) indlæser n bytes i objektet på adressen ptr og ophæver dermed virkningen af en binær skrivning.
#include <iostream>
#include <fstream>
int main() {
int original = 777;
std::ofstream("i.bin", std::ios::binary).write(reinterpret_cast<const char*>(&original), sizeof(original));
int loaded = 0;
std::ifstream in("i.bin", std::ios::binary);
in.read(reinterpret_cast<char*>(&loaded), sizeof(loaded));
std::cout << loaded << '\n';
return 0;
}Skrivning af en POD-struktur
Strukturer med simple data (ingen pointere og medlemmer med fast størrelse) kan gemmes og indlæses igen som én samlet blok af bytes.
#include <iostream>
#include <fstream>
struct Record { int id; double balance; };
int main() {
Record r{1, 99.5};
std::ofstream out("rec.bin", std::ios::binary);
out.write(reinterpret_cast<const char*>(&r), sizeof(r));
std::cout << "struct saved\n";
return 0;
}Læsning af strukturen igen
Læsningen genskaber hele strukturen i ét enkelt kald til read.
#include <iostream>
#include <fstream>
struct Record { int id; double balance; };
int main() {
Record w{42, 250.0};
std::ofstream("r2.bin", std::ios::binary).write(reinterpret_cast<const char*>(&w), sizeof(w));
Record r{};
std::ifstream in("r2.bin", std::ios::binary);
in.read(reinterpret_cast<char*>(&r), sizeof(r));
std::cout << r.id << ' ' << r.balance << '\n';
return 0;
}Skrivning af et array
Du kan skrive et helt array i ét kald ved at angive den samlede størrelse i bytes.
#include <iostream>
#include <fstream>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
std::ofstream out("arr.bin", std::ios::binary);
out.write(reinterpret_cast<const char*>(arr), sizeof(arr));
std::cout << "wrote " << sizeof(arr) << " bytes\n";
return 0;
}Læsning af arrayet igen
Læs det samme antal bytes ind i et array med samme størrelse.
#include <iostream>
#include <fstream>
int main() {
int src[5] = {10, 20, 30, 40, 50};
std::ofstream("a2.bin", std::ios::binary).write(reinterpret_cast<const char*>(src), sizeof(src));
int dst[5] = {};
std::ifstream in("a2.bin", std::ios::binary);
in.read(reinterpret_cast<char*>(dst), sizeof(dst));
for (int x : dst) std::cout << x << ' ';
std::cout << '\n';
return 0;
}Søgning efter positioner
seekg (get) og seekp (put) flytter læse-/skrivepositionen, så du kan få tilfældig adgang til filen.
#include <iostream>
#include <fstream>
int main() {
int data[3] = {100, 200, 300};
std::ofstream("seek.bin", std::ios::binary).write(reinterpret_cast<const char*>(data), sizeof(data));
std::ifstream in("seek.bin", std::ios::binary);
in.seekg(sizeof(int)); // skip to second int
int second; in.read(reinterpret_cast<char*>(&second), sizeof(second));
std::cout << second << '\n';
return 0;
}Aflæsning af positionen
tellg og tellp angiver den aktuelle position og er nyttige til at måle filstørrelse eller forskydninger.
#include <iostream>
#include <fstream>
int main() {
int data[4] = {1, 2, 3, 4};
std::ofstream("tell.bin", std::ios::binary).write(reinterpret_cast<const char*>(data), sizeof(data));
std::ifstream in("tell.bin", std::ios::binary);
in.seekg(0, std::ios::end);
std::cout << "file size: " << in.tellg() << " bytes\n";
return 0;
}Hvorfor ikke pointere?
Gem aldrig objekter med pointere eller std::string direkte i binær form: du gemmer pointeradressen, ikke de data, den peger på. Serialisér i stedet indholdet.
#include <iostream>
#include <fstream>
#include <string>
int main() {
std::string s = "hello";
std::ofstream out("str.bin", std::ios::binary);
std::size_t len = s.size();
out.write(reinterpret_cast<const char*>(&len), sizeof(len));
out.write(s.data(), len); // write the chars, not the object
std::cout << "serialized " << len << " chars\n";
return 0;
}Forbehold for portabilitet
Binære datastrukturer afhænger af byteorden og typestørrelser. Filer, der er skrevet på én platform, kan muligvis ikke læses korrekt på en anden, så definér et fast format til deling.
#include <iostream>
#include <cstdint>
int main() {
std::int32_t fixed = 1; // fixed-width type for portability
std::cout << "sizeof int32_t = " << sizeof(fixed) << '\n';
return 0;
}Hurtigt tjek
Test din forståelse af binær I/O.
Opsummering
Du har lært om binær fil-I/O:
- åbn med
std::ios::binary; brugwrite/readmedreinterpret_cast<char*> seekg/seekpogtellg/tellpgiver tilfældig adgang- gem aldrig pointere eller strenge direkte; serialisér deres indhold, og vær opmærksom på byteorden
Nu skal du lære at kontrollere strømtilstand og håndtere fejl.
Lær C++ med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 51
- Lektioner
- 203
Ofte stillede spørgsmål
Er lektionen “Binær fil-I/O” gratis?
Ja — alle 3 lektioner i læringssporet C++ Academy, inklusive “Binær fil-I/O”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. C++ Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Binær fil-I/O”?
Læs og skriv rå bytes Du øver dig i C++ Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på C++ Academy?
Der kræves ingen tidligere erfaring. C++ Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Binær fil-I/O”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne C++ Academy-lektion?
Ja. Alle C++ Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.