A binary file is any file on your computer. All information on a computer and its associated media is recorded in bits (hence the name). However, for comparison, a text file can be read in readers corresponding to the extension (the simplest ones - even in Notepad), but an executable file cannot. And although in fact the txt file is the same binary file, but when they talk about the problem of opening the contents of binary files, they mean executable files, as well as compressed data.

You will need

• - Hex program Edit.

Instruction

Download the Hex Edit program to the hard drive - a file editor that represents their contents in binary form. Open the program by double-clicking on the start file. Given software allows you to read binary files in real time, change the content, add your own own records and much more. To fully work in this environment, you need to know a little about general terms binary files.

The program window is not much different from a regular editor: familiar menus and a panel with buttons, the body of the file being edited, bookmarks and the status bar. open binary file via the File menu or by clicking on the corresponding icon on the panel. The binary file will appear before you in the form of strings with numbers and letters. Do not confuse these characters with printed data. text files. They can also be edited by deleting characters, however, in doing so, you will delete cells with data, pieces of the file.

Make changes to the contents of the file. The application can show important parts of the file for more convenient search and also has flexible configuration graphic display binary code. Switch content view to ASCII+IBM/OEM mode to see programming code file. If you enter the wrong lines in the file, it may not work correctly, causing serious consequences for operating system personal computer.

Save your changes. If you are not experienced in this kind of file editing, be prepared for the fact that the file will not open and refuse to work after making changes. You will most likely mess up a few copies before you get it right. Try not to save all changes to original file to keep its contents unchanged.

records ), then it is quite understandable to want to somehow reduce the unused, but occupied amount of memory.

For such cases, there are entries with a variant part.

Record description with variant part

In the var section notation with a variant part describe it like this:

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

Non-variant part records (up to keyword case ) follows the same rules as normal notation. Generally speaking, the nonvariant part may be completely absent.

Variant part begins with the reserved word case , after which the record field is indicated, which will later serve as a switch. As with a normal case statement, the switch must belong to one of the enumerated types data (see lecture 3). The list of choices can be a constant, a range, or the union of several constants or ranges. The set of fields that must be included in the record structure if the corresponding option has been executed is enclosed in parentheses.

Example. In order to describe the content of the library, the following information is required:

The columns "Title" and "Publisher" are common for all three options, and the remaining fields depend on the type of publication. To implement this structure, we use notation with a variant part:

type biblio = record name, publisher: string; case item: char of "b": (author: string; year: 0..2004); "n": (data: date); "m": (year: 1700..2004; month: 1..12; number: integer); end;

Depending on the value of the item field, the record will contain either 4, or 5, or 6 fields.

Mechanism for using a record with a variant part

The number of bytes allocated by the compiler for notation with a variant part, is determined by its longest variant. The "shorter" field sets from the other options take up only a fraction of the allocated memory.

In the example above, the "b" option is the "longest": it requires 23 bytes (21 bytes for a string and 2 bytes for an integer). Options "n" and "m" require 4 and 5 bytes respectively (see table).

name, publisher	item	Variant part
...	"b"	author																				year
...	"n"	data
...	"m"	year	month	number
...	"b"	author																				year

Binaries

Binary files store information in the form in which it is presented in the computer's memory, and therefore are inconvenient for humans. Looking into such a file, it is impossible to understand what is written in it; it cannot be created or corrected manually - in some text editor - and so on. However, all these inconveniences are compensated by the speed of working with data.

Also, text files are structs sequential access, and binary - direct. This means that at any time you can refer to anyone, not just the current element.

Working with binary files

All information is stored in the computer in the form of 0 and 1, i.e. in binary form. Binary files differ from text files only in the way they are handled. For example, if we write the number "4" to a text file, then it is written as a character, and one byte is needed to store it. Accordingly, the file size will be equal to one byte. The text file containing the entry: "145687" will be six bytes in size.

If we write the integer 145687 to a binary file, then it will have a size of four bytes, since that is how much is needed to store data of the int type. That is, binaries are more compact and, in some cases, easier to process.

