Beschrijving en interne presentatie van bestanden

De bestanden verschillen van elkaar. Alle bestanden die op de computer zijn opgeslagen, hebben speciale kenmerken, d.w.z. speciale beschrijvingsmethoden om het ene bestand van het andere te onderscheiden: 1) naam; maat 2; 3) datum en tijd; 4) icoon.

Elk bestand heeft een naam - de naam van het bestand. De naam van het bestand beschrijft de inhoud of suggereert waarvoor het kan worden gebruikt. De naam wordt aan het bestand toegewezen wanneer het wordt gemaakt. Dit geldt voor alle bestanden.

Elk bestand heeft een fysieke grootte. Het bestand neemt een bepaalde hoeveelheid computergeheugen en een bepaalde hoeveelheid schijfruimte in beslag.

Op het moment dat het bestand wordt gemaakt, drukt het besturingssysteem het af met de datum en tijd van aanmaak. Hiermee kunt u bestanden sorteren op datum en tijd en zo orde op zaken stellen in uw computer. De datum en tijd waarop het bestand is bijgewerkt of gewijzigd, wordt ook vermeld.

Elk bestand is van een specifiek type, nauw verwant aan het bestandspictogram dat we zien. Het bestandstype is afhankelijk van de inhoud. Elk programma wijst een bepaald type en een passend pictogram toe aan het gemaakte document.

De bestandsgrootte wordt gemeten in bytes, net als de hoeveelheid geheugen.

De bestandsgrootte kan 0 bytes zijn, wat betekent dat het bestand bestaat, maar niets bevat. S De maximale bestandsgrootte is 4 GB. Maar zulke enorme bestanden zijn zeer zeldzaam.

De ingebouwde computerklok is met name nodig om de tijd en datum van hun aanmaak toe te wijzen aan bestanden. Dit verklaart hoe belangrijk het is om deze klok correct in te stellen. Er zijn ook extra attributen voor het beschrijven van bestanden, zoals systeembestanden, verborgen bestanden, alleen-lezen bestanden, archiefbestanden, enz. Het besturingssysteem zoekt het zelf uit.

Elk bestand heeft een unieke index. De index bevat de informatie die elk proces nodig heeft om toegang te krijgen tot het bestand. Processen toegangsbestanden gebruiken een goed gedefinieerde set systeemaanroepen en identificeren het bestand met een reeks tekens die fungeren als de onderscheidende bestandsnaam. Elke DN-naam identificeert een bestand op unieke wijze, dus de kernel vertaalt die naam in een index voor het bestand. De index bevat een tabel met adressen voor de locatie van bestandsinformatie op schijf. Aangezien elk blok op schijf wordt geadresseerd door zijn eigen nummer, slaat deze tabel een verzameling schijfbloknummers op. Voor flexibiliteit voegt de kernel stukjes tegelijk aan een bestand toe, zodat de informatie van het bestand door het bestandssysteem kan worden verspreid. Maar deze lay-out bemoeilijkt de taak om gegevens te vinden. De adrestabel bevat een lijst met bloknummers met informatie die bij het bestand hoort, maar eenvoudige berekeningen laten zien dat de lineaire lijst met bestandsblokken in de index moeilijk te beheren is. Om ervoor te zorgen dat de kleine indexstructuur grote bestanden kan bevatten, wordt de schijfblokadrestabel uitgelijnd met de structuur.

Tekst en binaire bestanden

Met bestanden kan de gebruiker grote hoeveelheden gegevens rechtstreeks van de schijf lezen zonder deze vanaf het toetsenbord in te typen. Er zijn twee hoofdtypen bestanden: tekst en binair.

Tekst bestanden die uit willekeurige tekens bestaan, worden aangeroepen. Ze zijn georganiseerd in regels, die elk eindigen met " einde van de lijn ". Het einde van het bestand zelf wordt aangegeven door het symbool " einde van bestand "... Bij het schrijven van informatie naar een tekstbestand, dat kan worden bekeken met elke teksteditor, worden alle gegevens geconverteerd naar een tekentype en opgeslagen in tekenvorm.

