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 being 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 generated 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 the 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

Additionally, you cannot iterate over all the values ​​of an enumeration:

// 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 only with 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 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 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 expression max_files-3 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, 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 - neither at the compilation stage, nor 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 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 into 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. It is permissible to specify not the entire array, but a certain range of it, as a list of initial values:

// 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;

It is more typical within this idiom to use iterators:

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 instead 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 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 – 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 Array class as an example. 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 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 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);

// member access 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 corresponding 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; // ... );

Last update: 09/17/2017

Each variable has a specific type. And this type determines what values ​​a variable can have, what operations can be performed on it, and how many bytes in memory it will occupy. The following basic data types are defined in the C++ language:

bool : boolean type. Can take one of two values: true and false. The memory footprint for this type is not precisely defined.

char : Represents a single ASCII character. Occupies 1 byte (8 bits) in memory. Can store any value from -128 to 127, or from 0 to 255

signed char : Represents a single character. Occupies 1 byte (8 bits) in memory. Can store any value from -128 to 127

unsigned char : Represents a single character. Occupies 1 byte (8 bits) in memory. Can store any value from 0 to 255

wchar_t : Represents a wide character. On Windows it takes up 2 bytes (16 bits) of memory, on Linux it takes 4 bytes (32 bits). Can store any value from the range from 0 to 65,535 (for 2 bytes), or from 0 to 4,294,967,295 (for 4 bytes)

char16_t: Represents a single Unicode character. Occupies 2 bytes (16 bits) in memory. Can store any value from 0 to 65,535

char32_t : Represents a single Unicode character. Occupies 4 bytes (32 bits) in memory. Can store any value from 0 to 4,294,967,295

short : Represents an integer in the range –32768 to 32767. Occupies 2 bytes (16 bits) of memory.

This type also has synonyms short int, signed short int, signed short.

unsigned short: Represents an integer in the range 0 to 65535. Occupies 2 bytes (16 bits) of memory.

This type also has a synonym unsigned short int .

int: represents an integer. Depending on the processor architecture, it can occupy 2 bytes (16 bits) or 4 bytes (32 bits). The range of limit values ​​accordingly can also vary from –32768 to 32767 (with 2 bytes) or from −2,147,483,648 to 2,147,483,647 (with 4 bytes). But in any case, the size must be greater than or equal to the size of the short type and less than or equal to the size of the long type

This type has synonyms signed int and signed .

unsigned int : Represents a positive integer. Depending on the processor architecture, it may occupy 2 bytes (16 bits) or 4 bytes (32 bits), and because of this, the range of limit values ​​may vary: from 0 to 65535 (for 2 bytes), or from 0 to 4,294,967,295 (for 4 bytes).

unsigned can be used as a synonym for this type

long : Represents an integer in the range −2,147,483,648 to 2,147,483,647. Occupies 4 bytes (32 bits) of memory.

This type also has synonyms long int , signed long int and signed long

unsigned long: Represents an integer in the range 0 to 4,294,967,295. Occupies 4 bytes (32 bits) of memory.

Has the synonym unsigned long int .

long long : Represents an integer in the range −9,223,372,036,854,775,808 to +9,223,372,036,854,775,807. Occupies typically 8 bytes (64 bits) of memory.

Has synonyms long long int , signed long long int and signed long long .

unsigned long long : Represents an integer in the range 0 to 18,446,744,073,709,551,615. Typically 8 bytes (64 bits) in memory.

Has the synonym unsigned long long int .

float : Represents a single-precision floating-point real number in the range +/- 3.4E-38 to 3.4E+38. Occupies 4 bytes (32 bits) in memory

double : Represents a double precision floating point real number in the range +/- 1.7E-308 to 1.7E+308. Occupies 8 bytes (64 bits) in memory

long double : Represents a double-precision floating-point real number of at least 8 bytes (64 bits). Depending on the size of the occupied memory, the range of valid values ​​may vary.

void : type without value

Thus, all data types except void can be divided into three groups: character (char, wchar_t, char16_t, char32_t), integer (short, int, long, long long) and floating point number types (float, double, long double).

Character types

The types used to represent characters in the application are char, wchar_t, char16_t, and char32_t.

Let's define several variables:

Char c="d"; wchar_t d="c";

