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

Лучшие IDE для C и C++ Программирование и разработка

Лучшие IDE для C и C++

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

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

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

Фундаментальные типы — это скалярные типы.

bool

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

char, unsigned char и signed char

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

Integer

Существует пять стандартных целочисленных типов без знака и пять стандартных целочисленных типов со знаком. Пятью беззнаковыми целочисленными типами являются: 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 образуют другой набор, называемый целочисленными (целочисленными) типами.

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

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

Предположим, что числа 457 000 и 457 230 — это одно и то же значение, измеренное двумя разными измерительными приборами. 457 230 является более точным, чем 457 000, потому что значение более детализировано (включает меньшие места: + 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 Type

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

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

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

Читайте также:  Процесс разработки мобильных приложений

Массивы

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

     int arrInt[] = {1, 2, 3, 4, 5};
char arrCha[] = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’};

cout << arrInt[2] <<‘ ‘ <<arrCha[2] <<\n

Результат: 3 c.

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

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

enum {a=3, b, c};
cout << b <<\n;

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

Класс

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

#include
using namespace std;

class TheCla
{
public:
int num = 5;
int fn()
{
return num;
}
};

int main()
{
TheCla obj1;
TheCla obj2;

cout << obj1.num << ‘ ‘ << obj2.num <<\n;

return ;
}

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

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

Union

struct

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

#include
using namespace std;

struct TheCla
{
int num = 5;
float flt = 2.3;
char ch = ‘a’;
} obj1, obj2;

int main()
{
cout << obj2.num <<«, «<< obj2.flt <<«, «<< obj2.ch <<\n;

return ;
}

Результат:

5, 2.3, а

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

Union

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

#include
using namespace std;

union TheCla
{
int num;
float flt = 2.3;
char ch;
} obj1, obj2;

int main()
{
cout << obj2.flt <<\n;

return ;
}

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

References

Ссылка — это синоним идентификатора. Следующий фрагмент кода показывает, как получить ссылку на идентификатор:

int id = 5;
int& ref1 = id;
int& ref2 = id;
cout << id << ‘ ‘ << ref1 << ‘ ‘ << ref2 <<\n;

Результат: 5 5 5. ref1 и ref2 — синонимы идентификатора.

Ссылка lvalue и ссылка rvalue

Вышеупомянутые ссылки являются ссылками на lvalue. Следующий код показывает ссылку на rvalue:

int&& ref = 5;
cout << ref <<\n;

Результатом будет: 5. Эта ссылка создается без указания места в памяти. Для этого необходим двойной &, т. Е. &&.

Pointer

Указатель на самом деле не является сущностью C ++. Однако он обеспечивает лучшую схему работы со ссылками. Следующий код показывает, как можно создать указатель:

int ptdId = 5;
int ptdId = 5;
int *ptrId;
ptrId = &ptdId;

cout << *ptrId <<\n;

Результат: 5. Обратите внимание на разницу в именах между ptdId и ptdId. ptdId — это заостренный объект, а ptrId — это объект-указатель. & ptdId возвращает адрес указанного объекта, который назначен ptrId. Чтобы вернуть значение указанного объекта, используйте * ptrId.

Functions

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

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

#include
using namespace std;

int fn(int num)
{
cout<<«seen»<<\n;
return num;
}

int main()
{
int ret = fn(5);

cout << ret <<\n;

return ;
}

На выходе определение функции 5.

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

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

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

int (*func)();

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

func = &fn;

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

#include
using namespace std;

int fn(int num)
{
/* some statements */
return num;
}

int main()
{
int (*func)(int);
func = &fn;
int ret = func(5);

cout << ret <<\n;

return ;
}

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

Читайте также:  Java Networking (сеть)

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

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

typedef

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

typedef unsigned long int IduIL;

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

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

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

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

int arr[3] = {1, 2, 3};
auto [x, y, z](arr);
cout << x <<‘ ‘<< y <<‘ ‘<< z <<\n;

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

Битовое поле

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

struct Date
{
unsigned short wkDay : 3;   //3 bits
unsigned short monDay : 6;   //6 bits
unsigned short mon : 5;    //5 bits
unsigned short yr : 8;    //8 bits for 2 digit year
} dte;

dte.wkDay = 1; dte.monDay = 2; dte.mon = 2; dte.yr = 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 ():

#include
using namespace std;

namespace NS1
{
int myInt = 8;
float flt;
}

namespace 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;

return ;
}

Результат:

  • 9
  • 8
  • 2,5
  • 4.8

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

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

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

#include
using namespace std;

template void func (T cha, U no)
{
cout << «I need bread for « << cha << no << ‘.’ << \n;
}

int main()
{
func(‘$’, 3);

return ;
}

Результат:

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

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

Заключение

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

Оцените статью
bestprogrammer.ru
Добавить комментарий