in binair NS bestanden informatie wordt gelezen en geschreven in de vorm van blokken van een bepaalde grootte, waarin gegevens van welke aard en structuur dan ook kunnen worden opgeslagen.

Om met bestanden te werken, worden speciale datatypes gebruikt, genaamd stromen. De ifstream wordt gebruikt om met bestanden in leesmodus te werken, en ifstream in schrijfmodus. De ifstream-stroom wordt gebruikt om met bestanden te werken in zowel schrijf- als leesmodus.

Als u in C++-programma's met tekstbestanden werkt, moet u de ifstream- en iostream-bibliotheken opnemen.

Om gegevens naar een tekstbestand te schrijven, moet u: 1) beschrijf een variabele van het type van stroom open; 3) output informatie naar een bestand; 4) zorg ervoor dat u het bestand sluit.

Om gegevens uit een tekstbestand te lezen, moet u:

1) beschrijf een variabele van het type ifstream; 2) open het bestand met de functie open; 3) informatie uit het bestand lezen; bij het lezen van elk stuk data moet worden gecontroleerd of het einde van het bestand is bereikt; 4) sluit het bestand.

Opgemerkt moet worden dat in alle hierboven besproken voorbeelden de functie fopen () in de modi "r" en "w" een tekstbestand opent voor respectievelijk lezen en schrijven. Dit betekent dat sommige tekstopmaaktekens, zoals regelterugloop '\ r', niet kunnen worden gelezen als afzonderlijke tekens, ongeacht hoe ze in het bestand voorkomen, maar ze zijn er wel. Dit is een kenmerk van de tekstmodus van het bestand. Voor meer "fijn" werk met de inhoud van bestanden is er een binaire modus, die de inhoud van het bestand weergeeft als een reeks bytes, waarbij alle mogelijke besturingscodes slechts getallen zijn. In deze modus is het mogelijk om controletekens te verwijderen of toe te voegen die niet beschikbaar zijn in de tekstmodus. Om een ​​bestand in binaire modus te openen, wordt de functie fopen () ook gebruikt met de laatste parameter gelijk aan respectievelijk "rb" en "wb", voor lezen en schrijven.

Een binair bestand is elk bestand op uw computer. Alle informatie op een computer en aanverwante media wordt in bits vastgelegd (vandaar de naam). Ter vergelijking kan echter een tekstbestand worden gelezen in de lezers die overeenkomen met de extensie (de eenvoudigste - zelfs in Kladblok), maar het uitvoerbare bestand niet. En hoewel een txt-bestand in feite hetzelfde binaire bestand is, bedoelen ze, als ze het hebben over het probleem van het openen van de inhoud van binaire bestanden, uitvoerbare bestanden, evenals gecomprimeerde gegevens.

Je zal nodig hebben

• - Hex Edit-programma.

instructies:

Speciaal voor dergelijke gevallen zijn er records met variant part.

Beschrijving van een record met een variantdeel

In de var-sectie opnemen met variant part omschrijven als volgt:

var<имя_записи>: dossier<поле1>: <тип1>; [<поле2>: <тип2>;] [...] geval<поле_переключатель>: <тип>van<варианты1>: (<поле3>: <тип3>; <поле4>: <тип4>; ...); <варианты2>: (<поле5>: <тип5>; <поле6>: <тип6>; ...); [...] einde;

niet-variant deel notatie (vóór het sleutelwoord hoofdletters) voldoet aan dezelfde regels als reguliere notatie. Over het algemeen kan het niet-variante deel helemaal ontbreken.

