Features of real numbers in Delphi. Structural data types Delphi real types

Data type

The program can operate with data of various types: integer and fractional numbers, characters, character strings, logical values.

Integer type

The Delphi language supports seven integer data types: shortint, smailint, Longint, Int64, Byte, word and Longword, a description of which is given in Table. 1.1.

Table 1.1. Integer types

Object Pascal also supports the most universal integer type -Integer which is equivalent Longint.

Real type

The Delphi language supports six real types: Reai48, single, Double, Extended, comp, Currency. The types differ in the range of acceptable values, the number of significant digits and the number of bytes required to store data in computer memory (Table 1.2).

Table 1.2. Real (fractional) types

The Delphi language also supports the most universal real type -Real, which is equivalent to Double.

Character type

The Delphi language supports two character types: Ansichar and Widechar:

• Ansichar type is ANSI characters that correspond to numbers in the range from 0 to 255;
  
• The widechar type is Unicode characters and corresponds to numbers from 0 to 65,535.
  

Object Pascal also supports the most universal character type - Char, which is equivalent to Ansichar.

String type

Delphi language supports three string types: shortstring, longstring

• WideString:
  
• the shortstring type is a string with a length from 0 to 255 characters statically allocated in computer memory;
  
• The Longstring type is a string dynamically allocated in memory, the length of which is limited only by the amount of free memory;
  
• The WideString type is a dynamically allocated string whose length is limited only by the amount of free memory. Each character in a WideString is a Unicode character.
  

In Delphi, the string identifier can be used to denote a string type. The string type is equivalent to the shortstring type.

Boolean type

A Boolean value can take one of two values: True or False. In Delphi, Boolean values ​​are classified as type Boolean.

Variable

A variable is an area of ​​memory that contains data that a program operates on. When a program manipulates data, it actually operates on the contents of memory cells, i.e., variables.

In order for a program to access a variable (memory area), for example, in order to obtain initial data for a calculation using a formula or to save the result, the variable must have a name. The variable name is created by the programmer.

As a variable name, you can use a sequence of Latin letters, numbers and some special characters. The first character in a variable name must be a letter. Space cannot be used in a variable name.

Note that the Delphi compiler does not distinguish between uppercase and lowercase letters in variable names, so the names SUMMA, Summa, and summa refer to the same variable.

It is desirable that the variable name be logically related to its purpose. For example, variables designed to store the coefficients and roots of a quadratic equation, which in general form is traditionally written

ax2 + bx + c = 0

it is quite logical to assign names a, b, c, x1 and x2. Another example. If the program has variables designed to store the purchase amount and discount amount, then these variables can be given names

TotalSumm and Discount or ObSumma and Skidka.

In Delphi, every variable must be declared before it can be used. With the help of a declaration, not only the fact of the existence of a variable is established, but its type is also specified, which also indicates the range of permissible values.

In general, a variable declaration instruction looks like this:

Name: type;

Where:

• name - variable name;
  
• type - the type of data the variable is intended to store.
  

Example:

a: Real; b: Real; i: Integer;

In the examples given, two variables of type real and one variable of type integer are declared.

In the program text, the declaration of each variable is usually placed on a separate line.

If the program has several variables of the same type, then the names of these variables can be listed on one line, separated by commas, and the type of the variables can be indicated after the name of the last variable, separated by a colon, for example:

a,b,c: Real; x1,x2: Real;

Constants

There are two types of constants in Delphi: regular and named.

A regular constant is an integer or fractional number, a string of characters or a single character, or a Boolean value.

Numeric constants

In the program text, numerical constants are written in the usual way, that is, in the same way as numbers, for example, when solving mathematical problems. When writing fractional numbers, a dot is used to separate the whole and fractional parts. If the constant is negative, then a minus sign is placed immediately before the first digit.

Below are examples of numeric constants:

123 0.0

524.03 0

Fractional constants can be represented as a floating point number. The floating-point representation is based on the fact that any number can be written in algebraic form as the product of a number less than 10, called the mantissa, and a power of ten, called the exponent.

"2.4"

"D"

Here you should pay attention to the constant "2.4". This is precisely a character constant, i.e. a string of characters that represents the number “two point four”, and not the number 2.4.

