Integers int. char, short, int, and long types

The following code, however, will not produce errors because there is an implicit type conversion

Int a = 10u; double g = 3.f;

Hexadecimal and octal format

When working with numbers, you can use hexadecimal and octal representations. Numbers in hexadecimal start with 0x, in octal start with zero. Accordingly, if the number starts from zero, then it should not contain digits higher than 7:

#include #include void main() ( int x = 0xFF; int y = 077; printf("hex x = %x\n", x); printf("dec x = %d\n", x); printf("oct x = %o\n", x); printf("oct y = %o\n", y); printf("dec y = %d\n", y); printf("hex y = %x", y); getch(); )

Exponential representation of numbers

The exponential form of representing a number is the representation of a number in the form M e ± p , where M- mantis of the number, p- power of ten. In this case, the mantissa must have one non-zero sign before the decimal point.
For example 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 etc.
Views 3.2435e7 is equivalent to 3.2435e+7
There is another representation ("engineering"), in which the degree must be a multiple of three. For example 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 etc.

Declaring Variables

In C, variables are always declared at the beginning of a block (a block is a piece of code delimited by curly braces)

<возвращаемый тип> <имя функции> (<тип> <аргумент>[, <тип> <аргумент>]) ( variable declaration everything else )

When declaring a variable, its type and name are written.

int a; double parameter;

You can declare multiple variables of the same type by separating the names with a comma

Long long arg1, arg2, arg3;

for example

#include #include int main() ( int a = 10; int b; while (a>0)( int z = a*a; b += z; ) )

Variables are declared here a and b inside a function main, and variable z inside the loop body. The following code will cause a compilation error

int main() ( int i; i = 10; int j; )

This is because the variable declaration comes after the assignment statement. When declaring variables, you can immediately initialize them.
int i = 0;
At the same time, initialization when declaring a variable is not considered a separate statement, so the following code will work

int main() ( int i = 10; int j; )

The initial value of the variable

It is very important to remember that variables in C are not initialized to zero by default, as in many other programming languages. After the variable is declared, it stores "garbage" - a random value that remains in the memory area that was allocated for the variable. This is primarily due to the optimization of the program: if there is no need for initialization, then there is no need to spend resources to write zeros (note: global variables are initialized with zeros, why so, read this article).

#include #include int main() ( int i; printf("%d", i); getch(); )

If you run this program on VC, then a warning will fly out during execution
Run-Time Check Failure #3 - The variable "i" is being used without being initialized.
If you click "Continue", the program will display "garbage". In many other compilers, there will be no warning when the program is executed.

Variable scope

Variables can be local (declared inside some function) and global. The global variable is visible to all functions declared in this file. A local variable is limited by its scope. When I say that a variable is "visible in some place", it means that in this place it is defined and can be used. For example, consider a program that has a global variable

#include #include int global = 100; void foo() ( printf("foo: %d\n", global); ) void bar(int global) ( printf("bar: %d\n", global); ) int main() ( foo() ; bar(333); getch(); )

Will be displayed
foo:100
bar: 333
Here is a global variable global visible to all functions. But the function argument overwrites the global variable, so passing the argument 333 prints the local value 333.
Here is another example

#include #include int global = 100; int main() ( int global = 555; printf("%d\n", global); getch(); )

The program will print 555. Just like in the previous case, the local variable is "more important". A variable declared in some scope is not visible outside of it, for example

#include #include int global = 100; int main() ( int x = 10; ( int y = 30; printf("%d", x); ) printf("%d", y); )

This example will not compile because the variable y exists only within its block.
Here is another example where variables declared inside a block overlap each other

#include #include int global = 100; int main() ( int x = 10; ( int x = 20; ( int x = 30; printf("%d\n", x); ) printf("%d\n", x); ) printf( "%d\n", x); getch(); )

The program will output
30
20
10
Global variables should be avoided. You can hear this very often. Let's try to figure out why. In your simple projects, global variables look quite normal. But imagine that you have an application that

• 1) Developed by several people and consists of hundreds of thousands of lines of code
• 2) Works in multiple threads

First, a global variable, if it is visible to everyone, can be changed by any part of the program. You changed a global variable, you want to write it, and another part of the program has already overwritten a different value into it (in fact, this is a whole class of problems that arise in a multithreaded environment). Secondly, with large project sizes, it is impossible to keep track of who and when created global variables. The examples above show how variables can overlap, and the same will happen in a large project.

Of course, there are situations where global variables simplify the program, but such situations do not happen often and not in your homework, so DO NOT CREATE GLOBAL VARIABLES!
Variables can be not only integer and floating point. There are many other types that we will study further.

In the C language, the concepts of “data type” and “type modifier” are distinguished. 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 only have positive values. There are five basic types in C language.

• char - character.

A char type variable 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 is an integer.

The size of a variable of type int is not defined in the C standard. In most programming systems, the size of a variable of type int corresponds to the size of a whole 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 range from -32768 to 32767.

• float is real.

The float keyword allows you to define floating point variables. 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" - the order. A float variable occupies 32 bits in memory. It can take values ​​in the range from 3.4e-38 to 3.4e+38.

• double – real double precision;

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 variable of type double can take values ​​in the range from 1.7e-308 to 1.7e+308.

• void - has no value.

The void keyword is used to neutralize the value of an object, such as declaring a function that does not return any value.

Variable types:

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

A variable is a location 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 value is erased.

It is good style to name variables meaningfully. The variable name can contain from one to 32 characters. You can use lowercase and uppercase letters, numbers, and the underscore character, which is considered a letter in C. The first character must be a letter. The variable name cannot be the same as 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). A 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 type 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 the number, otherwise the zero bit is interpreted as a sign.

type int

The integer value int can be short (short) or long (long). The short keyword is placed after the signed or unsigned keywords. Thus, 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. Exactly two bytes of memory (16 bits) are allocated for each of them.

When declaring a variable of type signed short int, the 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 a single short keyword.

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

Each signed long int or unsigned long int has 4 bytes of memory (32 bits). The values ​​of variables of this type can range from -2147483648 to 2147483647 and from 0 to 4294967295, respectively.

There are also variables of type long long int, for which 8 bytes of memory (64 bits) are allocated. 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 with 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] typespecifier id [, id] ...

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

Charx; int a, b, c; unsigned long long y;

When declaring a variable, you can initialize it, that is, assign it an initial value.

int x = 100;

The number 100 will immediately be written to the variable x upon declaration. It is better to declare initialized variables in separate lines.

Data types

Data types are of particular importance in C# because it is a strongly typed language. This means that all operations are strictly type-checked by the compiler, and invalid operations are not compiled. Therefore, strong typing helps to eliminate bugs and improve the reliability of programs. To ensure type checking, all variables, expressions, and values ​​must be of a particular type. There is no such thing as a "typeless" variable in this programming language. Moreover, the value type determines the operations that are allowed to be performed on it. An operation that is allowed for one data type may not be allowed 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, while reference types are stored in an area called 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 mainly used to represent characters and is therefore treated separately. The remaining eight integer types are for numeric calculations. Below are their range of representation of numbers and bit depth:

As the table above shows, C# defines both signed and unsigned versions of the various integer types. Signed integer types differ from their unsigned counterparts in the way they interpret the most significant bit of an integer. For example, if a program specifies a signed integer value, the C# compiler will generate code that uses the high-order 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, in which all the binary digits of a negative number are first inverted, and then 1 is added to this number.

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

So, if the value needs to be stored without a sign, then for it you can choose uint type, for large signed values ​​- long type, and for large unsigned values, the 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 variable of type long:

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 notation. In the latter case, the 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 accepted int. To explicitly specify which other integer type the value should have, the following characters can be added to the number:

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

U and L can also be written in lowercase, although the lowercase L can 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 kinds of floating point data types in C#: float and double. They represent single and double precision numeric values, respectively. Thus, 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 bit depth 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 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 source code (for example, 12.3), then the compiler usually assumes that a value of type double is meant. If a value needs to be specified as a float, you will need to add an 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 is 128 bits wide to represent numeric values ​​ranging from 1E-28 to 7.9E+28. You probably know that normal floating-point arithmetic is prone to decimal rounding errors. These errors are eliminated by using the decimal type, which allows numbers to be represented with a precision of up to 28 (and sometimes 29) decimal places. Because it can represent decimal values ​​without rounding errors, this data type is especially useful for financial calculations:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // *** Calculating 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; for (i = 1; i

The output of this program will be:

Symbols

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

When writing a program in any language, you need to use different variables to store different information. Variables are nothing but reserved memory locations for storing values. This means that when you create a variable, you save some space in memory.

You can store information of various data types such as character, wide character, integer, floating point, double floating point, boolean, etc. Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory .

Primitive built-in types

C++ offers the programmer a rich set of built-in as well as user-defined data types. The following tables list the seven main C++ data types:

Some of the basic types can be modified using one or more of that type's modifiers:

• signed
• unsigned
• short

The following table shows the type of the variable, the amount of memory it takes to store the value in memory, and what are the maximum and minimum values ​​that can be stored in such variables.

The size of the variables may differ from the size shown in the table above, depending on the compiler and computer you are using. Below is an example that will give the correct size for various data types on your computer.

#include using namespace std; int main() ( cout<< "Size of char: " << sizeof(char) << endl; cout << "Size of int: " << sizeof(int) << endl; cout << "Size of short int: " << sizeof(short int) << endl; cout << "Size of long int: " << sizeof(long int) << endl; cout << "Size of float: " << sizeof(float) << endl; cout << "Size of double: " << sizeof(double) << endl; cout << "Size of wchar_t: " << sizeof(wchar_t) << endl; return 0; }

This example uses endl, which introduces a newline character after each line, and the operator<< используется для передачи нескольких значений на экран. Мы также используем оператор sizeof() to get the size of various data types.

When the above code is compiled and executed, it produces the following output, which may vary from machine to machine:

Size of char: 1 Size of int: 4 Size of short int: 2 Size of long int: 4 Size of float: 4 Size of double: 8 Size of wchar_t: 4

typedef declarations

You can create a new name for an existing type with a typedef . Following is the simple syntax to define a new type using typedef:

Typedef type newname;

For example, the following tells the compiler that feet is another name for int:

Typedef int feet;

Now the following declaration is perfectly legal and creates an integer variable called distance:

Feet distance;

Listed types

An enumerated type declares an optional type name and a set of zero or more identifiers that can be used as values ​​of the type. Each enumerator is a constant whose type is an enum. The use of the keyword is required to create an enum. enum. General view of enum type:

Enum enum-name ( list of names ) var-list;

Here enum-name is the enum type name. The list of names is separated by a comma. For example, the following code defines an enumeration of colors called colors and a variable c of type color. Finally, c is assigned the value "blue".

Enum color ( red, green, blue ) c; c = blue;

By default, the value of the first name is 0, the second name has a value of 1, and the third name has a value of 2, and so on. But you can specify a name, a specific value, by adding an initializer. For example, in the following enumeration, green would have the value 5.

Enum color ( red, green = 5, blue );

Here blue will have the value 6 because each name will be greater than the previous one.