Основные операции, используемые при записи выражений



Мы поможем в написании ваших работ!


Мы поможем в написании ваших работ!



Мы поможем в написании ваших работ!


ЗНАЕТЕ ЛИ ВЫ?

Основные операции, используемые при записи выражений



Арифметические унарные
+ унарный плюс
- унарный минус (арифметическое отрицание)
++ увеличение на 1 (инкремент)
-- уменьшение на 1 (декремент)
Арифметические бинарные
* умножение
/ деление
% деление по модулю (остаток от деления)
+ сложение
- вычитание
Логические унарные
! отрицание
Логические бинарные
&& логическое И (конъюнкция)
|| логическое ИЛИ (дизъюнкция)
Операции отношения
< меньше
<= не больше
== равно
!= не равно
>= не меньше
> больше
Прочие
sizeof(…) размер типа
(…) ? … : … условное выражение

Унарные операции инкремента и декремента могут использоваться в двух формах: префиксной и постфиксной.

Префиксная форма

++х - инкремент, увеличение значения операнда на 1 до его использования;

--х - декремент, уменьшение значения операнда на 1 до его использования;

сначала изменяется переменная (x), а затем с учетом этого изменения вычисляется выражение, в которое входит инкремент (декремент).

 

Постфиксная форма

x++ - инкремент, увеличение значения операнда на 1 после его использования;

x-- - декремент, уменьшение значения операнда на 1 после его использования;

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

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

Приоритет Обозначение операции Название операции
++ постфиксный инкремент
-- постфиксный декремент
sizeof размер операнда в байтах
++ префиксный инкремент
-- префиксный декремент
! логическое НЕ
+ унарный плюс
- унарный минус
* умножение
/ деление
% деление по модулю
+ сложение
- вычитание
< меньше
> больше
<= меньше или равно
>= больше или равно
== равно
!= не равно
&& логическое И
|| логическое ИЛИ
? : условная

 

Примеры:

++x-y/4-(5*d-y)

(a+2*b)/y--

Условное выражение

(x<0) ? 35 : 18 //если x<0, то выражение принимает значение 35, иначе 18

(a<b) ? b : a // максимальное из значений двух переменных

 

Преобразование типов в выражениях

Результат операции 7/2 равен 3 (деление нацело, поскольку оба операнда целые). Если мы хотим, чтобы результат был равен 3.5, надо писать, например, так 7.0/3. Таким образом, знаком / обозначается как операция деления нацело, так и операция деления вещественных чисел. Характер операции в конкретном выражении определяется из контекста по типу операндов. Такой двойственный характер операции, обозначаемой одинаково, но интерпретируемой по-разному в зависимости от контекста, называется свойством перегрузки.

Если же мы делим две переменные x и y типа int и хотим получить результат 3.5 типа double, необходимо выполнить преобразование типа хотя бы одного из операндов: double(x)/y. Операция преобразования типа выражения в форме (double) x/yтакже преобразует его к типу double.

 

Операторы C++.

В C++ каждый оператор заканчивается знаком «точка с запятой». Любое выражение, которое заканчивается символом «точка с запятой» воспринимается компилятором как оператор.

Оператор (операция) присваивания

В C++присваивание вводится как бинарная операция вида

<переменная> = <выражение>

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

Замечание. Здесь слева от знака операции может стоять так называемое l-значение (left value), частным случаем которого является переменная. Под l-значением понимается ссылка на некоторую именованную область памяти, значение которой может быть модифицировано.

Оператором присваивания может называться конструкция вида

<переменная> = <выражение>;

которая завершается символом «точка с запятой» и в силу этого рассматривается как оператор.

Примеры:

b=(c-.86*z)+r/t;

x=4; y=x++; // здесь x будет иметь значение 5, а y – значение 4.

x=4; y=++x; // здесь x и y будут иметь значение 5.

Существует несколько модификаций операции присваивания, которые позволяют в более краткой форме записать операцию модификации переменной, стоящей слева. Так, вместо x=x+a можно писать x+=a.

