В С++ роль оператора << значительно расширена. Он продолжает выполнять роль оператора побитового сдвига влево, но используется также как оператор вывода данных в случае, если записан в указанной в примере форме. Слово cout представляет собой идентификатор, соответствующий экрану. Так же как и С, язык С++ поддерживает перенаправление ввода/ вывода, но, чтобы избежать дискуссий на эту тему, мы можем принять, что cout ссылается на экран. Можно использовать cout и оператор << для вывода данных любого встроенного типа, а также для вывода строк символов.
12.Оператор присваивания в языке программирования С++.
Оператор присваивания является самым важным оператором в любом языке программирования. Этот оператор служит для изменения областей памяти. Оператор присваивания заменяет значение переменной, идентификатор которой стоит в левой части оператора, значением выражения, стоящего в правой части, и имеет следующую форму:
идентификатор переменной = выражение.
Необходимо учесть, что переменная и выражение должны быть согласованы по типам.
После присваивания переменной нового значения, старое просто стирается. Поскольку переменная может хранить только одно число, то выполнение оператора присваивания приводит к потере предыдущего значения переменной. Переменная всегда содержит результат последнего оператора присваивания.
13.Преобразование и совместимость типов по присваиванию в языке программирования С++.
Как отмечалось, тип переменной позволяет не только устанавливать длину ее внутреннего представления, но и контролировать те действия, которые осуществляются над ней в программе. Ниже приведены схемы преобразования типов, гарантирующие сохранение точности и неизменность численного значения:
signed char ==> short ==> int ==> long
float ==> double ==> long double
unsigned char ==> unsigned short ==> unsigned int ==> unsigned long
В языке С считается, что все арифметические операции выполняются с двойной точностью. Поэтому всякий раз, когда в выражении появляются значение с плавающей точкой, его "удлиняют" до удвоенной точности, добавляя к дробной части нули. При преобразовании значения с двойной точностью к одинарной, например, при присваивании, прежде чем отбросить лишни для обычной точности разряды, происходит округление.
Кроме автоматических преобразований типов, существуют явные преобразования типов. Синтаксис использования явного преобразования типов имеет две различные формы:
(имя_типа) операнд
Или
Имя_типа (операнд).
Во второй форме не может использоваться составное наименование типа (например, unsigned short). Как и при автоматическом преобразовании типов, ответственность за сохранение значения и точности результата лежит на разработчике программы.
Кроме классической записи оператора присваивания, в языке С++ используются операции увеличения ++ и уменьшения. Операция увеличения увеличивает свой операнд на 1, а операция уменьшения уменьшает свой операнд на 1. Существует две формы этих операций: постфиксная и префиксная. Разница между ними заключается в том, что они показывают, в какой момент осуществляется увеличение или уменьшение операнда:
x++, x-- постфиксная запись;
++x, --x префиксная запись.
14.Условный оператор if, опеpация условия:? в языке программирования С++.
Условный оператор служит для ветвлений в программе и имеет следующий синтаксис:
if(<условие>) <оператор1>; else <оператор2>.
Здесь if, else - ключевые слова (пер. с англ. если, иначе соответственно); <условие> - это условное выражение типа сравнения (например, a>b, c<=d, f==1); <оператор1> и <оператор2>? любые операторы C++.
Оператор работает следующим образом: если условие истинно, то выполняется <оператор1> и управление передается на следующий за условным оператор; если условие ложно, то выполняется <оператор2> и управление передается на следующий за условным оператор. Таким образом, всегда выполняется один из двух операторов: либо <оператор1>, либо <оператор2>.
Существует сокращенная форма условного оператора, в которой отсутствует ветвь else:
if <условие> <оператор1>.
Оператор работает следующим образом: если условие истинно, то выполняется <оператор1> и управление передается на следующий за условным оператор; если условие ложно, то управление сразу передается на следующий за условным оператор. Таким образом, в зависимости от условия, <оператор1> либо выполняется, либо не выполняется.
Вложенные условные операторы уменьшают число необходимых проверок, обеспечивают большую эффективность, но ухудшают читаемость программы, поэтому не рекомендуется слишком увлекаться вложением условных операторов.
При определении последовательности выполнения вложенных условных операторов каждое else соответствует тому if, которое ему непосредственно предшествует. Таким образом, исключается всякая двусмысленность.
Условный оператор может оказаться негибким, так как выполняемые действия могут быть описаны только одним оператором. Если необходимо выполнить в ветви условного оператора несколько операторов, то в этом случае можно использовать составной оператор.
операция условия: "?" имеет три операнда.
(выражение1)?(выражение2):(выражение3);
Вначале вычисляется (выражение1). Если результат имеет ненулевое значение, то вычисляется (выражение2). Результатом операции будет это значение (выражения2).
Если значение (выражения1) равно нулю, то вычисляется (выражение3) и его значение и будет результатом операции. Вы видите, что в зависимости от того, чему равно (выражение1), вычисляется либо (выражение2), либо (выражение3).
15.Составной оператор в языке программирования С++.
Чтобы последовательность операторов работала как единый оператор, можно помещать эту последовательность между открывающейся и закрывающейся фигурными скобками. Такая конструкция называется составным оператором, или операторными скобками. Каждый оператор, входящий в состав составного оператора, заканчивается точкой с запятой.
16.Оператор пеpеключения switch в языке программирования С++.
Оператор выбора предназначен для организации ветвлений в программе, когда возникает необходимость избрания одного из множества различных вариантов дальнейшего хода программы. В общем случае оператор выбора записывается следующим образом:
switch (<выражение>)
{
case <выражение_1>: <операторы>;
case <выражение_2>: <операторы>;
...
case <выражение_n>: <операторы>;
[default: <операторы>;]
}
Здесь switch, case, default – ключевые слова (пер. с англ.: переключатель, случай, невыполнение обязательств); <выражение> – выражение любого целого типа; <выражение_1>, <выражение_2>, <выражение_n> – константа или константное выражение того же типа, что и <выражение>; <операторы> – один или несколько операторов С++.
Работа оператора начинается с вычисления <выражения>. Значение этого выражения является критерием для выбора из нескольких вариантов. Если полученное значение выражения совпадает с одной из констант, то выполняется та группа операторов, которой предшествует эта константа, а потом все группы операторов, расположенные ниже. Но так как часто программист использует этот оператор, чтобы выполнить только одну группу, то в конце каждой группы используется специальный оператор break, осуществляющий выход из оператора switch (а также из всех операторов цикла). Если такой константы не обнаруживается, то выполняется оператор, следующий за ключевым словом default. Ветвь default может отсутствовать, и в этом случае управление передается оператору, следующему за оператором switch.
17.Операторы goto, break, continue в языке программирования С++.
В языке C++ достаточно управляющих операторов, позволяющих написать любую программу. Тем не менее, в языке имеется оператор безусловного перехода. Безусловный переход приводит к передаче управления из одного места в программе в другое. Структура оператора перехода следующая:
goto <метка>
Здесь goto - ключевое слово (англ.: перейти на [метку]).
Метка - это произвольный идентификатор. Метка ставится перед оператором, получающим управление, и отделяется от него двоеточием. Метки в языке С++ не требуют предварительного описания. Перемещаться с помощью оператора перехода можно только внутри текущей функции.
Специальный оператор break, осуществляющий выход из оператора switch (а также из всех операторов цикла). Говоря об операторах цикла, нельзя не сказать и о возможностях, позволяющих изменить привычный ход выполнения операторов цикла. Один из таких операторов, а именно оператор break, уже использовался в операторе выбора. Если оператор break встречается в теле цикла, то управление передается следующему за оператором цикла оператору, т. е. приводит к досрочному выходу из цикла.
Другим оператором, изменяющим обычный ход выполнения оператора цикла, является оператор continue. Этот оператор приводит к пропусканию той части тела цикла, которая расположена после оператора continue, и перехода на новую итерацию цикла.
18.Оператор цикла for в языке программирования С++.
В языке С++ имеется специальная конструкция для организации циклов со счетчиком. Синтаксис оператора цикла со счетчиком в общем случае следующий:
for (<п.ц.> = <н.з.>; <условие>; <коррекция п.ц.>)
<оператор>;
Здесь for – ключевое слово (перев. с англ. для); <п.ц.> – переменная цикла, которая может быть только простого типа; <н.з.> – начальное значение, выражение такого же простого типа, как и переменная цикла; <условие> – выражение типа сравнения, используемое для выхода из цикла; <коррекция п.ц.> – оператор присваивания, задающий изменение переменной цикла; <оператор> – любой оператор языка C++, в том числе и составной, являющийся телом цикла.
Оператор работает таким образом: сначала вычисляется выражение, соответствующее начальному значению, и присваивается переменной цикла, потом проверяется условие выхода из цикла и, если получается истинное значение, выполняется оператор, являющийся телом цикла. Затем изменяется переменная цикла и снова проверяется условие и т. д. Если значение выражения ложно, то осуществляется выход из цикла. Если начальное значение переменной цикла больше конечного значения, то операторы тела цикла не выполняются. Можно сказать, что оператор цикла со счетчиком – это оператор цикла с предусловием. Если нужно выполнить несколько операторов в теле цикла, то пользуются составным оператором.
19.Оператор цикла do while в языке программирования С++.
Оператор цикла с постусловием. Синтаксис:
do <оператор> while(<условие>)
Здесь do,while – ключевые слова (перев. с англ.: выполнять и пока);
<оператор> – любой оператор языка С++, в том числе и составной (его называют телом цикла);
<условие> – условное выражение типа сравнения, используемое дл я выхода из цикла.
Оператор работает следующим образом: сначала выполняются операторы, расположенные в теле цикла, затем вычисляется условное выражение и, если получается ложное значение, осуществляется выход из цикла. Если значение выражения истинно, то выполнение операторов тела цикла повторяется, а затем снова проверяется условие. Итак, операторы тела цикла выполняются хотя бы раз, а потом все зависит от условия выхода из цикла. Очевидно, один из операторов тела цикла должен влиять на значение условного выражения, поскольку иначе цикл будет повторяться бесконечно.
20.Оператор цикла while в языке программирования С++.
Оператор цикла с предусловием вычисляет и проверяет условие до выполнения операторов, составляющих тело цикла. Синтаксис этого оператора следующий:
while (<условие>) <оператор>;
Здесь while – ключевое слово (перев. с англ.: пока); <оператор> – любой оператор языка C++, в том числе и составной (этот оператор называют телом цикла); <условие> – условное выражение типа сравнения, используемое для выхода и з цикла.
Оператор работает следующим образом: сначала вычисляется условное выражение и, если получается истинное значение, выполняется оператор, являющийся телом цикла, а затем снова проверяется условие. Если значение условного выражения ложно, то осуществляется выход из цикла. Таким образом, если условие было ложно при первом входе в цикл, то операторы тела цикла не выполнятся ни разу. Очевидно, один из операторов тела цикла должен влиять на значение условного выражения, поскольку иначе цикл будет повторяться бесконечно.
21.Обработка массивов в языке программирования С++.
В программировании используется следующее определение массива: массив – это совокупность однотипных элементов данных.
Массив – не простой тип данных, а структурированный, т. е. имеет один или более компонент и построен на основе других типов. Компоненты массива называют элементами. Все элементы массива имеют общее имя. Обращение к конкретному элементу производится с помощью индекса. Важной отличительной чертой массива является однотипность элементов массива. В качестве типа используется любой простой или структурированный тип (т. е. возможна вложенность типов). В языке С++ количество элементов массиве фиксировано и определяется во время трансляции. Это является недостатком языка, поскольку не во всех задачах можно заранее определить количество элементов в массиве.
Одномерные массивы.
Одномерные массивы имеют аналогию с таким понятием в математике, как вектор. Описание переменной типа массив задается следующим образом:
<тип> <идентификатор массива>[<t>];
Здесь <тип> – тип элементов массива (любой тип языка С++);
<имя массива> – правильный идентификатор;
<t> – количество элементов массива.
В языке программирования С++ индексы элементов массива изменяются от 0. Индекс последнего элемента на единицу меньше количества элементов в массиве. Размерность массива – величина произвольная, но суммарная длина внутреннего представления любого массива не может быть больше 65520 байт. Так как память выделяется под массив во время компиляции программы, границы изменения индексов должны быть константами, или константными выражениями.
Обращение к элементам массива осуществляется по их индексам.
При обработке массивов возникают такие задачи, как ввод элементов массива, нахождение суммы, произведения, среднего и т. д., поиск некоторого элемента в массиве, сортировка элементов массива, вывод элементов массива.
Для формирования массива (во всех случаях, когда требуется перебор всех элементов массива) лучше всего подходит оператор цикла со счетчиком. В каждой итерации оператора цикла очередному элементу массива (индекс элемента является переменной цикла) присваивается псевдослучайное число. Результатом работы программы является сформированный массив и сумма элементов этого массива.
определения максимального элемента массива и произведения положительных элементов, а также замены максимального элемента массива произведением положительных элементов массива
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
const int N1 = 100; //Максимальный размер массива
int a[N1], // Mассив
i, //Индекс элемента массива
n, p, //Количество элементов в массиве и их
//произведение
imax; //Индекс максимального элемента
printf ("\nВведите число элементов массива:");
scanf ("%d",&n);
printf ("Введите элементы массива");
for (i = 0; i<n; i++)
scanf ("%d", &a[i]);
p = 1;
imax = 0; //Пpедполагаем, что пеpвый элемент максимальный}
for (i = 0; i<n; i++)
{
//Если элемент положительный, то р умножаем на него
if (a[i]>0) p = p*a[i];
//Если текущий элемент массива больше
//максимального, то запоминаем его индекс
if (a[imax] < a[i]) imax = i;
}
printf ("\nМаксимальный элемент массива=%d", a[imax]);
a[imax] = p; // Замена максимального элемента printf ("\n p = %d", p); printf ("\n Обpаботанный массив:"); for (i = 0; i<n; i++) printf ("%5d", a[i]); getch ();
}
В приведенном примере массив вводится с клавиатуры. Для ввода массива используется оператор цикла со счетчиком. За начальное значение для индекса максимального элемента берем 0, т. е. предполагаем, что первый элемент максимальный. Далее в цикле перебираются все элементы массива и сравниваются c нулем для того, чтобы умножать или не умножать на элемент. В этом же цикле каждый элемент сравнивается с a[imax] для выяс-нения, не встретился ли элемент, больший прежнего максимального, и если встретился, то запоминается его индекс, чтобы в следующий раз сравнивать текущий элемент с большим из перебранных. В условном операторе if a[i]>a[imax] ветвь else отсутствует; это означает, что в случае невыполнения условия imax остается без изменения, что и обеспечивает наличие в области памяти с идентификатором imax значения индекса максимального из перебранных элементов.
сортировки элементов одномерного массива " методом пузырька " в порядке неубывания. Суть этой сортировки состоит в том, что сравниваются два соседних элемента; если они расположены в порядке убывания, то меняются местами, что фиксируется в переменной fl. После сравнения всех элементов массива принимается решение об очередном прохождении по массиву по состоянию fl.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
FILE *in = fopen ("in.txt", "r");
FILE *out = fopen ("out.txt", "w");
const int n1 = 100; //Максимальный размер массива
int i, //Индекс элемента массива
n, p, //Количество и произведение элементов в массиве
fl; //Флаг пеpестановок
float a[n1], d; //Дополнительная пеpеменная для
// пеpестановки местами двух элементов массива
fscanf(in, "%d", &n);
for (i = 0; i<n; i++)
fscanf(in, "%f", &a[i]);
/*_______ Соpтиpовка_________*/
do
{
fl = 1;// Флаг поднять
// В очередной раз просматриваем элементы массива
for (i = 0; i<n-1; i++)
if (a[i] > a[i+1])
{
//Меняем местами соседние элементы
d=a[i];
a[i]=a[i+1];
a[i+1]=d;
fl=0; //Если был обмен, то флаг опускаем
}
}
while (!fl); //Если fl = 1, то массив отсортирован
for (i=0;i<n;i++)
fprintf (out, "%7.2f", a[i]);
}
Основной цикл do while прекращает выполняться, когда значение переменной fl остается равной 1 после выполнения вложенного цикла for. Это происходит в том случае, если ни одну пару элементов не удается переставить, что указывает на то, что все элементы стоят на своих местах.
Двумерные массивы
Двумерные массивы имеют аналогию с таким понятием в математике, как матрица. Двумерный массив – это одномерный массив, элементами которого являются одномерные массивы
В описании N и M – количество строк и количество столбцов матрицы. Традиционно в качестве идентификатора номера строки используют символ i, а столбца – j. При изменении второго индекса j на единицу перемещение идет вдоль строки, а при изменении первого индекса i на единицу – вертикально вдоль столбца. Элемент одномерного массива а[i] является указателем на начало i-ой строки матрицы. К элементу двумерного массива, описанному выше, можно обратиться с помощью идентификатора а[i][j].
При обработке двумерных массивов возникают такие же задачи, как и при обработке одномерных массивов: ввод элементов массива, нахождение суммы, произведения, среднего и т. д., поиск некоторого элемента в массиве, сортировка элементов массива, вывод элементов массива.
В графической схеме алгоритма совмещены в одном цикле формирование, нахождение суммы и вывод элементов массива. Анализируя предложенную программу, можно заметить, что для ввода, вывода и нахождения суммы элементов массива используются два вложенных цикла. Обычно разбивают решение задачи на три этапа: ввод, обработка и вывод информации. Так как массив располагается в непрерывной области памяти построчно, более рационально будет и обрабатывать элементы построчно. В программе во вложенных циклах для каждого значения индекса i индекс j изменяется от 0 до m – 1, т. е. индекс j изменяется чаще. При выводе элементов массива на экран для каждого значения i в теле цикла выполняются два оператора: первый оператор цикла выводит на экран в строчку элементы одной строки, а второй оператор вывода переводит курсор на новую строку, что как раз и обеспечивает вывод матрицы в виде прямоугольника.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main ()
{
const int N 1 = 10, // Mаксимальнoе число стpок
M1 = 10; // Mаксимальное число столбцов
int a [N1][M1], // Mатрица
i, // Tекущий номеp строки
j, // Tекущий номеp столбца
n, m; // Tекущий размер матрицы
printf ("Введите число стpок и столбцов массива:");
scanf ("%d%d", &n, &m);
randomize ();
int s = 0; // Сумма элементов матрицы
for (i = 0; i<n; i++)
for (j = 0; j<m; j++)
{
a[i][j] = random (10);
s = s+a[i][j];
}
printf (" Полученный массив \n");
for (i = 0; i<n; i++)
{
for (j = 0; j<m; j++)
printf ("%5d", a[i][j]);
printf ("\n");
}
printf ("s = %d \n", s);
getch ();
}
Дана квадратная матрица. Заменить отрицательные элементы побочной диагонали суммой элементов главной диагонали матрицы. Главная диагональ проходит из левого верхнего в правый нижний угол. Так как работаем с квадратной матрицей, только на главной диагонали будут лежать элементы, индексы строк и столбцов которых одинаковы. Именно этот факт и используется при решении задачи. Мы не будем перебирать все элементы массива и проверять, совпали ли индексы, а сразу задаем оба индекса с помощью одного идентификатора i. Побочная диагональ проходит из правого верхнего в левый нижний угол матрицы. Нетрудно заметить, что при движении по побочной диагонали номер строки возрастает от 1 до n, номер столбца убывает от n до 1. Значит, только на побочной диагонали лежат элементы, у которых номер столбца определяется по формуле j=n –i+1. В то же время, если об-ратить внимание на эту формулу в программе, она там другая j = n–i-1, так как индексы в языке С++ изменяются от 0.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
const int N 1 = 10, //максимальнoе число стpок
M1 = 10; // и столбцов матрицы
int a[N1][M1], //матрица
i, // текущий номеp строки
j, // текущий номеp столбца
n, m, s; // текущий размер матрицы
printf ("Введите число стpок и столбцов массива:");
scanf ("%d%d", &n, &m);
printf ("Введите элементы матрицы \n");
for (i = 0; i<n; i++)
for (j = 0; j<m; j++)
scanf ("%d", &a[i][j]);
printf (" Исходный массив \n");
for (i =0; i<n; i++)
{
for (j = 0; j<m; j++)
printf ("%5d", a[i][j]);
printf ("\n");
}
s = 0;
//Сумма элементов главной диагонали
for (i = 0; i<n; i++)
s = s+a[i][i];
//Замена элементов побочной диагонали
for (i = 0; i<n; i++)
{
j = n-i-1;
if (a[i][j]<0) a[i][j] = s;
}
printf (" Полученный массив \n");
for (i = 0; i<n; i++)
{
for (j = 0; j<m; j++)
printf ("%5d", a[i][j]);
printf ("\n");
}
getch ();
}