What do these programs do?
It turns out that the second implementation runs twice as fast as the first. Did you expect such a result? How do you explain it?

Exercise 3.15

Could you improve or add anything to the set of operations of the string class given in the last section? Explain your proposals

3.5. const specifier

Let's take the following code example:

For (int index = 0; index< 512; ++index) ... ;

There are two problems with using the 512 literal. The first is the ease of perception of the program text. Why should the upper bound of the loop variable be exactly 512? What is hidden behind this value? She seems random...
The second problem concerns the ease of modification and maintenance of the code. Let's say the program has 10,000 lines and the literal 512 occurs in 4% of them. Let's say that in 80% of cases the number 512 must be changed to 1024. Can you imagine the complexity of such work and the number of mistakes that can be made by correcting the wrong value?
We solve both of these problems at the same time: we need to create an object with the value 512. Giving it a meaningful name, such as bufSize, we make the program much more understandable: it is clear what exactly the loop variable is compared to.

Index< bufSize

In this case, changing the size of bufSize does not require going through 400 lines of code to modify 320 of them. How much the likelihood of errors is reduced by adding just one object! Now the value is 512 localized.

Int bufSize = 512; // input buffer size // ... for (int index = 0; index< bufSize; ++index)
// ...

One small problem remains: the bufSize variable here is an l-value that can be accidentally changed in the program, leading to a hard-to-catch error. Here's one common mistake: using the assignment operator (=) instead of the comparison operator (==):

// random change in bufSize value if (bufSize = 1) // ...

Executing this code will cause the bufSize value to be 1, which can lead to completely unpredictable program behavior. Errors of this kind are usually very difficult to detect because they are simply not visible.
Using the const specifier solves this problem. By declaring the object as

Const int bufSize = 512; // input buffer size

we turn the variable into a constant with value 512, the value of which cannot be changed: such attempts are suppressed by the compiler: incorrect use of the assignment operator instead of comparison, as in the example above, will cause a compilation error.

// error: attempt to assign a value to a constant if (bufSize = 0) ...

Since a constant cannot be assigned a value, it must be initialized at the place where it is defined. Defining a constant without initializing it also causes a compilation error:

Const double pi; // error: uninitialized constant

Const double minWage = 9.60; // Right? error?
double *ptr =

Should the compiler allow such an assignment? Since minWage is a constant, it cannot be assigned a value. On the other hand, nothing prevents us from writing:

*ptr += 1.40; // changing the minWage object!

As a rule, the compiler is not able to protect against the use of pointers and will not be able to signal an error if they are used in this way. This requires too deep an analysis of the program logic. Therefore, the compiler simply prohibits the assignment of constant addresses to ordinary pointers.
So, are we deprived of the ability to use pointers to constants? No. For this purpose, there are pointers declared with the const specifier:

Const double *cptr;

where cptr is a pointer to an object of type const double. The subtlety is that the pointer itself is not a constant, which means we can change its value. For example:

Const double *pc = 0; const double minWage = 9.60; // correct: we cannot change minWage using pc
pc = double dval = 3.14; // correct: we cannot change minWage using pc
// although dval is not a constant
pc = // correct dval = 3.14159; //Right
*pc = 3.14159; // error

The address of a constant object is assigned only to a pointer to a constant. At the same time, such a pointer can also be assigned the address of a regular variable:

Pc =

