Базовые типы данных C++




Базовые типы данных C++ 


Содержание


Поиск на других ресурсах:

1. Какие базовые (основные) типы данных используются в языке C++?

Ответ:
  1. Целочисельные типы данных:
short int, unsigned short int, int, unsigned int, long, unsigned long, long long, unsigned long long
  1. Типы данных с плавающей запятой (соответствуют вещественным типам):
float, double, long double
  1. Символьный тип данных:
char (signed char), unsigned char, wchar_t
  1. Логический тип данных:
bool
  1. Перечислимый тип данных (введен в Visual C++):
enum


2. Какие особенности использования целочисленных типов данных?

В C++ определены следующие основные целочисленные типы данных:

short int
unsigned short int
int
unsigned int
long (long int)
unsigned long (unsigned long int)
long long
unsigned long long

Эти типы данных представляют значения из множества целых чисел. Например:

2
-100
398
23090230932

Типы данных, которые начинаются с приставки unsigned, могут содержать только положительные числа.

Данные типа short int, unsigned short int занимают в два раза меньше места в памяти чем данные типа int, unsigned int. В последних версиях компилятора данные типа short int занимают 2 байта.

В более ранних версиях компиляторов данные типа long, unsigned long занимают в 2 раза больше места в памяти, чем данные типа int, unsigned int. В последних версиях компиляторов данные типа int (unsigned int) занимают такое же место в оперативной памяти как и данные типа long (unsigned long).

Данные типа long long (unsigned long long) занимают в 2 раза больше места в памяти чем данные типа long (unsigned long).

Пример. В примере определяется размер данных целочисленного типа с помощью инструкции sizeof. Более подробно об операторе sizeof можно прочитать здесь.

#include <iostream>
using namespace std;

void main()
{
  // Размер в байтах различных целочисленных типов
  cout << "sizeof(short int) = " << sizeof(short int) << endl;
  cout << "sizeof(unsigned short int) = " << sizeof(unsigned short int) << endl;
  cout << "sizeof(int) = " << sizeof(int) << endl;
  cout << "sizeof(unsigned int) = " << sizeof(unsigned int) << endl;
  cout << "sizeof(long) = " << sizeof(long) << endl;
  cout << "sizeof(unsigned long) = " << sizeof(unsigned long) << endl;
  cout << "sizeof(long long) = " << sizeof(long long) << endl;
  cout << "sizeof(unsigned long long) = " << sizeof(unsigned long long) << endl;
}

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

sizeof(short int) = 2
sizeof(unsigned short int) = 2
sizeof(int) = 4
sizeof(unsigned int) = 4
sizeof(long) = 4
sizeof(unsigned long) = 4
sizeof(long long) = 8
sizeof(unsigned long long) = 8

Проанализировав результат, можно сделать вывод, что в ранних версиях компиляторов:

  • переменные типов short int и unsigned short int занимают 2 байта;
  • переменные типов int, unsigned int, long (long int), unsigned long (unsigned long int) занимают 4 байта;
  • переменные типов long long (unsigned long long) занимают 8 байт.


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.0


10. Какие особенности использования данных типа 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 = False


12. Как определить размер памяти, который занимает переменная данного типа?

Для этого используется операция sizeof().

Фрагмент кода, который определяет размер некоторых типов данных:

int d;
d = sizeof(char);         // d = 1
d = sizeof(unsigned int); // d = 4
d = sizeof(float);        // d = 4
d = sizeof(double);       // d = 8


13. Каким образом осуществляется инициализация переменных разных типов?

 

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 = -128


15. Какие особенности использования типа 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 = December


16. Какие особенности применения типа void в программах на C++? Указатель на void

Тип данных void используется в следующих случаях:

  • если нужно описать функцию, которая не возвращает никакого значения (см. пример 1);
  • если нужно описать функцию, которая не получает параметров (см. пример 1);
  • когда нужно объявить указатель на void, который может взаимодействовать с указателями на другие типы (смотрите пример 2). В данном случае указатель на void может быть приведен к типу указателя на любой другой тип (int*, float*, double* и т.д.).

Пример 1. Функция MyFun() без параметров, которая не возвращает никакого значения (возвращает тип void) и не получает параметров.

public: void MyFun(void)
{
   // тело функции

   // ...

   return; // возврат из функции, которая не возвращает значения
}

// вызов функции из программы
...
MyFun();
...

Пример 2. В примере демонстрируются некоторые особенности использования указателя на void.

#include <iostream>
using namespace std;

void main()
{
  // Объявить указатель на void
  void *pVoid;

  // Объявить указатели на другие типы
  int *pInt = new int;
  float *pFloat = new float;
  char *pChar = new char;
  double *pDouble = new double;

  // Заполнить значениями по указателям на другие типы
  *pInt = 25;
  *pFloat = (float)3.88;
  *pChar = '+';
  *pDouble = 17.25;

  // Присвоить указателю на void значения указателей на другие типы
  // - на указатель на тип float
  pVoid = pFloat; // указатель pVoid указывает на область пам'яти pFloat
  *(float*)pVoid = 85.77; // изменить значение *pFloat
  cout << "*pFloat = " << *pFloat << endl; // *pFloat = 85.77

  // - на указатель типа char*
  pVoid = pChar; 
  *(char*)pVoid = 'a';
  cout << "*pChar = " << *pChar << endl; // *pChar = a

  // -----------------------------------------------------------------
  // Использовать указатель на void для обмена значениями указателей на int
  int *p1 = new int; 
  int *p2 = new int;

  // заполнить значениями память, на которую указывают указатели p1, p2
  *p1 = 28;
  *p2 = 35;

  cout << "*p1 = " << *p1 << endl; // *p1 = 28
  cout << "*p2 = " << *p2 << endl; // *p2 = 35

  // обмен значениями указателей с помощью указателя на void
  pVoid = p1;
  p1 = p2;
  p2 = (int*)pVoid;

  cout << "*p1 = " << *p1 << endl; // *p1 = 35
  cout << "*p2 = " << *p2 << endl; // *p2 = 28 
}

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