Recording standard types data to binary files

To open a binary file, you must set the access mode to ios::binary (in some C++ compilers, ios::bin).

To create an output file, create an object:

outstream outBinFile("out.bin", ios::out | ios::binary);

/* creating a class object outstream out. bin

if (! out_f and 1) //standard check

Data is written using the write () method, which has two parameters: the first is a pointer to the beginning (start address) of the data being written, the second is the number of bytes to write. In this case, the pointer must be explicitly converted to the char type.

Example 1 Write variables of various types to a binary file:

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

ios: :binary); /^create class object of stream and trying to link it to a file test. bin in binary write mode */

int a - 145687; //declaration of an integer variable but

outBinFile. write ((char*) &a, sizeof(a)) ; /^write to file

variable but as a stream of bytes, i.e. writing to a file the internal representation of an integer variable a */ float x - 123.25; // real variable declaration X

outBinFile .write ((char*) &x, sizeof(x)) ; /^write to file

variable X as a stream of bytes, i.e. writing to a file the internal representation of an integer variable x*/

//character variable definition from and initializing it with g outBinFile.write((char*)&c, sizeof(c));

//character entry g to file

outBinFile.close(); return 0;

If you open the contents of the test .bin file with a text editor, it will look like this:

and the file size will be 9 bytes.

Reading Standard Data Types from Binary Files

To open an existing binary file for reading, you need to create an object:

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

/* use a disjunction of flags indicating that the file is opened for reading in binary form */

if(!inpBinFile)

cout To read data, we use the read() function, which has parameters similar to the write() function.

#include using namespace std; int main()

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

ios: :binary); / / open the file for reading in binary form

int a; float x; char c = "g";

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

//read integer variable inpBinFile.read((char*)&x, sizeof(x));

//read real variable inpBinFile.read((char*)&c, sizeof(c));

//read character variable

inpBinFile.close(); cout

The result of the program:

a = 145687 x = 123.25 c = g

Note that when using the write and read functions, no information conversion takes place. The internal representation of the data is written to and read from the file. That is why two previous programs gave the correct result.

Writing and reading custom types data to binary files

Unlike text files, working with custom data types using binary files is no different from standard data types. The write() and read() methods are used similarly. The programmer only needs to specify the address of the memory area to be written and the number of bytes to be written, taking into account that no data conversion occurs, only the internal representation of information is written and read.

Also, when working with binary files, the seekg(), tellg(), seekp(), tellp() methods can be used.

Example 3 Write a program that writes information about a group of tourists to a binary file.

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

Questionnaire Group = ; for (int i = 0; i

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

Example 4 The file "ankety.bin" contains data about a group of tourists, it is necessary to read them and display them on the screen.

#include using namespace std; struct Question (

charname; int age;

structural data type Questionnaire on screen*/

stream & operator

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

for (int i = 0; i

//immediately read all the bytes occupied type variable Anketa BinFile.read((char*)&Gruppa[i], sizeof(Anketa));

BinFile.close(); return 0;

The result of the program:

Ivanov, 23 Sidorov, 21 Petrov,22

Press any key to continue. . .

Developing your own classes for working with files

It is inconvenient to use the write() and read() methods all the time, it is much nicer to be able to use the ">" operations by analogy with text files. Let's give an example of the implementation of our class for working with binary files.

using namespace std;

struct Question //declaring a structure for storing information

/* overloading the insert operation into the stream to output a custom

structural data type Questionnaire on screen*/

stream & operator

class outBinaryFile: public of stream /^we define our class for working with output binary files. We generate it from the class for working with output file streams */

/* when describing the constructor of the generated class, do not forget to call the constructor of the base class, passing the necessary parameters to it */

outBinaryFile(char* name) : ofstream(name, ios::out I ios::binary)

//reload necessary operations like class methods outBinaryFile& operator

write((char*)&chislo, sizeof(chislo)); return *this;

outBinaryFile& operator

write((char*)&ank, sizeof(ank)); return *this;

class inpBinaryFile: public if stream /* we define our class for working with input binary files. We generate it from the class for working with input file streams */

inpBinaryFile(char* name) : ifstream(name, ios::in I ios::binary)

/*call the base class constructor with the required parameters,

enough for the constructor of the derived class */

//overload the necessary operations

inpBinaryFile& operator >> (int& number)

read((char*)&chislo, sizeof(chislo)); return *this;

inpBinaryFile& operator >> (Anketa& ank)

read((char*)&ank, sizeof(ank)); return *this;

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

// open the file for reading

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

for (int i = 0; i

inpFile >> a; //read the questionnaire from the file

cout //and display it on the screen

inpFile >> anketa; cout

The result of the program:

Kolya, 1990, 582-78-95.

Press any key to continue. . .

1. Is it possible to use the operation in the program?

ios::in I ios::out

• a) yes, in any case;
• b) yes, but only when working with text files;
• c) No, anyway.
• 2. Specify the correct option for opening a text file for reading:
  • a) ifstream inpF("input.txt", ios::in);
  • b) ifstream inpF("input.txt", ios::input);
  • c) ifstream inpF(ios:in, "input.txt").

H. What will be displayed as a result of executing the following code?

inputFile.get(c);

next - inputFile.peek();

if (next == EOF)

• a) the contents of the file associated with the inputFile stream will be displayed once;
• b) the contents of the file associated with the inputFile stream will be displayed on the screen infinite number once;
• c) nothing will be displayed on the screen.
• 4. How many characters are in the file?
• 12 3 4 5 6
• a) 6;
• b) 7;
• at 11.
• 5. What methods allow you to determine the end of a file?
• a) eof();
• b) good();
• c) both of these methods.
• 6. What is the purpose of the getline() function?
• a) reads a word from a file;
• b) reads the entire contents of the file;
• c) reads a line from a file.
• 7. To write/read user-defined data types to a file, you must:
  • a) overload the operations ">>" and "
  • b) writing and reading user-defined data types are available without additional actions;
  • c) writing and reading user-defined data types to a file is not possible.
• 8. What functions are used to write / read information in binary form?
• a) printf/scanf
• b) write / read;
• c) put / get.

• 1. Write a program that writes letters of the English alphabet to a file.
• 2. The input.txt file contains information from several text strings. Display the contents of this file on the screen, count the number of lines in the file.
• 3. The disk contains the file result.txt with the results of chemical experiments. Write a program that creates a copy of this file named copy_resylt.txt.
• 4. Use the keyboard to enter a file name. IN specified file remove all even lines.
• 5. Write a program that, in a text file, replaces everything lower case capital letters and vice versa.
• 6. The source text file contains numbers separated by spaces. Generate two new files: the first should contain only even numbers, and the second - odd.
• 7. The file contains real numbers. Write a program that discards fractional part these numbers and writes them to a new file.
• 8. Information about airline flights is recorded in a text file. Select from this data flights departing in the afternoon and display them on the screen.
• 9. Overload the >> and operators
• 10. Write your own class for working with binary files.
• 11. Write a list of 10 students in a class to a text file and a binary file. Compare these files. Explain the resulting difference.
• 12. Develop a class that writes information about cars (year of manufacture, brand, color, etc.) to a text file in a file. In this case, each symbol of information is replaced by its ABO 1-code. Display the resulting file on the screen.

test questions

• 1. What classes are used to work with file streams?
• 2. What access modes can be used when working with files? Give examples.
• 3. What method is used to open a file? Give examples.
• 4. What operations are available for working with files? What functions are designed to perform these operations?
• 5. What methods allow you to determine the end of a file when reading information from it? What is the difference between these methods? Give examples.
• 6. How can variables of standard data types be read from text files?
• 7. Is it possible to read variables of custom data types from text files?
• 8. What features are intended for random reading information from a file? Give examples.
• 9. Name the features of binary files. What are the benefits of using such files?
• 10. What functions can be used to write/read information to binary files?
• 11. How to read variables of standard data types from a binary file?
• 12. What are the considerations when reading custom data types from binary files?

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