Logical constants

A logical statement (expression) can be either true or false. True corresponds to the constant True, and the value "false" corresponds to a constant False.

Named constant

A named constant is a name (identifier) ​​that is used in a program instead of the constant itself.

A named constant, like a variable, must be declared before it can be used. In general, the instruction for declaring a named constant looks like this:

constant = value;

Where:

• constant - the name of the constant;
  
• value - the value of the constant.
  

Named constants are declared in the program in the constant declaration section, which begins with the word const. Below is an example of declaring named constants (integer, string and fraction).

const

Bound = 10;

Title = "Running speed";!}

pi = 3.1415926;

After declaring a named constant in a program, you can use its name instead of the constant itself.

Unlike a variable, when declaring a constant, the type is not explicitly specified. The type of a constant is determined by its type, for example:

• 125 - integer constant;
  
• 0.0 - constant of real type;
  
• "execute" is a string constant;
  
• "\" is a character constant.

In previous lessons, we casually got acquainted with data types. All this time we were talking about simple types. Today we will summarize what we have covered previously, and also get acquainted with new material that you need to know within the framework of the topic “Simple data types”. There are a variety of reasons why you need to be smart about choosing data types for the variables you use in your programs. First, having the variety of available types at hand and skillfully managing them, you can reduce the amount of memory required by the program to operate. Nobody will notice a saving of 1-2 bytes, but if we are talking about large amounts of data, these bytes can result in very real megabytes. Secondly, a reasonable choice of data types allows you to avoid some errors, both on the part of the programmer (at the stage of creating the program) and on the part of the user (while using the program).

Simple data types - overview

Simple data types are called simple because they do not contain any other types within them. In addition, simple data types ensure that only one value is stored in memory. Simple data types include the following:

• integer;
• real;
• logical;
• string (character).

It should be noted that all of these types, with the exception of real, are ordered. What does it mean? This means that within this type, the values ​​are not arranged in random order, but in ascending order. Knowing this, in some cases you can eliminate unnecessary code in your program. Let me explain with an example exactly how the values ​​in these data types are ordered:

Integer type - contains numeric values, integers. The numbers are ordered in ascending order: ..., -2, -1, 0, 1, 2, 3, ...
Boolean type - contains only 2 values ​​- True, False, which are also ordered: False, True (follows from the correspondence False - 0, True - 1).
Character type - characters from the code table. Since each symbol has its own code, the symbols are arranged in order of increasing code. For example, the letters of the Latin alphabet A, B, C, D, ... appear in the code table exactly like this, because The further from the beginning of the alphabet, the higher the code the letter has. The same applies to Arabic numbers in the code table - they go in order: 0, 1, 2, ..., 8, 9. This allows comparisons such as "A"< "Z" (this is true).

Since the listed data types are ordered, it follows that all values ​​form a finite sequence. This corresponds to our ideas about data types - they all have their limitations. For example, there is no numeric data type that allows you to store an arbitrarily large number. There are “large” types, but they cannot store “number” “infinity”.

Functions and procedures for ordinal data types

There are several useful functions and procedures, without which it is sometimes difficult to operate with ordinal data types:

Pred() - the function returns the previous value for the expression specified as the only argument.

Examples: Pred(5) = 4, Pred("E") = "D", Pred(True) = False.

Succ() is the inverse function of Pred() and returns the next value.

Examples: Succ(5) = 6, Succ("E") = "F", Succ(False) = True.

Ord() - returns the ordinal number of a value in a list of data type values. We have already encountered this function when working with strings - with its help we recognized the character code.

Examples: Ord("A") = 65, Ord(True) = 1.

Low() - returns the minimum value of the specified data type.

Examples: Low(Byte) = 0, Low(Boolean) = False, Low(Char) = #0 (character with code 0).

High() - returns the maximum value of the specified data type.

Examples: High(Byte) = 255, High(Boolean) = True, High(Char) = #255 (in the Russian locale this is the character “ya”).

Well, and two more procedures that we are already familiar with:

Dec() - decreases the value by one.

Inc() - increases the value by one.

Don't forget about the second optional parameter of these procedures.

Custom Data Types

Based on ordinal data types, the programmer can create his own types - enumerable and interval. They will be discussed below.