A char variable takes as its value one character in single quotes: char c ="d" . You can also assign a number from the range specified above in the list: char c = 120 . In this case, the value of the variable c will be the character that has code 120 in the ASCII character table.

It is worth considering that to output wchar_t characters to the console, you should use not std::cout, but the std::wcout stream:

#include int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

In this case, the std::wcout stream can work with both char and wchar_t. And the std::cout stream for the wchar_t variable will output its numeric code instead of a character.

The C++11 standard added the char16_t and char32_t types, which are oriented towards using Unicode. However, threads for working with these types have not yet been implemented at the OS level. Therefore, if you need to display the values ​​of variables of these types to the console, you need to convert the variables to types char or wchar_t:

#include int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

In this case, when outputting, the variables are preceded by a cast operation to the char type - (char) , due to which the values ​​of the variables b, c and d are converted to the char type and can be output to the console using the std::cout stream.

Integer types

Integer types are represented by the following types: short, unsigned short, int, unsigned int, long, unsigned long, long long and unsigned long long:

Short a = -10; unsigned short b= 10; int c = -30; unsigned int d = 60; long e = -170; unsigned long f = 45; long long g = 89;

Types of floating point numbers

Floating-point and fractional number types are represented by float, double and long double:

Float a = -10.45; double b = 0.00105; long double c = 30.890045;

Data type sizes

The list above shows for each type the size it occupies in memory. However, it is worth noting that compiler developers can choose the size limits for types independently, based on the hardware capabilities of the computer. The standard sets only the minimum values ​​that should be. For example, for the int and short types the minimum value is 16 bits, for the long type - 32 bits, for the long double type. In this case, the size of the long type must be no less than the size of the int type, and the size of the int type must not be less than the size of the short type, and the size of the long double type must be greater than double. For example, the g++ compiler for Windows uses 12 bytes for long doubles, and the compiler built into Visual Studio and also runs under Windows uses 8 bytes for long doubles. That is, even within the same platform, different compilers may approach the sizes of certain data types differently. But in general, the sizes that are indicated above when describing data types are used.

However, there are situations when it is necessary to know exactly the size of a certain type. And for this, C++ has the sizeof() operator, which returns the size of the memory in bytes that the variable occupies:

#include int main() ( long double number = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Console output when compiling in g++:

sizeof(number) = 12

At the same time, when defining variables, it is important to understand that the value of a variable should not go beyond the limits outlined for its type. For example:

Unsigned short number = -65535;

The G++ compiler, when compiling a program with this line, will generate an error stating that the value -65535 is not within the range of valid values ​​for the unsigned short type and will be truncated.

In Visual Studio, compilation can proceed without errors, but the number variable will receive the value 2 - the result of converting the number -65535 to an unsigned short type. That is, again, the result will not be exactly what is expected. The value of a variable is just a collection of bits in memory that are interpreted according to a specific type. And for different types, the same set of bits can be interpreted differently. Therefore, it is important to consider the value ranges for a given type when assigning a value to a variable.

auto specifier

Sometimes it can be difficult to determine the type of expression. And according to the latest standards, you can let the compiler infer the type of the object itself. And the auto specifier is used for this. Moreover, if we define a variable with the auto specifier, this variable must be initialized with some value:

Auto number = 5;

Based on the assigned value, the compiler will infer the type of the variable. Uninitialized variables with the auto qualifier are not allowed.

This cheat sheet provides information about the main data types of the C++ programming language and the features of their implementation. Also, at the end of the record there is a table with the ranges of values ​​of these types.

Data Type Concept

The main purpose of any program is to process data. Different types of data are stored and processed differently. In any algorithmic language, every constant, variable, expression, or function must have a specific type.

The data type defines:

• internal representation of data in computer memory;
• the set of values ​​that quantities of this type can take;
• operations and functions that can be applied to the quantities of this type.

Based on these characteristics, the programmer selects the type of each quantity used in the program to represent real objects. A required type declaration allows the compiler to check the validity of various program constructs. The type of value determines the machine instructions that will be used to process the data.

All types of C++ language can be divided into basic And composite . The C++ language defines six main data types to represent integer, real, character and logical values. Based on these types, the programmer can enter a description composite types. These include arrays, enumerations, functions, structures, references, pointers, unions, and classes.