The examples we have considered so far have demonstrated formatted input / output of information to files. Formatted file input/output of numbers should be used only if they are small and small, and also if it is necessary to provide the ability to view files without software tools. Otherwise, of course, it is much more efficient to use binary I/O, which stores numbers in the same way as in the computer's RAM, and not as character strings. Let me remind you that an integer (int) or real (float) value occupies 4 bytes in memory, the value type double is 8 bytes, and a character value of type char is 1 byte. For example, the number 12345 in a text (formatted) file takes 5 bytes, and in a binary file it takes 4 bytes.

Binaries, i.e. files in which information is stored in an internal representation form are used for subsequent use by software tools; they cannot be viewed by non-software tools. The advantage of binary files is that, firstly, when reading / writing, no time is wasted converting data from a symbolic representation form to an internal one and vice versa, and secondly, there is no loss of precision of real numbers. Both in the case of formatted input/output and in the case of binary input/output, for the "correct" processing of information from a file, it is necessary to know what types of data, how and in what sequence are written to a binary file, especially since viewing a binary file using text editor will give nothing.

Let's consider an example that demonstrates writing integer elements of a dynamic array to a binary file and reading them from this file.

#include

#include

#include

using namespace std;

cout<< "Vvedite kol-vo elementov celochisl. massiva: "; cin >>N;

int *mas = new int[N];