Integer types

As the name suggests, integer types allow you to store integer numbers. Among them, there are types that store signed numbers (i.e., positive or negative), and there are also those that store only positive ones. The more values ​​a type can contain, the more memory it takes up. Let's look at integer data types.

First let's look at unsigned types, i.e. those that allow you to store only positive numbers and zero:

Byte - values 0..255 - occupies memory 1 byte.

Word - meanings 0..65535 - 2 byte.

LongWord - meanings 0..4294967295 - 4 byte.

Now signed types (negative numbers are written with a minus sign "-" in front, non-negative numbers can be written with or without a "+" sign):

ShortInt - values -128..127 - 1 byte.

SmallInt - values -32768..32767 - 2 byte.

LongInt - values -2147483648..2147483647 - 4 byte.

Int64 - values -2 ^53 ..2 ^53 -1 - 8 byte.

There are also 2 general types, which are reflected in the above. It is recommended to use these types, because... the compiler is “tailored” for them and creates faster and more efficient code:

Integer - values -2147483648..2147483647 - 4 byte.

Cardinal - meanings 0..4294967295 - 4 byte.

It should be noted that integers can be represented not only in decimal, but also in hexadecimal number systems, i.e. in the form $xxxxxxxx, where x is one of the symbols 0, 1, ..., 8, 9, A, B, ..., E, F. For example, all colors (more precisely, their codes) are represented in the form hexadecimal numbers.

Boolean types

We are already familiar with logical expressions and the logical data type - this is the Boolean type, which takes values True And False. In addition to Boolean, the following logical types exist: ByteBool, WordBool and LongBool. However, the latter were introduced only to ensure compatibility with other languages ​​and programming systems. It is recommended to use only the Boolean type. A Boolean value occupies 1 byte in memory. In fact, of course, one bit is enough, but, unfortunately, we cannot operate on cells smaller than a byte.

Character types

Character types provide storage for individual characters. The main data type is Char, which contains characters with codes 0..255 . There are also types AnsiChar and WideChar. Type AnsiChar equivalent to type Char, i.e. they are essentially the same type. Occupies memory 1 byte. The code used to encode characters is ANSI (American National Standards Institute). Type WideChar encoded by international code Unicode and occupies memory 2 byte. The Unicode table includes characters from almost all languages ​​of the world.

Real types

From the name it follows that these types are used to store real values, i.e. real numbers. They differ in the limits of permissible values ​​and accuracy, i.e. number of digits after the decimal point. These are the types:

Real (aka Double) - values ​​from 5.0x10^-324 to 1.7x10 ^308, accuracy - 15-16 numbers, occupies memory 8 byte.

Real48 - values ​​from 2.9x10^-39 to 1.7x10^38, accuracy - 11-12 numbers, 6 byte of memory.

Single - values ​​from 1.7x10^-45 to 3.4x10^38, accuracy - 7-8 numbers, 4 byte.

Extended - from 3.6x10^-4951 to 1.1x10 ^4932, accuracy - 19-20 numbers, 10 byte of memory.

Comp - from -2x10 ^63 +1 to 2x10^63 -1, accuracy - 19-20 numbers, 8 byte.

Currency - from -922337203685477.5808 to 922337203685477.5807 , accuracy - 19-20 digits, occupies memory 8 byte.

As with integers, real numbers can be preceded by a "+" or "-" sign.

There are 2 forms of writing real numbers - with fixed point and with floating.

Fixed-point notation is a regular notation in which the integer and decimal parts are separated by a period/comma.

Floating-point notation involves writing the order of a number, which is separated from the number itself by the letter "E" (notation "e" is also acceptable). For example, record 1.5e2 means the number 1.5 with order +2, i.e. that's 1.5x10^2 = 150.

Types Comp And Currency were introduced specifically for making accurate cash payments. At the same time, type Comp, as can be seen from the range boundary values, stores integers, so when given numbers with a fractional part, they are automatically converted to the nearest integer.

Enumerable data types

From considering ready-made data types, let's move on to types that can be created by the programmer himself. One option, as noted above, is an enum type.

The point of an enumerated type is that we explicitly specify (enumerate) all possible values. The advantages are that, in addition to the given values, variables of this type will not be able to take any more values. In addition, meanings can be set that are quite meaningful - for example words. This will make it easier to understand the code and write the program.

Data type values ​​are listed separated by commas, and the entire set is enclosed in parentheses. The type description must be made in a special section of the descriptions section - the type description section. This section is preceded by the type keyword. Those. the recording is approximately the same as the description of variables or constants, only instead of var And const is written type. The type itself is described as follows: the name of the type, then the equal sign and then the value itself. In the case of an enumerated type, this will be the set of possible values.

Note: Almost all data types in Object Pascal are usually named with the letter "T" (short for "Type"). This is not a law of language - just one of the rules of good manners. Knowing that "T***" is a type, you will never be mistaken, otherwise the name can be confused, for example, with the name of a variable.

Let's say we want to set a data type that defines one of the months of the year. We can describe it like this:

Please note that after the declaration of an enumerated type, the program cannot contain variables whose name matches the name of the values ​​of the declared type. In our example, there cannot be variables "Jan", "Feb", etc. If you try to assign a variable of an enumerated type to a value not specified in the list, the compiler will throw an error, so it is not possible to make a mistake.

The type section exists as a module of the entire form (this section initially describes the form itself: TForm1 = class(TForm) ...), and in any subroutine. The scope of a type is, accordingly, determined by the place in the program in which it is described.

Interval data types

Interval data types (also called bounded data types) are derived from existing types by restricting the range of values. The interval is specified by two constants - the initial and final boundaries. Each time a value is assigned to a variable, a check is made to ensure that the new value falls within the specified range. If the value does not fall within the range, an error message is generated. During program execution, specifying an invalid value does not result in an error, but the value of the variable may become incorrect.
A restricted data type can only be created from a simple ordered type. The value of the second constant (i.e. the right border) must be greater than the value of the first (left border).
Restricted data types are also described in section type. The recording format is similar, only two dots are placed between the boundary constants.

For example, we want to work with dates in the program. You can create limited data types for day, month, and year values ​​(the range for the year value should be set depending on the task context):

Remember that using a limited data type will not reduce the memory footprint. This follows from the fact that setting an interval is just a conditional setting of possible values ​​from the general set of values ​​of a given type.

Conclusion

Today we looked at simple data types - integer, real, character and logical, and also learned how to create enumerated and interval data types in our programs. As noted at the beginning, all of these types allow you to store only one value and do not contain other types within them. Later we will move on to consider structural data types, where the situation is different.

a - Latin) - only the article address (URL);
((article:122))- a full HTML link to the article (the link text is the title of the article).

The built-in data types in the Delphi language include integer, real, characters, strings, pointers, and boolean types.

Ordinal types. Ordinal types are those in which the values ​​are ordered, and for each of them you can specify a previous and subsequent value.

Structural types. Structural types include sets, arrays, records, files, classes, and interfaces.

Integer data types. In variables of integer types, information is represented in the form of integers, i.e. numbers without a fractional part.

Table 1 Operations on ordinal types

Table 2

There is also a type called Integer, which is equivalent to the LongInt type. Its range is from -2147483648 to 21474836478. It occupies 4 bytes in memory. The main ones are Integer and Cardinal, so in most cases it is desirable to use these types.

All operations defined for ordinal types are performed on integer data. Operations on integer types:

Table 3

Valid data types. Variables of real types contain numbers consisting of an integer and a fractional part.

Table 4

The main type that provides maximum performance is the Real type, which is currently equivalent to the Double type.

Table 5 Functions of real types

Character data types. Character types are designed to store a single character.

Table 6

Boolean data types. Boolean data type variables represent Boolean values, such as true and false.

Table 7 Dimensions of variables of Boolean types

An array is a data structure that is a collection of variables of the same type that have a common name. Arrays are convenient to use for storing information that is homogeneous in nature, for example, tables and lists.

Array Declaration

An array, like any program variable, must be declared in the variable declaration section before use. In general, the array declaration instruction looks like this:

Name: [lower_index..upper_index] of type

where: name is the name of the array;

array is a Delphi reserved word indicating that the declared name is the name of an array;

lower_index and upper_index are integer constants that determine the range of changes in the index of the array elements and, implicitly, the number of elements (size) of the array;

type -- type of array elements.

What they don’t write about in Delphi books Grigoriev A.B.

3.2.2. Delphi Real Types

There are four real types in Delphi: Single, Double, Extended and Real. Their general format is the same (Fig. 3.1, a).

The sign is always one bit. It is equal to zero for positive numbers and one for negative ones. As for the sizes of the mantissa and exponent, this is where the difference between the types lies.

Before moving on to specific numbers, let’s take a closer look at the Real type, making a short excursion into history. Real is a standard type of the Pascal language that was present there initially. When Pascal was created, processors did not yet have built-in support for real numbers, so all operations with Real data were reduced to operations with integers. Accordingly, the size of the fields in the Real type was chosen to optimize these operations.

a) general form of a real number

b) Binary representation of a number of type Single

Rice. 3.1. Storing a real number in memory

The Intel 8086/88 microprocessor and its improved variants - 80286 and 80386 - also did not have hardware support for real numbers. But systems based on these processors had the ability to connect a so-called coprocessor. This chip worked with memory through the buses of the main processor and provided hardware support for real numbers. In mid-range systems, the coprocessor slot was usually empty, since this reduced the price (of course, inserting a coprocessor there was not a problem). Each central processor had its own coprocessors, labeled Intel 8087, 80287 and 80387, respectively. There were even coprocessors produced by other companies. They were faster than Intel coprocessors, but appeared on the market later. The real number type supported by coprocessors is not the same as Real . It is defined by the IEEE (Institute of Electrical and Electronics Engineers) standard.

To support IEEE types in its systems, Borland introduces the Single, Double, and Extended types into Turbo Pascal. Extended is the main type for the coprocessor, and Single and Double are obtained from it by very simple truncation. The coprocessor instruction system allows working with these types: when loading a number of type Single or Double into the internal register of the coprocessor, the latter converts them to Extended. On the contrary, when loading numbers of these types from a register into memory, the coprocessor truncates them to the required size. Internal operations are always performed with data of the Extended type (however, there is an exception to this rule, which we will discuss later, after a detailed discussion of the format of various types). Single and Double allow you to save memory. Neither of them are the same as the Real type. In systems with coprocessors, new types are processed noticeably (2–3 times) faster than Real (this takes into account the fact that the Real type, after appropriate conversion, was also processed by the coprocessor; if we compare the processing of the Extended type on a machine with a coprocessor and Real on a machine without coprocessor, then in individual operations a difference in speed of about 100 times was achieved). So that programs with these types can be executed on systems without a coprocessor, it was possible to connect a software coprocessor emulator to them. The emulator's processing of these types was slower than Real's processing.

Starting with the 486 series, Intel is heading towards integrating the processor and coprocessor into one chip. The percentage of defects in microcircuits is too high, so Intel resorts to a trick: if a microcircuit is defective only in the coprocessor part, then jumpers are burned on this chip that block the coprocessor, and the microcircuit is sold as an 80486SX processor, which does not have a built-in coprocessor (unlike the full version, which was called 80486DX). There were also the opposite situations, when the coprocessor was not damaged, but the processor was inoperable. Such microcircuits were turned into an “80487 coprocessor”. But this is already exotic, and, according to the information we have, such a coprocessor has not reached Russia.

The Pentium processor in all its variants had a built-in floating point unit (FPU - Floating Point Unit), and did not require a separate coprocessor. Thus, with the arrival of this processor, the Real type remained only for backward compatibility, and the Single, Double and Extended types came to the fore. Starting with Delphi 4, the Real type becomes synonymous with the Double type, and the old 6-byte type is called Real48.

Note

There is a compiler directive ($REALCOMPATIBILITY ON/OFF) that when enabled (it is disabled by default) makes Real a synonym for Real48 rather than Double.

The field sizes for various real types are shown in Table. 3.1.

Table 3.1. Field sizes in real types

Other parameters of real types, such as range and precision, can be found in the Delphi help.

Value Types, Reference Types, and the Assignment Operator Now examine the following Main() method and look at its output, shown in Figure 1. 3.12.static void Main(string args) ( Console.WriteLine("*** Value Types / Reference Types ***"); Console.WriteLine(-› Creating p1"); MyPoint