Внутреннее представление простых типов

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

Например: auto pi=3.1415926;

Спецификатор register предписывает компилятору распределить память для переменной в каком-либо регистре процессора или кэш-памяти, если это возможно, для повышения скорости доступа к этой переменной. Формально спецификатор register представляет собой лишь запрос, который компилятор вправе проигнорировать. Переменная с таким спецификатором должна иметь тип int и быть локальной.

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

// Пример 1.2 Использование спецификатора static

void fun(int x) {

static int i=x; cout << i << “ “;

}

int main(){

fun(1); fun(2);… return 0;

}

Результат этого, в общем то, бесполезного, примера будет неожиданным – 1 1. Дело в том, что инициализация статической переменной выполняется только один раз – при первом исполнении блока, в котором она описана. Если переменная со спецификатором static явным образом не инициализирована, она инициализируется нулём.

Спецификатор static можно применять и при описании глобальных переменных, в этом случае переменная будет доступна только в том файле, в котором она описана. Такое употребление static не рекомендуется – лучшим способом будет использование пространства имён.

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

Файл a.cpp:

int x;

Файл b.cpp:

extern int x;

int main(){

x=5; …

}

Обратим внимание – если при объявлении переменной указан класс памяти register или static, то тип можно не указать – по умолчанию будет int.

1.4. Выражения. Преобразование типов

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

Операнды и операции

Выражение состоит из операндов, знаков операций и, при необходимости, круглых скобок для изменения порядка выполнения операций. Операнды, в свою очередь, тоже являются выражениями, в частном случае, операндом может быть переменная, константа или результат функции (определенной в программе или в стандартной библиотеке С++). Функции с типом void не могут быть операндами в выражении, для их вызова используется отдельный оператор-выражение.

Рассмотрим операции над простыми типами данных. Они могут быть унарными (требуется только один операнд), бинарными (два операнда) и даже тернарными (три операнда).

Арифметические операции:

+ (плюс – унарный и бинарный)

- (минус – унарный и бинарный)

* (умножение)

/ (деление)

Следует заметить, что целое деление дает целый результат, при этом дробная часть усекается: 8 / 3 есть 2. Над целыми может выполняться операция % получения остатка: 11 % 4 равно 3, а 1 % 4 равно 1 (1 / 4 равно 0).

Логические операции:

&& (логическое И)

|| (логическое ИЛИ)

! (логическое НЕ – унарная операция)

В языке C++ логические операции могут быть применены ко всем целочисленным типам, а не только к типу bool. При этом все нулевые значения трактуются как false, а значения, отличные от нуля, – true.

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

& (поразрядная операция И). Например, 3 & 5 = 1 (в двоичной системе 011 & 101 = 001).

| (поразрядная ИЛИ). Например, 3 | 5 = 7.

^ (исключающее ИЛИ). Например, 3 ^ 5 = 6.

<< (сдвиг операнда влево на заданное число разрядов).
Например, 3 << 2 = 12.

>> (сдвиг операнда вправо на заданное число разрядов).
Например, 3 >> 1 = 1.

Операции сравнения:

== (два подряд идущих знака равно – сравнение на равенство)

!= (не равно)

< (меньше)

> (больше)

<= (меньше или равно)

>= (больше или равно)

В C++ есть операция присваивания =, а не оператор присваивания, как в некоторых других языках, например, Pascal. Операция не только присваивает значение справа левому операнду, но и возвращает это значение. Таким образом, присваивание может встречаться в неожиданном контексте; например, x=3*(a=2*x); - в результате новое значение получит не только переменная x, но и переменная a (однако, не рекомендуется злоупотреблять подобными конструкциями). Выражение a=b=c; означает присвоение c сначала переменной b, а затем переменной a.

Другим свойством операции присваивания является то, что она может совмещаться с большинством бинарных операций – получаются составные операции: +=, -=, *=, /=, %=

Например, выражение x+=2 равносильно x=x+2.

Операция запятая (‘,’) – операция последовательного вычисления. Вычисляет значение левого и правого операнда, при этом возвращает значение правого операнда. Например:

c=(a=8,9);

В a будет помешено значение 8, в c – значение 9 (не рекомендуем использовать подобные конструкции). Заметим, что если вы имели в виду число 8.9, но случайно поставили запятую вместо точки, то сообщения об ошибке не будет выведено.

Операции -- и ++ - декремент и инкремент – уменьшают или увеличивают значение аргумента на 1. Могут быть записаны как перед операндом (префиксная форма), так и после операнда (постфиксная форма). Если знак операции записан перед операндом, то изменение операнда происходит до его использования в выражении, если после операнда – после его использования. Например:

x=3; a=++x; //a=4, x=4

x=3; a=x++; //a=3, x=4

Ещё пример:

x=3; a=++x+ ++x; //a=10, x=5

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

Операция sizeof (объект) – возвращает размер в байтах того объекта, к которому применяется (объектом может быть тип или переменная).

В большинстве программ на C++ широко применяются указатели. Указатель – это переменная, содержащая адрес другой переменной. Унарная операция * разыменовывает указатель, т.е. *p есть объект, на который указывает p. Эта операция также называется косвенной адресацией. Например, если имеется объявление char* p, то *p есть символ, на который указывает p. Операция, противоположная разыменованию – получение адреса (&). Об указателях в C++ мы ещё поговорим подробнее.

В языке C++ имеется одна тернарная операция (с тремя аргументами) – условная операция, которая имеет следующий формат:

операнд1? операнд2: операнд3

Операнд1 в данной операции задаёт условие. Если имеет значение true, то результатом операции будет являться значение операнда 2, иначе – операнда 3. Например, x=(a>0)?1:-1; - переменная x получит значение 1 или -1 в зависимости от значения переменной a. В данном примере скобки, в которые заключается условие, не являются обязательными, но с ними текст получается более наглядным.

Приоритет операций

Приоритет операций – очерёдность выполнения операций при условии, что в выражении нет круглых скобок. Приоритеты перечисленных выше операций представим в виде списка, в котором операции представлены в порядке убывания приоритетов:

· постфиксные ++ и --, вызов функции, обращение к элементу массива

· унарные + и -, префиксные ++ и --,!, sizeof, * и & (разыменование и адрес)

· *, /, %

· +, - бинарные

· <<, >>

· <, >, <=, >=

· =,!=

· &

· ^

· |

· &&

· ||

· =,+=, -= и другие составные операции

· Операция "," - у неё самый низкий приоритет

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

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

1.4.3 Преобразование типов

При присваивании и арифметических операциях C++ выполняет все осмысленные преобразования между основными типами, чтобы их можно было сочетать без ограничений в выражениях. При автоматическом преобразовании типов операндов в выражении компилятор исходит из простого правила – преобразование выполняется к типу с более широким диапазоном. Например, при вычислении выражения 1/5.0 единица в числителе будет преобразована к вещественному типу и операция деления будет выполнена над двумя операндами с плавающей точкой – т.е. будет получен результат вещественного типа (без отсечения дробной части). Если нужно точнее указать тип знаменателя – можно написать 1/5.0F или 1/5.0L.

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

int x=1, y=5;

double z = x / y;

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

В этой и многих других подобных ситуациях возникает необходимость явного преобразования типов, т.е. указания в выражении, к какому именно типу следует преобразовать операнд. Для этого существует несколько способов.

1). Преобразование в стиле С – c-style cast. Синтаксис:

(тип) выражение или тип(выражение)

Например, для нашего случая:

int x=1, y=5; double z=(double)x/y;

В таком варианте переменная z получит корректное значение 0.2.

Этот способ может быть использован для преобразования любого типа в любой другой тип, при этом не проверяется корректность и безопасность преобразования – вся ответственность целиком ложится на программиста. Мы не рекомендуем использовать этот небезопасный способ. К тому же, такую конструкцию сложно искать в коде программы.

2). static_cast.

Для нашего примера:

int x=1, y=5; double z=static_cast<double>(x)/y;

Этот способ отличается тем, что не позволяет делать недопустимых преобразований типов. Допустимость проверяется на этапе компиляции. Например, недопустимо преобразовывать указатель на один простой тип в указатель на простой тип другого размера.

3). const_cast − преобразование константной переменной в неконстантную (применяется только для типов - указателей и ссылок).

const int x = 1;

int *p = &x; // ошибка компиляции

int *p = const_cast<int*>(&x); // компилируется

В хорошо организованном коде необходимость такого преобразования, как правило, не возникает.

4). dynamic_cast – используется в объектно-ориентированном программировании для безопасного преобразования типов по иерархии наследования. Этот вариант будет рассмотрен в главе, посвящённой ООП.

5). reinterpret_cast − преобразование типов, которое никак не контролируется. Обычно используется, чтобы привести указатель к указателю, указатель к целому, целое к указателю. Применяется только в случае полной уверенности программиста в собственных действиях.

Ветвления и циклы

1.5.1 Организация ветвлений в программах на С++

Как и во многих других языках программирования, в С++ имеется два оператора для реализации ветвлений: условный оператор и оператор выбора.

Условный оператор (оператор if).

if (выражение) оператор1 [else оператор2]

В зависимости от условия, которое задаётся выражением в скобках, будет выполняться или оператор1, или оператор2, причём else оператор2 можно и опустить – тогда получится сокращённая форма условного оператора, позволяющая выполнять какие-либо действия только при определённом условии. Безусловно, оператор1 и оператор2 могут быть составными (в С++ обычно используют термин блок – группа операторов, заключённая в фигурные скобки).

Отметим, что в качестве условия можно использовать любое выражение – мы уже обращали внимание, что если результат вычисления выражения равен нулю, то это трактуется, как false (ложь), все значения, отличные от нуля, означают true (истина). Например, оператор if (x=0) x=1; является синтаксически правильным, но, скорее всего, это ошибка программиста, который вместо сравнения на равенство (два знака равно) записал обнуление переменной x – результат такого выражения трактуется как false, и значение 1 переменная x никогда не получит. Рекомендуем в настройках проекта включать максимальный уровень предупреждений (warnings) – это может помочь в обнаружении подобных ошибок.

Пример 1.3. Программа выполняет преобразование дюймов в сантиметры или сантиметров в дюймы в зависимости от введённых данных; предполагается, что вы укажете единицы измерения, добавляя i для дюймов и c для сантиметров (допустим, 5i или 4.3с). В программе как раз и проверяется введённая единица измерения. Если единица измерения указана некорректно, программа должна вывести нули.

// Пример 1.3 – использование оператора if

#include <iostream>

using namespace std;

int main() {

setlocale(LC_ALL, "Russian");

const float fac = 2.54; // коэффициент пересчёта

float x, in, cm; char ch = 0;

cout << "введите длину: "; cin >> x >> ch;

if (ch == 'i') { // inch - дюймы

in = x; cm = x*fac;

}

else if (ch == 'c') { // cm - сантиметры

in = x/fac; cm = x;

}

else

in = cm = 0; // неправильный ввод

cout << in << " in = " << cm << " cm\n";

system("pause"); return 0;

}