Аналогично можно использовать операции присваивания

-=, *=, /=, %=.

Вместо x=x+1 можно писать x+=1 или, используя инкремент, ++x.

Операцию присваивания можно использовать как выражение, значение которого равно значению левой части после выполнения операции присваивания, например, (y=++x)==5. Здесь при вычислении логического выражения используется значение, которое получит переменная y в результате присваивания ей значения выражения ++x.

Можно писать и так (множественное присваивание):

y=s=a+b;

при этом операции присваивания выполняются справа налево, т.е. эквивалентная запись выглядит так:

s=a+b; y=s;

Ввод-вывод в Си++

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

#include <iostream.h>

помещается в начале файла с программным кодом.

Для стандартного ввода с клавиатуры используется поток ввода cin, для вывода на дисплей – поток вывода cout.

 

Ввод с клавиатуры

Операция ввода значения обозначается знаком >>. Ввод с клавиатуры (поток ввода cin) выполняется следующим оператором:

cin >>переменная >> переменная … >> переменная >>;

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

Вывод на дисплей

Операция вывода значений обозначается знаком <<. Вывод на дисплей (поток вывода cout) выполняется следующим оператором:

cout <<выражение <<выражение …<<выражение;

Здесь следует напомнить, что частным случаем выражения является переменная, константа или значение. Необходимо учитывать, что никакие разделители выводимых на экран значений автоматически в поток вывода не помещается, поэтому их надо включать в список выводимых значений (например, пробел ‘ ‘ или переход к началу следующей строки ‘\n’).

Примеры:

cout <<"\ninpute symbol: ";

cin >>symbol;

cout <<"number of symbol " <<symbol <<" is " <<number;

cout <<"input a b:"; cin >>a >>b;

cout <<"/ninput next chislo: "; cin >> cur;

Здесь наличие символа ‘/n’ в потоке вывода означает переход на следующую строку.

 

Условный оператор

Общий вид условного оператора:

if (<выражение-условие >)

<оператор_1>;

Else

<оператор_2>;

Если выражение-условие истинно (не равно нулю), выполняется оператор_1, в противном случае выполняется оператор_2.

Если после if или elseнеобходимо выполнить несколько операторов, то аналогично Паскалю необходимо заключить их в фигурные скобки, т.е. использовать конструкцию «составной оператор» или «блок», при этом конструкция вида {…} обладает всеми правами простого оператора. Все операторы, входящие в конструкцию {…}, включая последний оператор, должны заканчиваться точкой с запятой, однако после самой конструкции точка с запятой не ставится, поскольку ограничителем для блока и составного оператора является закрывающаяся фигурная скобка. Заметим, что блок отличается от составного оператора наличием в нем объявлений или описаний локальных объектов (переменных, констант и т.д.).

В этом случае условный оператор будет выглядеть так:

if (<выражение-условие>)

{<оператор>; <оператор>; …;}

Else

{<оператор>; <оператор>; …;}

Пример (вычисление наибольшего из двух чисел):

if(x<y)

max=y;

Else

max=x;

Замечание. Аналогичный результат можно получить, используя условное выражение:

max=(x<y)? y : x

Как и в Паскале допускается сокращенная форма условного оператора без else:

if (<выражение-условие>)

<оператор>;

В отличие от Паскаля, где в качестве выражения-условия может использоваться только логическое выражение, в C++ им может быть кроме логического любое арифметическое выражение целого типа или символьное. В этом случае значению «ложь» ставится в соответствие нулевое значение, а любое ненулевое трактуется как «истина».

Допускается вложение условных операторов. В конструкции с вложенным условным оператором вида

if (a<b)

{++x; y+=h;}

else if (a>b)

y*=5;

Else

{y=x+h; x++;}

действует правило: «каждое else относится к ближайшему предшествующему ему if».

В качестве примера использования в условном операторе выражения-условия числового типа, значение которого может трактоваться как false (нулевое значение) или true (ненулевое значение) можно привести алгоритм деления двух целых чисел:

int a,b;

cin >>a >>b;//ввод чисел aиb

if (b)

y=a/b;// bне равно нулю

Else

cout << “\nделение на нуль”;// bравно нулю

 

Оператор выбора

Условный оператор осуществляет ветвление на два направления. Во многих случаях приходится сталкиваться с ситуацией, когда необходимо выбирать один вариант из нескольких возможных, т.е. осуществлять множественное ветвление. Использование в таких случаях вложенного условного оператора зачастую приводит к весьма громоздким конструкциям. В Паскале для более компактного описания такого множественного ветвления имеется оператор выбора case. Аналогичный оператор множественного ветвления в C++ имеет вид:

switch (<выражение-селектор>)

{

case <константа>: <оператор>; <оператор>; …; break;

case <константа>: <оператор>; <оператор>; …; break;

case <константа>: <оператор>; <оператор>;

default : <оператор>; <оператор>; …;

}

Здесь выражение-селектор (или переменная-селектор) может быть любого скалярного типа, кроме вещественного. Сначала вычисляется выражение-селектор, затем полученное значение этого выражения ищется среди констант целого типа, стоящих после case. Если вычисленное значение найдено, выполняются операторы, начиная с соответствующего case, и до default; в противном случае выполняются операторы, идущие после default.

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

Ветвь default не является обязательной, однако, из соображений безопасности ее не рекомендуется опускать.

Пример 1:

Switch (x)

{

case 0: y+=h; break;

case 1: y*=3; z++; break;

case 2: y/=2; d=(h+y)/5;

default : y++;

}

Пример 2 (вычисление оценки в четырехбалльной системе по заданному значению стобалльного рейтинга):

int k;

cout <<”\nвведите ваш рейтинг: “; cin >> k;

k/=10;

Switch (k)

{

case 0:

case 1:

case 2:

case 3:

case 4: cout <<”\nВаша оценка – неудовлетворительно”; break;

case 5:

case 6: cout <<”\nВаша оценка – удовлетворительно”; break;

case 7:

case 8: cout <<”\nВаша оценка – хорошо”; break;

case 9:

case 10: cout <<”\nВаша оценка – отлично”;

default : cout <<”недопустимое значение рейтинга”;

}

Операторы цикла

Оператор цикла используется для описания повторяющихся (циклических) вычислений.

Как и в Паскале в Си++ можно использовать 3 формы оператора цикла: с предусловием, с постусловием и с параметром (цикл for).

Цикл с предусловием

while (<выражение-условие>)

<оператор>;

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

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

Пример (вычисление суммы последовательности целых чисел с числом нуль в качестве признака конца последовательности):

int S=0;

cout << “\ninput a: ”; cin >> a;

while (a!=0)

{

S+=a;

cout << “input a: ”; cin >> a;

}

Цикл с постусловием

do

<оператор>

while (<выражение-условие>);

Цикл с постусловием отличается от цикла с предусловием только тем, что на каждом шаге сначала выполняется оператор-тело цикла, а затем вычисляется выражение-условие и если оно принимает значение «ложь», выполнение оператора цикла завершается. Таким образом, в отличие от цикла с предусловием здесь оператор-тело цикла всегда выполняется хотя бы один раз.

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

Пример (вычисление суммы последовательности целых чисел, последнее из которых равно нулю):

int S=0;

do

{

cout << “input a: ”; cin >> a;

S+=a;

}

while (a!=0);

Принципиальное отличие этого оператора в C++ от Паскаля состоит в том, что и в цикле с предусловием, и в цикле с постусловием итерации продолжаются до тех пор, пока выражение-условие сохраняет значение «истина», т.е. отлично от нуля. Таким образом, это выражение должно быть сформулировано как условие продолжения цикла.

Цикл с параметром ( цикл for)

for (<инициализация>; <выражение-условие>; <модификатор>)

<оператор>;

Модификатор – это выражение, которое изменяет модифицируемую переменную цикла.

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

Пример (вычисление суммы последовательности n целых чисел):

