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

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

Типом называется размерность представления данных, которая создает объект, находящийся в оперативной памяти. Он может задавать не только размерность, но и диапазон действительных значений. Эти значение можно назвать свойствами объекта. Краткое обозначение Т.

Объект – это структурированные данные, соответствующие определённому типу, по которому была выделена память. Краткое обозначение О.

С помощью выражения формируется объект. Выражения бывают двух типов:

• указателем типа, который содержит адрес объекта в памяти, обозначается E;
• адресное выражение, ссылается на объект, на который указывает E, обозначается *E;

Понятие lvalue происходит от английского left value – значение в левой части. Обозначает адресное выражение ссылающееся на объект. т.е. E1 = E2 , где E1 – адресное выражение; E2 – выражение типа или его адреса .

Фундаментальные типы(встроенные типы) являются базовыми типами на которых строятся производные типы и типы определённые пользователем.

К фундаментальным типам относят:

• логические типы;
• символьные типы;
• целые типы;
• Типы с плавающей точкой;

К таким типам относится тип bool. Он может принимать только два значения TRUE или FALSE. Если применить интегральное продвижение значения типа bool будут иметь следующие значения:

• false равняется нулю;
• true равняется единицы;

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

#if !defined Bool_usertype
#define Bool_usertype 1

typedef Bool_type { False=0, True } Bool_t;

#endif /*Bool_usertype*/


char относиться к символьному типу. Используется для объявления символьных переменных, содержащих один символ. Может быть представлен с учетом знака, так и без него. Без учётом знака к типу прибавляется префикс unsigned. Таким образом, выражение будет иметь вид:

unsigned char value	Значение объекта value будет находится в диапазоне 0...65353
signed char value	Значение объекта value будет находится в диапазоне -127...128

К целым типам относятся: int, signed int, unsigned int.

Целые типы имеют три размерности: short int, int, long int, где имеют быть следующее тождества:

short int == short; long int == long;

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

Десятичное	0	1	2	4	8	16	32	64	256
Восьмеричное	00	01	02	04	010	020	040	0100	0400

Десятичное значение 255, что означает 8-мь единиц в байте может быть представлено в шестнадцатеричном виде как 0xff, а в восьмеричном виде как 377.

В некоторых старых учебниках авторы ссылаясь на стандарты C89 и С99 часто пишут, что размерность типа int составляет два байта. А на самом деле в ОС Linux он имеет 4 байта, потому что мы имеем дело с 32-х разрядной архитектурой процессора, которая определяет размерность типов данных. В 64-х разрядной архитектуре, соответственно, тип int может иметь будет размерность 8 байт, но это не факт о чем скажу ниже. А вот как раз на 16-ти разрядной архитектуре, часто используемая в контроллерах, этот тип будет иметь размерность в два байта. Поэтому, когда используем разные архитектуры с отличающийся друг от друга разрядностью обращаем внимание на то, какую размерность имеют типы данных.

В ОС Linux разрядность и диапазоны значений определены в заголовочном файле >limits.h< системной библиотеки, и если мы посмотрим, то что определено в этом файле касательно int увидим следующее

/* Minimum and maximum values a `signed int' can hold. */
# define INT_MIN (-INT_MAX - 1)
# define INT_MAX 2147483647

/* Maximum value an `unsigned int' can hold. (Minimum is 0.) */
# define UINT_MAX 4294967295U



Тип с плавающей точкой представляющий числа с плавающей точкой может быть представлено тремя типами:

Тип	Тип вещественного значения	Размерность(в байтах)	Допустимый диапазон
float	одинарной точностью	4	3.4E Являются производной от фундаментальных типов, описанные нами ранее . К производным типам относиться: Являются производной от фундаментальных типов, описанные нами ранее . К производным типам относиться: +/- 38 (7 разрядов)
double	двойной точностью	8	1.7E +/- 308 (15 разрядов)
long double	расширенной точностью	8	3.4e-/+4932 (31 разряд)

5.5.2 Литерал

5.6 Размерность арифметических типов

5.7. Интегральное продвижение типов

5.8. Преобразование знаковое в без знаковое

6. Тип void

7. Производные типы

7.2 Массивы данного типа

7.2.2 Многомерные массивы

7.2.3 Инициализация

7.2.3.1 Для одномерных массивов

Пусть имеется массив T O[size], где T = int, а size = 8, array – имя объекта O:

int array [8] = { 1,2,3,4 };


Первым четырем элементам будет присвоены значения: 1,2,3,4 – а последующим четырем элементам значение нуль. Это обнуление производится всегда для не про инициализированных элементов одномерного массива.

Пусть имеется массив T O[m][size], где T= int, а m = 2, size = 8, array – имя объекта O:

int array [2][8] = { {1,2,3,4} };



Первый массив объектов array[0], состоящий из 8-ми однородных объектов типа int будет про инициализирован, как это было бы сделано для однородного массива, который рассматривался ранее.

Второй массив объектов array[1] состоящий из 8-ми однородных объектов типа int будет про инициализирован нулями. Хотя была бы правильнее такая запись

int array [2][8] = { {1,2,3,4},{ 0 } }; /br>

7.2.3.3 Инициализация пустого массива разных типов

int empties [8] = { 0 }; unsigned int empties [8] = { 0u }; long int empties [8] = { 0L }; float empties [8] = { 0f }; double empties [8] = { 0.0 }; long double empties [8] = { 0.0L };

7.2.4 Размер массива

7.3 Указатели

Для присвоение адреса объекта другого типа, отличного от указателя, рекомендуется пользоваться преобразованием типа:

T0 O;

T1* p= (T1*)&O;

Для двойного указателя T** присвоение адреса одинарного указателя производится по тому же правилу, как адрес объекта одинарному указателю.

T0* op;

T0** dp = &op;

7.2 Операции с указателями

Существуют три основных операторов:

• &' - присвоения адреса;
• '*' - разыменовывания;
• '=' - присвоения.

Оператор '*' называется оператором разыменования. Он производит получение значения по адресу на который ссылается указатель T*. Оператор разыменования является унарным(префиксным).

T* p;

T O = *p;

Для равнозначных типов существует оператор присвоение '=':

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

Пример. Инициализации строкового литерала( lvalue имеет тип int*).

     . . .
void f()
{
int* chs = «It's first my of string literal»;
cout <<__FUNSTION__<<'':''< }
     . . .


Создание такого lvalue с типом 'int*' является ошибкой, потому что для строкового литерала тип lvalue должен быть const char*.

Сообщение компилятора:

__FILE__:__LINE__: error: cannot convert ‘const char*’ to ‘int*’ in initialization

Объяснение:

При инициализации невозможно преобразовать тип const char* к int*

Код:

см. пример ниже «Инициализации строкового литерал»

Объявляем lvalue, как требует от нас следующее правило: lvalue строкового литерала должен быть всегда тип const char*.

Пример. Инициализации строкового литерал lvalue имеет тип const char*.

При вызове функции f() на стандартное устройство ввода/вывода будет выведено:

f:it's 1st my of characters literal

lvalue является указателем типа 'const char*' на постоянный объект, в данном случае на однородный массив объектов типа 'const char' (константы и указатели будут рассмотрены в ПП 4.3 «Указатели» настоящего документа). Поэтому выше сказанное, что lvalue должен быть указатель типа 'const char*' не со всем верно. Можно использовать указатель 'char*'. (см. пример ''Использование в качестве возвращаемое значения функции'');

Размер массива будет (n-1) * 1 байт, т.к. n-1 символом является невидимый символ 'конца строки', которым эквивалентен символьному литерал '\0'.

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

Пример. Использование в качестве возвращаемое значения функции

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

где m – размерность массива, а n – размерность литерала. Для того, чтобы не задумываться сколько должено быть выделено памяти под однородный массив для инициализации его литералом, можно использовать неопределённый массив. В этом случае, всю головную боль за Вас возьмёт компилятор.

Пример. Инициализация однородного массива с помощью литерала.

При вызове функции f(), на стандартное устройство ввода/ввода будет выведено все та же строчка, что и в примере «Инициализации строкового литерал(где lvalue имеет тип 'const char*' ):

f:it's 1st my of characters literal