for(i=0; i

cout<< " Vvedite " << i << "-i element: "; cin >> mas[i];

cout<< "\nIdet zapis dannyh v fail..." << endl;

ofstream fout("c:\\os\\bin.dat", ios::binary);//create. out. binary stream

if(!fout) ( cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; }

fout.write(reinterpret_cast (mas), N*sizeof(int));//write array to file

fout.close();//closing the stream

cout<< "Dannye uspeshno zapisany!" << endl;

for(i=0; i

ifstream fin("c:\\os\\bin.dat", ios::binary); //create a stream to read the file

if(!fin) ( cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; }

cout<< "Fail sodergit:" << endl;

fin.read(reinterpret_cast (mas), N*sizeof(int));//read array from file

for(i=0; i

getch(); return 0;

Particular attention in this program should be paid to the use of the write () functions (method ofstream class) and read() (ifstream class method). These functions think of data in terms of bytes and are designed to transfer a certain number of bytes from the data buffer to the file and back. The parameters of these functions are the address of the buffer and its length in bytes.

The write() function is designed to write to the file the number of bytes specified in the second parameter from the number specified in the first parameter. addresses data buffer, and the read() function is designed to read data from a file. It should be noted here that these functions work with a data buffer of type char only. In this regard, in this program we used the operator reinterpret_cast<> , which converts our data buffer of type int (mas) to a buffer of type char.

It must be remembered that type casting using the operator reinterpret_cast necessary only in cases where the first parameter of the functions write() And read() is not a character array (because a character of type char occupies only 1 byte). In addition, if you need to write or read not an array, but individual variables, then you need to use the reference mechanism (reference to the address of the data buffer), for example:

ofstream fout(filename, ios::app | ios::binary);

fout.write(reinterpret_cast (& cb), sizeof(float));

Now it is necessary to discuss the second parameter of the considered functions. In this program, as the second parameter, we used the expression N * sizeof (int), with which we calculated the number of bytes. For example, if we have 5 integer array elements, then the number of bytes will be 20. The sizeof() function returns the number of bytes allocated for the data type specified as a parameter. For example, sizeof( int) will return 4.

So, the program given in this example allows you to write data in binary form to the bin.dat file and read them from this binary file. Moreover, after reading, this data is converted to the int type, acquires the structure of an array, and any operations can be performed with them.

Now, imagine that you need to write a program that allows you to read data from the bin.dat file, and we only know that this file contains elements of an integer array in binary form. Number of recorded elements ( N ) we do not know. When creating a program, we do not have the right to use a constant array, i.e. allocate memory for it at the stage of program creation. This will give an erroneous result. Since a too small value of N will lead to the fact that not all elements of the array are considered, and a too large value of N will lead to filling extra cells with random values.

Consider an example of a program that allows you to read elements of an integer array from a binary file by dynamically allocating memory, and to prove the realism of the read data, calculate their sum.

#include

#include

#include

using namespace std;

int N, i, sum=0, dfb; //dfb - file length in bytes

ifstream fin("c:\\os\\bin.dat", ios::binary);

if(!fin) ( cout<< "Oshibka otkrytiya faila!"; getch(); return 1; }

fin.seek(0, ios::end);//set the read position to the end of the file (from the end of 0 bytes)

dfb = fin.tellg();//get end of file position value (in bytes)

N=dfb/4;//knowing that an integer takes 4 bytes, we calculate the number of numbers

int *arr = new int[N];// create a dynamic array

fin.seekg(0, ios::beg);//before reading the data, move the current position to the beginning of the file

fin.read(reinterpret_cast (arr), dfb);

cout<< "Iz faila schitano " << N << " elementov:" << endl;

for(i=0; i

for(i=0; i

cout<< "\n Ih summa = " << sum;

getch(); return 0;

Let's take a closer look at this program, in which we actively used the seekg() and tellg() functions, which are methods of the ifstream class. Here it should be noted that any file is associated with a so-called current read or write position when it is opened. When a file is opened for reading, this position defaults to the beginning of the file. But quite often it is necessary to control the position manually in order to be able to read and write starting from an arbitrary location in the file. The seekg() and tellg() functions let you set and check the current read pointer, while the seekp() and tellp() functions do the same for the write pointer.

The seekg(1_parameter, 2_parameter) method moves the current read position from the file by the number of bytes specified in 1_parameter relative to the location specified in 2_parameter. 2_parameter can take one of three values:

ios::beg - from the beginning of the file;

ios::cur - from the current position;

ios::end - from the end of the file.

Here, beg, cur, and end are constants defined in the ios class, and the symbols:: denote an access operation to this class. For example, the operator fin.seekg(-10, ios::end); allows you to set the current reading position from the file 10 bytes before the end of the file.

Now back to the description of the program. Based on the fact that we do not know the number of numbers written to the file, we first need to find out the number of numbers. For this, using fin.seek(0, ios::end); we move to the end of the file and use the tellg() function to return the length of the file in bytes to the dfb variable. The tellg() function returns the current position of the pointer in bytes. Since the length of one integer in bytes is known to us (4 bytes), it is not difficult to calculate the number of numbers written to the file, knowing the length of the file in bytes ( N=dfb/4;). Having learned the number of numbers, we create a dynamic array and move to the beginning of the file in order to start reading data using the read () function. After the number of data bytes specified by us (dfb) is transferred to the data buffer (arr), the data read in this way acquires the structure of an array and becomes fully suitable for any operations and transformations.

Files. At the same time, from the point of view of technical implementation at the hardware level, text files are a special case of binary files, and, thus, in the broad sense of the word, any file is suitable for the definition of "binary file".

Binary files are often referred to as executable files and compressed data, but it is incorrect to limit this concept in this way.

Visualization

For a visual representation of a binary file, it is divided into pieces of equal size, represented as numbers, usually written in hexadecimal, sometimes in octal, binary, or decimal. The indicated size of a piece can be equal to one octet, as well as two or four (in the case of splitting into pieces of several octets, the byte order adopted on the platform used is applied). The dependence of the range of represented numbers on the size of the piece is shown in the table:

octets	number of bits	hexadecimal	octal	decimal unsigned	decimal iconic
1	8	00 … FF	000 … 377	0 … 255	-128 … 127
2	16	0000 … FFFF	000000 … 177777	0 … 65535	-32768 … 32767
4	32	00000000 … FFFFFFFF	00000000000 … 37777777777	0 … 4294967295	-2147483648 … 2147483647

Often, in addition to the numerical values ​​of the bytes, code page characters are also displayed, for example, printed ASCII characters on the right) of the beginning of the PNG file of the Wikipedia logo:

00000000 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 |.PNG........IHDR| 00000010 00 00 00 87 00 00 00 a0 08 03 00 00 00 11 90 8f |................| 00000020 b6 00 00 00 04 67 41 4d 41 00 00 d6 d8 d4 4f 58 |.....gAMA.....OX| 00000030 32 00 00 00 19 74 45 58 74 53 6f 66 74 77 61 72 |2....tEXtSoftwar| 00000040 65 00 41 64 6f 62 65 20 49 6d 61 67 65 52 65 61 |e.Adobe ImageRea| 00000050 64 79 71 c9 65 3c 00 00 03 00 50 4c 54 45 22 22 |dyq.e<....PLTE""| 00000060 22 56 56 56 47 47 47 33 33 33 30 30 30 42 42 42 |"VVVGGG333000BBB| 00000070 4b 4b 4b 40 40 40 15 15 15 4f 4f 4f 2c 2c 2c 3c |[email protected]@@...ooo,<| 00000080 3c 3c 3e 3e 3e 3a 39 39 04 04 04 1d 1d 1d 35 35 |<<>>>:99......55| 00000090 35 51 50 50 37 37 37 11 11 11 25 25 25 0d 0d 0d |5QPP777...%%%...| 000000a0 27 27 27 1a 1a 1a 38 38 38 2a 2a 2a 08 08 08 20 |"""...888***... | ..............|

Instruments

For visualization

• debug (on Microsoft Windows, partially)
• hexdump (on GNU/Linux etc.)

For editing

Literature

• Webster's New World Dictionary of Computer Terms, 4th. Ed, Prentice Hall, NY, 1992. ISBN 0-671-84651-5
• Leontiev B.K. Microsoft Windows XP File Formats: A Handbook, M.: ZAO "New Publishing House", 2005. ISBN 5-9643-0059-6

Wikimedia Foundation. 2010 .

See what "Binary file" is in other dictionaries:

Exist., m., use. comp. often Morphology: (no) what? file, no? file, (see) what? file what? file about what? about the file pl. what? files, (no) what? files than? files, (see) what? files than? files about what? about files 1. An array is called a file ... ... Dictionary of Dmitriev

Binary (binary) file in the broad sense: a sequence of arbitrary bytes. The name is due to the fact that bytes consist of bits, that is, binary (English binary) digits. In the narrow sense of the word, binary files are opposed to text files. ... ... Wikipedia

Binary (binary) file in the broad sense: a sequence of arbitrary bytes. The name is due to the fact that bytes consist of bits, that is, binary (English binary) digits. In the narrow sense of the word, binary files are opposed to ... ... Wikipedia

configuration file- A binary or text file containing information that defines the behavior of an application, computer, or network device. Network topics computing EN configuration file … Technical Translator's Handbook

This term has other meanings, see IPA (meanings). .IPA is an application archive file format from Apple for the iPhone, iPod Touch, and iPad. Files with this extension are stored in the App Store and downloaded using iTunes for ... ... Wikipedia

This article or section needs revision. There are no modules, OOP and other newfangled trends in Pascal. Description of extensions should be present only in articles about corresponding ... Wikipedia

Pascal Semantics: procedural Execution type: compiler Introduced in: 1970 Author(s): Niklaus Wirth Pascal is a general-purpose high-level programming language. One of the most famous programming languages, widely ... ... Wikipedia

Gopher Name: Gopher Port/ID: 70/TCP Specification: RFC 1436 Main implementations (clients): Mozilla Firefox, Microsoft Windows: IE 5.x, IE 6 (limited to MS) ... Wikipedia

Name: Gopher Port / ID: 70 / TCP Specification: RFC 1436 Main implementations (clients): Mozilla Firefox, Microsoft Windows: Internet Explorer 5.x, Internet Explorer 6 (limited to MS) Gopher distributed search and transmission network protocol ... ... Wikipedia

- /* A B C D E F G H I J K L M N O P Q R S T U V W X Y Z