Последнее обновление: 13.11.2017
Как и во многих языках программирования, в C# есть своя система типов данных, которая используется для создания переменных. Тип данных определяет внутреннее представление данных, множество значений, которые может принимать объект, а также допустимые действия, которые можно применять над объектом.
В языке C# есть следующие примитивные типы данных:
bool : хранит значение true или false (логические литералы). Представлен системным типом System.Boolean
Bool alive = true; bool isDead = false;
byte : хранит целое число от 0 до 255 и занимает 1 байт. Представлен системным типом System.Byte
Byte bit1 = 1; byte bit2 = 102;
sbyte : хранит целое число от -128 до 127 и занимает 1 байт. Представлен системным типом System.SByte
Sbyte bit1 = -101; sbyte bit2 = 102;
short : хранит целое число от -32768 до 32767 и занимает 2 байта. Представлен системным типом System.Int16
Short n1 = 1; short n2 = 102;
ushort : хранит целое число от 0 до 65535 и занимает 2 байта. Представлен системным типом System.UInt16
Ushort n1 = 1; ushort n2 = 102;
int : хранит целое число от -2147483648 до 2147483647 и занимает 4 байта. Представлен системным типом System.Int32 . Все целочисленные литералы по умолчанию представляют значения типа int:
Int a = 10; int b = 0b101; // бинарная форма b =5 int c = 0xFF; // шестнадцатеричная форма c = 255
uint : хранит целое число от 0 до 4294967295 и занимает 4 байта. Представлен системным типом System.UInt32
Uint a = 10; uint b = 0b101; uint c = 0xFF;
long : хранит целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт. Представлен системным типом System.Int64
Long a = -10; long b = 0b101; long c = 0xFF;
ulong : хранит целое число от 0 до 18 446 744 073 709 551 615 и занимает 8 байт. Представлен системным типом System.UInt64
Ulong a = 10; ulong b = 0b101; ulong c = 0xFF;
float : хранит число с плавающей точкой от -3.4*10 38 до 3.4*10 38 и занимает 4 байта. Представлен системным типом System.Single
double : хранит число с плавающей точкой от ±5.0*10 -324 до ±1.7*10 308 и занимает 8 байта. Представлен системным типом System.Double
decimal : хранит десятичное дробное число. Если употребляется без десятичной запятой, имеет значение от ±1.0*10 -28 до ±7.9228*10 28 , может хранить 28 знаков после запятой и занимает 16 байт. Представлен системным типом System.Decimal
char : хранит одиночный символ в кодировке Unicode и занимает 2 байта. Представлен системным типом System.Char . Этому типу соответствуют символьные литералы:
Char a = "A"; char b = "\x5A"; char c = "\u0420";
string : хранит набор символов Unicode. Представлен системным типом System.String . Этому типу соответствуют символьные литералы.
String hello = "Hello"; string word = "world";
object : может хранить значение любого типа данных и занимает 4 байта на 32-разрядной платформе и 8 байт на 64-разрядной платформе. Представлен системным типом System.Object , который является базовым для всех других типов и классов.NET.
Object a = 22; object b = 3.14; object c = "hello code";
Например, определим несколько переменных разных типов и выведем их значения на консоль:
Using System; namespace HelloApp { class Program { static void Main(string args) { string name = "Tom"; int age = 33; bool isEmployed = false; double weight = 78.65; Console.WriteLine($"Имя: {name}"); Console.WriteLine($"Возраст: {age}"); Console.WriteLine($"Вес: {weight}"); Console.WriteLine($"Работает: {isEmployed}"); } } }
Для вывода данных на консоль здесь применяется интерполяция: перед строкой ставится знак $ и после этого мы можем вводить в строку в фигурных скобках значения переменных. Консольный вывод программы:
Имя: Tom Возраст: 33 Вес: 78,65 Работает: False
Использование суффиксов
При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы рассматриваются как значения типа double . И чтобы указать, что дробное число представляет тип float или тип decimal , необходимо к литералу добавлять суффикс: F/f - для float и M/m - для decimal.
Подобным образом все целочисленные литералы рассматриваются как значения типа int . Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u , для типа long - суффикс L/l , а для типа ulong - суффикс UL/ul :
Uint a = 10U; long b = 20L; ulong c = 30UL;
Использование системных типов
Выше при перечислении всех базовых типов данных для каждого упоминался системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:
Int a = 4; System.Int32 b = 4;
Неявная типизация
Ранее мы явным образом указывали тип переменных, например, int x; . И компилятор при запуске уже знал, что x хранит целочисленное значение.
Однако мы можем использовать и модель неявной типизации:
Var hello = "Hell to World"; var c = 20; Console.WriteLine(c.GetType().ToString()); Console.WriteLine(hello.GetType().ToString());
Для неявной типизации вместо названия типа данных используется ключевое слово var . Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. В примере выше использовалось выражение Console.WriteLine(c.GetType().ToString()); , которое позволяет нам узнать выведенный тип переменной с. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int , то поэтому в итоге переменная c будет иметь тип int или System.Int32
Эти переменные подобны обычным, однако они имеют некоторые ограничения.
Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:
// этот код работает int a; a = 20; // этот код не работает var c; c= 20;
Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null:
// этот код не работает var c=null;
Так как значение null, то компилятор не сможет вывести тип данных.
double или decimal
Из выше перечисленного списка типов данных очевидно, что если мы хотим использовать в программе числа до 256, то для их хранения мы можем использоват переменные типа byte . При использовании больших значений мы можем взять тип short, int, long. То же самое для дробных чисел - для обычных дробных чисел можно взять тип float, для очень больших дробных чисел - тип double. Тип decimal здесь стоит особняком в том плане, что несмотря на большую разрядность по сравнению с типом double, тип double может хранить большее значение. Однако значение decimal может содержать до 28 знаков после запятой, тогда как значение типа double - 15-16 знаков после запятой.
Decimal чаще находит применение в финансовых вычислениях, тогда как double - в математических операциях. Общие различия между этими двумя типами можно выразить следующей таблицей.
Ответ:
- Целочисельные типы данных:
short int , unsigned short int , int , unsigned int , long , unsigned long .
- Типы данных с плавающей запятой (соответствуют вещественным типам):
float , double , long double .
- Символьный тип данных:
char (signed char ), unsigned char, wchar_t .
- Логический тип данных:
bool .
- Перечислимый тип данных (введен в Visual C++ ):
enum .
2. Какие особенности использования целочисленных типов данных?
В C++ основные целочисленные типы данных: short int , unsigned short int , int , unsigned int , long (long int ), unsigned long (unsigned long int ).
Эти типы данных представляют значения из множества целых чисел. Например:
2 -100 398Типы данных, которые начинаются из приставки unsigned , могут содержать только положительные числа.
Данные типа short int , unsigned short int занимают в два раза меньше места в памяти чем данные типа int , unsigned int .
Данные типа long , unsigned long занимают в два раза больше места в памяти чем данные типа int , unsigned int .
3. Как в программе описать переменную с именем x целого типа?
Ответ:
int x; // целое со знакомВ результате под переменную x будет выделено место в памяти размером 4 байта. Размер памяти, которая выделяется под переменную зависит от характеристик компьютера, типа операционной системы и настроек компилятора.
4. Как в переменную целого типа записать число 239?
Для этого используется оператор присваивания, который обозначается символом ‘= ‘.
Ответ 1. Внесение числа в переменную после ее описания.
int x; x = 239;Ответ 2. Внесение числа в переменную во время ее описания (начальная инициализация).
int x = 239;5. Какие особенности типов данных с плавающей запятой?
Типы данных с плавающей запятой разрешают представлять значения из множества вещественных чисел. Например:
8.35 -990.399 239.0.В C++ есть следующие базовые типы данных с плавающей запятой: float , double , long double .
Переменная типа double занимает в 2 раза больше места в памяти компьютера чем переменная типа float .
Так же переменная типа long double занимает в 2 раза больше места в памяти компьютера, чем переменная типа double .
6. Как описать переменную, которая принимает значение с плавающей запятой?
Пример описания переменных типа float , double , long double :
float f; double d; long double ld;7. Как в переменную с плавающей запятой записать числовые значения?
Пример внесения числовых данных в переменные типы с плавающей запятой:
float f = -9928.45; // начальная инициализация double d; long double ld; d = 0.445332; // оператор присваивания ld = 3892923898239.030903; // оператор присваивания8. Как перевести переменную типа float в тип int ?
Для этого используется операция приведения типов. В скобках нужно указать название типа к которому происходит приведение.
float a; int b; a = 8.457; b = (int ) a; // b = 8При использовании операций приведения типов, нужно учитывать ограничения, которые накладываются на типы, которые занимают меньше места в памяти компьютера.
Например, переменная типа short int может представлять меньший диапазон чисел, чем переменные типов float , double . В следующему листинге происходит переполнение значения в переменной типа short int :
short int i; float f; f = 3990099.8; i = (int )f; // i = -7597 - переполнение9. Как перевести переменную из типа int в тип double ?
Пример приведения с int в double :
int i; double d; i = 982; d = (double )i; // d = 982.010. Какие особенности использования данных типа char (символьных данных) в программе?
Данные типа char представляют символьное значение кода, введенного с клавиатуры. Код символа есть целое число.
Например, код символа ‘f’ равен значению 102 .
Фрагмент кода, в котором вычисляется код символа:
int code; char symbol; symbol = "f" ; code = (int )symbol; // code = 102Данные типа char есть теми же целыми числами. Данные типа char занимают в памяти компьютера 1 байт.
Соотношение «символ-код» размещается в таблице символов Windows. Символы с кодами от 0 до 127 – это зарезервированные символы BIOS. Они включают наиболее употребляемые символы, символы цифр, символы латинской азбуки. Эти символы изменить нельзя.
Символы с кодами от 128 до 255 – это региональные символы, которые привязанные к конкретной азбуке того компьютера на котором установленная операционная система Windows.
11. Какие особенности использования данных типа bool (логический тип)?
Переменные типа bool могут принимать только два значения:
true – истина,
false – ложь.
Эти переменные используются для проверки логических выражений. Числовое значение true равно 1 . Числовое значение false равно 0 .
Фрагмент кода, который определяет числовые значения true и false :
int result; bool b; result = (int )true ; // result = 1 b = false ; result = (int )b; // result = 0Фрагмент кода, который превращает типы int и float в bool :
int i; float f; bool b; i = 6; b = (bool )i; // b = True f = 0.0; b = (bool )f; // b = False12. Как определить размер памяти, который занимает переменная данного типа?
Для этого используется операция sizeof() .
Фрагмент кода, который определяет размер некоторых типов данных:
int d; d = sizeof (char ); // d = 1 d = sizeof (unsigned int ); // d = 4 d = sizeof (float ); // d = 4 d = sizeof (double ); // d = 813. Каким образом осуществляется инициализация переменных разных типов?
int d = 28; float z = (float )2.85; char c = "k" ; String ^s = "Hello!" ; double r = -8.559;14. Каким образом определить максимально допустимое (минимально допустимое) значение переменной определенного типа?
Чтобы определить максимально допустимое или минимально допустимое значение переменной некоторого типа в библиотеке .NET Framework используются свойства MaxValue и MinValue .
Примеры определения предельных значений переменных разных типов.
Для переменных типа int :
// тип int int i; long MaxInt; long MinInt; MaxInt = (long )i.MaxValue; // MaxInt = 2147483647 MinInt = (long )i.MinValue; // MinInt = -2147483648Для переменных типа short int :
// тип short int short int si; int MaxInt; int MinInt; MaxInt = (int )si.MaxValue; // MaxInt = 32767 MinInt = (int )si.MinValue; // MinInt = -32768Для переменных типа unsigned int :
// тип unsigned int unsigned int ui; unsigned int MaxInt; unsigned int MinInt; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0Для переменных типа float :
// тип float float f; float MaxF; float MinF; MaxF = f.MaxValue; // MaxF = 3.402823E+38 MinF = f.MinValue; // MinF = -3.402823E+38Для переменных типа double :
// тип double double d; double MaxD; double MinD; Max = d.MaxValue; // Max = 1.79769313486232E+308 Min = d.MinValue; // Min = -1.79769313486232E+308Для переменных типа char :
// тип char char c; int MaxC; int MinC; Max = (int )c.MaxValue; // Max = 127 Min = (int )c.MinValue; // Min = -12815. Какие особенности использования типа enum ?
Тип enum – это перечислительный тип данных. В нем задаются мнемонические значения для множеств целых значений. Каждое мнемоническое значение имеет определенное содержание и представляется целым числом.
Пример использования типа enum для обозначения месяцев года:
enum months { January, February, March, April, May, June, July, August, September, October, November, December } mn; mn = January; // mn = 0 mn = March; // mn = 2 mn = September; // mn = 8В приведенном примере описывается переменная с именем mn типа enum months . Мнемонические значения месяцев (January , February , …) начинаются с 0 (0 , 1 , 2 , …). Мнемоническому значению January соответствует целое значение 0 , мнемоническому значению February соответствует целое значение 1 , и т.д.
Итак, с помощью типа enum , в тексте программы можно использовать мнемонические обозначения для лучшей наглядности исходного кода.
Можно написать и так:
mn = (enum months)2; // mn = March mn = (enum months)11; // mn = December16. Какие особенности применения типа void в программах на C ++ ?
Тип данных void используется в следующих случаях:
- если нужно описать функцию, которая не возвращает никакого значения (см. пример);
- если нужно описать функцию, которая не получает параметров (см. пример).
Пример . Функция MyFun() без параметров, которая не возвращает никакого значения (возвращает тип void ) и не получает параметров.
public : void MyFun(void ) { // тело функции // ... return; // возврат из функции, которая не возвращает значения } // вызов функции из программы ... MyFun(); ...17. Можно ли объявлять переменную типа void в программе?
Нельзя, так как тип void не связан со значением.
Объявление переменной типа void приводит к ошибке компиляции с выводом сообщения:
"Illegal use of type void "18. Какие особенности применения типа wchar _ t в Visual C ++ ?
Переменные типа char (смотрите предыдущие пункты) используются для сохранения 8-разрядных ASCII -символов.
Тип wchar_t используется для сохранения символов, которые входят в состав больших символьных наборов. Например, в китайской азбуке есть огромное количество символов. 8 разрядов недостаточно, чтобы представить весь набор символов китайской азбуки. Поэтому, если нужно использовать программу на международном рынке, целесообразно заменить тип char на wchar_t .
Пример использования типа wchar_t .
... wchar_t t; // для переменной t выделяется 2 байта памяти t = "s"; ...В языке Си различают понятия “тип данных” и “модификатор типа”. Тип данных – это целый, а модификатор – со знаком или без знака. Целое со знаком будет иметь как положительные, так и отрицательные значения, а целое без знака – только положительные значения. В языке Си можно выделить пять базовых типов.
- char – символьный.
- int – целый.
- float – вещественный.
- double – вещественный двойной точности;
- void – не имеющий значения.
Переменная типа char имеет размер 1 байт, ее значениями являются различные символы из кодовой таблицы, например: ‘ф’, ‘:’, ‘j’ (при записи в программе они заключаются в одинарные кавычки).
Размер переменной типа int в стандарте языка Си не определен. В большинстве систем программирования размер переменной типа int соответствует размеру целого машинного слова. Например, в компиляторах для 16-разрядных процессоров переменная типа int имеет размер 2 байта. В этом случае знаковые значения этой переменной могут лежать в диапазоне от -32768 до 32767.
Ключевое слово float позволяет определить переменные вещественного типа. Их значения имеют дробную часть, отделяемую точкой, например: -5.6, 31.28 и т.п. Вещественные числа могут быть записаны также в форме с плавающей точкой, например: -1.09e+4. Число перед символом “е” называется мантиссой, а после “е” – порядком. Переменная типа float занимает в памяти 32 бита. Она может принимать значения в диапазоне от 3.4е-38 до 3.4e+38.
Ключевое слово double позволяет определить вещественную переменную двойной точности. Она занимает в памяти в два раза больше места, чем переменная типа float. Переменная типа double может принимать значения в диапазоне от 1.7e-308 до 1.7e+308.
Ключевое слово void используется для нейтрализации значения объекта, например, для объявления функции, не возвращающей никаких значений.
Типы переменных:
Программы оперируют с различными данными, которые могут быть простыми и структурированными. Простые данные – это целые и вещественные числа, символы и указатели (адреса объектов в памяти). Целые числа не имеют, а вещественные имеют дробную часть. Структурированные данные – это массивы и структуры; они будут рассмотрены ниже.
Переменная – это ячейка в памяти компьютера, которая имеет имя и хранит некоторое значение. Значение переменной может меняться во время выполнения программы. При записи в ячейку нового значения старое стирается.
Хорошим стилем является осмысленное именование переменных. Имя переменной может содержать от одного до 32 символов. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква. Имя переменной не может совпадать с зарезервированными словами.
Тип 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.
| Тип | Диапазон | Шестнадцатеричный диапазон | Размер |
| unsigned char | 0 … 255 | 0x00 … 0xFF | 8 bit |
| signed char
или просто char |
-128 … 127 | -0x80 … 0x7F | 8 bit |
| unsigned short int
или просто unsigned int или unsigned short |
0 … 65535 | 0x0000 … 0xFFFF | 16 bit |
| signed short int
или signed int
или просто short или int |
-32768 … 32767 | 0x8000 … 0x7FFF | 16 bit |
| unsigned long int
или просто unsigned long |
0 … 4294967295 | 0x00000000 … 0xFFFFFFFF | 32 bit |
| signed long
или просто long |
-2147483648 … 2147483647 | 0x80000000 … 0x7FFFFFFF | 32 bit |
| unsigned long long | 0 … 18446744073709551615 | 0x0000000000000000 … 0xFFFFFFFFFFFFFFFF | 64 bit |
| signed long long
или просто long long |
-9223372036854775808 … 9223372036854775807 | 0x8000000000000000 … 0x7FFFFFFFFFFFFFFF | 64 bit |
Объявление переменных
Переменные объявляют в операторе описания. Оператор описания состоит из спецификации типа и списка имён переменных, разделённых запятой. В конце обязательно должна стоять точка с запятой.
[модификаторы] спецификатор_типа идентификатор [, идентификатор] ...
Модификаторы – ключевые слова signed, unsigned, short, long.
Спецификатор типа – ключевое слово char или int, определяющее тип объявляемой переменной.
Идентификатор – имя переменной.
Char x; int a, b, c; unsigned long long y;
При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение.
Int x = 100;
В переменную x при объявлении сразу же будет записано число 100. Инициализируемые переменные лучше объявлять в отдельных строках.
В этом уроке вы узнаете алфавит языка C++ , а также какие типы данных может обрабатывает программа на нем. Возможно, это не самый увлекательный момент, но эти знания необходимы!Кроме того, начав изучать любой другой язык программирования, Вы с большей уверенностью пройдете аналогичную стадию обучения. Программа на языке C++ может содержать следующие символы:
- прописные, строчные латинские буквы A, B, C…, x, y, z и знак подчеркивания;
- арабские цифры от 0 до 9;
- специальные знаки: { } , | , () + - / % * . \ ‘ : ? < > = ! & # ~ ; ^
- символы пробела, табуляции и перехода на новую строку.
В тесте программы можно использовать комментарии . Если текст с двух символов «косая черта» // и заканчивается символом перехода на новую строку или заключен между символами /* и */, то компилятор его игнорирует.
Данные в языке C++
Для решения задачи в любой программе выполняется обработка каких-либо данных. Они могут быть различных типов: целые и вещественные числа, символы, строки, массивы. Данные в языке C++ принято описывать в начале функции. К основным типам данных языка относят:
Для формирования других типов данных используют основные и так называемые спецификаторы. В C++ определенны четыре спецификатора типов данных:
- short - короткий;
- long - длинный;
- signed - знаковый;
- unsigned - беззнаковый.
Целочисленный тип
Переменная типа int в памяти компьютера может занимать либо 2, либо 4 байта. Это зависит разрядности процессора. По умолчанию все целые типы считаются знаковыми, то есть спецификатор signed можно не указывать. Спецификатор unsigned позволяет представлять только положительные числа. Ниже представлены некоторые диапазоны значений целого типа
| Тип | Диапазон | Размер |
| int | -2147483648…2147483647 | 4 байта |
| unsigned int | 0…4294967295 | 4 байта |
| signed int | -2147483648…2147483647 | 4 байта |
| short int | -32768…32767 | 2 байта |
| long int | -2147483648…2147483647 | 4 байта |
| unsigned short int | 0…65535 | 2 байта |
Вещественный тип
Число с плавающей точкой представлено в форме mE +- p, где m - мантисса (целое или дробное число с десятичной точкой), p - порядок (целое число). Обычно величины типа float занимают 4 байта, а double 8 байт. Таблица диапазонов значений вещественного типа:
| float | 3,4E-38…3,4E+38 | 4 байта |
| double | 1,7E-308…1,7E+308 | 8 байт |
| long double | 3,4E-4932…3,4E+4932 | 8 байт |
Логический тип
Переменная типа bool может принимать только два значения true (истина) или fasle (ложь). Любоезначение, не равное нулю, интерпретируется как true. Значение false представлено в памяти как 0.
Тип void
Множество значений этого типа пусто. Он используется для определения функций, которые не возвращают значения, для указания пустого списка аргументов функции, как базовый тип для указателей и в операции приведения типов.
Преобразование типов данных
В C++ различают два вида преобразования типов данных: явное и неявное.
- Неявное преобразование происходит автоматически. Это выполняется во время сравнения, присваивания или вычисления выражения различных типов. Например, следующая программа выведет на консоль значение типа float.
#include "stdafx.h"
#include
#include "stdafx.h" #include using namespace std ; int main () int i = 5 ; float f = 10.12 ; cout << i / f ; system ("pause>>void" ) ; return 0 ; |
Наивысший приоритет получает тот тип, при котором информация теряется менее всего. Не стоит злоупотреблять неявным преобразованием типов, так как могут возникнуть разного рода непредвиденные ситуации.
- Явное преобразование в отличие от неявного осуществляется программистом. Существует несколько способов такого преобразования:
- Преобразование в стили C : (float ) a
- Преобразование в стили C++ : float ()
Также приведения типов может осуществляться при помощи следующих операций:
static_cast <> () const_cast <> () reinterpret_cast <> () dynamic_cast <> ()
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 ). Все они начинаются с обратного «слеша», а также обрамляются двойными кавычками.
|
Изображение |
Шестнадцатеричный код |
Наименование |
|
Звуковой сигнал бипера |
||
|
Возврат на шаг |
||
|
Перевод страницы (формата) |
||
|
Перевод строки |
||
|
Возврат каретки |
||
|
Горизонтальная табуляция |
||
|
Вертикальная табуляция |
||
Все данные в языке Си имеют свой тип. Переменные определенных типов занимают в памяти какое-то место, разное в зависимости от типа. В Си нет четкого закрепления количества памяти за определенными типами. Это отдано на реализацию конкретного компилятора под конкретную платформу. Например, переменная типа int в одном компиляторе может занимать в памяти 16 бит, в другом — 32 бита, в третьем — 8 бит. Все определяет конкретный компилятор. Правда, все стремятся к универсализации, и в основном в большинстве компиляторов тип int , например, занимает 2 байта, а тип char — один.
Я в последнее время немного затупил, не мог вспомнить, сколько байт занимает тип double в AVR-GCC . Обычно при программировании контроллеров работаешь с целочисленными типами, типа int и char , а к типам с плавающей точкой прибегаешь не часто, в связи с их ресурсоемкостью.
Поэтому, на будущее, оставлю себе здесь памятку с указанием размеров занимаемой памяти типами данных для компилятора AVR-GCC и диапазон изменения переменных этого типа.
Типы данных в языке Си для компилятора AVR-GCC
| Тип | Размер в байтах (битах) |
Интервал изменения |
|---|---|---|
| char | 1 (8) | -128 .. 127 |
| unsigned char | 1 (8) | 0 .. 255 |
| signed char | 1 (8) | -128 .. 127 |
| int | 2 (16) | -32768 .. 32767 |
| unsigned int | 2 (16) | 0 .. 65535 |
| signed int | 2 (16) | -32768 .. 32767 |
| short int | 2 (16) | -32768 .. 32767 |
| unsigned short int | 2 (16) | 0 .. 65535 |
| signed short int | 2 (16) | -32768 .. 32767 |
| long int | 4 (32) | -2147483648 .. 2147483647 |
| unsigned long int | 4 (32) | 0 .. 4294967295 |
| signed long int | 4 (32) | -2147483648 .. 2147483647 |
| float | 4 (32) | 3.4Е-38 .. 3.4Е+38 |
| double | 4 (32) | 3.4Е-38 .. 3.4Е+38 |
| long double | 10 (80) | 3.4Е-4932 .. 3.4Е+4932 |
Реализация типа double в AVR-GCC отступает от стандарта. По стандарту double занимает 64 бита. В AVR-GCC переменная этого типа занимает 32 бита, и соответственно, она эквивалентна переменной с типом float !
В дополнение к этому, в библиотеках AVR-GCC введено несколько производных от стандартных типов. Они описаны в файле stdint.h . Сделано это, наверно, для улучшения наглядности и уменьшения текста программ (ускорения их написания:)). Вот табличка соответствия:
Производные типы от стандартных в языке Си для компилятора AVR-GCC
| Производный тип | Стандартный тип |
|---|---|
| int8_t | signed char |
| uint8_t | unsigned char |
| int16_t | signed int |
| uint16_t | unsigned int |
| int32_t | signed long int |
| uint32_t | unsigned long int |
| int64_t | signed long long int |
| uint64_t | unsigned long long int |
Тип Void
В языке Си есть еще один тип — тип void . Void используется для указания, что функция не возвращает ничего в качестве результата, или не принимает на вход никаких параметров. Этот тип не применяется для объявления переменных, соответственно он не занимает места в памяти.