Пример. Модификация однородного массива, инициализируемого строковым литералом.

При вызове функции f() на стандартное устройство ввода/ввода вместо строки '' It's a string's literal'' будет выведено:

f:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

T M[24];

Массив M – является адресом на первый элемент массива, состоящего из 24-х элементов типа T.

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

Результат выполнения функции f():

array's address 0xbf8bdfd8
first element address 0xbf8bdfd8

Для вывода адреса в этом примере используется форматирование потока вывода объекта cout. Он управляет выводом на буфер потока, который ассоциируются с объектом stdout(Стандартное устройство вывода), декларируемое в <cstdio>. По умолчанию, потоки стандартов C и C++ являются синхронизируемыми.

При операции присвоения (=) происходит назначение адреса массива указателю. Допустим имеется массив из 14-ти символов, который при создании будет инициализирован.

Операция присвоение адреса указателю можно так же назвать операцией преобразования типов, потому что тип T[] преобразуется к T*.

Следующий пример иллюстрирует как тип T[] преобразуется к T*.

Результат выполнения функции f():

Characters message(array type):Hello world!
Characters message(pointer type):Hello world!

Вывод адреса указателя, массива на стандартное устройства ввода/вывода производится cout из стандартной библиотеки C++.

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

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

Characters message(array type):Hello world!
Characters message(pointer type):0xbfbc7307

В четвертой строке определения функции f() производится явное преобразование типа char[] к unsigned long int*, который определен как пользовательский тип paddr_t в начале примера.

Индексация или доступ к элементам массива осуществляется оператором []. Следующий пример иллюстрирует использование этого оператора:

В результате выполнения функции f() будет выведен каждый элемент массива.

0's element: H
1's element: e
2's element: l
3's element: l
4's element: o
5's element:
6's element: w
7's element: o
8's element: r
9's element: l
10's element: d
11's element: !

void f() {
      typedef unsigned long int* paddr_t;
      char hello[] = "Hello world!";
      char* ptr = hello;
      char* first = hello;

      cout.setf(std::ios_base::dec,std::ios_base::basefield);

      while ( *ptr ) {
         cout << ptr - first << "\'s element:" << *ptr << endl;
         ptr++;
      }
}


void f(){
   const char* hello = ''Неllo world!'';
   *hello = 'c';
}


void f() {
    const char* p1 = "pppp", p3;
    const char* const p2 = p1;
    p3 = p2;
}


void f() {
    long int p = 123;
    int & s = p;
}


Временная переменная существует до конца области видимости, где она была объявлена.

T t = T(n);

где t – временная переменная, n – значение такой переменной.

Для ссылок будут верными следующие выражения:

T t = T(n);
const T& s = t;

При использовании такого инициализатора создается временная переменная с присвоением значения n, которое используется как инициализатор.

В отличии от lvalue, временная переменная может иметь тип большей размерности чем ссылка. И обратно, может иметь тип меньшей размерности. А при использовании типов не равной размерности происходит явное преобразование типов.

Cпецификатор typedef не создает новых типов в памяти, а присваивает идентификатор синтаксически эквивалентный ключевому слову спецификатора типа T. Поэтому, при использование данного спецификатора нельзя говорить о создание новых типов, а лишь о возможности присваивания им синонимов (P_t) существующим типам используемого стандарта C/C++.

typedef  T  P_t;

Возможность создания P_t от типа T используется различными библиотеками системного и прикладного программного обеспечения для задания базового набора, применяемых типов используемого стандарта C/C++. Одним из таких примеров является библиотека Gtk+, являющейся мультиплатформенным инструментарием для создания графических пользовательских интерфейсов. В ней задается базовый набор типов языка Си, призванный облегчить программисту жизнь при их использовании и дальнейшей портируемости.

1. Const Correctness in C++
2. ISBN 5-7989-0223-4, 5-7940-0064-3, 0-201-70073-5 Бьерн Страуструп. Язык прораммирования С++. Специальное издание 3-е издание.
3. The typeid operator (C++ only)
4. Data Type Ranges
5. Преобразование 32-биного приложения в 64-битное: что нужно учитывать
6. Беззнаковая арифметика
7. Объявление typedef