A constant pointer does not allow the object it addresses to be modified using indirect addressing. Although dval in the example above is not a constant, the compiler will not allow dval to be changed via pc. (Again, because it is not able to determine which object's address may contain a pointer at any time during program execution.)
In real programs, pointers to constants are most often used as formal parameters of functions. Their use ensures that the object passed to a function as an actual argument will not be modified by that function. For example:

// In real programs, pointers to constants are most often // used as formal parameters of functions int strcmp(const char *str1, const char *str2);

(We'll talk more about constant pointers in Chapter 7, when we talk about functions.)
There are also constant pointers. (Note the difference between a const pointer and a pointer to a constant!). A const pointer can address either a constant or a variable. For example:

Int errNumb = 0; int *const currErr =

Here curErr is a const pointer to a non-const object. This means that we cannot assign it the address of another object, although the object itself can be modified. Here's how the curErr pointer could be used:

Do_something(); if (*curErr) (
errorHandler();
*curErr = 0; // correct: reset errNumb value
}

Trying to assign a value to a const pointer will cause a compilation error:

CurErr = // error

A constant pointer to a constant is a union of the two cases considered.

Const double pi = 3.14159; const double *const pi_ptr = π

Neither the value of the object pointed to by pi_ptr nor the value of the pointer itself can be changed in the program.

Exercise 3.16

Explain the meaning of the following five definitions. Are any of them wrong?

(a) int i; (d) int *const cpi; (b) const int ic; (e) const int *const cpic; (c) const int *pic;

Exercise 3.17

Which of the following definitions are correct? Why?

(a) int i = -1; (b) const int ic = i; (c) const int *pic = (d) int *const cpi = (e) const int *const cpic =

Exercise 3.18

Using the definitions from the previous exercise, identify the correct assignment operators. Explain.

(a) i = ic; (d) pic = cpic; (b) pic = (i) cpic = (c) cpi = pic; (f) ic = *cpic;

3.6. Reference type

A reference type, sometimes called an alias, is used to give an object an additional name. A reference allows you to manipulate an object indirectly, just like you can with a pointer. However, this indirect manipulation does not require the special syntax required for pointers. Typically, references are used as formal parameters of functions. In this section, we will look at using reference type objects on our own.
A reference type is indicated by specifying the address operator (&) before the variable name. The link must be initialized. For example:

Int ival = 1024; // correct: refVal - reference to ival int &refVal = ival; // error: reference must be initialized to int

Int ival = 1024; // error: refVal is of type int, not int* int &refVal = int *pi = // correct: ptrVal is a reference to a pointer int *&ptrVal2 = pi;

Once a reference is defined, you can't change it to work with another object (which is why the reference must be initialized at the point where it is defined). In the following example, the assignment operator does not change the value of refVal; the new value is assigned to the variable ival - the one that refVal addresses.

Int min_val = 0; // ival receives the value of min_val, // instead of refVal changes the value to min_val refVal = min_val;

RefVal += 2; adds 2 to ival, the variable referenced by refVal. Similarly int ii = refVal; assigns ii the current value of ival, int *pi = initializes pi with the address of ival.

// two objects of type int are defined int ival = 1024, ival2 = 2048; // one reference and one object defined int &rval = ival, rval2 = ival2; // one object, one pointer and one reference are defined
int inal3 = 1024, *pi = ival3, &ri = ival3; // two links are defined int &rval3 = ival3, &rval4 = ival2;

A const reference can be initialized by an object of another type (assuming, of course, it is possible to convert one type to another), as well as by an addressless value such as a literal constant. For example:

Double dval = 3.14159; // only true for constant references
const int &ir = 1024;
const int &ir2 = dval;
const double &dr = dval + 1.0;

If we had not specified the const specifier, all three reference definitions would have caused a compilation error. However, the reason why the compiler does not pass such definitions is unclear. Let's try to figure it out.
For literals, this is more or less clear: we should not be able to indirectly change the value of a literal using pointers or references. As for objects of other types, the compiler converts the original object into some auxiliary object. For example, if we write:

Double dval = 1024; const int &ri = dval;

then the compiler converts it to something like this:

Int temp = dval; const int &ri = temp;

If we could assign a new value to the ri reference, we would actually change not dval, but temp. The dval value would remain the same, which is completely unobvious to the programmer. Therefore, the compiler prohibits such actions, and the only way to initialize a reference with an object of another type is to declare it as const.
Here is another example of a link that is difficult to understand the first time. We want to define a reference to the address of a constant object, but our first option causes a compilation error:

Const int ival = 1024; // error: constant reference needed
int *&pi_ref =

An attempt to correct the matter by adding a const specifier also fails:

Const int ival = 1024; // still an error const int *&pi_ref =

What is the reason? If we read the definition carefully, we will see that pi_ref is a reference to a constant pointer to an object of type int. And we need a non-const pointer to a constant object, so the following entry would be correct:

Const int ival = 1024; // Right
int *const &piref =

There are two main differences between a link and a pointer. First, the link must be initialized at the place where it is defined. Secondly, any change to a link transforms not the link, but the object to which it refers. Let's look at examples. If we write:

Int *pi = 0;

we initialize the pointer pi to zero, which means that pi does not point to any object. At the same time recording

const int &ri = 0;
means something like this:
int temp = 0;
const int &ri = temp;

As for the assignment operation, in the following example:

Int ival = 1024, ival2 = 2048; int *pi = &ival, *pi2 = pi = pi2;

the variable ival pointed to by pi remains unchanged, and pi receives the value of the address of the variable ival2. Both pi and pi2 now point to the same object, ival2.
If we work with links:

Int &ri = ival, &ri2 = ival2; ri = ri2;

// example of using links // The value is returned in the next_value parameter
bool get_next_value(int &next_value); // overloaded operator Matrix operator+(const Matrix&, const Matrix&);

Int ival; while (get_next_value(ival)) ...

Int &next_value = ival;

(The use of references as formal parameters of functions is discussed in more detail in Chapter 7.)

Exercise 3.19

Are there any errors in these definitions? Explain. How would you fix them?

(a) int ival = 1.01; (b) int &rval1 = 1.01; (c) int &rval2 = ival; (d) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (g) int &rval5 = pi*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (j) const int &*prval2 =

Exercise 3.20

Are any of the following assignment operators erroneous (using the definitions from the previous exercise)?

(a) rval1 = 3.14159; (b) prval1 = prval2; (c) prval2 = rval1; (d) *prval2 = ival2;

Exercise 3.21

Find errors in the given instructions:

(a) int ival = 0; const int *pi = 0; const int &ri = 0; (b)pi =
ri =
pi =

3.7. Type bool

An object of type bool can take one of two values: true and false. For example:

// initialization of the string string search_word = get_word(); // initialization of the found variable
bool found = false; string next_word; while (cin >> next_word)
if (next_word == search_word)
found = true;
// ... // shorthand: if (found == true)
if (found)
cout<< "ok, мы нашли слово\n";
else cout<< "нет, наше слово не встретилось.\n";

Although bool is one of the integer types, it cannot be declared as signed, unsigned, short, or long, so the above definition is erroneous:

// error short bool found = false;

Objects of type bool are implicitly converted to type int. True becomes 1 and false becomes 0. For example:

Bool found = false; int occurrence_count = 0; while (/* mumble */)
{
found = look_for(/* something */); // value found is converted to 0 or 1
occurrence_count += found; )

In the same way, values ​​of integer types and pointers can be converted to values ​​of type bool. In this case, 0 is interpreted as false, and everything else as true:

// returns the number of occurrences extern int find(const string&); bool found = false; if (found = find("rosebud")) // correct: found == true // returns a pointer to the element
extern int* find(int value); if (found = find(1024)) // correct: found == true

3.8. Transfers

Often you have to define a variable that takes values ​​from a certain set. Let's say a file is opened in any of three modes: for reading, for writing, for appending.
Of course, three constants can be defined to denote these modes:

Const int input = 1; const int output = 2; const int append = 3;

and use these constants:

Bool open_file(string file_name, int open_mode); // ...
open_file("Phoenix_and_the_Crane", append);

This solution is possible, but not entirely acceptable, since we cannot guarantee that the argument passed to the open_file() function is only 1, 2 or 3.
Using an enum type solves this problem. When we write:

Enum open_modes( input = 1, output, append );

we define a new type open_modes. Valid values ​​for an object of this type are limited to the set of 1, 2, and 3, with each of the specified values ​​having a mnemonic name. We can use the name of this new type to define both an object of that type and the type of the function's formal parameters:

Void open_file(string file_name, open_modes om);

input, output and append are enumeration elements. The set of enumeration elements specifies the allowed set of values ​​for an object of a given type. A variable of type open_modes (in our example) is initialized with one of these values; it can also be assigned any of them. For example:

Open_file("Phoenix and the Crane", append);

An attempt to assign a value other than one of the enumeration elements to a variable of this type (or pass it as a parameter to a function) will cause a compilation error. Even if we try to pass an integer value corresponding to one of the enumeration elements, we will still receive an error:

// error: 1 is not an element of the enumeration open_modes open_file("Jonah", 1);

There is a way to define a variable of type open_modes, assign it the value of one of the enumeration elements and pass it as a parameter to the function:

Open_modes om = input; // ... om = append; open_file("TailTell", om);

However, it is not possible to obtain the names of such elements. If we write the output statement:

Cout<< input << " " << om << endl;

then we still get:

This problem is solved by defining a string array in which the element with an index equal to the value of the enumeration element will contain its name. Given such an array, we can write:

Cout<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

In addition, you cannot iterate over all the values ​​of an enum:

// not supported for (open_modes iter = input; iter != append; ++inter) // ...

To define an enumeration, use the enum keyword, and element names are specified in curly braces, separated by commas. By default, the first one is 0, the next one is 1, and so on. You can change this rule using the assignment operator. In this case, each subsequent element without an explicitly specified value will be 1 more than the element that comes before it in the list. In our example, we explicitly specified the value 1 for input, and output and append will be equal to 2 and 3. Here is another example:

// shape == 0, sphere == 1, cylinder == 2, polygon == 3 enum Forms( share, spere, cylinder, polygon );

Integer values ​​corresponding to different elements of the same enumeration do not have to be different. For example:

// point2d == 2, point2w == 3, point3d == 3, point3w == 4 enum Points ( point2d=2, point2w, point3d=3, point3w=4 );

An object whose type is an enumeration can be defined, used in expressions, and passed to a function as an argument. Such an object is initialized with only the value of one of the enumeration elements, and only that value is assigned to it, either explicitly or as the value of another object of the same type. Even integer values ​​corresponding to valid enumeration elements cannot be assigned to it:

Void mumble() ( Points pt3d = point3d; // correct: pt2d == 3 // error: pt3w is initialized with type int Points pt3w = 3; // error: polygon is not included in the Points enumeration pt3w = polygon; // correct: both object of type Points pt3w = pt3d )

However, in arithmetic expressions, an enumeration can be automatically converted to type int. For example:

Const int array_size = 1024; // correct: pt2w is converted to int
int chunk_size = array_size * pt2w;

3.9. Type "array"

We already touched on arrays in section 2.1. An array is a set of elements of the same type, accessed by an index - the serial number of the element in the array. For example:

Int ival;

defines ival as an int variable, and the instruction

Int ia[ 10 ];

specifies an array of ten objects of type int. To each of these objects, or array elements, can be accessed using the index operation:

Ival = ia[ 2 ];

assigns the variable ival the value of the array element ia with index 2. Similarly

Ia[ 7 ] = ival;

assigns the element at index 7 the value ival.

An array definition consists of a type specifier, an array name, and a size. The size specifies the number of array elements (at least 1) and is enclosed in square brackets. The size of the array must be known already at the compilation stage, and therefore it must be a constant expression, although it is not necessarily specified as a literal. Here are examples of correct and incorrect array definitions:

Extern int get_size(); // buf_size and max_files constants
const int buf_size = 512, max_files = 20;
int staff_size = 27; // correct: constant char input_buffer[ buf_size ]; // correct: constant expression: 20 - 3 char *fileTable[ max_files-3 ]; // error: not a constant double salaries[ staff_size ]; // error: not a constant expression int test_scores[ get_size() ];

The buf_size and max_files objects are constants, so the input_buffer and fileTable array definitions are correct. But staff_size is a variable (albeit initialized with the constant 27), which means salaries are unacceptable. (The compiler is unable to find the value of the staff_size variable when the salaries array is defined.)
The max_files-3 expression can be evaluated at compile time, so the fileTable array definition is syntactically correct.
Element numbering starts at 0, so for an array of 10 elements the correct index range is not 1 – 10, but 0 – 9. Here is an example of iterating through all the elements of the array:

Int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 0; ix< array_size; ++ ix)
ia[ ix ] = ix;
}

When defining an array, you can explicitly initialize it by listing the values ​​of its elements in curly braces, separated by commas:

Const int array_size = 3; int ia[ array_size ] = ( 0, 1, 2 );

If we explicitly specify a list of values, then we don’t have to specify the size of the array: the compiler itself will count the number of elements:

// array of size 3 int ia = ( 0, 1, 2 );

When both the size and the list of values ​​are explicitly specified, three options are possible. If the size and number of values ​​coincide, everything is obvious. If the list of values ​​is shorter than the specified size, the remaining array elements are initialized to zero. If there are more values ​​in the list, the compiler displays an error message:

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; int ia[ array_size ] = ( 0, 1, 2 );

A character array can be initialized not only with a list of character values ​​in curly braces, but also with a string literal. However, there are some differences between these methods. Let's say

Const char cal = ("C", "+", "+" ); const char cal2 = "C++";

The dimension of the ca1 array is 3, the ca2 array is 4 (in string literals, the terminating null character is taken into account). The following definition will cause a compilation error:

// error: the string "Daniel" consists of 7 elements const char ch3[ 6 ] = "Daniel";

An array cannot be assigned the value of another array, and initialization of one array by another is not allowed. Additionally, it is not allowed to use an array of references. Here are examples of the correct and incorrect use of arrays:

Const int array_size = 3; int ix, jx, kx; // correct: array of pointers of type int* int *iar = ( &ix, &jx, &kx ); // error: reference arrays are not allowed int &iar = ( ix, jx, kx ); int main()
{
int ia3( array_size ]; // correct
// error: built-in arrays cannot be copied
ia3 = ia;
return 0;
}

To copy one array to another, you have to do this for each element separately:

Const int array_size = 7; int ia1 = ( 0, 1, 2, 3, 4, 5, 6 ); int main() (
int ia3[ array_size ]; for (int ix = 0; ix< array_size; ++ix)
ia2[ ix ] = ia1[ ix ]; return 0;
}

An array index can be any expression that produces a result of an integer type. For example:

Int someVal, get_index(); ia2[ get_index() ] = someVal;

We emphasize that the C++ language does not provide control of array indices, either at the compilation stage or at the runtime stage. The programmer himself must ensure that the index does not go beyond the boundaries of the array. Errors when working with an index are quite common. Unfortunately, it is not very difficult to find examples of programs that compile and even work, but nevertheless contain fatal errors that sooner or later lead to crash.

Exercise 3.22

Which of the following array definitions are incorrect? Explain.

(a) int ia[ buf_size ]; (d) int ia[ 2 * 7 - 14 ] (b) int ia[ get_size() ]; (e) char st[ 11 ] = "fundamental"; (c) int ia[ 4 * 7 - 14 ];

Exercise 3.23

The following code snippet must initialize each element of the array with an index value. Find the mistakes made:

Int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 1; ix<= array_size; ++ix)
ia[ ia ] = ix; // ...
}

3.9.1. Multidimensional arrays

In C++, it is possible to use multidimensional arrays, when declaring them you must indicate the right boundary of each dimension in separate square brackets. Here is the definition of a two-dimensional array:

Int ia[ 4 ][ 3 ];

The first value (4) specifies the number of rows, the second (3) – the number of columns. The ia object is defined as an array of four strings of three elements each. Multidimensional arrays can also be initialized:

Int ia[ 4 ][ 3 ] = ( ( 0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

Inner curly braces, which break the list of values ​​into lines, are optional and are generally used to make the code easier to read. The initialization below is exactly the same as the previous example, although it is less clear:

Int ia = ( 0,1,2,3,4,5,6,7,8,9,10,11 );

The following definition initializes only the first elements of each line. The remaining elements will be zero:

Int ia[ 4 ][ 3 ] = ( (0), (3), (6), (9) );

If you omit the inner curly braces, the result will be completely different. All three elements of the first row and the first element of the second will receive the specified value, and the rest will be implicitly initialized to 0.

Int ia[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

When accessing elements of a multidimensional array, you must use indexes for each dimension (they are enclosed in square brackets). This is what initializing a two-dimensional array looks like using nested loops:

Int main() ( const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; for (int = 0; i< rowSize; ++i)
for (int j = 0; j< colSize; ++j)
ia[ i ][ j ] = i + j j;
}

Design

Ia[ 1, 2 ]

is valid from the point of view of C++ syntax, but it does not mean at all what an inexperienced programmer expects. This is not a declaration of a two-dimensional 1-by-2 array. An aggregate in square brackets is a comma-separated list of expressions that will result in the final value 2 (see the comma operator in Section 4.2). Therefore the declaration ia is equivalent to ia. This is another opportunity to make a mistake.

3.9.2. Relationship between arrays and pointers

If we have an array definition:

Int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );

then what does simply indicating his name in the program mean?

Using an array identifier in a program is equivalent to specifying the address of its first element:

Similarly, you can access the value of the first element of an array in two ways:

// both expressions return the first element *ia; ia;

To take the address of the second element of the array, we must write:

As we mentioned earlier, the expression

also gives the address of the second element of the array. Accordingly, its meaning is given to us in the following two ways:

*(ia+1); ia;

Note the difference in expressions:

*ia+1 and *(ia+1);

The dereference operation has a higher a priority than the addition operation (operator priorities are discussed in Section 4.13). Therefore, the first expression first dereferences the variable ia and gets the first element of the array, and then adds 1 to it. The second expression delivers the value of the second element.

You can traverse an array using an index, as we did in the previous section, or using pointers. For example:

#include int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); int *pbegin = ia; int *pend = ia + 9; while (pbegin != pend) ( cout<< *pbegin <<; ++pbegin; } }

The pbegin pointer is initialized to the address of the first element of the array. Each pass through the loop increments this pointer by 1, which means it is shifted to the next element. How do you know where to stay? In our example, we defined a second pend pointer and initialized it with the address following the last element of the ia array. As soon as the value of pbegin becomes equal to pend, we know that the array has ended. Let's rewrite this program so that the beginning and end of the array are passed as parameters to a certain generalized function that can print an array of any size:

#include void ia_print(int *pbegin, int *pend) (
while (pbegin != pend) (
cout<< *pbegin << " ";
++pbegin;
}
) int main()
{
int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );
ia_print(ia, ia + 9);
}

Our function has become more universal, however, it can only work with arrays of type int. There is a way to remove this limitation: convert this function into a template (templates were briefly introduced in section 2.5):

#include template void print(elemType *pbegin, elemType *pend) ( while (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

We can now call our print() function to print arrays of any type:

Int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); double da = ( 3.14, 6.28, 12.56, 25.12 ); string sa = ( "piglet", " eeyore", "pooh" ); print(ia, ia+9);
print(da, da+4);
print(sa, sa+3);
}

We wrote generalized function. The standard library provides a set of generic algorithms (we already mentioned this in Section 3.4) implemented in a similar way. The parameters of such functions are pointers to the beginning and end of the array with which they perform certain actions. Here, for example, is what calls to a generalized sorting algorithm look like:

#include int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( "piglet", "eeyore", "pooh" ); sort(ia, ia+6);
sort(sa, sa+3);
};