Variant deel begint met het gereserveerde woord case, waarna het veld van het record wordt aangegeven, dat verder als schakelaar zal dienen. Net als bij een gewone case-statement, moet de switch behoren tot een van de opgesomde typen gegevens (zie college 3). De lijst met keuzes kan een constante, een bereik of de vereniging van meerdere constanten of bereiken zijn. De set velden die in de recordstructuur moet worden opgenomen, als de bijbehorende optie is uitgevoerd, staat tussen haakjes.

Voorbeeld... Om de inhoud van de bibliotheek te beschrijven, is de volgende informatie nodig:

De kolommen "Titel" en "Uitgever" zijn gemeenschappelijk voor alle drie de opties, en de rest van de velden is afhankelijk van het type gedrukte editie. Om deze structuur te implementeren, gebruiken we invoer met variantdeel:

type biblio = recordnaam, uitgever: string; case item: char van "b": (auteur: string; jaar: 0..2004); "n": (gegevens: datum); "m": (jaar: 1700..2004; maand: 1..12; getal: geheel getal); einde;

Afhankelijk van de waarde van het itemveld, zal het record 4, 5 of 6 velden bevatten.

Het mechanisme voor het gebruik van een record met een variantpart

Het aantal bytes dat door de compiler is toegewezen voor opnemen met variant part, wordt bepaald door de "langste" versie. Kortere sets velden uit andere varianten nemen slechts een fractie van het toegewezen geheugen in beslag.

In het bovenstaande voorbeeld is de "langste" optie "b": deze vereist 23 bytes (21 bytes voor een string en 2 bytes voor een geheel getal). Voor de opties "n" en "m" zijn respectievelijk 4 en 5 bytes nodig (zie tabel).

Binaire bestanden

Binaire bestanden slaan informatie in de vorm waarin deze wordt weergegeven in het geheugen van de computer op en zijn daarom onhandig voor de mens. Als je in zo'n bestand kijkt, is het onmogelijk te begrijpen wat erin staat; het kan niet handmatig worden gemaakt of gecorrigeerd - in sommige teksteditors - enz. Al deze ongemakken worden echter gecompenseerd door de snelheid van het werken met data.

Tekstbestanden behoren ook tot structuren sequentiële toegang, en binair - direct. Dit betekent dat u op elk moment naar iedereen kunt verwijzen, niet alleen naar het huidige element.

Werken met binaire bestanden

Alle informatie wordt op de computer opgeslagen in de vorm van 0 en 1, dat wil zeggen in binaire vorm. Binaire bestanden verschillen alleen van tekstbestanden in de manier waarop ze ermee werken. Als we bijvoorbeeld het nummer "4" naar een tekstbestand schrijven, wordt het geschreven als een teken en is er één byte nodig om het op te slaan. Dienovereenkomstig zal de bestandsgrootte gelijk zijn aan één byte. Het tekstbestand met de vermelding "145687" zal zes bytes groot zijn.

Als we het gehele getal 145687 in een binair bestand schrijven, heeft het een grootte van vier bytes, aangezien dit precies is hoeveel er nodig is om gegevens van het type int op te slaan. Dat wil zeggen, binaire bestanden zijn compacter en in sommige gevallen gemakkelijker te verwerken.

Standaard gegevenstypen naar binaire bestanden schrijven

Om een ​​binair bestand te openen, moet u de toegangsmodus instellen op ios :: binary (in sommige C++-compilers - ios ::bin).

Maak een object om een ​​uitvoerbestand te maken:

ofstream outBinFile ("out.bin", ios :: out | ios :: binair);

