Константа – это величина (число или символ), которая при выполнении программы всегда остаётся неизменной, т. е. не может изменяться во время выполнения программы. В зависимости от значения константы, компилятор самостоятельно присваивает ей тот или иной тип (char, int и т. д.).
Переменная – это область памяти для временного хранения данных. Предполагается, что в процессе выполнения программы значения переменных могут изменяться.
Любая переменная до её использования в программе на языке Си должна быть объявлена (т.е. дано её описание). Вначале указывается тип переменной, а затем её имя.
Имя переменной в языке Си может начинаться с подчерка или буквы, но не с числа. Переменная может включать в себя символы английского алфавита, цифры и знак подчёркивания. Также имя переменной не должно совпадать с ключевыми словами (т. е. специальными словами, которые используются в качестве управляющих функций в языке Си).
Типы данных можно разделить условно на три группы:
1. целые – данные целого типа,
2. вещественные – данные, которые могут иметь дробную часть,
3. символы – данные типа char, которые представляют собой какой-то символ и занимают в памяти всего один байт. Также char можно считать целым типом малой величины, так как зачастую его используют в этом качестве, когда хотят оперировать малыми значениями, чтобы сэкономить память.
Теперь давайте определим минимальное и максимальное значение числа, которое может хранить переменная каждого из типов, а также объём, который оно занимает в памяти микропроцессора.
| Тип | Размер в байтах (битах) | Интервал изменения |
| unsigned char | 1 (8) | от 0 до 255 |
| signed char (char) | 1 (8) | от -128 до 127 |
| unsigned short | 2 (16) | от 0 до 65 535 |
| signed short (short) | 2 (16) | от -32 768 до 32 767 |
| unsigned int (unsigned) | 4 (32) | от 0 до 4 294 967 296 |
| signed int (int) | 4 (32) | от -2 147 483 648 до 2 147 483 648 |
| unsigned long | 4 (32) | от 0 до 4 294 967 295 |
| signed long (long) | 4 (32) | от -2 147 483 648 до 2 147 483 647 |
| unsigned long long | 8 (64) | от 0 до 18 446 744 073 709 551 615 |
| signed long long (long long) | 4 (32) | от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 |
| float | 4 (32) | от 3.4Е-38 до 3.4Е+38 |
| double | 8 (64) | от 1.7Е-308 до 1.7Е+308 |
| long double | 10 (80) | от 3.4Е-4932 до 3.4Е+4932 |
Самоучитель C++ (6 серия) Visual Studio, Типы double и float, диапозоны типов
Приведём примеры объявления и определения переменных. В Си это осуществляется в следующей форме:
int i, n; // i и n объявлены как переменные целого числа типа int
Далее этим числам можно присвоить определённые значения:
Точно также это выглядит и для символьных переменных:
char sym1, sym2 ; // sym1 и sym2 объявлены как переменные типа char
sym1 = ‘c’ ; sym2 = ‘f’ ; // и им присвоены символьные значения c и f
Начальное значение может быть присвоено переменной и сразу в момент её объявления в форме: тип_переменной имя_переменной = значение;
Для приведённых выше примеров это будет выглядеть следующим образом:
int i = 0 , n = 154 ;
char sym1 = ‘c’ , sym2 = ‘f’ ;
Работая с вещественными переменными (float, double, long double), при присвоении им значений обязательно присутствие десятичной точки либо экспоненциальной формы в записи, а для «float» ещё и суффикса f. Например:
float f1 = 120.f ; // f1 =120 – переменная типа float
double f2 = 30.0 ; либо double f2 = 3e+1 ; // f2 =30 — переменная типа double
Типы переменных
- 1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
- 2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).
Целые
- char — размер 1 байт. Всегда! Это нужно запомнить.
- short — размер 2 байта
- int — размер 4 байта
- long — размер 4 байта
- long long — размер 8 байт.
Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.
Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char — все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.
| unsigned char | 1 | 0 | 255 |
| signed char ( char ) | 1 | -128 | 127 |
| unsigned short | 2 | 0 | 65535 |
| signed short ( short ) | 2 | -32768 | 32767 |
| unsigned int ( unsigned ) | 4 | 0 | 4294967296 |
| signed int ( int ) | 4 | -2147483648 | 2147483647 |
| unsigned long | 4 | 0 | 4294967296 |
| signed long ( long ) | 4 | -2147483648 | 2147483647 |
| unsigned long long | 8 | 0 | 18446744073709551615 |
| signed long long ( long long ) | 8 | -9223372036854775808 | 9223372036854775807 |
sizeof
В си есть оператор, который позволяет получить размер переменной в байтах. sizeof переменная, или sizeof(переменная) или sizeof(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.
#include #include int main() < char c; short s; int i; long l; long long L; //Вызов sizeof как «функции» printf(«sizeof(char) = %dn», sizeof(c)); printf(«sizeof(short) = %dn», sizeof(s)); printf(«sizeof(int) = %dn», sizeof(i)); printf(«sizeof(long) = %dn», sizeof(l)); printf(«sizeof(long long) = %dn», sizeof(L)); //Вызов как оператора printf(«sizeof(char) = %dn», sizeof c); printf(«sizeof(short) = %dn», sizeof s); printf(«sizeof(int) = %dn», sizeof i); printf(«sizeof(long) = %dn», sizeof l); printf(«sizeof(long long) = %dn», sizeof L); _getch(); >
(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще
#include #include int main() < printf(«sizeof(char) = %dn», sizeof(char)); printf(«sizeof(short) = %dn», sizeof(short)); printf(«sizeof(int) = %dn», sizeof(int)); printf(«sizeof(long) = %dn», sizeof(long)); printf(«sizeof(long long) = %dn», sizeof(long long)); //нельзя произвести вызов sizeof как оператора для имени типа //sizeof int — ошибка компиляции _getch(); >
В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned
Другие типы данных
- Указатель — хранит адрес в памяти компьютера, указывающий на какую-либо информацию, как правило — указатель на переменную.
Программа, написанная на языке Си, оперирует с данными различных типов. Все данные имеют имя и тип. Обращение к данным в программе осуществляется по их именам (идентификаторам).
Идентификатор — это последовательность, содержащая не более 32 символов, среди которых могут быть любые буквы латинского алфавита a — z, A — Z, цифры 0 — 9 и знак подчеркивания (_). Первый символ идентификатора не должен быть цифрой.
Несмотря на то, что допускается имя, имеющее до 32 символов, определяющее значение имеют только первые 8 символов. Помимо имени, все данные имеют тип. Указание типа необходимо для того, чтобы было известно, сколько места в оперативной памяти будет занимать данный объект.
Компилятор языка Си придерживается строгого соответствия прописных и строчных букв в именах идентификаторов и лексем.
| Верно | Неверно |
| int a = 2, b; b = a+3; | Int a=2; // правильно int |
| INT a=2; | |
| int a = 2, b; b = A + 3; // идентификатор А не объявлен |
Пример объявления объектов
int n; // Переменная n целого типа
double a; // Переменная a вещественного типа двойной точности
Целочисленные данные
Целочисленные данные могут быть представлены в знаковой и беззнаковой форме.
Беззнаковые целые числа представляются в виде последовательности битов в диапазоне от 0 до 2 n -1, где n-количество занимаемых битов.
Знаковые целые числа представляются в диапазоне -2 n-1 …+2 n-1 -1. При этом старший бит данного отводится под знак числа (0 соответствует положительному числу, 1 – отрицательному).
Основные типы и размеры целочисленных данных:
| Количество бит | Беззнаковый тип | Знаковый тип |
| 8 | unsigned char 0…255 | char -128…127 |
| 16 | unsigned short 0…65535 | short -32768…32767 |
| 32 | unsigned int | int |
| 64 | unsigned long int | long int |
C double data type
In C double is a keyword for the double data type. It represents floating point numbers with better precision. Usually we associate the name with the idea that it has double the precision of the float type.
Advertise on this site. I promise you will like the rates 🙂
Declaring a variable is just like with any other type:
double price = 9.95;
Specifier : the d specifier can be appended to the end of the value like this:
double length = 6.55d;
However, in C by default all floating point values are interpreted as double. That is why you will seldom see that being used, even though you can use it to explicitly show that this will not be a float value(float values on the other hand must be followed by the float specifier f: float height = 177.50f )
Printing uses the format specifier %lf (%lg, %le or %la are equivalent). This is the only correct way for compilers that comply with С99 or later. Anyway, many compilers still use the ANSI way and allow printing doubles with the old %f.
printf( «price: % l f» , price);
Reading with scanf is done with %lf with all compilers.
double salary; scanf(«%lf», printf(«salary: %lf», salary);
Representation of double in C
In C double’s exact precision depends on the implementation. Most compilers today use the IEEE-754 standard(even though most compilers do not conform to the 2019 active revision, but instead to the superseded standards from 2008 and 1985). To represent the numbers the compilers use 64 bits as follows:
- The first bit stands for the sign. 1 means negative, 0 means positive
- 52 bits of significand (mantissa)
- 11 bits of exponent
It can keep up to about 16 digits before the variable is overflowed. For instance we can keep the pi number with a precision of 15 digits after the decimal point:
double pi = 3.141592653589793;
If we try to keep too much data in a variable, information will be lost. The information will be lost right to left:
double bigNumber = 9876543210.123456789012345; printf(«big num: %lfn», bigNumber);
This will print 9876543210.123457 for a total of 16 digits, where the last is rounded up to 7.
Normally the range and precision of double is more than enough in practice.
Основы языка Си: структура Си-программы, базовые типы и конструирование новых типов, операции и выражения
При рассмотрении типов переменных в Си и C++ следует различать понятия базового типа и конструкции, позволяющей строить новые типы на основе уже построенных. Базовых типов совсем немного — это целые и вещественные числа, которые могут различаться по диапазону возможных значений (или по длине в байтах) и, в случае языка C++, логический тип . К конструкциям относятся массив , указатель и структура, а также класс в C++.
В языке Си используются всего два базовых типа: целые и вещественные числа. Кроме того, имеется фиктивный тип void («пустота»), который применяется либо для функции, не возвращающей никакого значения, либо для описания указателя общего типа (когда неизвестна информация о типе объекта, на который ссылается указатель).
В C++ добавлен логический тип.
Целочисленные типы
Целочисленные типы различаются по длине в байтах и по наличию знака. Их четыре — char , short , int и long . Кроме того, к описанию можно добавлять модификаторы unsigned или signed для беззнаковых (неотрицательных) или знаковых целых чисел.
Тип int
Самый естественный целочисленный тип — это тип int , от слова integer — целое число. Тип int всегда соответствует размеру машинного слова или адреса. Все действия с элементами типа int производятся максимально быстро. Всегда следует выбирать именно тип int , если использование других целочисленных типов не диктуется явно спецификой решаемой задачи. Параметры большинства стандартных функций, работающих с целыми числами или символами, имеют тип int . Целочисленные типы были подробно рассмотрены в «лекции 2» . Подчеркнем еще раз, что целочисленные переменные хранят на самом деле не целые числа, а элементы кольца вычетов по модулю m , где m — степень двойки.
В современных архитектурах элемент типа int занимает 4 байта, т.е. m = 2 32 . Элементы типа int трактуются в Си как числа со знаком. Минимальное отрицательное число равно -2 31 = -2147483648 , максимальное положительное равно 2 31 -1 = 2147483647 .
При описании переменной сначала указывается базовый тип, затем — имя переменной или список имен, разделенных запятыми, например,
int x; int y, z, t;
При описании переменных можно присваивать им начальные значения:
int maxind = 1000; int a = 5, b = 7;
Кроме типа int , существуют еще три целочисленных типа: char , short и long .
Тип char
Тип char представляет целые числа в диапазоне от -128 до 127 . Элементы типа char занимают один байт памяти. Слово » char » является сокращением от character , что в переводе означает «символ». Действительно, традиционно символы представляются их целочисленными кодами, а код символа занимает один байт (см. лекцию 3). Тем не менее, подчеркнем, что элементы типа char — это именно целые числа, с ними можно выполнять все арифметические операции. С математической точки зрения, элементы типа char — это элементы кольца вычетов m = Z256 . Стандарт Си не устанавливает, трактуются ли элементы типа char как знаковые или беззнаковые числа, но большинство Си-компиляторов считают char знаковым типом. Примеры описаний переменных типа char :
char c; char eof = (-1); char letterA = ‘A’;
В последнем случае значение переменной » letterA » инициализируется кодом латинской буквы ‘A’ , т.е. целым числом 65 . В Си символьные константы записываются в одинарных апострофах и означают коды соответствующих символов в кодировке ASCII. Рассмотрим следующий пример:
char c = 0; char d = ‘0’;
Здесь переменная c инициализируется нулевым значением, а переменная d — значением 48 , поскольку символ ‘0’ имеет код 48 .
Типы short и long
Слова short и long означают в Си короткое и длинное целое число со знаком. Стандарт Си не устанавливает конкретных размеров для типов short и long . В самой распространенной в настоящее время 32-разрядной архитектуре переменная типа short занимает 2 байта (диапазон значений — от -32768 до 32767 ), а тип long совпадает с типом int , размер его равен четырем байтам. Примеры описаний:
short s = 30000; long x = 100000; int y = 100000;
В 32-разрядной архитектуре переменные x и y имеют один и тот же тип.
Модификатор unsigned
Типы int , short и long представляют целые числа со знаком. Для типа char стандарт Си не устанавливает явно наличие знака, однако большинство компиляторов трактуют элементы типа char как целые числа со знаком в диапазоне от -128 до 127 . Если необходимо трактовать целые числа как неотрицательные, или беззнаковые, следует добавить модификатор unsigned при описании переменных. Примеры:
unsigned char c = 255; unsigned short s = 65535; unsigned int i = 1000000000; unsigned j = 1;
При описании типа » unsigned int » слово » int » можно опускать, что и сделано в последнем примере.
Следует по возможности избегать беззнаковых типов, поскольку арифметика беззнаковых чисел не на всех компьютерах реализована одинаково и из-за этого при переносе программы с одной платформы на другую могут возникнуть проблемы. По этой причине в языке Java беззнаковые числа запрещены.
Имеется также модификатор signed (знаковый). Его имеет смысл использовать на тех платформах, в которых тип char является беззнаковым. Пример описания:
signed char d = (-1);
Вещественные типы
Вещественных типов два: длинное вещественное число double (переводится как «двойная точность») и короткое вещественное число float (переводится как «плавающее»). Вещественные типы были подробно рассмотрены в разделе 1.4.2. Вещественное число типа double занимает 8 байтов, типа float — 4 байта.
Тип double является основным для компьютера. Тип float — это, скорее, атавизм, оставшийся от ранних версий языка Си. Компьютер умеет производить арифметические действия только с элементами типа double , элементы типа float приходится сначала преобразовывать к double . Точность, которую обеспечивает тип float , низка и не достаточна для большинства практических задач. Все стандартные функции математической библиотеки работают только с типом double . Рекомендуем вам никогда не использовать тип float !
Примеры описаний вещественных переменных:
double x, y, z; double a = 1.5, b = 1e+6, c = 1.5e-3;
В последних двух случаях использовалось задание вещественных констант в экспоненциальной форме (см. раздел 1.4.2).
Логический тип
В языке Си специального логического типа нет, вместо него используются переменные целого типа. Значению «истина» соответствует любое ненулевое целое число, значению «ложь» — ноль. Например, в Си допустим такой фрагмент программы:
int b; double s; . . . if (b)
Здесь целочисленная переменная b используется в качестве условного выражения в операторе if («если»). Если значение b отлично от нуля, то выполняется тело оператора if , т.е. переменной s присваивается значение 1.0 ; если значение b равно нулю, то тело оператора if не выполняется.
На самом деле, приведенный пример представляет собой дурной стиль программирования. Гораздо яснее выглядит следующий фрагмент, эквивалентный приведенному выше:
if (b != 0)
В более строгом языке Java второй фрагмент корректен, а первый нет.
Язык C++ вводит логический тип bool в явном виде (отметим, что этот тип появился в C++ далеко не сразу!). Переменные типа bool принимают два значения: false и true (ложь и истина). Слова false и true являются ключевыми словами языка C++.
Примеры описания логических переменных в C++:
bool a, b; bool c = false, d = true;
Оператор sizeof
Переменная одного и того же типа на разных платформах может занимать различное число байтов памяти. Язык Си предоставляет программисту возможность получить размер элемента данного типа или размер переменной в байтах, для этого служит оператор sizeof . Аргумент sizeof указывается в круглых скобках, он может быть типом или переменной. Рассмотрим несколько примеров. Пусть определены следующие переменные:
int i; char c; short s; long l; double d; float f; bool b;
Тогда приведенные ниже выражения в 32-разрядной архитектуре имеют следующие значения:
| sizeof(i) | sizeof(int) | 4 |
| sizeof(c) | sizeof(char) | 1 |
| sizeof(s) | sizeof(short) | 2 |
| sizeof(l) | sizeof(long) | 4 |
| sizeof(d) | sizeof(double) | 8 |
| sizeof(f) | sizeof(float) | 4 |
| sizeof(b) | sizeof(bool) | 1 |
Тип void
Слово void означает «пустота». Тип void в Си обозначает отсутствие чего-либо там, где обычно предполагается описание типа. Например, функция, не возвращающая никакого значения, в Си описывается как возвращающая значение типа void :
void f(int x);
Другое применение ключевого слова void состоит в описании указателя общего типа, когда заранее не известен тип объекта, на который он будет ссылаться.
Шпаргалка начинающего программиста AVR МК.
Переменные и константы в языке Си
Константа – это величина (число или символ), которая при выполнении программы всегда остаётся неизменной, т. е. не может изменяться во время выполнения программы. В зависимости от значения константы, компилятор самостоятельно присваивает ей тот или иной тип (char, int и т. д.).
Переменная – это область памяти для временного хранения данных. Предполагается, что в процессе выполнения программы значения переменных могут изменяться.
Любая переменная до её использования в программе на языке Си должна быть объявлена (т.е. дано её описание). Вначале указывается тип переменной, а затем её имя.
Имя переменной в языке Си может начинаться с подчерка или буквы, но не с числа. Переменная может включать в себя символы английского алфавита, цифры и знак подчёркивания. Также имя переменной не должно совпадать с ключевыми словами (т. е. специальными словами, которые используются в качестве управляющих функций в языке Си).
Типы данных можно разделить условно на три группы:
1. целые – данные целого типа,
2. вещественные – данные, которые могут иметь дробную часть,
3. символы – данные типа char, которые представляют собой какой-то символ и занимают в памяти всего один байт. Также char можно считать целым типом малой величины, так как зачастую его используют в этом качестве, когда хотят оперировать малыми значениями, чтобы сэкономить память.
Теперь давайте определим минимальное и максимальное значение числа, которое может хранить переменная каждого из типов, а также объём, который оно занимает в памяти микропроцессора.
| Тип | Размер в байтах (битах) | Интервал изменения |
| unsigned char | 1 (8) | от 0 до 255 |
| signed char (char) | 1 (8) | от -128 до 127 |
| unsigned short | 2 (16) | от 0 до 65 535 |
| signed short (short) | 2 (16) | от -32 768 до 32 767 |
| unsigned int (unsigned) | 4 (32) | от 0 до 4 294 967 296 |
| signed int (int) | 4 (32) | от -2 147 483 648 до 2 147 483 648 |
| unsigned long | 4 (32) | от 0 до 4 294 967 295 |
| signed long (long) | 4 (32) | от -2 147 483 648 до 2 147 483 647 |
| unsigned long long | 8 (64) | от 0 до 18 446 744 073 709 551 615 |
| signed long long (long long) | 4 (32) | от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 |
| float | 4 (32) | от 3.4Е-38 до 3.4Е+38 |
| double | 8 (64) | от 1.7Е-308 до 1.7Е+308 |
| long double | 10 (80) | от 3.4Е-4932 до 3.4Е+4932 |
Приведём примеры объявления и определения переменных. В Си это осуществляется в следующей форме:
int i, n; // i и n объявлены как переменные целого числа типа int
Далее этим числам можно присвоить определённые значения:
Точно также это выглядит и для символьных переменных:
char sym1, sym2 ; // sym1 и sym2 объявлены как переменные типа char
sym1 = ‘c’ ; sym2 = ‘f’ ; // и им присвоены символьные значения c и f
Начальное значение может быть присвоено переменной и сразу в момент её объявления в форме: тип_переменной имя_переменной = значение;
Для приведённых выше примеров это будет выглядеть следующим образом:
int i = 0 , n = 154 ;
char sym1 = ‘c’ , sym2 = ‘f’ ;
Работая с вещественными переменными (float, double, long double), при присвоении им значений обязательно присутствие десятичной точки либо экспоненциальной формы в записи, а для «float» ещё и суффикса f. Например:
float f1 = 120.f ; // f1 =120 – переменная типа float
double f2 = 30.0 ; либо double f2 = 3e+1 ; // f2 =30 — переменная типа double
Примитивные типы данных
Примитивные типы данных — это базовые типы данных языка программирования. Их ключевая особенность в том, что данные в них, в отличие от ссылочных типов, располагаются непосредственно [«в переменной».] на участке памяти компьютера в котором находится переменная. Перечислим и опишем основные примитивные типы данных в программировании.
- Логический тип данных или булевый. Переменные данного вида могу принимать лишь два значения: истина (true, либо 1) или ложь (false, либо 0). В различных языках программирования булевы переменные объявляются с помощью ключевого слова bool либо boolean. Логический тип данных имеет широчайшее применение (как собственно и другие типы). Например, он фигурирует в условных операторах ветвления (if) и операторах цикла (for, while, do-while).
- Целочисленный тип данных. Обычно объявляется ключевым словом int или integer. Переменные данного типа могут принимать только целочисленные значения. Часто тип int занимает четыре байта (2 32 = 4294967296), следовательно переменные могут принимать значения от — 2 147 483 648 и до 2 147 483 647 в случае, когда целый тип учитывает знак числа. Если использовать беззнаковый целый тип данных (unsigned int), то его диапазон значений от 0 до 4294967295. В языке программирования Java целый тип всегда 4 байта. В языках Си и C# предполагаемый размер также 4 байта, но на деле — всё зависит от конкретной реализации языка на программной платформе.
Данный тезис относится не только к типу int. Размер каждого примитивного типа данных в любой реализации языка Java всегда строго определен и одинаков. В C-подобных языках это не так. - Целочисленный тип byte. Исходя из названия типа, он занимает в памяти один байт, то есть восемь бит. 2 8 = 256 — такое количество значений он может в себя вместить. Если говорить конкретно, то в случае, если тип byte со знаком, то диапазон от -128 до 127 (не забываем, что есть еще число ноль); когда byte беззнаковый, то от 0 до 255.
- Короткий целый тип short. В памяти для него выделено 2 байта = 16 бит (2 16 = 65536). Диапазон принимаемых значений типом short со знаком — это [-32768; 32767].
- Длинный целый тип long. Длинный целый тип занимает в памяти 8 байт, то есть 64 бита. 2 64 = 1,8446744 × 10 19 . Диапазон допустимых значений очень велик: в случае знакового типа, это [-9223372036854775808; 9223372036854775807]. Кроме того, модификатор long можно использовать в сочетании с другими типами (long пишется перед названием типа, например: long double), расширяя, тем самым, диапазон допустимых значений типа согласно спецификации конкретного языка программирования.
- Число с плавающей запятой. Этот тип обозначается ключевым словом float, также же этот тип называют вещественным типом одинарной точности. float — это ни что иное, как десятичная дробь (привычная нам на письме), но в памяти компьютера она представляется в виде экспоненциальной записи: состоит из мантиссы и показателя степени. Например: 0,0506 = 506,0 ⋅ 10 -4 , где 506 — мантисса, а -4 — показатель степени десяти. Размер типа данных float в спецификации языка Си четко не определен.
- Число с плавающей запятой двойной точности — это тип double. Данный тип схож с типом float, единственное их различие — это размер в памяти и, соответственно, диапазон принимаемых значений. Естественно тип double больше; но всё зависит от реализации языка, говоря строго: тип double по крайней мере должен быть не меньше, чем float.
- Символьный тип данных занимает в памяти один байт — если используется кодировка ASCII и два байта — если установлена кодировка Unicode. Данный тип по сути является целым числом. Цифра, хранящаяся в переменной символьного типа — это номер символа в таблице кодировки. Обычно объявляется с помощью ключевого слова char. Нужно четко представлять себе, что char — это число, и работать с ним, как с числом, в некоторых случаях очень удобно и эффективно.
Ключевая особенность примитивных типов данных в том, что они передаются по значению. Это значит, что при передачи переменной в качестве аргумента функции (или методу) она копируется туда. Следовательно манипуляции, производимые с переменной в вызванной функции, никак не повлияют на значение переменной в вызывающей функции.
Примечание: модификатор unsigned (то есть беззнаковый) применим к любому целочисленному типу (в том числе и к символьному), а long (длинный) применим практически к любому типу, за исключением логического.
Ссылочные типы данных
Самая важная особенность ссылочных типов данных состоит в том, что они передаются не по значению, а по ссылке. Что это значит?
Ссылочные типы данных не являются примитивными и их размер не фиксирован и может быть произвольным, кроме того они хранятся не [«в переменной».] на участке памяти переменной, а в совершенно другом месте памяти компьютера. Ссылочными типами, например, являются массивы. В объектно-ориентированных языках программирования — это экземпляры классов, коллекции и т.п.
При создании нового массива:
