Типы C ++

Сущность C ++ - это значение, объект, ссылка, функция, перечислитель, тип, член класса, битовое поле, структурированная привязка, пространство имен, шаблон, специализация шаблона или пакет параметров. Сущность может быть одного или нескольких типов. Существует две категории типов C ++: фундаментальные и составные типы. Скаляр - это арифметический или объектный тип указателя. Фундаментальные типы - это скаляры, а остальные типы сущностей - составные.

Память компьютера - это серия ячеек. Каждая ячейка имеет размер один байт, обычно это пространство, занимаемое западноевропейским символом. Размер объекта указывается в байтах. В этой статье дается обзор типов C ++. У вас уже должны быть базовые знания C ++, чтобы понять эту статью.

Содержание статьи

- Основные типы
- Способы построения составных типов
- Массивы
- Перечисление
- Класс
- Союз
- Рекомендации
- Функции
- Другие типы соединений
- Заключение

Основные типы

Основные типы - это скалярные типы.

bool

Логический или логический тип имеет значение true или false для 1 или 0. Истина или ложь занимает один байт.

char, unsigned char и signed char

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

Целое число

Существует пять стандартных целочисленных типов без знака и пять стандартных целочисленных типов со знаком. Пятью беззнаковыми целочисленными типами являются: unsigned char, unsigned short int, unsigned int, unsigned long int и unsigned long long int. Пять соответствующих целочисленных типов со знаком: «signed char», «short int», «int», «long int» и «long long int».

«Unsigned char» - тот же тип, что и узкие символьные типы (см. Выше). «Signed char» - другой тип узких символьных типов (см. Выше).

В компиляторе g ++ «unsigned char» или «signed char» занимает один байт; «Unsigned short int» или «short int» занимает два байта; «Unsigned int» или «int» занимает четыре байта; «Unsigned long int» или «long int» занимает 8 байтов; «Unsigned long long int» или «long long int» по-прежнему занимает 8 байтов (на данный момент).

char16_t, char32_t, wchar_t

При работе с западноевропейскими символами типа char достаточно во многих ситуациях. Однако при работе с китайским и другими восточными языками необходимы char16_t, char32_t или wchar_t. В компиляторе g ++ char16_t занимает два байта; char32_t занимает четыре байта, а wchar_t также занимает четыре байта.

Целочисленные типы bool, char, char16_t, char32_t, wchar_t, signed и unsigned образуют другой набор, называемый целочисленными (целочисленными) типами.

На этом этапе статьи были упомянуты два коллективных типа: узкие символьные типы и интегральные типы.

Типы с плавающей запятой

Предположим, что числа 457000 и 457230 - это одно и то же значение, измеренное двумя разными измерительными приборами. 457230 точнее, чем 457000, потому что значение более детализировано (включает меньшие места: + 200 плюс 30). Число с плавающей запятой - это число с дробной (десятичной) частью. Хотя числа в компьютере представляют собой последовательность битов, некоторые числа с плавающей запятой более точны, чем другие.

Некоторые измерительные приборы проводят измерения с минимальным шагом, скажем, 10 единиц. Такой инструмент будет иметь следующие показания: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 и т. Д. Хотя числа в компьютере представляют собой последовательность битов, числа с плавающей запятой варьируются с некоторыми минимальными шагами (намного меньше, чем 10 единиц).

В C ++ есть три типа с плавающей запятой: float, double и long double. Для любого компилятора точность double должна быть выше, чем у float или, по крайней мере, у float; long double должен иметь точность выше, чем double, или, по крайней мере, точность double.

Есть третье собирательное название: арифметический тип. Это имя для целочисленных типов и типов с плавающей запятой. Обратите внимание, что это также имя для всех скалярных типов, как объяснялось до сих пор.

В компиляторе g ++ количество байтов для числа с плавающей запятой равно четырем; количество байтов для дубля - восемь; количество байтов для длинного дубля - шестнадцать.

void Тип

В компиляторе g ++ размер типа void составляет один байт. Байт официально не имеет битов, что означает, что его местоположение имеет пустое содержимое.

Способы построения составных типов

Составные типы не являются фундаментальными типами. Это означает, что составные типы не являются скалярными типами. В этом разделе объясняются основы составных типов.

Массивы

Следующий сегмент кода показывает массив целых чисел и массив символов:

int arrInt [] = 1, 2, 3, 4, 5;
char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <Результат: 3 c.

Перечисление

Перечисление - это тип с именованными константами. Рассмотрим следующий фрагмент кода:

перечисление a = 3, b, c;
cout << b <<'\n';

Результат: 4. Первая строка сегмента кода - это перечисление, а a, b или c - перечислитель.

Класс

Класс - это обобщенная единица, из которой могут быть созданы (созданы экземпляры) многие объекты одной и той же обобщенной единицы. Следующая программа показывает класс и два объекта, созданные из него. Такой объект отличается от скалярного объекта.

#включать
используя пространство имен std;
класс TheCla

общественность:
int num = 5;
int fn ()

return num;

;
int main ()

TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
возврат 0;

Результат: 5 5. Имя класса - TheCla, а имена двух объектов - obj1 и obj2. Обратите внимание на точку с запятой сразу после описания (определения) класса. Обратите внимание, как два объекта были созданы в функции main ().

Примечание: num - это член данных, а fn - это функция-член.

Союз

структура

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

#включать
используя пространство имен std;
struct TheCla

