Программирование C++/Основные операции
Сейчас мы рассмотрим некоторые базовые операции, которые есть почти во всех языках программирования. Начнем мы с побитовых операций.
В данной статье представлены следующие группы операторов языка программирования:
Побитовые
Я надеюсь, что Вы знаете о внутреннем представлении всех типов данных в памяти и их хранение. Ну, может, не всех, но хотя бы некоторых основных - целых и вещественных. Если не знаете, по рекомендую прочесть данную статью, либо же переходите к следующему классу операций.
Все данные в памяти компьютера, как мы знаем, представляются в виде некоторого двоичного кода. И иногда необходимо как-то обработать это представление. В некоторых случаях можно воспользоваться более общие функции, на подобие умножения, сложения, вычитания..., но нужно хорошо понимать, что эти операции работают не так быстро, как хотелось бы. Поэтому в некоторых случаях лучше воспользоваться побитовыми операциями, которые работают очень быстро. Все дело в том, что когда мы вызываем высокоуровневые операции (умножение, сложение,...), то они каким-либо образом преобразуются в побитовые операции (в некоторых языках программирования на этапе компиляции. Но в большинстве случаев они преобразуются в побитовые функции на этапе выполнения (это очень грубо сказано. Лучше сказать, что во время выполнения программы высокоуровненые операции выполняются с помощью некоторого набора более примитивных операций. В общем мы не об этом)). Поэтому по возможности лучше писать программы через операции побитового сдвига.
Начнем с операции побитового сдвига влево. Во многих языках программирования она записывается как shl. Эта операция сдвигает все биты числа влево на некоторое значение, при этом вначале числа дописывается нули, а в конце "вырезаются" лишние символы. Например:
1100 1111 >> 1001110
Если Вы подумаете, то можете догадаться, что эта операция является операцией умножения на 2n, где n мы указываем сами.
В языке С++ эта операция имеет следующий синтаксис:
i << 3
В данном случае это не ввод, а операция побитового сдвига влево на 3
Если данные скобки будут стоять в другую сторону, то это побитовый сдвиг вправо
i >> 3
На самом деле операции побитового сдвига просто-напросто перегружены для ввода/вывода.
Побитовая операция "или" записывается как "|"
or - "|"
and - "&"
xor - "^"
not - "~"
Алгебраические
В данном языке есть один интересный момент. Если одно и тоже значение нужно присвоить нескольким переменным, то можно воспользоваться многоразовым присваиванием.
k=j=i=2;
Каждая из этих переменных получит значение 2. Это объясняется просто: в языке С++ есть только операции. И каждая из операций что-нибудь возвращает. Операция присваивания возвращает значение, которое присваивается.
k=(j=(i=2));
Также в данном языке есть конструкция
a+=2;
И все ее вытекающие. Эта конструкция впервые появилась в языке С, а в дальнейшем все остальные языки, как грибы, это перенимали.
Есть еще одна интересная операция
i++;
Она означает i увеличить на 1. Это обычно пишут вместо
i+=1;
Теперь догадываетесь, откуда пошло название С++?
Интересно, что это можно написать по другому.
++i;
И это будет то же самое. Однако нужно понимать, что это две разные операции. И давайте все-таки поймем, что она возвращает, поскольку операция всегда что-то возвращает в C++. Если возвращаемое значение ничему не присвоить, то он уйдет в никуда. С этой точки зрения можно написать:
1;
1+4;
Это тоже операции, только их значения уйдут в никуда, однако эти выражения компьютер все равно вычислит. И это правильно, в отличие от Pascal.
Давайте подробнее рассмотрим выражение i++. Это выражение возвращает i, то увеличения.
int i=5;
int a=i++; //a=5 i=6
Теперь в обратную сторону.
int i=5;
int a=++i; //a=i=6;
Здесь ++i Возвращает i после увеличения.
Эти две операции очень хорошие, но я рекомендую ими пользоваться очень осторожно. Для того, чтобы Вы поняли почему, рассмотрим пример:
int x=2;
int y=3;
int a=x+++--y;
И этот код правильный. X, конечно, получит значение 3, y получит значение 2. Это никто и не спорит. А чему будет равно значение а? Мы можем упростить последнюю строку до
int a=2+2;
Из этой строки видно, что в а будет значение 4. И многие за такие строки любят С++, за его компактность, а остальные ненавидят. Равнодушных нет.
Есть и более катастрофичный пример:
int a =x++-x--;
Это просто не правильно. Очевидно, что значение переменной х не изменится, а вот по поводу значения самого выражения мы уже не можем быть так уверены, потому что мы не знаем, какая из операций будет выполнена первой. Все зависит от самого компилятора. Именно в нем заложено, какая из операция будет выполнена первой. А это уже как повезет, ведь для тестовых и для готовых версий разные компиляторы. А вы сами понимаете, как оно будет работать. В режиме тестирований будет работать по одному, а при издании будет работать по-другому. Вывод из этого следующий: нельзя использовать одну переменную дважды в одном выражении с подобными операциями. Поэтому такой стиль лучше не использовать.
Деление
i/j
В отличие от Pascal правило более простое. Если оба числа - целые, то и результат - целое. Так 7/3 = 2. Аналогом этого является операция div в Pascal. А вот, если хотите поделить так, чтобы результатом было вещественное число, то тогда хотя бы одна из переменных должна быть вещественной.
int i=7;
int j=3;
double r=i/(double) j;
В С++ есть еще одна очень интересная операция
int min=a < b ? a : b;
Эта операция частично заменяет логическое if. Эту операцию можно трактовать так: a меньше b? Если - да, то возвращаемое значение a, иначе b. Это очень замечательная операция, которая состоит из вопросительного знака и двоеточия и включает в себя 3 операции. Это полный эквивалент следующему
if ( a < b )
min = a;
else
min = b;
Это условный оператор. Вначале него пишется некоторое условие в скобках после ключевого слова if. А после условия идет действие, выполняемое при истинности данного условия. Также можно добавить операцию по ветке else. Эта операция будет выполняться в том случае, если указанное условие ложно.
Если нам нужно написать несколько операций в Паскале, то мы пишем слова begin и end. Здесь же вместо них пишутся скобки
if (a < b) {
double v{a};
a = b;
b = v;
}
Логические.
В С++ логическая операция and записывается как "&&", а or записывается как "||"
i>2 && i!=3
Обратите внимание на то, как пишется не равно "!=".
Также обратите внимание, что скобки не пишутся. Это потому что операции отношения более сильные чем операция and, в отличие от Pascal
Для сравнения двух данных используется операция "==". Из-за этого многие начинающие программисты вначале делают ошибки. Вот например:
i=2 || i>5
В данном случае результат первой операции - это целое число 2, которое будет приводится к логическому типу. А в логическом типе это true. Тем самым это условие всегда будет истинным и мы испортим значение переменной i. И при этом никакой ошибки не будет. Программа сработает и нормально завершится, однако она будет выполнена как-то неправильно. И, к сожалению, эту ошибку найти будет очень трудно. Поэтому начинающим программистам рекомендуют писать в выражении вначале константу, а затем переменную
2=i || i>5
Так компилятор Вам сразу выдаст ошибку о том, что константному значению ничего нельзя присвоить. И вы сразу найдете ошибку.
Оператор выбора.
Оператор выбора - это одно из немногих мест в языке С++, которое является позором этого языка. Конструкция этого оператора крайне стара и была ориентирована на программистов 60-ых годов. В языке Pascal она гораздо лучше.
switch(i) {
case 1:
case 2:
j=5;
k+=1;
break;
case 3:
case 4:
k-=1;
break;
default:
k=0;
}
При этом нужно учесть, что нельзя после case писать диапазон, как это можно сделать в Pascal. Для этого придется писать каждое из значений этого диапазона. Начинается этот оператор с заголовка switch. Затем идет переменная значение которой мы рассматриваем. Далее идет блок кода, который разделяется метками case, после каждого из которых идет значение и двоеточие. Это означает, что последующий код будет выполнен, если переменная i имеет значение 1 или 2. Далее идет код, который будет выполнен и по метке case 1 и по метке case 2. Затем закончилась это последовательность. Мы должны покинуть эту метке. Это делается с помощью break. Далее идет следующая метка. После всех меток идет метка default, внутри которой писать break не нужно.
Очень большим минусом данного оператора является то, что нельзя указывать диапазон значений для одних и тех же действий. Поэтому, если захотим сделать одно и то же действие для всех значений от 1 до N, то придется все N раз писать ветки case. А это крайне неудобно, да и усложняет код.
switch (i) {
case 1:
case 2:
case 3:
...
...
...
case N:
Action;
break;
}
Другого пути нет. Или можно воспользоваться условным оператором.
Перейдем от этой позорной страницы далее.
Циклы
Здесь все более или менее просто.
while (Predicate) {
Action;
}
Это синтаксис цикла с предусловием. После ключевого слова while пишется в скобках условие. И до тех пор, пока данное условие является истинным, будет выполняться тело цикла (это все, что идет между скобками). Также, как и в условном операторе нужно писать только одну операцию, если не указывать скобки. Но зачастую нужно сделать за одну итерацию цикла более одного действия, поэтому встретить цикл while без скобок почти невозможно.
Следующий цикл - это цикл с постусловием. Обратите внимание, что это тот же самый цикл While, только условие будет проверяться после выполнения цикла, а не до выполнения. И обратите внимание, что цикл будет осуществляться до тех пор, пока условие будет истинно.
do {
Action;
} while (Predicate);
В данном языке очень хороший оператор for. Он намного лучше, чем в Pascal, но намного коварнее.
for (int i=0; i << 5; i++)
cout << i << "";
Плюс этого цикла заключается в том, что здесь мы можем контролировать шаг, в отличие от Pascal. В самом заголовке здесь три секции. Первая секция - это секция инициализации (int i=0). В ней идет инициализация переменной, по которой будет идти отчет. Вторая секция - это условие продолжения (i<5). А третья секция - это то, что выполняется каждый раз после тела цикла
for (int i=0; i < 5; i+=2)
Здесь мы сделали цикл с шагом 2. И это действует не только для целых переменных
for (double d=1; d <= 2; d +=0.1)
Коварность этого цикла заключается в том, что он может зациклиться
for (int i=0; i < 5; i--)
Или
for (int i=0; i < 5; j--)