S=0;

for (i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

Здесь модификатором является постфиксное выражение i++, согласно которому на каждом шаге значение переменной цикла i увеличивается на 1.

Можно инициализировать в цикле и переменную S:

for (S=0, i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

Более того, внутри цикла можно и описать тип переменной, необходимо лишь помнить, что это описание будет действовать только в теле цикла.

for (S=0, int i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

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

Замечание: в отличие от Паскаля в теле цикла разрешается изменять параметр цикла и после завершения цикла значение параметра считается определенным.

Оператор breakвыполняет выход из цикла (досрочное завершение оператора), а оператор continue - досрочное завершение очередного шага цикла (досрочный переход к следующему шагу).

 

Структура программы на C++. Функции.

Программа на языке C++ состоит из функций, описаний и директив препроцессора. Одна из функций должна иметь имя main, программа начинает выполняться с первого оператора этой функции. Тело функции является блоком. В отличие от Паскаля функции не могут быть вложенными.

Простейшее определение функции выглядит так:

<тип> <имя функции> (<спецификация формальных параметров>)

{

<операторы>

}

Функция может не возвращать никакого значения, в этом случае в качестве ее типа указывается void (например, функция main).

Возврат вычисленного значения функции осуществляется оператором

return <выражение>;

Если функция имеет тип void, оператор return может отсутствовать.

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

<имя функции> (<список фактических параметров>);

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

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

Замечание: в прототипе могут отсутствовать имена формальных параметров, достаточно лишь указать их типы.

Пример 1: Вычислить сумму последовательности отличных от нуля целых чисел, после которой следует число нуль (признак конца последовательности).

#include <iostream.h>

Void main()

{

int a, S=0;

cout << “\nВведите a: ”; cin >> a;

while (a!=0)

{

S+=a;

cout << “\nВведите a: ”; cin >> a;

}

cout << “Сумма=” <<S <<’\n’;

}

 

Пример 2: В последовательности из n целых чисел вычислить произведение чисел, попадающих в отрезок [b, c].

#include <iostream.h>

Void main()

{

int n, a, b, c, P=1;

cout << “\nВведите n: ”; cin >> n;

cout << “\nВведите b c: ”; cin >> b >>c;

for ( int i=1; i<=n; i++)

{

cout << “Введите a: ”; cin >> a;

if ((a>=b)&&(a<=c)) P*=a;

}

cout << “Произведение=” <<P <<’\n’;

}

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

 

Структурированные типы данных в C++

Массивы.

Как и в Паскале, массив представляет собой упорядоченную последовательность данных одного типа, занимающих последовательные ячейки памяти. Для упорядочивания используется индексация элементов массива, т.е. приписывание каждому элементу значения индекса. В отличие от Паскаля, где для выбора индексного типа имеется значительная свобода, в C++ индекс представляет собой целое положительное число или ноль. Таким образом, элементы массива упорядочиваются приписыванием каждому из них порядкового номера, причем нумерация начинается с нуля, а не с единицы, т.е. первый элемент массива имеет индекс ноль. Общий вид описания массива:

<базовый тип> <имя массива> [<целая константа>];

Пример:

long int a, b[5], c;

const int n=10;

double s[n];

Здесь определен массив b, состоящий из 5 элементов типа long int: b[0] b[1] b[2] b[3] b[4]и массив s из 10 элементов типа double: s[0] s[1] … s[9].

При определении массив может быть инициализирован:

int a[5]={2, -3, 5, 4, 38};

Во многих случаях удобно бывает определить новый тип-массив:

typedef long int mas[10];

mas a,b;

В программе элементы массива представляют собой переменные с индексами.

Пример (ввод и суммирование массива).

#include <iostream.h>

Void main()

{

const int n=10;

int a[n], S=0;

cout << “\ninput array: ”;

for (int i=0; i<n; i++)

{

cin >> a[i];

S+=a[i];

}

cout << “Summa=” <<S <<’\n’;

}

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

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

int a [5][3];

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

Пример:

int a [2][3]={{1, 6, -3}, //первая строка

{5, 24, 0}}; //вторая строка

Все операции над массивами, включая ввод-вывод и присваивание, выполняются поэлементно.

Пример (ввод двумерного массива):

for (int i=0; i<5; i++)

for (int j=0; j<3; j++)

cin >>a[i][j];

 

Символьные строки.

Символьная строка является аналогом типа string Паскаля. В C++ она объявляется как массив символов, но при этом дополняется нуль-символом ‘\0’, что позволяет определять текущую длину строки:

char str[10]=”alfa”; // str[0]=’a’ str[1]=’l’ str[2]=’f’ str[3]=’a’ str[4]=’\0’

При инициализации можно было бы опустить длину строки:

char str[]=”alfa”;

но при этом под нее было бы выделено не 10 байт, а только 5.

Строки можно использовать в операторах ввода (cin) и вывода (cout), однако при вводе строки с клавиатуры необходимо учитывать, что оператор >> в качестве признака конца строки рассматривает символы пробела, табуляции или Enter и, встретив один из этих символов, завершает ввод строки. Поэтому, если в ответ на запрос

Введите строку

следующего фрагмента программы:

char text[50];

cout <<”/nВведите строку”;

cin >> text;

cout <<’Вы ввели/n’ <<text;

вы введете

Иван Петров

на экран будет выведено

Вы ввели

Иван

Эта проблема может быть разрешена использованием библиотечной функции

gets(<имя массива>)

стандартной библиотеки stdio.h, которая должна быть подключена инструкцией #include <stdio.h>.

Поскольку строка является массивом, для нее не определены операции присваивания и сравнения. Эти операции могут выполняться поэлементно или с помощью функций стандартной библиотеки string.h, которая должна быть подключена инструкцией #include <string.h>:

strcpy(str1, str2) //копирование строкиstr2в строкуstr1,

strlen(str) //длина строки без ноль-символа,

strcmp(str1, str2) //сравнение строк: совпадают –false(0),иначе –true(1),

strcat(str1, str2) //конкатенация строк(str1+str2).

В операции копирования длина строки str1должна быть на один символ больше,чемstr2.

 

Структуры.

Структура (struct) в C++ является аналогом типа record в Паскале. Структура позволяет группировать данные разных типов. Определение типа struct выглядит так:

struct <имя типа> {

<тип поля> <имя поля>;

<тип поля> <имя поля>;

……………..

<тип поля> <имя поля>;

}

Пример:

struct anketa {

char name[20];

enum {man, woman} pol;

int born;

}

anketa a[5], b;

Можно определять переменные типа struct,не определяя новое имя типа, т.е. используя анонимный тип. Соответствующее описание переменных типа structбудет выглядеть так:

struct {

<тип поля> <имя поля>;

<тип поля> <имя поля>;

……………..

<тип поля> <имя поля>;

} <список переменных>;

Пример:

struct {

char name[20];

enum {man, woman} pol;

int born;

} a[5], b;

Здесь, как и в предыдущем примере определен массив a[5]из 5 элементов структурного типа и простая переменная b того же структурного типа. Одновременно с определением структурного типа можно описать и переменные этого типа, например:

struct anketa {

char name[20];

enum {man, woman} pol;

int born;

} a[5], b;

Обращение к элементам структуры, аналогично Паскалю выглядит так:

<имя переменной типа struct >.<имя поля>

Пример:

a[2].name=”Petrov”;

a[2].pol=man;

a[2].born=1985;

b.name=”Orlova”;

b.pol=woman;

b.born=1990;

Переменные типа struct можно использовать в операторе присваивания, но при этом действует правило именной эквивалентности типов.

 



Последнее изменение этой страницы: 2016-08-15; Нарушение авторского права страницы; Мы поможем в написании вашей работы!

infopedia.su Все материалы представленные на сайте исключительно с целью ознакомления читателями и не преследуют коммерческих целей или нарушение авторских прав. Обратная связь - 34.239.170.169 (0.077 с.)