int num = 5;
float flt = 2.3;
char ch = 'а';
obj1, obj2;
int main ()

cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
возврат 0;

Результат:

5, 2.3, а

Имя структуры - TheCla. obj1 и obj2 - два разных объекта структуры.

Союз

Следующая программа показывает объединение и его использование:

#включать
используя пространство имен std;
союз TheCla

int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()

cout << obj2.flt <<'\n';
возврат 0;

Результат: 2.3. Объединение похоже на структуру. Основное различие между структурой и объединением состоит в том, что для структуры только один член может иметь значение (инициализированное) в любой момент времени. В приведенной выше программе член flt имеет значение 2.3. Каждый из других членов, num или ch, может иметь значение next только в том случае, если значение для flt оставлено.

Функции

Базовая функция и ее вызов

В следующем коде показано определение базовой функции и ее вызов:

#включать
используя пространство имен std;
int fn (целое число)

cout<<"seen"<<'\n';
return num;

int main ()

int ret = fn (5);
cout << ret <<'\n';
возврат 0;

На выходе

определение функции

Вызов функции - fn (5). Имя функции - fn.

Ссылка и указатель на функцию

& fn возвращает адрес в памяти функции с именем fn. Следующий оператор объявляет указатель на функцию:

int (* функция) ();

Здесь func - это имя указателя на функцию. Первая пара круглых скобок отличает указатель на функцию от указателя на скалярный объект. func можно сделать так, чтобы он содержал адрес функции, идентифицируемой fn, следующим образом:

func = &fn;

Следующая программа приводит в действие ссылку на функцию и указатель:

#включать
используя пространство имен std;
int fn (целое число)

/ * некоторые утверждения * /
return num;

int main ()

интервал (* функция) (интервал);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
возврат 0;

Результат: 5. Обратите внимание, что и fn, и func имеют параметр int в объявлении.

Другие типы соединений

Вышеуказанные основные типы соединений сами по себе являются составными. Они также используются для создания сложных составных типов.

typedef

Зарезервированное слово typedef используется для замены последовательности типов одним именем (для последовательности). Следующий фрагмент кода иллюстрирует это:

typedef unsigned long int IduIL;

IduIL myInt = 555555555555555555;
cout << myInt <<'\n';

На выходе получается 555555555555555555. В коде IduIL стал типом, который означает «unsigned long int».

Структурированная привязка

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

int arr [3] = 1, 2, 3;
авто [x, y, z] (обр);
cout << x <<"<< y <<"<< z <<'\n';

Выход 1 2 3. Итак, значениям: 1, 2, 3 присвоены имена, x, y, z. Обратите внимание на использование и положение зарезервированного слова, авто. Также обратите внимание на использование квадратных скобок.

Битовое поле

Память - это последовательность ячеек. Каждая ячейка занимает байт. Также каждый байт состоит из восьми битов. Группа битов, не обязательно восемь битов, может быть установлена и изменена. Такая группа называется битовым полем. Эти группы будут лежать рядом друг с другом. Если группы не будут составлять тип, скажем, 16 бит для короткого int, добавляются биты заполнения. Следующий код иллюстрирует это с помощью структуры:

структура Дата

беззнаковый короткий wkDay: 3; // 3 бита
беззнаковый короткий понедельник: 6; // 6 бит
беззнаковый короткий пн: 5; // 5 бит
беззнаковый короткий год: 8; // 8 бит для 2-значного года
dte;
dte.wkDay = 1; dte.monDay = 2; dte.пн = 2; dte.год = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

Результат: 2/2/21. Общее количество бит для wkDay, MonDay и mon равно 3 + 6 + 5 = 14. Таким образом, два бита заполнения будут добавлены, чтобы составить 16 бит для короткого целого числа в 2 байта (16 бит). Следующие 8 бит начинают следующий короткий int, который затем заполняется 8 битами заполнения.

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

Пространство имен

Пространство имен - это набор имен, который не должен конфликтовать с такими же именами других наборов имен. Следующая программа иллюстрирует использование одних и тех же имен из двух разных пространств имен, примененных в пространстве имен функции main ():

#включать
используя пространство имен std;
пространство имен NS1

int myInt = 8;
float flt;

пространство имен NS2

int myInt = 9;
float flt;

int main ()

cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1 :: flt = 2.5;
NS2 :: flt = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
возврат 0;

Результат:

2.5

4.8

В коде есть два конфликтующих одинаковых имени int и два конфликтующих одинаковых имени float.

Шаблон и специализация шаблонов

Схема шаблона позволяет использовать заполнитель для различных возможных скалярных типов. Специализация - это выбор определенного скалярного типа. Следующий код иллюстрирует это для функции:

#включать
используя пространство имен std;
шаблон void func (T cha, U no)

cout << "I need bread for " << cha << no << '.' << '\n';

int main ()

func ('$', 3);
возврат 0;

Результат:

«Мне нужен хлеб за 3 доллара.”

Пакет параметров шаблона

Компиляторы еще не полностью реализовали эту функцию - см. Позже.

Заключение

Типы C ++ существуют в двух категориях: фундаментальные типы и составные типы. Основные типы - это скалярные типы. Основные составные типы - это массивы, перечисления, классы, объединения, ссылки, указатели и функции. Эти базовые составные типы используются для создания сложных составных типов, которые являются typedef, структурированными привязками, битовыми полями, пространством имен и функциями шаблона.

Chrys