(We'll go into more detail about generalized algorithms in Chapter 12; the Appendix will give examples of their use.)
The C++ Standard Library contains a set of classes that encapsulate the use of containers and pointers. (This was discussed in Section 2.8.) In the next section, we'll take a look at the standard container type vector, which is an object-oriented implementation of an array.

3.10. Vector class

Using the vector class (see Section 2.8) is an alternative to using built-in arrays. This class provides much more functionality, so its use is preferable. However, there are situations when you cannot do without arrays of the built-in type. One of these situations is the processing of command line parameters passed to the program, which we will discuss in section 7.8. The vector class, like the string class, is part of the C++ standard library.
To use the vector you must include the header file:

#include

There are two completely different approaches to using a vector, let's call them the array idiom and the STL idiom. In the first case, a vector object is used in exactly the same way as an array of a built-in type. A vector of a given dimension is determined:

Vector< int >ivec(10);

which is similar to defining an array of a built-in type:

Int ia[ 10 ];

To access individual elements of a vector, the index operation is used:

Void simp1e_examp1e() ( const int e1em_size = 10; vector< int >ivec(e1em_size); int ia[ e1em_size ]; for (int ix = 0; ix< e1em_size; ++ix)
ia[ ix ] = ivec[ ix ]; // ...
}

We can find out the dimension of a vector using the size() function and check if the vector is empty using the empty() function. For example:

Void print_vector(vector ivec) ( if (ivec.empty()) return; for (int ix=0; ix< ivec.size(); ++ix)
cout<< ivec[ ix ] << " ";
}

The elements of the vector are initialized with default values. For numeric types and pointers, this value is 0. If the elements are class objects, then the initiator for them is specified by the default constructor (see section 2.3). However, the initiator can also be specified explicitly using the form:

Vector< int >ivec(10, -1);

All ten elements of the vector will be equal to -1.
An array of a built-in type can be explicitly initialized with a list:

Int ia[ 6 ] = ( -2, -1, O, 1, 2, 1024 );

A similar action is not possible for an object of the vector class. However, such an object can be initialized using a built-in array type:

// 6 ia elements are copied to ivec vector< int >ivec(ia, ia+6);

The constructor of the vector ivec is passed two pointers - a pointer to the beginning of the array ia and to the element following the last one. As a list of initial values, it is permissible to specify not the entire array, but a certain range of it:

// 3 elements are copied: ia, ia, ia vector< int >ivec(&ia[ 2 ], &ia[ 5 ]);

Another difference between a vector and a built-in array is the ability to initialize one vector object with another and use the assignment operator to copy objects. For example:

Vector< string >svec; void init_and_assign() ( // one vector is initialized by another vector< string >user_names(svec); // ... // one vector is copied to another
svec = user_names;
}

When we talk about the STL idiom, we mean a completely different approach to using a vector. Instead of immediately specifying the desired size, we define an empty vector:

Vector< string >text;

Then we add elements to it using various functions. For example, the push_back() function inserts an element at the end of a vector. Here's a piece of code that reads a sequence of lines from standard input and adds them to a vector:

String word; while (cin >> word) ( text.push_back(word); // ... )

Although we can use the index operation to iterate over the elements of a vector:

Cout<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

A more typical use of iterators within this idiom would be:

Cout<< "считаны слова: \n"; for (vector::iterator it = text.begin(); it != text.end(); ++it) cout<< *it << " "; cout << endl;

An iterator is a standard library class that is essentially a pointer to an array element.
Expression

dereferences the iterator and gives the vector element itself. Instructions

Moves the pointer to the next element. There is no need to mix these two approaches. If you follow the STL idiom when defining an empty vector:

Vector ivec;

It would be a mistake to write:

We don't have a single element of the ivec vector yet; The number of elements is determined using the size() function.

The opposite mistake can also be made. If we defined a vector of some size, for example:

Vector ia(10);

Then inserting elements increases its size, adding new elements to existing ones. Although this seems obvious, a novice programmer might well write:

Const int size = 7; int ia[ size ] = ( 0, 1, 1, 2, 3, 5, 8 ); vector< int >ivec(size); for (int ix = 0; ix< size; ++ix) ivec.push_back(ia[ ix ]);

This meant initializing the ivec vector with the values ​​of the ia elements, which resulted in an ivec vector of size 14.
Following the STL idiom, you can not only add but also remove elements from a vector. (We will look at all this in detail and with examples in Chapter 6.)

Exercise 3.24

Are there any errors in the following definitions?
int ia[ 7 ] = ( 0, 1, 1, 2, 3, 5, 8 );

(a)vector< vector< int >>ivec;
(b)vector< int >ivec = ( 0, 1, 1, 2, 3, 5, 8 );
(c)vector< int >ivec(ia, ia+7);
(d)vector< string >svec = ivec;
(e)vector< string >svec(10, string("null"));

Exercise 3.25

Implement the following function:
bool is_equal(const int*ia, int ia_size,
const vector &ivec);
The is_equal() function compares two containers element by element. In the case of containers of different sizes, the “tail” of the longer one is not taken into account. It is clear that if all compared elements are equal, the function returns true, if at least one is different, false. Use an iterator to iterate over elements. Write a main() function that calls is_equal().

3.11. class complex

The class of complex numbers complex is another class from the standard library. As usual, to use it you need to include the header file:

#include

A complex number consists of two parts - real and imaginary. The imaginary part is the square root of a negative number. A complex number is usually written in the form

where 2 is the real part, and 3i is the imaginary part. Here are examples of definitions of objects of type complex:

// purely imaginary number: 0 + 7-i complex< double >purei(0, 7); // imaginary part is 0: 3 + Oi complex< float >rea1_num(3); // both real and imaginary parts are equal to 0: 0 + 0-i complex< long double >zero; // initialization of one complex number with another complex< double >purei2(purei);

Since complex, like vector, is a template, we can instantiate it with the types float, double and long double, as in the examples given. You can also define an array of elements of type complex:

Complex< double >conjugate[ 2 ] = ( complex< double >(2, 3), complex< double >(2, -3) };

Complex< double >*ptr = complex< double >&ref = *ptr;

3.12. typedef directive

The typedef directive allows you to specify a synonym for a built-in or custom data type. For example:

Typedef double wages; typedef vector vec_int; typedef vec_int test_scores; typedef bool in_attendance; typedef int *Pint;

Names defined using the typedef directive can be used in exactly the same way as type specifiers:

// double hourly, weekly; wages hourly, weekly; //vector vecl(10);
vec_int vecl(10); //vector test0(c1ass_size); const int c1ass_size = 34; test_scores test0(c1ass_size); //vector< bool >attendance; vector< in_attendance >attendance(c1ass_size); // int *table[ 10 ]; Pint table [10];

This directive begins with the typedef keyword, followed by a type specifier, and ends with an identifier, which becomes a synonym for the specified type.
What are names defined using the typedef directive used for? By using mnemonic names for data types, you can make your program easier to understand. In addition, it is common to use such names for complex composite types that are otherwise difficult to understand (see the example in Section 3.14), to declare pointers to functions and member functions of a class (see Section 13.6).
Below is an example of a question that almost everyone answers incorrectly. The error is caused by a misunderstanding of the typedef directive as a simple text macro substitution. Definition given:

Typedef char *cstring;

What is the type of the cstr variable in the following declaration:

Extern const cstring cstr;

The answer that seems obvious is:

Const char *cstr

However, this is not true. The const specifier refers to cstr, so the correct answer is a const pointer to char:

Char *const cstr;

3.13. volatile specifier

An object is declared volatile if its value can be changed without the compiler noticing, such as a variable being updated by the system clock. This specifier tells the compiler that it does not need to optimize the code to work with this object.
The volatile specifier is used similarly to the const specifier:

Volatile int disp1ay_register; volatile Task *curr_task; volatile int ixa[ max_size ]; volatile Screen bitmap_buf;

display_register is a volatile object of type int. curr_task is a pointer to a volatile object of the Task class. ixa is an unstable array of integers, and each element of such an array is considered unstable. bitmap_buf is a volatile object of the Screen class, each of its data members is also considered volatile.
The only purpose of using the volatile specifier is to tell the compiler that it cannot determine who can change the value of a given object and how. Therefore, the compiler should not perform optimizations on code that uses this object.

3.14. class pair

The pair class of the C++ standard library allows us to define a pair of values ​​with one object if there is any semantic connection between them. These values ​​can be the same or different types. To use this class you must include the header file:

#include

For example, instructions

Pair< string, string >author("James", "Joyce");

creates an author object of type pair, consisting of two string values.
The individual parts of a pair can be obtained using the first and second members:

String firstBook; if (Joyce.first == "James" &&
Joyce.second == "Joyce")
firstBook = "Stephen Hero";

If you need to define several objects of the same type of this class, it is convenient to use the typedef directive:

Typedef pair< string, string >Authors; Authors proust("marcel", "proust"); Authors joyce("James", "Joyce"); Authors musil("robert", "musi1");

Here is another example of using a pair. The first value contains the name of some object, the second is a pointer to the table element corresponding to this object.

Class EntrySlot; extern EntrySlot* 1ook_up(string); typedef pair< string, EntrySlot* >SymbolEntry; SymbolEntry current_entry("author", 1ook_up("author"));
// ... if (EntrySlot *it = 1ook_up("editor")) (
current_entry.first = "editor";
current_entry.second = it;
}

(We'll return to the pair class when we talk about container types in Chapter 6 and about generic algorithms in Chapter 12.)

3.15. Class Types

The class mechanism allows you to create new data types; with its help, the string, vector, complex and pair types discussed above were introduced. In Chapter 2, we introduced the concepts and mechanisms that support object and object-oriented approaches, using the example of the implementation of the Array class. Here, based on the object approach, we will create a simple String class, the implementation of which will help us understand, in particular, operator overloading - we talked about it in section 2.3. (Classes are covered in detail in Chapters 13, 14, and 15.) We have given a brief description of the class in order to give more interesting examples. A reader new to C++ may want to skip this section and wait for a more systematic description of classes in later chapters.)
Our String class must support initialization by an object of the String class, a string literal, and the built-in string type, as well as the operation of assigning values ​​to these types. We use class constructors and an overloaded assignment operator for this. Access to individual String characters will be implemented as an overloaded index operation. In addition, we will need: the size() function to obtain information about the length of the string; the operation of comparing objects of type String and a String object with a string of a built-in type; as well as the I/O operations of our object. Finally, we implement the ability to access the internal representation of our string as a built-in string type.
A class definition begins with the keyword class, followed by an identifier—the name of the class, or type. In general, a class consists of sections preceded by the words public (open) and private (closed). A public section typically contains a set of operations supported by the class, called methods or member functions of the class. These member functions define the public interface of the class, in other words, the set of actions that can be performed on objects of that class. A private section typically includes data members that provide internal implementation. In our case, the internal members include _string - a pointer to a char, as well as _size of type int. _size will store information about the length of the string, and _string will be a dynamically allocated array of characters. This is what a class definition looks like:

#include class String; istream& operator>>(istream&, String&);
ostream& operator<<(ostream&, const String&); class String {
public:
// set of constructors
// for automatic initialization
// String strl; // String()
// String str2("literal"); // String(const char*);
// String str3(str2); // String(const String&); String();
String(const char*);
String(const String&); // destructor
~String(); // assignment operators
// strl = str2
// str3 = "a string literal" String& operator=(const String&);
String& operator=(const char*); // equality testing operators
// strl == str2;
// str3 == "a string literal"; bool operator==(const String&);
bool operator==(const char*); // overloading the access operator by index
// strl[ 0 ] = str2[ 0 ]; char& operator(int); // access to class members
int size() ( return _size; )
char* c_str() ( return _string; ) private:
int_size;
char *_string;
}

The String class has three constructors. As discussed in Section 2.3, the overloading mechanism allows you to define multiple implementations of functions with the same name, as long as they all differ in the number and/or types of their parameters. First constructor

It is the default constructor because it does not require an explicit initial value. When we write:

For str1, such a constructor is called.
The two remaining constructors each have one parameter. Yes, for

String str2("character string");

The constructor is called

String(const char*);

String str3(str2);

Constructor

String(const String&);

The type of the constructor called is determined by the type of the actual argument. The last of the constructors, String(const String&), is called a copy constructor because it initializes an object with a copy of another object.
If you write:

String str4(1024);

This will cause a compilation error, because there is no constructor with a parameter of type int.
An overloaded operator declaration has the following format:

Return_type operator op(parameter_list);

Where operator is a keyword, and op is one of the predefined operators: +, =, ==, and so on. (See Chapter 15 for a precise definition of the syntax.) Here is the declaration of the overloaded index operator:

Char& operator(int);

This operator has a single parameter of type int and returns a reference to a char. An overloaded operator may itself be overloaded if the parameter lists of individual instantiations differ. For our String class, we will create two different assignment and equality operators.
To call a member function, use the member access operators dot (.) or arrow (->). Let us have declarations of objects of type String:

String object("Danny");
String *ptr = new String("Anna");
String array;
Here's what a call to size() looks like on these objects:
vector sizes(3);

// access member for objects (.); // objects has a size of 5 sizes[ 0 ] = object.size(); // member access for pointers (->)
// ptr has size 4
sizes[ 1 ] = ptr->size(); // access member (.)
// array has size 0
sizes[ 2 ] = array.size();

It returns 5, 4 and 0 respectively.
Overloaded operators are applied to an object in the same way as regular ones:

String name("Yadie"); String name2("Yodie"); // bool operator==(const String&)
if (name == name2)
return;
else
// String& operator=(const String&)
name = name2;

A member function declaration must be inside a class definition, and a function definition can be inside or outside a class definition. (Both the size() and c_str() functions are defined inside a class.) If a function is defined outside a class, then we must specify, among other things, which class it belongs to. In this case, the definition of the function is placed in the source file, say String.C, and the definition of the class itself is placed in the header file (String.h in our example), which must be included in the source:

// contents of the source file: String.C // enabling the definition of the String class
#include "String.h" // include the definition of the strcmp() function
#include
bool // return type
String:: // class to which the function belongs
operator== // function name: equality operator
(const String &rhs) // list of parameters
{
if (_size != rhs._size)
return false;
return strcmp(_strinq, rhs._string) ?
false: true;
}

Recall that strcmp() is a C standard library function. It compares two built-in strings, returning 0 if the strings are equal and non-zero if they are not equal. The conditional operator (?:) tests the value before the question mark. If true, the value of the expression to the left of the colon is returned; otherwise, the value to the right is returned. In our example, the value of the expression is false if strcmp() returned a non-zero value, and true if it returned a zero value. (The conditional operator is discussed in section 4.7.)
The comparison operation is used quite often, the function that implements it turned out to be small, so it is useful to declare this function built-in (inline). The compiler substitutes the text of the function instead of calling it, so no time is wasted on such a call. (Built-in functions are discussed in Section 7.6.) A member function defined within a class is built-in by default. If it is defined outside the class, in order to declare it built-in, you need to use the inline keyword:

Inline bool String::operator==(const String &rhs) ( // the same thing )

The definition of a built-in function must be in the header file that contains the class definition. By redefining the == operator as an inline operator, we must move the function text itself from the String.C file to the String.h file.
The following is the implementation of the operation of comparing a String object with a built-in string type:

Inline bool String::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

The constructor name is the same as the class name. It is considered not to return a value, so there is no need to specify a return value either in its definition or in its body. There can be several constructors. Like any other function, they can be declared inline.

#include // default constructor inline String::String()
{
_size = 0;
_string = 0;
) inline String::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) else ( _size = str1en(str); strcpy(_string, str); ) // copy constructor
inline String::String(const String &rhs)
{
size = rhs._size;
if (! rhs._string)
_string = 0;
else(
_string = new char[ _size + 1 ];
} }

Since we dynamically allocated memory using the new operator, we need to free it by calling delete when we no longer need the String object. Another special member function serves this purpose - the destructor, which is automatically called on an object at the moment when this object ceases to exist. (See Chapter 7 about object lifetime.) The name of a destructor is formed from the tilde character (~) and the name of the class. Here is the definition of the String class destructor. This is where we call the delete operation to free the memory allocated in the constructor:

Inline String: :~String() ( delete _string; )

Both overloaded assignment operators use the special keyword this.
When we write:

String namel("orville"), name2("wilbur");
name = "Orville Wright";
this is a pointer that addresses the name1 object within the function body of the assignment operation.
this always points to the class object through which the function is called. If
ptr->size();
obj[ 1024 ];

Then inside size() the value of this will be the address stored in ptr. Inside the index operation, this contains the address of obj. By dereferencing this (using *this), we get the object itself. (The this pointer is described in detail in Section 13.4.)

Inline String& String::operator=(const char *s) ( if (! s) ( _size = 0; delete _string; _string = 0; ) else ( _size = str1en(s); delete _string; _string = new char[ _size + 1 ]; strcpy(_string, s); return *this;

When implementing an assignment operation, one mistake that is often made is that they forget to check whether the object being copied is the same one into which the copy is being made. We will perform this check using the same this pointer:

Inline String& String::operator=(const String &rhs) ( // in the expression // namel = *pointer_to_string // this represents name1, // rhs - *pointer_to_string. if (this != &rhs) (

Here is the complete text of the operation of assigning an object of the same type to a String object:

Inline String& String::operator=(const String &rhs) ( if (this != &rhs) ( delete _string; _size = rhs._size; if (! rhs._string)
_string = 0;
else(
_string = new char[ _size + 1 ];
strcpy(_string, rhs._string);
}
}
return *this;
}

The operation of taking an index is almost identical to its implementation for the Array array that we created in section 2.3:

#include inline char&
String::operator (int elem)
{
assert(elem >= 0 && elem< _size);
return _string[ elem ];
}

Input and output operators are implemented as separate functions rather than class members. (We'll talk about the reasons for this in Section 15.2. Sections 20.4 and 20.5 talk about overloading the iostream library's input and output operators.) Our input operator can read a maximum of 4095 characters. setw() is a predefined manipulator, it reads a given number of characters minus 1 from the input stream, thereby ensuring that we do not overflow our internal buffer inBuf. (Chapter 20 discusses the setw() manipulator in detail.) To use manipulators, you must include the appropriate header file:

#include inline istream& operator>>(istream &io, String &s) ( // artificial limit: 4096 characters const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() is included in the iostream library // it limits the size of the readable block to 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf; s = mBuf; // String::operator=(const char*);

The output operator needs access to the internal representation of the String. Since operator<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

Inline ostream& operator<<(ostream& os, const String &s) { return os << s.c_str(); }

Below is an example program using the String class. This program takes words from the input stream and counts their total number, as well as the number of "the" and "it" words, and records the vowels encountered.

#include #include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / The words "The" and "It"
// we will check using operator==(const char*)
String but, the("the"), it("it"); // operator>>(ostream&, String&)
while (cin >> buf) (
++wdCnt; // operator<<(ostream&, const String&)
cout<< buf << " "; if (wdCnt % 12 == 0)
cout<< endl; // String::operator==(const String&) and
// String::operator==(const char*);
if (buf == the | | buf == "The")
++theCnt;
else
if (buf == it || buf == "It")
++itCnt; // invokes String::s-ize()
for (int ix =0; ix< buf.sizeO; ++ix)
{
// invokes String::operator(int)
switch(buf[ ix ])
{
case "a": case "A": ++aCnt; break;
case "e": case "E": ++eCnt; break;
case "i": case "I": ++iCnt; break;
case "o": case "0": ++oCnt; break;
case "u": case "U": ++uCnt; break;
default: ++notVowe1; break;
}
}
) // operator<<(ostream&, const String&)
cout<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

Let's test the program: we will offer it a paragraph from a children's story written by one of the authors of this book (we will meet with this story in Chapter 6). Here is the result of the program:

Alice Emma has long flowing red hair. Her Daddy says when the wind blows through her hair, it looks almost alive, 1ike a fiery bird in flight. A beautiful fiery bird, he tells her, magical but untamed. "Daddy, shush, there is no such thing," she tells him, at the same time wanting him to tell her more. Shyly, she asks, "I mean, Daddy, is there?" Words: 65
the/The: 2
it/It: 1
consonants: 190
a: 22
e: 30
i: 24
o: 10
u: 7

Exercise 3.26

Our implementations of constructors and assignment operators contain a lot of repetition. Consider moving duplicate code into a separate private member function, as was done in Section 2.3. Make sure the new option works.

Exercise 3.27

Modify the test program so that it also counts the consonants b, d, f, s, t.

Exercise 3.28

Write a member function that counts the number of occurrences of a character in a String using the following declaration:

Class String ( public: // ... int count(char ch) const; // ... );

Exercise 3.29

Implement the string concatenation operator (+) so that it concatenates two strings and returns the result in a new String object. Here is the function declaration:

Class String ( public: // ... String operator+(const String &rhs) const; // ... );

Variables are used to store various data in programming languages. A variable is an area of ​​memory that has a name, otherwise called an identifier.

By giving a variable a name, the programmer at the same time names the memory area where the variable’s values ​​will be written for storage.

It is good style to name variables meaningfully. It is allowed to use lowercase and uppercase letters, numbers and the underscore, which is considered a letter in C. The first character must be a letter, and there must be no spaces in the variable name. In modern versions of compilers, the name length is practically unlimited. The variable name cannot match reserved keywords. Uppercase and lowercase letters in variable names are different, variables a And A- different variables.

Reserved Keywords auto double int struct break else long switch register tupedef char extern return void case float unsigned default for signed union do if sizeof volatile continue enum short while
In C, all variables must be declared. This means that, firstly, at the beginning of each program or function you must provide a list of all the variables used, and secondly, indicate the type of each of them.

When a variable is declared, the compiler allocates memory space for it depending on its type. Using standard AVR GCC tools, it works with data types char(character type) and int(integer type).

Type char

char- is the most economical type. The char type can be signed or unsigned. Denoted accordingly as " signed char" (signed type) and " unsigned char" (unsigned type). The signed type can store values ​​in the range from -128 to +127. Unsigned - from 0 to 255. A char variable has 1 byte of memory (8 bits).

Keywords (modifiers) signed And unsigned indicate how the zero bit of the declared variable is interpreted, i.e., if the unsigned keyword is specified, then the zero bit is interpreted as part of a number, otherwise the zero bit is interpreted as signed.

Type int

Integer value int May be short(short) or long(long).

Keyword (modifier) short placed after keywords signed or unsigned. Thus, the following types are distinguished: signed short int, unsigned short int, signed long int, unsigned long int.

Type variable signed short int(signed short integer) can take values ​​from -32768 to +32767, unsigned short int(unsigned short integer) - from 0 to 65535. Exactly two bytes of memory (16 bits) are allocated for each of them.

When declaring a type variable signed short int keywords signed And short can be omitted, and such a variable type can be declared simply int. It is also possible to declare this type with one keyword short.

Variable unsigned short int can be declared as unsigned int or unsigned short.

For every size signed long int or unsigned long int 4 bytes of memory are allocated (32 bits). The values ​​of variables of this type can be in the ranges from -2147483648 to 2147483647 and from 0 to 4294967295, respectively.

There are also variables like long long int, for which 8 bytes of memory are allocated (64 bits). They can also be signed or unsigned. For a signed type, the range of values ​​is from -9223372036854775808 to 9223372036854775807, for an unsigned type - from 0 to 18446744073709551615. A signed type can be declared simply by two keywords long long.

Variables are declared in a declaration statement. A declaration statement consists of a type specification and a comma-separated list of variable names. There must be a semicolon at the end.

A variable declaration has the following format:

[modifiers] type_specifier identifier [, identifier] ...

Modifiers- keywords signed, unsigned, short, long.
Type specifier- keyword char or int, which determines the type of the declared variable.
Identifier- variable name.

Example: char x; int a, b, c; unsigned long long y;
This way the variables will be declared x, a, b, c, y. To a variable x it will be possible to write values ​​from -128 to 127. In variables a, b, c- from -32768 to +32767. To a variable y- from 0 to 18446744073709551615.

Initializing the value of a variable upon declaration

When declared, a variable can be initialized, that is, assigned an initial value. You can do this as follows. int x = 100; Thus, into the variable x When announced, the number 100 will be immediately written down.

It is better to avoid mixing initialized variables in one declaration statement, that is, it is better to declare initialized variables on separate lines.

A variable of any type can be declared unmodifiable. This is achieved by adding the keyword const to the type specifier. Variables with type const is read-only data, meaning that the variable cannot be assigned a new value. If after the word const If there is no type specifier, then constants are treated as signed values ​​and are assigned a type int or long int according to the value of the constant: if the constant is less than 32768, then it is assigned the type int, otherwise long int.

Example: const long int k = 25; const m = -50; // implied const int m=-50 const n = 100000; // implied const long int n=100000

The "=" sign is used for assignment in C. The expression to the right of the assignment sign is evaluated, and the resulting value is assigned to the variable to the left of the assignment sign. In this case, the previous value stored in the variable is erased and replaced with a new one.

The "=" operator should not be understood as equality.
For example, the expression a = 5; should be read as "assign variable a to 5".

Examples: x = 5 + 3; // add the values ​​5 and 3, // assign the result to variable x (write to variable x) b = a + 4; // add 4 to the value stored in variable a, // assign the resulting result to variable b (write to variable b) b = b + 2; // add 2 to the value stored in variable b, // assign the resulting result to variable b (write to variable b)
On the right side, the value of the variable can be used several times: c = b * b + 3 * b;

Example: x = 3; // variable x will be assigned the value 3 y = x + 5; // the number 5 will be added to the value stored in the x variable, // the resulting result will be written to the y variable z = x * y; // the values ​​of the x and y variables will be multiplied, // the result will be written to the z variable z = z - 1; // 1 will be subtracted from the value stored in the z variable // the result will be written to the z variable
Thus, in the variable z the number 23 will be stored

In addition to the simple assignment operator "=", there are several more combined assignment operators in C: "+=", "-=", "*=
Examples: x += y; // same as x = x + y; - add x and y // and write the result to the variable x x -= y; // same as x = x - y; - subtract the value y from x // and write the result to the variable x x *= y; // same as x = x * y; - multiply x by y // and write the result to the variable x x /= y; // same as x = x / y; - divide x by y // and write the result to the variable x x %= y; // same as x = x % y; // calculate the integer remainder when dividing x by y // and write the result to the variable x

If you need to change the value of a variable to 1, then use increment or decrement.

Increment- the operation of increasing the value stored in a variable by 1.

Example: x++; // the value of the variable x will be increased by 1$WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?>
Decrement- the operation of decreasing the value stored in a variable by 1.

Example: x--; // the value of the variable x will be decreased by 1
Increment and decrement are assignment operators. When using decrement and increment together with the assignment operator "=", use postfix (x++) or prefix (++x) notation. The prefix entry is executed first.

Examples: y = x++;
Let us assume that in the variable x the value 5 was stored. Then in y the value 5 will be written, after which the value of the variable x will be increased by 1. Thus, in y will be 5, and in x- 6. y = --x;
If in x If the value 5 was stored, then the decrement will be performed first x to 4 and then this value will be assigned to the variable y. Thus, x And y will be assigned the value 4.

Data types

Data types are especially important in C# because it is a strongly typed language. This means that all operations are subject to strict type checking by the compiler, and illegal operations are not compiled. Therefore, strict type checking eliminates errors and increases the reliability of programs. To enforce type checking, all variables, expressions, and values ​​must be of a specific type. There is no such thing as a “typeless” variable in this programming language at all. Moreover, the type of a value determines the operations that can be performed on it. An operation that is legal for one data type may not be valid for another.

There are two general categories of built-in data types in C#: value types And reference types. They differ in the contents of the variable. Conceptually, the difference between the two is that a value type stores data directly, while a reference type stores a reference to a value.

These types are stored in different locations in memory: value types are stored in an area known as the stack, and reference types are stored in an area known as the managed heap.

Let's take a look value types.

Integer types

C# defines nine integer types: char, byte, sbyte, short, ushort, int, uint, long and ulong. But the char type is used primarily to represent characters and is therefore treated separately. The remaining eight integer types are for numeric calculations. Below are their range of numbers and bit depth:

As the table above shows, C# defines both signed and unsigned variants of the various integer types. Signed integer types differ from their unsigned counterparts in the way they interpret the most significant bit of the integer. Thus, if a program specifies a signed integer value, the C# compiler will generate code that uses the most significant bit of the integer as the sign flag. A number is considered positive if the sign flag is 0, and negative if it is 1.

Negative numbers are almost always represented by the two's complement method, whereby all the binary digits of the negative number are first inverted and then 1 is added to that number.

Probably the most common integer type in programming is int type. Variables of type int are often used for loop control, array indexing, and general purpose mathematical calculations. When you need an integer value with a larger range of representations than the int type, there are a number of other integer types available for this purpose.

So, if the value needs to be stored without a sign, then for it you can select uint type, for large signed values ​​- long type, and for large unsigned values ​​- type ulong. As an example, below is a program that calculates the distance from the Earth to the Sun in centimeters. To store such a large value, it uses a long variable:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( long result; const long km = 149800000; // distance in km. result = km * 1000 * 100; Console.WriteLine(result); Console.ReadLine(); ) ) )

All integer variables can be assigned values ​​in decimal or hexadecimal notations. In the latter case, a 0x prefix is ​​required:

Long x = 0x12ab;

If there is any uncertainty as to whether an integer value is of type int, uint, long, or ulong, then default int is accepted. To explicitly specify what other integer type a value should have, the following characters can be appended to a number:

Uint ui = 1234U; long l = 1234L; ulong ul = 1234UL;

U and L can also be written in lowercase, although a lowercase L can easily be visually confused with the number 1 (one).

Floating Point Types

Floating-point types allow you to represent numbers with a fractional part. There are two types of floating point data types in C#: float And double. They represent numeric values ​​in single and double precision, respectively. Thus, the width of the float type is 32 bits, which approximately corresponds to the range of representation of numbers from 5E-45 to 3.4E+38. And the width of the double type is 64 bits, which approximately corresponds to the range of representation of numbers from 5E-324 to 1.7E+308.

The float data type is intended for smaller floating-point values ​​that require less precision. The double data type is larger than float and offers a higher degree of precision (15 bits).

If a non-integer value is hard-coded in the source code (for example, 12.3), then the compiler usually assumes that a double value is intended. If the value needs to be specified as a float, you will need to append the F (or f) character to it:

Float f = 12.3F;

Decimal data type

A decimal type is also provided to represent high-precision floating-point numbers. decimal, which is intended for use in financial calculations. This type has a width of 128 bits to represent numeric values ​​ranging from 1E-28 to 7.9E+28. You're probably aware that regular floating-point arithmetic is prone to decimal rounding errors. These errors are eliminated by using the decimal type, which allows numbers to be represented to 28 (and sometimes 29) decimal places. Because this data type can represent decimal values ​​without rounding errors, it is especially useful for financial-related calculations:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // *** Calculation of the cost of an investment with *** // *** fixed rate of return*** decimal money, percent; int i; const byte years = 15 ; money = 1000.0m; percent = 0.045m;

The result of this program will be:

Symbols

In C#, characters are represented not in 8-bit code, as in many other programming languages ​​such as C++, but in 16-bit code, called Unicode. Unicode's character set is so broad that it covers characters from almost every natural language in the world. While many natural languages, including English, French and German, have relatively small alphabets, some other languages, such as Chinese, use fairly large character sets that cannot be represented in 8-bit code. To overcome this limitation, C# defines type char, which represents unsigned 16-bit values ​​ranging from 0 to 65,535. However, the standard 8-bit ASCII character set is a subset of Unicode ranging from 0 to 127. Therefore, ASCII characters are still valid in C# .

An important difference between the SI language and other languages ​​(PL1, FORTRAN, etc.) is the absence of a default principle, which leads to the need to declare all variables used in the program explicitly along with an indication of their corresponding types.

Variable declarations have the following format:

[memory-class-specifier] type-specifier descriptor [=initiator] [,descriptor [= initiator] ]...

A descriptor is an identifier for a simple variable or a more complex construct with square brackets, parentheses, or an asterisk (a set of asterisks).

A type specifier is one or more keywords that determine the type of the variable being declared. The SI language has a standard set of data types, using which you can construct new (unique) data types.

Initiator - specifies the initial value or list of initial values ​​that are assigned to the variable when declared.

Memory class specifier - determined by one of the four SI keywords: auto, extern, register, static, and indicates how memory will be allocated for the declared variable, on the one hand, and, on the other, the scope of this variable, i.e. , from which parts of the program it can be accessed.

1.2.1 Categories of data types

Keywords to define basic data types

Integer types: Float types: char float int double short long double long signed unsigned

A variable of any type can be declared unmodifiable. This is achieved by adding the const keyword to the type-specifier. Objects with type const represent read-only data, i.e. this variable cannot be assigned a new value. Note that if there is no type-specifier after the word const, then the type-specifier int is implied. If the keyword const comes before the declaration of composite types (array, structure, mixture, enumeration), then this leads to the fact that each element must also be unmodifiable, i.e. it can only be assigned a value once.

Const double A=2.128E-2; const B=286; (const int B=286 is implied)

Examples of declaring composite data will be discussed below.

1.2.2. Integer data type

To define data of an integer type, various keywords are used, which determine the range of values ​​and the size of the memory area allocated for variables (Table 6).

Table 6

Note that the signed and unsigned keywords are optional. They indicate how the zero bit of the declared variable is interpreted, i.e., if the unsigned keyword is specified, then the zero bit is interpreted as part of a number, otherwise the zero bit is interpreted as signed. If the unsigned keyword is missing, the integer variable is considered signed. If the type specifier consists of a key type signed or unsigned followed by a variable identifier, then it will be treated as a variable of type int. For example:

Unsigned int n; unsigned int b; int c; (signed int c is implied); unsigned d; (implies unsigned int d); signed f; (signed int f is implied).

Note that the char type-modifier is used to represent a character (from an array representation of characters) or to declare string literals. The value of a char object is the 1-byte code corresponding to the character it represents. To represent characters of the Russian alphabet, the data identifier type modifier is unsigned char, since the codes of Russian letters exceed the value of 127.

The following note should be made: the SI language does not define the memory representation and range of values ​​for identifiers with the int and unsigned int type modifiers. The size of memory for a variable with the signed int type modifier is determined by the length of the machine word, which has a different size on different machines. So, on 16-bit machines the word size is 2 bytes, on 32-bit machines it is 4 bytes, i.e. the int type is equivalent to the short int or long int types, depending on the architecture of the PC used. Thus, the same program can work correctly on one computer and incorrectly on another. To determine the length of the memory occupied by a variable, you can use the SI language sizeof operator, which returns the length of the specified type modifier.

For example:

A = sizeof(int); b = sizeof(long int); c = sizeof(unsigned long); d = sizeof(short);

Note also that octal and hexadecimal constants can also have the unsigned modifier. This is achieved by specifying the prefix u or U after the constant; a constant without this prefix is ​​considered signed.

For example:

0xA8C (int signed); 01786l (long signed); 0xF7u (int unsigned);

1.2.3. Floating data

For variables representing a floating point number, the following type modifiers are used: float, double, long double (in some implementations of the long double language there is no SI).

A value with the float type modifier takes 4 bytes. Of these, 1 byte is allocated for the sign, 8 bits for the excess exponent and 23 bits for the mantissa. Note that the most significant bit of the mantissa is always 1, so it is not filled, so the range of values ​​for a floating point variable is approximately 3.14E-38 to 3.14E+38.

A double value takes up 8 bits of memory. Its format is similar to the float format. The memory bits are distributed as follows: 1 bit for the sign, 11 bits for the exponent, and 52 bits for the mantissa. Taking into account the omitted high bit of the mantissa, the range of values ​​is from 1.7E-308 to 1.7E+308.

Float f, a, b; double x,y;

1.2.4. Signposts

A pointer is the address of memory allocated to accommodate an identifier (the identifier can be the name of a variable, array, structure, or string literal). If a variable is declared as a pointer, then it contains a memory address where a scalar value of any type can be located. When declaring a variable of type pointer, you must specify the type of data object whose address the variable will contain, and the name of the pointer preceded by an asterisk (or group of asterisks). Pointer declaration format:

type-specifier [ modifier ] * specifier.

The type-specifier specifies the type of the object and can be any basic type, structure type, mixture (this will be discussed below). By specifying the keyword void instead of the type specifier, you can in a unique way defer the specification of the type to which the pointer refers. A variable declared as a pointer to type void can be used to refer to an object of any type. However, in order to be able to perform arithmetic and logical operations on pointers or on the objects to which they point, it is necessary to explicitly determine the type of objects when performing each operation. Such type definitions can be made using the type casting operation.

The keywords const, near, far, huge can be used as modifiers when declaring a pointer. The const keyword indicates that the pointer cannot be modified in the program. The size of a variable declared as a pointer depends on the computer architecture and on the memory model used for which the program will be compiled. Pointers to different data types do not have to be the same length.

To modify the pointer size, you can use the keywords near, far, huge.

Unsigned int * a; /* variable a is a pointer to type unsigned int */ double * x; /* variable x indicates double precision floating point data type */ char * fuffer ; /* declare a pointer named fuffer which points to a variable of type char */ double nomer; void *addresses; addresses = &nomer; (double *)addres++; /* The addres variable is declared as a pointer to an object of any type. Therefore, it can be assigned the address of any object (& is the operation of calculating the address). However, as noted above, no arithmetic operation can be performed on a pointer unless the type of data to which it points is explicitly determined. This can be done by using a cast operation (double *) to convert addres to a pointer to type double, and then incrementing the address. */ const * dr; /* The dr variable is declared as a pointer to a constant expression, i.e. The value of a pointer can change during program execution, but the value it points to cannot. */ unsigned char * const w = &obj. /* The variable w is declared as a constant pointer to unsigned char data. This means that w will point to the same memory location throughout the program. The contents of this area may be changed. */

1.2.5. Enumerated variables

A variable that can take a value from some list of values ​​is called an enumerated variable or enumeration.

An enumeration declaration begins with the enum keyword and has two presentation formats.

Format 1. enum [enum-tag-name] (enum-list) descriptor[,descriptor...];

Format 2. enum enum-tag-name descriptor [,descriptor..];

An enumeration declaration specifies the type of the enumeration variable and defines a list of named constants called an enumeration-list. The value of each list name is some integer.

An enumeration type variable can take the value of one of the list's named constants. Named list constants are of type int. Thus, the memory corresponding to an enumeration variable is the memory required to accommodate an int value.

Variables of type enum can be used in index expressions and as operands in arithmetic and relational operations.

In the first format 1, enum names and values ​​are specified in an enumeration list. The optional enumeration-tag-name is an identifier that names the enumeration tag defined by the enumeration list. The descriptor names an enumeration variable. More than one enumeration type variable can be specified in a declaration.

An enumeration list contains one or more constructs of the form:

identifier [= constant expression]

Each identifier names an element of the enumeration. All identifiers in the enum list must be unique. If there is no constant expression, the first identifier corresponds to the value 0, the next identifier to the value 1, etc. The name of an enumeration constant is equivalent to its value.

An identifier associated with a constant expression takes on the value specified by that constant expression. The constant expression must be of type int and can be either positive or negative. The next identifier in the list is assigned the value of the constant expression plus 1 if that identifier does not have its own constant expression. The use of enumeration elements must obey the following rules:

1. The variable may contain duplicate values.

2. Identifiers in an enumeration list must be distinct from all other identifiers in the same scope, including regular variable names and identifiers from other enumeration lists.

3. Names of enum types must be distinct from other names of enum types, structures, and mixtures in the same scope.

4. The value can follow the last element of the enumeration list.

Enum week ( SUB = 0, /* 0 */ VOS = 0, /* 0 */ POND, /* 1 */ VTOR, /* 2 */ SRED, /* 3 */ HETV, /* 4 */ PJAT /* 5 */ ) rab_ned ;

In this example, an enumerable tag week is declared, with a corresponding set of values, and a variable rab_ned is declared of type week.

The second format uses the name of an enumeration tag to refer to an enumeration type defined somewhere else. The enumeration tag name must refer to an already defined enumeration tag within the current scope. Because the enumeration tag is declared somewhere else, the enumeration list is not represented in the declaration.

In declaring a pointer to an enumeration data type and declaring typedefs for enumeration types, you can use the name of an enumeration tag before that enumeration tag is defined. However, the enum definition must precede any use of the typedef declaration's pointer to the type. A declaration without a subsequent list of descriptors describes a tag, or, so to speak, an enumeration pattern.

1.2.6. Arrays

Arrays are a group of elements of the same type (double, float, int, etc.). From the array declaration, the compiler must obtain information about the type of array elements and their number. An array declaration has two formats:

type-specifier descriptor [const - expression];

type-specifier descriptor ;

The descriptor is the identifier of the array.

The type-specifier specifies the type of the elements of the declared array. Array elements cannot be functions or void elements.

The constant-expression in square brackets specifies the number of elements in the array. When declaring an array, a constant expression can be omitted in the following cases:

When declared, the array is initialized,

The array is declared as a formal parameter of the function,

SI defines only one-dimensional arrays, but since an element of an array can be an array, multidimensional arrays can also be defined. They are formalized by a list of constant-expressions following the array identifier, with each constant-expression enclosed in its own square brackets.

Each constant-expression in square brackets specifies the number of elements along that dimension of the array, so that a two-dimensional array declaration contains two constant-expressions, a three-dimensional array contains three, and so on. Note that in SI, the first element of an array has an index of 0.

Int a; /* represented as a matrix a a a a a a */ double b; /* vector of 10 elements of type double */ int w = ( ( 2, 3, 4 ), ( 3, 4, 8 ), ( 1, 0, 9 ) );

In the last example, the array w is declared. Lists enclosed in curly braces correspond to array strings; if there are no braces, initialization will not be performed correctly.

In the SI language, you can use array sections, as in other high-level languages ​​(PL1, etc.), however, a number of restrictions are imposed on the use of sections. Sections are formed by omitting one or more pairs of square brackets. Pairs of square brackets can only be dropped from right to left and strictly sequentially. Sections of arrays are used to organize the computational process in SI functions developed by the user.

If you write s when calling a function, then the zero string of the array s will be passed.

When accessing an array b, you can write, for example, b and a vector of four elements will be transferred, and accessing b will give a two-dimensional array of size 3 by 4. You cannot write b, implying that a vector will be transferred, because this does not comply with the restriction imposed on the use array sections.

An example of a character array declaration.

char str = "character array declaration";

Note that there is one more element in a character literal, since the last element is the escape sequence "\0".

1.2.7. Structures

Structures are a composite object that includes elements of any type, with the exception of functions. Unlike an array, which is a homogeneous object, a structure can be heterogeneous. The structure type is determined by an entry of the form:

struct (definition list)

At least one component must be specified in the structure. The definition of structures is as follows:

data-type descriptor;

where data-type specifies the type of structure for the objects defined in the descriptors. In their simplest form, handles are identifiers or arrays.

Struct ( double x,y; ) s1, s2, sm; struct (int year; char moth, day; ) date1, date2;

Variables s1, s2 are defined as structures, each of which consists of two components x and y. The variable sm is defined as an array of nine structures. Each of the two variables date1, date2 consists of three components year, moth, day. >p>There is another way to associate a name with a structure type, it is based on the use of a structure tag. A structure tag is similar to an enum type tag. The structure tag is defined as follows:

struct tag(list of descriptions; );

where tag is an identifier.

The example below describes the student identifier as a structure tag:

Struct student ( char name; int id, age; char prp; );

The structure tag is used to subsequently declare structures of this type in the form:

struct id-list tag;

struct studeut st1,st2;

The use of structure tags is necessary to describe recursive structures. The following discusses the use of recursive structure tags.

Struct node ( int data; struct node * next; ) st1_node;

The structure tag node is indeed recursive since it is used in its own description, i.e. in the formalization of the next pointer. Structures cannot be directly recursive, i.e. a node structure cannot contain a component that is a node structure, but any structure can have a component that is a pointer to its type, as is done in the example above.

Structure components are accessed by specifying the structure name and the following, separated by a dot, name of the selected component, for example:

St1.name="Ivanov"; st2.id=st1.id; st1_node.data=st1.age;

1.2.8. Combinations (mixtures)

A union is similar to a structure, but only one of the elements of the union can be used (or in other words responded to) at any time. The join type can be specified as follows:

Union ( element 1 description; ... element n description; );

The main feature of a union is that the same memory area is allocated for each of the declared elements, i.e. they overlap. Although this memory region can be accessed using any of the elements, the element for this purpose must be selected so that the result obtained is not meaningless.

Members of a union are accessed in the same way as structures. The union tag can be formalized in exactly the same way as the structure tag.

The association is used for the following purposes:

Initializing a memory object in use if at any given time only one of many objects is active;

Interpret the underlying representation of an object of one type as if that object were assigned a different type.

The memory that corresponds to a union type variable is determined by the amount required to accommodate the longest element of the union. When a shorter element is used, the union type variable may contain unused memory. All elements of a union are stored in the same memory area, starting at the same address.

Union (char fio; char addresses; int vozrast; int telefon; ) inform; union ( int ax; char al; ) ua;

When using an infor object of type union, you can process only the element that received the value, i.e. After assigning a value to the inform.fio element, there is no point in accessing other elements. The ua concatenation allows separate access to the low ua.al and high ua.al bytes of the two-byte number ua.ax .

1.2.9. Bit fields

An element of the structure can be a bit field that provides access to individual bits of memory. Bit fields cannot be declared outside structures. You also cannot organize arrays of bit fields and you cannot apply the address determination operation to the fields. In general, the type of structure with a bit field is specified as follows:

Struct ( unsigned identifier 1: field-length 1; unsigned identifier 2: field-length 2; )

length - fields are specified by an integer expression or constant. This constant specifies the number of bits allocated to the corresponding field. A zero-length field indicates alignment to the next word boundary.

Struct ( unsigned a1: 1; unsigned a2: 2; unsigned a3: 5; unsigned a4: 2; ) prim;

Bit field structures can also contain signed components. Such components are automatically placed on appropriate word boundaries, and some word bits may remain unused.

1.2.10. Variables with mutable structure

Very often, some program objects belong to the same class, differing only in some details. Consider, for example, the representation of geometric shapes. General information about shapes may include elements such as area, perimeter. However, the corresponding geometric dimension information may differ depending on their shape.

Consider an example in which information about geometric shapes is represented based on the combined use of structure and union.

Struct figure ( double area,perimetr; /* common components */ int type; /* component attribute */ union /* enumeration of components */ ( double radius; /* circle */ double a; /* rectangle */ double b; /* triangle */ ) geom_fig; ) fig1, fig2;

In general, each figure object will consist of three components: area, perimetr, type. The type component is called the active component label because it is used to indicate which component of the geom_fig union is currently active. This structure is called a variable structure because its components change depending on the value of the active component's label (the value of type).

Note that instead of an int type component, it would be advisable to use an enumerated type. For example, like this

Enum figure_chess ( CIRCLE, BOX, TRIANGLE ) ;

The constants CIRCLE, BOX, TRIANGLE will receive values ​​equal to 0, 1, 2, respectively. The type variable can be declared as having an enumerated type:

enum figure_chess type;

In this case, the SI compiler will warn the programmer about potentially erroneous assignments, such as

figure.type = 40;

In general, a structure variable will consist of three parts: a set of common components, a label for the active component, and a part with changing components. The general form of a variable structure is as follows:

Struct (common components; active component label; union (component description 1; component description 2; ::: component description n; ) union-identifier; ) structure-identifier;

Example of defining a structure variable named helth_record

Struct ( /* general information */ char name ; /* name */ int age; /* age */ char sex; /* gender */ /* active component label */ /* (marital status) */ enum merital_status ins ; /* variable part */ union ( /* single */ /* no component */ struct ( /* married */ char spouse_name; int no_children; ) marriage_info; /* divorced */ char date_divorced; ) marital_info; ) health_record; enum marital_status ( SINGLE, /* single */ MARRIGO, /* married */ DIVOREED /* divorced */ ) ;

You can access the components of the structure using links:

Helth_record.neme, helth_record.ins, helth_record.marriage_info.marriage_date .

1.2.11. Defining Objects and Types

As mentioned above, all variables used in SI programs must be declared. The type of variable being declared depends on which keyword is used as the type specifier and whether the specifier is a simple identifier or a combination of an identifier with a pointer (asterisk), array (square brackets), or function (parentheses) modifier.

When declaring a simple variable, structure, mixture or union, or enumeration, the handle is a simple identifier. To declare a pointer, array, or function, the identifier is modified accordingly: an asterisk on the left, square or parentheses on the right.

Let us note an important feature of the SI language: when declaring, more than one modifier can be used simultaneously, which makes it possible to create many different complex type descriptors.

However, we must remember that some combinations of modifiers are unacceptable:

Array elements cannot be functions.

Functions cannot return arrays or functions.

When initializing complex descriptors, square brackets and parentheses (to the right of the identifier) ​​take precedence over the asterisk (to the left of the identifier). Square or parentheses have the same precedence and are expanded from left to right. The type specifier is considered at the last step, when the descriptor has already been fully interpreted. You can use parentheses to change the order of interpretation as needed.

For interpreting complex descriptions, a simple rule is proposed that sounds like "from the inside out", and consists of four steps.

1. Start with the identifier and look to the right to see if there are square or parentheses.

2. If they are, then interpret this part of the descriptor and then look to the left in search of an asterisk.

3. If at any stage a closing parenthesis is encountered on the right, then all these rules within the parentheses must first be applied and then the interpretation continues.

4. Interpret the type specifier.

Int * (* comp ) (); 6 5 3 1 2 4

This example declares the variable comp (1) as an array of ten (2) pointers (3) to functions (4) returning pointers (5) to integer values ​​(6).

Char * (* (*var) ()) ; 7 6 4 2 1 3 5

The variable var (1) is declared as a pointer (2) to a function (3) that returns a pointer (4) to an array (5) of 10 elements, which are pointers (6) to char values.

In addition to declaring variables of various types, it is possible to declare types. This can be done in two ways. The first way is to specify a tag name when declaring a structure, union, or enumeration, and then use that name in variable and function declarations as a reference to that tag. The second is to use the typedef keyword to declare a type.

When declared with the typedef keyword, the identifier in place of the object being described is the name of the data type being considered, and this type can then be used to declare variables.

Note that any type can be declared using the typedef keyword, including pointer, function, or array types. A name with the typedef keyword for pointer, structure, and union types can be declared before those types are defined, but within the scope of the declarer.

Typedef double(*MATH)(); /* MATH - new type name representing a pointer to a function that returns double values ​​*/ MATH cos; /* cos pointer to a function returning values ​​of type double */ /* An equivalent declaration can be made */ double (* cos)(); typedef char FIO /* FIO - array of forty characters */ FIO person; /* The person variable is an array of forty characters */ /* This is equivalent to a declaration */ char person;

When declaring variables and types, type names (MATH FIO) were used here. In addition, type names can be used in three other cases: in the list of formal parameters, in function declarations, in type casting operations, and in the sizeof operation (type casting operation).

The type names for basic, enumeration, structure, and mixture types are the type specifiers for those types. The type names for array pointer and function types are specified using abstract descriptors as follows:

abstract-descriptor-type-specifier;

An abstract-handler is a non-identifier handle consisting of one or more pointer, array, or function modifiers. The pointer modifier (*) is always given before the identifier in the descriptor, and the array and function modifiers () are given after it. Thus, to correctly interpret an abstract descriptor, one must begin the interpretation with the implied identifier.

Abstract descriptors can be complex. The parentheses in complex abstract descriptors specify the order of interpretation in a similar way to the interpretation of complex descriptors in declarations.

1.2.12. Data Initialization

When a variable is declared, it can be assigned an initial value by appending an initiator to a declarator. The initiator begins with an "=" sign and has the following forms.

Format 1: = initiator;

Format 2: = (list - initiators);

Format 1 is used when initializing variables of basic types and pointers, and format 2 is used when initializing composite objects.

The tol variable is initialized with the character "N".

const long megabute = (1024 * 1024);

The non-modifiable megabute variable is initialized with a constant expression after which it cannot be changed.

static int b = (1,2,3,4);

A two-dimensional array of b integer values ​​is initialized; the array elements are assigned values ​​from the list. The same initialization can be done like this:

static int b = ( ( 1,2 ), ( 3,4 ) );

When initializing an array, you can omit one or more dimensions

static int b)