Basic data types in C++

Basic (standard) data types are often called arithmetic because they can be used in arithmetic operations. To describe the main types, the following are defined:

1. int(int);
2. char(char);
3. wchar_t(widechar);
4. bool(boolean);
5. float(real);
6. double (double precision real).

The first four types are called integer ( whole ), the last two - floating point types . The code that the compiler generates for handling integer values ​​is different from the code for floating-point values.

There are four type specifier , clarifying the internal representation and range of values ​​of standard types:

• short (short);
• long(long);
• signed(signed);
• unsigned.

Integer type (int)

The size of the int type is not defined by the standard, but depends on the computer and the compiler. For a 16-bit processor, 2 bytes are allocated for values ​​of this type, for a 32-bit processor - 4 bytes.

The short specifier before the type name indicates to the compiler that 2 bytes must be allocated for the number, regardless of the processor bit capacity. The long specifier means that the integer value will occupy 4 bytes. So on a 16-bit computer the equivalents are int and short int, and on a 32-bit computer the equivalents are int and long int.

Internal representation values ​​of integer type - an integer in binary code. When using the signed specifier, the most significant bit of the number is interpreted as signed (0 is a positive number, 1 is a negative number). The unsigned specifier allows only positive numbers to be represented, since the most significant bit is treated as part of the number's code. Thus, the range of values ​​of type int depends on the specifiers. The ranges of values ​​of integer type values ​​with various specifiers for IBM PC-compatible computers are given in the table “Value ranges of simple data types” at the end of the entry.

By default, all integer types are considered signed, meaning the signed specifier can be omitted.

Constants found in a program are assigned one type or another in accordance with their type. If for some reason the programmer is not satisfied with this type, he can explicitly indicate the required type using the suffixes L, l (long) and U, u (unsigned). For example, the constant 32L will be of type long and occupy 4 bytes. You can use the L and U suffixes at the same time, for example, 0x22UL or 05Lu.

Note

The types short int, long int, signed int, and unsigned int can be abbreviated to short, long, signed, and unsigned, respectively.

Character type (char)

The value of a character type is allocated a number of bytes sufficient to accommodate any character from the character set for a given computer, which is what determines the name of the type. Typically this is 1 byte. The char type, like other integer types, can be signed or unsigned. Signed values ​​can store values ​​in the range -128 to 127. Using the unsigned specifier, values ​​can range from 0 to 255. This is sufficient to store any character in the 256-character ASCII character set. Values ​​of the char type are also used to store integers that do not exceed the boundaries of the specified ranges.

Extended character type (wchar_t)

The wchar_t type is designed to work with a set of characters for which 1 byte is not enough to encode, for example, Unicode. The size of this type is implementation dependent; as a rule, it corresponds to the type short. String constants of type wchar_t are written with the prefix L, for example, L»Gates».

Boolean type (bool)

Boolean values ​​can only take the values ​​true and false, which are reserved words. The internal form of representing the value false is 0 (zero). Any other value is interpreted as true. When converted to an integer type, true has the value 1.

Floating point types (float, double and long double)

The C++ standard defines three data types for storing real values: float, double and long double.

Floating-point data types are stored differently in computer memory than integer data types. The internal representation of a real number consists of two parts - the mantissa and the exponent. On IBM PC-compatible computers, float values ​​occupy 4 bytes, of which one binary digit is allocated for the mantissa sign, 8 bits for the exponent and 23 for the mantissa. The mantissa is a number greater than 1.0 but less than 2.0. Since the leading digit of the mantissa is always 1, it is not stored.

For double values ​​that occupy 8 bytes, 11 and 52 bits are allocated for the exponent and mantissa, respectively. The length of the mantissa determines the precision of the number, and the length of the exponent determines its range. As you can see from the table at the end of the entry, with the same number of bytes allocated for float and long int values, the ranges of their permissible values ​​differ greatly due to internal representation form.

The long specifier before a double type name indicates that 10 bytes are allocated for its value.

Floating-point constants are of double type by default. You can explicitly specify the type of a constant using the suffixes F, f (float) and L, l (long). For example, the constant 2E+6L will be of type long double, and the constant 1.82f will be of type float.