/* klasse object maken van stroom uit. bin

als (! out_f і 1) // standaard controle

Gegevens worden geschreven met behulp van de methode write () die twee parameters heeft: de eerste is een aanwijzer naar het begin (adres van het begin) van de gegevens die worden geschreven, de tweede is het aantal te schrijven bytes. In dit geval moet de aanwijzer expliciet worden geconverteerd naar het char-type.

Voorbeeld 1. Schrijf variabelen van verschillende typen naar een binair bestand:

ofstream outBinFile ("test.bin", ios :: out I

ios:: binair); / ^ klasseobject maken van stroom en proberen om het te koppelen aan het bestand toets. bin in binaire schrijfmodus * /

int a - 145687; // declareer een integer-variabele een

outBinFi le. schrijf ((char *) & a, sizeof (a)); / ^ schrijf naar bestand

variabele een als een stroom van bytes, d.w.z. het schrijven naar een bestand van de interne representatie van een integer-variabele een * / float x - 123,25; // echte variabele declaratie NS

outBinFile .write ((char *) & x, sizeof (x)); / ^ schrijf naar bestand

variabele NS als een stroom van bytes, d.w.z. schrijven naar een bestand van de interne representatie van een integer-variabele x * /

// definieer een symbolische variabele met en initialiseren met het symbool g outBinFile.write ((char *) & c, sizeof (c));

// schrijf een symbool G archiveren

outBinFile.close (); retourneer 0;

Als u de inhoud van het test .bin-bestand opent met een teksteditor, ziet het er als volgt uit:

en de bestandsgrootte is 9 bytes.

Standaard gegevenstypen lezen uit binaire bestanden

Om een ​​bestaand binair bestand te openen om te lezen, moet u een object maken:

ifstream inpBinFile ("inp.bin", ios :: in I ios :: binair);

/* we gebruiken een disjunctie van vlaggen, wat aangeeft dat het bestand is geopend voor lezen in binaire vorm * /

als (! inpBinFile)

cout Gebruik de functie lezen () om gegevens te lezen, die parameters heeft die vergelijkbaar zijn met de functie schrijven ().

#include met namespace std; int hoofd ()

ifstream inpBinFile ("test.bin", ios :: in I

ios:: binair); / / open het bestand om in binaire vorm te lezen

int een; zweven x; char met = "g";

inpBinFile.read ((char *) & a, sizeof (a));

// lees een integer variabele inpBinFile.read ((char *) & x, sizeof (x));

// lees een echte variabele inpBinFile.read ((char *) & c, sizeof (c));

// lees een symbolische variabele

inpBinFile.close (); cout

Het resultaat van het programma:

a = 145687 x = 123,25 c = g

Merk op dat er geen informatieconversie plaatsvindt bij gebruik van de schrijf- en leesfuncties. De interne representatie van de gegevens wordt geschreven naar en ingelezen in het bestand. Daarom gaven de twee voorgaande programma's het juiste resultaat.

Aangepaste gegevenstypen schrijven en lezen naar binaire bestanden

In tegenstelling tot tekstbestanden verschilt het werken met aangepaste gegevenstypen met behulp van binaire bestanden niet van standaard gegevenstypen. De methoden schrijven () en lezen () worden op een vergelijkbare manier gebruikt. De programmeur hoeft alleen het adres van het te schrijven geheugengebied en het aantal te schrijven bytes aan te geven, rekening houdend met het feit dat er geen dataconversie plaatsvindt, alleen de interne representatie van informatie wordt geschreven en gelezen.

Als u met binaire bestanden werkt, kunnen ook de methoden seekg (), tellg (), seekp (), tellp () worden gebruikt.

Voorbeeld 3. Schrijf een programma dat informatie over een groep toeristen naar een binair bestand schrijft.

fstream BinFile ("ankety.bin", ios :: in I ios :: out | ios :: binair);

Anketa Gruppa =; voor (int i = 0; i

BinFile.write ((char *) & Gruppa [i], sizeof (Anketa)); BinFile.sluiten (); retourneer 0;

Voorbeeld 4. Het bestand "ankety.bin" bevat gegevens over een groep toeristen, het is noodzakelijk om ze te lezen en weer te geven.

#include met namespace std; structuur Anketa (

char naam; int leeftijd;

gestructureerd gegevenstype Anketa naar het scherm * /

ostream & operator

fstream BinFile ("ankety.bin", ios :: in | ios :: out | ios :: binair); if (! BinFile)

voor (int i = 0; i

// lees onmiddellijk alle bytes die worden ingenomen door de typevariabele Anketa BinFile.read ((char *) & Gruppa [i], sizeof (Anketa));

BinFile.sluiten (); retourneer 0;

Het resultaat van het programma:

Ivanov, 23 Sidorov, 21 Petrov, 22

Druk op een willekeurige toets om door te gaan. ... ...

Je eigen lessen ontwikkelen voor het werken met bestanden

Het is onhandig om constant de methodes schrijven () en lezen () te gebruiken, het is veel prettiger om de bewerkingen ">" naar analogie met tekstbestanden te kunnen gebruiken. Laten we een voorbeeld geven van het implementeren van onze klasse voor het werken met binaire bestanden.

namespace std; gebruiken;

struct Anketa // declareer een structuur voor het opslaan van informatie

/ * overbelast de invoegbewerking om de gebruiker uit te voeren

gestructureerd gegevenstype Anketa naar het scherm * /

ostream & operator

class outBinaryFile: public van stream / ^ definieer onze eigen klasse om met uitvoerbinaire bestanden te werken. We genereren het vanuit de klasse voor het werken met uitvoerbestandsstromen * /

/ * vergeet bij het beschrijven van de constructor van de gegenereerde klasse niet de constructor van de basisklasse aan te roepen en de nodige parameters door te geven * /

outBinaryFile (char * naam): ofstream (naam, ios :: out I ios :: binair)

// overbelast de noodzakelijke bewerkingen als klassenmethoden outBinaryFile & operator

schrijf ((char *) & chislo, sizeof (chislo)); retour * dit;

outBinaryFile & operator

schrijf ((char *) & ank, sizeof (ank)); retour * dit;

klasse inpBinaryFile: openbaar als stream / * we definiëren onze klasse voor het werken met binaire invoerbestanden. We genereren het vanuit de klas voor het werken met invoerbestandsstromen * /

inpBinaryFile (char * naam): ifstream (naam, ios :: in I ios :: binair)

/ * roep de constructor van de basisklasse aan met de vereiste parameters,

genoeg voor de constructor van de afgeleide klasse * /

// overbelast de noodzakelijke handelingen

inpBinaryFile & operator >> (int & chislo)

lezen ((char *) & chislo, sizeof (chislo)); retour * dit;

inpBinaryFile & operator >> (Anketa & ank)

lezen ((char *) & ank, sizeof (ank)); retour * dit;

int a = 111, b = 112; outBinaryFile outFile ("dannye.bin");

// open het bestand om te lezen

inpBinaryFile inpFile ("dannye.bin"); als (! inpFile)

voor (int і = 0; i

inpFile >> een; // lees de vragenlijst uit het bestand

cout // en toon het op het scherm

inpFile >> anketa; cout

Het resultaat van het programma:

Kolya 1990, 582-78-95.

Druk op een willekeurige toets om door te gaan. ... ...

1. Is het mogelijk om een ​​bewerking in het programma te gebruiken?

ios :: in I ios :: uit

• a) ja, in ieder geval;
• b) ja, maar alleen bij het werken met tekstbestanden;
• c) in ieder geval niet.
• 2. Specificeer de juiste optie voor het openen van een tekstbestand om te lezen:
  • a) ifstream inpF ("input.txt", ios :: in);
  • b) ifstream inpF ("input.txt", ios :: invoer);
  • c) ifstream inpF (ios: in, "input.txt").

H. Wat wordt weergegeven als resultaat van het uitvoeren van de volgende code?

inputFile.get (c);

volgende - inputFile.peek ();

als (volgende == EOF)

• a) de inhoud van het bestand dat is gekoppeld aan de inputFile-stroom wordt één keer weergegeven;
• b) de inhoud van het bestand dat is gekoppeld aan de inputFile-stroom zal een oneindig aantal keren op het scherm worden weergegeven;
• c) er wordt niets op het scherm weergegeven.
• 4. Hoeveel tekens bevat het bestand?
• 12 3 4 5 6
• a) 6;
• b) 7;
• om 11 uur.
• 5. Welke methoden kunnen worden gebruikt om het einde van het bestand te bepalen?
• a) eof ();
• b) goed ();
• c) beide methoden.
• 6. Waar is de functie getline () voor?
• a) leest een woord uit een bestand;
• b) leest de volledige inhoud van het bestand;
• c) leest een regel uit een bestand.
• 7. Om aangepaste gegevenstypen naar een bestand te schrijven/lezen, moet u:
  • a) overbelast de bewerkingen ">>" en "
  • b) schrijven en lezen van aangepaste gegevenstypen zijn beschikbaar zonder aanvullende acties;
  • c) het schrijven en lezen van door de gebruiker gedefinieerde gegevenstypen naar een bestand is niet mogelijk.
• 8. Welke functies worden gebruikt om informatie in binaire vorm te schrijven / lezen?
• a) printf / scanf;
• b) schrijven / lezen;
• c) zetten / krijgen.

• 1. Schrijf een programma dat letters van het Engelse alfabet naar een bestand schrijft.
• 2. Het bestand input.txt bevat informatie uit verschillende tekstregels. Geef de inhoud van dit bestand weer op het scherm, tel het aantal regels in het bestand.
• 3. De schijf bevat het bestand result.txt met de resultaten van chemische experimenten. Schrijf een programma dat een kopie van dit bestand maakt met de naam copy_resylt.txt.
• 4. Voer de bestandsnaam in met het toetsenbord. Verwijder in het opgegeven bestand alle even regels.
• 5. Schrijf een programma dat in een tekstbestand alle kleine letters vervangt door hoofdletters en vice versa.
• 6. Het originele tekstbestand bevat getallen gescheiden door spaties. Genereer twee nieuwe bestanden: de eerste mag alleen even getallen bevatten en de tweede - oneven.
• 7. Reële getallen worden naar het bestand geschreven. Schrijf een programma dat het fractionele deel van deze getallen weggooit en ze naar een nieuw bestand schrijft.
• 8. Het tekstbestand bevat informatie over de vluchten van de luchtvaartmaatschappij. Kies uit deze data vluchten die 's middags vertrekken en toon ze op het scherm.
• 9. Overbelastingsoperators >> en
• 10. Schrijf je eigen klas voor het werken met binaire bestanden.
• 11. Schrijf een lijst van 10 klasleden naar een tekstbestand en een binair bestand. Vergelijk deze bestanden. Leg het resulterende verschil uit.
• 12. Ontwikkel een klasse die informatie over auto's schrijft naar een bestand (bouwjaar, merk, kleur, enz.) naar een tekstbestand. In dit geval wordt elk informatiesymbool vervangen door zijn eigen ABO 1-code. Geef het resulterende bestand weer op het scherm.

Controlevragen

• 1. Welke klassen worden gebruikt om met bestandsstromen te werken?
• 2. Welke toegangsmodi kunnen worden gebruikt bij het werken met bestanden? Geef voorbeelden.
• 3. Welke methode wordt gebruikt om het bestand te openen? Geef voorbeelden.
• 4. Welke bewerkingen zijn beschikbaar voor het werken met bestanden? Welke functies zijn er voor deze bewerkingen?
• 5. Met welke methoden kunt u het einde van het bestand bepalen wanneer u er informatie uit leest? Wat is het verschil tussen deze methoden? Geef voorbeelden.
• 6. Hoe lees je variabelen van standaard datatypes uit tekstbestanden?
• 7. Kunnen door de gebruiker gedefinieerde gegevenstypevariabelen uit tekstbestanden worden gelezen?
• 8. Welke functies zijn bedoeld voor het willekeurig uitlezen van informatie uit een bestand? Geef voorbeelden.
• 9. Wat zijn de kenmerken van binaire bestanden? Wat zijn de voordelen van het gebruik van dergelijke bestanden?
• 10. Welke functies kunnen worden gebruikt om informatie naar binaire bestanden te schrijven / lezen?
• 11. Hoe lees ik variabelen van standaard datatypes uit een binair bestand?
• 12. Met welke overwegingen moet u rekening houden bij het lezen van aangepaste gegevenstypen uit binaire bestanden?

• "Ivanov", 23), ("Sidorov", 21),

Veel mensen hebben vaak een vraag over het openen van een binair bestand. Dit document is elk bestand dat zich op een pc bevindt. Alle gegevens op computers en bijbehorende media worden meestal in bits vastgelegd. Van dit woord komt de naam. Als we een eenvoudig tekstbestand als vergelijking geven, zijn er geen problemen met het lezen ervan. Om dit te doen, is het voldoende om een ​​gewone editor op je computer te hebben, zelfs een notitieblok is voldoende. Om een ​​binair bestand te openen, kun je niet met een eenvoudig kladblok doen. En als we het hebben over het feit dat de informatie van tekstbestanden met dezelfde bits is versleuteld, dan bedoelen ze meestal uitvoerbare documenten als ze het hebben over het lezen van binaire bestanden.

Instructies voor actie

Eerst moet een softwaretool genaamd HexEditor, een eenvoudige editor voor binaire bestanden, op de harde schijf van de personal computer worden geïnstalleerd. Na de installatie moet het programma worden geopend door te dubbelklikken op het pictogram. Met deze tool kunt u een binair bestand in echte modus lezen. In dit geval kunt u de gegevens in het bestand wijzigen, uw eigen informatie toevoegen, enz. Om in deze editor te werken en het binaire bestand te wijzigen, moet u op zijn minst enige kennis op dit gebied hebben.

Ten tweede moet u vertrouwd raken met het hoofdvenster dat niet veel verschilt van het venster van de gebruikelijke editor. Dezelfde knoppen, hetzelfde menu, dezelfde documenttekst, bladwijzers en statusbalken. U kunt het gewenste bestand openen via het tabblad Bestand of via een speciale knop in het programma. Daarna kunt u het uitvoerbare bestand zien, dat in de vorm van cijfers en letters zal verschijnen. Verwar de symbolen waarmee een binair bestand wordt weergegeven niet met die van een gewone editor. In het geval dat een beslissing wordt genomen om een ​​deel van het document te verwijderen of te wijzigen, moet worden begrepen dat een deel ervan zal verdwijnen of veranderen.

Ten derde kunt u met behulp van het programma proberen om elk deel van het document te wijzigen. Zoals eerder vermeld, geeft de tool het bestand weer op een manier die de manier verbetert waarop u het deel van het document kunt vinden waarnaar u op zoek bent. Daarnaast kent het programma een vrij flexibele opzet. Het kan worden gebruikt om de grafische weergave van de binaire code die het binaire bestand heeft, te wijzigen. In het geval dat er in een bepaald deel van het bestand onjuiste gegevens worden ingevoerd, kan het vervolgens ofwel volledig stoppen met werken, of het zal niet helemaal correct gaan werken. In elk geval zal het invoeren van dergelijke gegevens veranderingen veroorzaken in zowel het besturingssysteem als rechtstreeks in de personal computer zelf.

Ten vierde moet u na het wijzigen, verwijderen of toevoegen van bepaalde gegevens in het bestand het resultaat van uw werk opslaan. In het geval dat u niet voldoende ervaring heeft met het bewerken van bestanden, moet u voorbereid zijn op niet geheel aangename gevolgen. Een document kan bijvoorbeeld niet meer werken na het wijzigen van gegevens. Totdat u dit probleem goed begint te begrijpen, zullen veel kopieën van bestanden beschadigd raken. Als u niet zeker bent van uw mogelijkheden, moet u de gegevens niet zelf wijzigen, vooral niet in situaties waarin u het su binaire bestand moet repareren.