Типы данных С++

// ошибки компиляции: значения слева  не являются l-значениями

// ошибка: литерал - не l-значение

0 = 1;

// ошибка: арифметическое  выражение - не l-значение

salary + salary * 0.10 = new_salary;

     Оператор  определения переменной выделяет для неё память. Поскольку объект имеет только одну ассоциированную с ним область памяти, такой оператор может встретиться в программе только один раз. Если же переменная, определённая в одном исходном файле, должна быть использована в другом, появляются проблемы⁴. К примеру:

// файл module0.C

// определяет объект fileName

string fileName;

//присвоить_fileName_значение 
//_файл_module1.C 
//_использует_объект_fileName 
//_не_компилируется: 
// fileName не определен в module1.C 
ifstream input_file( fileName );

     С++ требует, чтобы объект был известен до первого обращения к нему. Это  вызвано необходимостью гарантировать правильность использования объекта в соответствии с его типом. В данном примере модуль module1.C вызовет ошибку компиляции, так как переменная fileName не определена в нём. Чтобы избежать этой ошибки, мы должны сообщить компилятору об уже определённой переменной fileName. Это делается с помощью инструкции объявления переменной:

// файл module1.C

// использует объект fileName

// fileName объявляется, то  есть программа  получает 
// информацию об этом объекте без вторичного его определения 
extern string fileName;

ifstream input_file( fileName )

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

     Имя переменной, или идентификатор, может состоять из латинских букв, цифр и символа подчеркивания⁵. Прописные и строчные буквы в именах различаются. Язык С++ не ограничивает длину идентификатора, но пользование слишком длинными именами типа gosh_this_is_an_impossibly_name_to_type может оказаться крайне неудобным. 
Некоторые слова являются ключевыми в С++ и они не могут быть использованы в качестве идентификаторов.

Таблица 1. Список ключевых слов С++.

1.3 Указатели.

     Указатель – это объект, содержащий адрес другого объекта и позволяющий косвенно манипулировать этим объектом⁶. Обычно, указатели используются для работы с динамически созданными объектами, для построения связанных структур данных, таких, как связанные списки и иерархические деревья. И для передачи в функции больших объектов – массивов и объектов классов в качестве параметров. 
Каждый указатель ассоциируется с некоторым типом данных, причем их внутреннее представление не зависит от внутреннего типа, и размер памяти, занимаемый объектом типа указатель, и диапазон значений у них одинаков. Разница состоит в том, как компилятор воспринимает адресуемый объект. Указатели на разные типы могут иметь одно и то же значение, но область памяти, в которой размещаются соответствующие типы, может быть различной:

• указатель на int, содержащий значение адреса 1000, направлен на область памяти 1000-1003 (в 32-битной системе);
• указатель на double, содержащий значение адреса 1000, направлен на область памяти 1000-1007 (в 32-битной системе).

К примеру:

int              *ip1, *ip2;

complex<double>  *cp;

string           *pstring;

vector<int>      *pvec;

double           *dp;

      Указатель обозначается звёздочкой перед именем. В определении переменных списком, звёздочка должна стоять перед каждым указателем⁷.

long *lp, lp2;

В этом примере lp – указатель на объект типа long, а lp2 – объект типа long.

     Оператор  разыменования (*) может отделяться пробелами от имени и даже непосредственно  примыкать к ключевому слову типа. Поэтому приведенные определения синтаксически правильны и абсолютно эквивалентны:

string *ls;

string* ls;

     Указателю не может быть присвоена величина, которая не является адресом.

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

Указатели могут быть использованы в арифметических выражениях:

int i, j, k;

int *mi = &i;

// i = i + 2 
*mi = *mi + 2;

// увеличение адреса, содержащегося в mi, на 2 
mi =mpi + 2;

     К указателю можно прибавлять целое значение, или можно также вычитать из него. Прибавление к указателю 1 увеличивает содержащееся в нем значение на размер области памяти, которая отводится объекту соответствующего типа. К примеру если тип char занимает 1 байт, int – 4 и double – 8, то прибавление 2 к указателям на char, int и double увеличит их значение соответственно на 2, 8 и 16⁸.

1.4 Строковые типы.

     В С++ поддерживаются два типа строк  – встроенный тип, который достался от С, и класс string из стандартной библиотеки С++. Класс string предоставляет гораздо больше возможностей и поэтому он более удобен в применении, однако на практике нередки ситуации, когда необходимо пользоваться встроенным типом или хорошо понимать, как он устроен.

Класс string стандартной библиотеки С++ реализует операции:

• инициализация массивом символов  или другим объектом типа string.
• копирование одной строки в другую.
• доступ к отдельным символам строки для чтения и записи.
• сравнение двух строк на равенство.
• конкатенация двух строк, получая результат либо как третью строку, либо вместо одной из исходных.
• вычисление длины строки.
• возможность узнать, пуста ли строка.

Для того чтобы использовать объекты класса string, необходимо включить соответствующий  заголовочный файл:

#include <string>

     Длину строки возвращает функция-член size() (длина не включает завершающий нулевой символ).

cout << "Длина "

     << sm

     << ": " << sm.size()

     << " всего символов, включая символ новой строки\n";

     2. Классы.

     Механизм классов  в C++ позволяет пользователям определять собственные типы данных⁹. По этой причине их часто называют пользовательскими типами. Класс может наделять дополнительной функциональностью уже существующий тип. С помощью классов можно создавать абсолютно новые типы, например Screen (экран) или Account (расчетный счет). Как правило, классы используются для абстракций, не отражаемых встроенными типами адекватно.

2.1 Определение класса.

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

class Screen { /* ... */ };

class Screen { /* ... */ } myScreen, yourScreen;

     Внутри  тела объявляются данные-члены и функции-члены и также указываются уровни доступа к ним. Таким образом, тело класса определяет список его членов.

Каждое  определение вводит новый тип  данных. Даже если два класса имеют  одинаковые списки членов, они все  равно считаются разными типами:

class First {

      int meha;

      double mend;

      };

class Second {

   int meha;

   double mend;

      };

class First obj1;

Second obj2 = obj1;   // ошибка: obj1 и obj2 имеют разные типы

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

После того как тип класса определён, на него можно ссылаться двумя способами:

• написать ключевое слово class, а после него – имя класса.
• указать только имя класса.

2.2 Друзья.

     Иногда  удобно разрешить некоторым функциям доступ к закрытым членам класса. Механизм друзей позволяет классу разрешать  доступ к своим неоткрытым членам.

Объявление  друга начинается с ключевого слова friend и может встречаться только внутри определения класса.

class Screen {

   friend istream&

      operator>>( istream&, Screen& );

   friend ostream&

      operator<<( ostream&, const Screen& );

public:

   // ... оставшаяся часть класса Screen

};

     Операторы ввода и вывода теперь могут напрямую обращаться к закрытым членам класса Screen. Простая реализация оператора  вывода выглядит следующим образом:

#include

ostream& operator<<( ostream& os, const Screen& s )

{ // правильно: можно обращаться к _height, _width и _screen

   os << "<" << s._height

      << "," << s._width << ">";

   os << s._screen;

   return os;