To write programs that are portable across platforms, you can't make assumptions about the size of the int type. To obtain it, you must use the sizeof operation, the result of which is the size of the type in bytes. For example, for the MS-DOS operating system sizeof (int) will result in 2, but for Windows 98 or OS/2 the result will be 4.

The ANSI standard does not specify value ranges for basic types; only the relationships between their sizes are defined, for example:

sizeof(float) ≤ slzeof(double) ≤ sizeof(long double)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(long)

Note

The minimum and maximum allowed values ​​for integer types are implementation dependent and are given in the header file (), characteristics of real types - in the file (), as well as in the numeric_limits class template

type void

In addition to those listed, the main types of the language include the void type, but the set of values ​​of this type is empty. It is used to define functions that do not return a value, to specify an empty list of function arguments, as the base type for pointers, and in type casting operations.

Value ranges of simple data types in C++ for IBM PC-compatible computers

Q: What does the term IBM PC-compatible computer mean?
A: An IBM PC compatible computer is a computer that is architecturally close to the IBM PC, XT and AT. IBM PC-compatible computers are built on microprocessors compatible with the Intel 8086 (and, as you know, all later Intel processors are fully backward compatible with the 8086). In fact, these are almost all modern computers.

Various types of integer and real types, differing in the range and accuracy of data representation, were introduced in order to give the programmer the opportunity to most effectively use the capabilities of specific equipment, since the speed of calculations and the amount of memory depend on the choice of type. But a program optimized for one type of computer may not be portable to other platforms, so in general you should avoid relying on specific characteristics of data types.

For real types, the table shows the absolute values ​​of the minimum and maximum values.

Tags: C++ data types, auto, decltype, automatic type inference

Data Types

As in C, variables in C++ must have a valid name. That is, consist of numbers, letters and an underscore, should not begin with a number and should not coincide with function words, of which there are now more

Like C, C++ is a case-sensitive language.

Basic Data Types

Basic data types in C++ can be divided into several groups

Sign type. Signed type variables can be used to store a single character. The simplest type is char, which is 1 byte in size. There are also types to represent characters larger than one byte

Actually, these types exist in C as well; we did not dwell in detail on studying the representation of strings.

Integer data types. As in C, they can have signed and unsigned modifiers. As in C, the main types are char, int, long and long long. Nothing new has appeared here.

Floating point numbers. Represented by float, double and long double types. Nothing new compared to C.

All types described above are also called arithmetic. In addition to them, there is also an empty type - void (also nothing new compared to C) and a null pointer. Now, instead of NULL with its amazing properties, there is a new fundamental type nullptr_t with a single value nullptr, which stores a null pointer and is equal only to itself. At the same time, it can be cast to a null pointer of the desired type.

The Boolean type was introduced into C++. It stores only two possible values, true and false.

C++ also supports many composite data types, which will be discussed later.

Declaring and initializing variables

In C++, variables can be declared anywhere inside a function, not just at the very beginning of a block of code. Variables can also be declared inside a for loop.

Float a; float b; float sum; float step; a = 3.0f; b = 4.3f; sum = 0.0f; step = 0.05f; for (float i = a; i< b; i += step) { sum += i * i; } float mid = sum / (b - a) / step;

You can initialize variables during creation as in C

Int x = 0;

or, using the constructor

Int x(0); double d(3.2);

In addition, in C++ 2011 the so-called uniform initialization, a universal initialization that allows you to use one syntax to initialize any objects

Struct Point ( int x; int y; ); struct Point position = ( 3, 4 ); Point *pt = new Point(6, 8); int length(5);

Type inference

In C++ 2011, the service word auto is used to automatically determine the type of variables. Often the type of a variable can be determined based on the right side of the initialization. In the case where the compiler can unambiguously determine the type, it can be specified using the auto function word:

Auto x = 3; //equivalent to int x = 3; auto point = new Point; //equivalent to Point *point = new Point

In addition, it is possible to set the type of a variable based on an existing type, using the service word decltype

Int intX = 42; decltype(intX) intY = 33; //equivalent to int intY = 33; auto pt1 = new Point; decltype(pt1) p2 = new Point(2, 6); //equivalent to //Point *pt1 = new Point; //Point *pt2 = new Point(2, 6)

Strings

C++ does not have a base type string. However, there is a standard library called string, which provides a class for working with strings.

#include #include void main() ( std::string first_name = "Vasya"; std::string last_name = ( "Pupkin" ); //string concatenation auto full_name = first_name + " " + last_name; std::string *department = new std ::string("Department of copying and scanning");<< full_name << std::endl; //сравнение строк std::string a = "A"; std::string b = "B"; if (first_name.compare(last_name) >0) ( std::cout<< a + " >" + b<< std::endl; } else { std::cout << a + " < " + b << std::endl; } //подстрока std::string subs = department->substr(0, 10); std::cout<< subs << std::endl; //замена подстроки std::cout << last_name.replace(0, 1, "G") << std::endl; //вставка std::string new_department = department->insert(department->length(), " and shreddering"); std::cout<< new_department << std::endl; delete department; system("pause"); }

We'll get to know the standard string library in more detail later.

In the C language, there is a distinction between the concepts of “data type” and “type modifier”. The data type is integer and the modifier is signed or unsigned. A signed integer will have both positive and negative values, while an unsigned integer will have only positive values. There are five basic types in the C language.

• char – character.

A variable of type char has a size of 1 byte, its values ​​are various characters from the code table, for example: 'f', ':', 'j' (when written in the program, they are enclosed in single quotes).

• int – whole.

The size of a variable of type int is not defined in the C language standard. In most programming systems, the size of an int variable corresponds to the size of an entire machine word. For example, in compilers for 16-bit processors, an int variable has a size of 2 bytes. In this case, the signed values ​​of this variable can lie in the range from -32768 to 32767.

• float – real.

The float keyword allows you to define variables of real type. Their values ​​have a fractional part separated by a dot, for example: -5.6, 31.28, etc. Real numbers can also be written in floating point form, for example: -1.09e+4. The number before the symbol “e” is called the mantissa, and after the “e” is called the exponent. A variable of type float occupies 32 bits in memory. It can take values ​​in the range from 3.4e-38 to 3.4e+38.

• double – double precision real;

The double keyword allows you to define a double precision real variable. It takes up twice as much memory space as a float variable. A double type variable can take values ​​in the range from 1.7e-308 to 1.7e+308.

• void – no value.

The void keyword is used to neutralize the value of an object, for example, to declare a function that does not return any value.

Variable types:

Programs operate with various data, which can be simple or structured. Simple data are integer and real numbers, symbols and pointers (addresses of objects in memory). Integers do not have a fractional part, but real numbers do. Structured data is arrays and structures; they will be discussed below.

A variable is a cell in computer memory that has a name and stores some value. The value of a variable can change during program execution. When a new value is written to a cell, the old one is erased.

It is good style to name variables meaningfully. The variable name can contain from one to 32 characters. 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. The variable name cannot match reserved words.

Type char

char is the most economical type. The char type can be signed or unsigned. Denoted as “signed char” (signed type) and “unsigned char” (unsigned type). The signed type can store values ​​in the range -128 to +127. Unsigned – from 0 to 255. 1 byte of memory (8 bits) is allocated for a char variable.

The signed and unsigned keywords 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

The integer value int can be short or long. The short keyword is placed after the signed or unsigned keywords. So there are types: signed short int, unsigned short int, signed long int, unsigned long int.

A variable of type signed short int (signed short integer) can take values ​​from -32768 to +32767, unsigned short int (unsigned short integer) - from 0 to 65535. Each of them is allocated exactly two bytes of memory (16 bits).

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

An unsigned short int variable can be declared as an unsigned int or an unsigned short.

For each signed long int or unsigned long int value, 4 bytes of memory (32 bits) are allocated. 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 of the long long int type, for which 8 bytes of memory are allocated (64 bits). They can 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 also be declared simply by two long long keywords.

Declaring Variables

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.

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

Modifiers – keywords signed, unsigned, short, long.
A type specifier is a char or int keyword that specifies the type of the variable being declared.
Identifier is the name of the variable.

Char x; int a, b, c; unsigned long long y;

When declared, a variable can be initialized, that is, assigned an initial value.

Int x = 100;

When declared, variable x will immediately contain the number 100. It is better to declare initialized variables on separate lines.