*pFloat = 85.77
*pChar = a
*p1 = 28
*p2 = 35
*p1 = 35
*p2 = 28


17. Можно ли объявлять переменную типа void в программе?

Нельзя, так как тип void не связан со значением. Объявление переменной типа void приводит к ошибке компиляции с выводом сообщения:

"Illegal use of type void"

Однако можно объявить указатель на void.


18. Какие особенности применения типа wchar_t в Visual C++?

Переменные типа char (смотрите предыдущие пункты) используются для сохранения 8-разрядных ASCII-символов.

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

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

...

wchar_t t; // для переменной t выделяется 2 байта памяти

t = 's';

...


19. Какой объем памяти резервируется для описания одной переменной типа wchar_t?

Одна переменная типа wchar_t занимает в памяти компьютера 2 байта (16 бит). Диапазон целочисленных значений переменных типа wchar_t составляет от 0 до 65535.

20. Как определить, какое максимальное (минимальное) значение может содержать переменная целочисленного или символьного типа? Константы INT32_MIN, INT32_MAX и другие

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

Например, если переменная целого типа занимает 2 байта (16 бит), то диапазон допустимых значений может быть следующим:

  • для знаковых переменных: -32768 … 32767;
  • для беззнаковых переменных (с префиксом unsigned): 0 … 65535.

В C++ существуют средства для определения минимального и максимального значения, которое может принимать переменная целочисленного или символьного типа. В библиотеку C++ входит модуль <limits.h>, который содержит описание соответствующих констант. Эти константы можно использовать в программах при перехвате различных исключительных ситуаций, например, переполнение, выход за допустимые пределы индекса в массиве и т.д.

Например, чтобы сравнить значение переменной типа int на максимум, можно использовать константу INT32_MAX по следующему образцу

...
// Определение момента, когда происходит переполнение
int i = 0;
while (1)
{
  // увеличить счетчик
  i++;

  // некоторые операции
  // ...

  // сравнить на максимально-допустимое значение
  if (i == INT32_MAX)
  {
    cout << "Error. Overflow.";
    return;
  }
}
...

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

#include <iostream>
using namespace std;

void main()
{
  // Символьные типы данных - максимальные и минимальные значения
  cout << "SCHAR_MIN = " << SCHAR_MIN << endl; // char - минимальное значение
  cout << "SCHAR_MAX = " << SCHAR_MAX << endl; // char - максимальное значение
  cout << "USCHAR_MAX = " << UCHAR_MAX << endl; // unsigned char - максимум

  // Целочисленные типы данных - максимальные и минимальные значения
  cout << "SHRT_MIN = " << SHRT_MIN << endl; // short int - минимальное значение
  cout << "SHRT_MAX = " << SHRT_MAX << endl; // short int - максимальное значение
  cout << "USHRT_MAX = " << USHRT_MAX << endl; // unsigned short int - максимум
  cout << "INT16_MAX = " << INT16_MAX << endl; // int (16 разрядное) - минимум
  cout << "INT16_MIN = " << INT16_MIN << endl; // int (16 разрядное) - максимум 
  cout << "UINT16_MAX = " << UINT16_MAX << endl; // unsigned int - максимум 
  cout << "INT32_MIN = " << INT32_MIN << endl; // int (32-разрядное) - минимум
  cout << "INT32_MAX = " << INT32_MAX << endl; // int (32-разрядное) - максимум
  cout << "UINT32_MAX = " << UINT32_MAX << endl; // unsigned int - максимум
  cout << "LONG_MIN = " << LONG_MIN << endl; // long int - минимум
  cout << "LONG_MAX = " << LONG_MAX << endl; // long int - максимум
  cout << "ULONG_MAX = " << ULONG_MAX << endl; // unsigned long - максимум
  cout << "LLONG_MAX = " << LLONG_MAX << endl; // long long - максимум
  cout << "LLONG_MIN = " << LLONG_MIN << endl; // long long - минимум
  cout << "ULLONG_MAX = " << ULLONG_MAX << endl; // unsigned long long - максимум
}

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

SCHAR_MIN = -128
SCHAR_MAX = 127
USCHAR_MAX = 255
SHRT_MIN = -32768
SHRT_MAX = 32767
USHRT_MAX = 65535
INT16_MAX = 32767
INT16_MIN = -32768
UINT16_MAX = 65535
INT32_MIN = -2147483648
INT32_MAX = 2147483647
UINT32_MAX = 4294967295
LONG_MIN = -2147483648
LONG_MAX = 2147483647
ULONG_MAX = 4294967295
LLONG_MAX = 9223372036854775807
LLONG_MIN = -9223372036854775808
ULLONG_MAX = 18446744073709551615


Связанные темы