ВУЗ: Не указан
Категория: Не указан
Дисциплина: Не указана
Добавлен: 03.03.2021
Просмотров: 582
Скачиваний: 1
Пример
#include <iostream>
#include <clocale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
int i;
for (i=0; i<5; i++)
cout << i <<"-я строка " << '\n';
cout << "Последняя строка\n";
return 0;
}
В цикле for можно объявлять переменную в области инициализации цикла.
for (int i=0; i<5; i++)
Однако переменная, объявленная в области инициализации, существует только внутри оператора for. Области инициализации и обновления переменной цикла могут содержать в себе оператор запятая. Любая из частей оператора for может быть опущена, но точки с запятой должны остаться на своих местах.
for ( ; ; )
тело цикла;
Здесь пропуск условия продолжения истолковывается как истинное значение, поэтому данный цикл будет бесконечным.
-
Цикл while (цикл с предусловием)
Цикл while представляет собой цикл for, область управления которого не содержит частей инициализации и обновления переменной цикла.
while (условие продолжения цикла)
тело цикла
Сначала программа проверяет условие продолжения цикла. Если в результате вычисления этого выражения получается логическое значение true, выполняются операторы в теле цикла. В качестве тела цикла, также может быть и составной оператор. Далее снова проверяется условие продолжения. Если данное условие оказывается ложным, то цикл прекращается. Для завершения цикла, в его теле должно быть выполнено некоторое действие, которое могло бы оказать влияние на значение условия продолжения цикла.
Пример. Найти все делители целого положительного числа.
Решение
#include <iostream>
#include <clocale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
int num;
cout << "\nВведите число: ";
cin >> num;
int half = num/2;
int div = 2;
while (div <= half)
{
if (!(num % div))
cout << div << "\n";
div++;
}
return 0;
}
Циклы for и while практически равнозначны. Обычно for применяют в качестве цикла со счетчиком, а while в том случае, когда количество итераций заранее точно не известно.
-
Цикл do while (цикл с постусловием)
Приведем синтаксис данного цикла
do
тело цикла
while (условие продолжения цикла);
Здесь вначале выполняется тело цикла и только после этого вычисляется выражение условия продолжения цикла. Если условие ложно, то цикл завершается, в противном случае выполняется следующая итерация. Подобный цикл всегда выполняется хотя бы один раз.
#include <iostream>
#include <conio.h>
#include <clocale>
using namespace std;
int main()
{
setlocale (LC_ALL, "Russian");
int a,b;
cout<<"Введите два числа\n";
cin>>a>>b;
int aa,bb;
aa=abs(a);bb=abs(b);
do
{
if (aa<bb)
{
int c=aa;
aa=bb;
bb=c;
}
aa %= bb;
}
while (aa!=0);
cout<<"НОД чисел "<<a<<" и "<<b<<" равен "<<bb;
_getch ();
return 0;
}
Операторы break и continue
Операторы break и continue позволяют программе пропускать фрагменты кода. Оператор break можно использовать в операторе switch и в любых циклах. Он вызывает переход к оператору, следующему за оператором switch или циклом. Оператор continue используется в циклах, в результате его действия, программа пропускает остальную часть тела цикла и начинает новую итерацию цикла.
Пример. Вычислить сумму только отрицательных чисел.
Решение
#include <iostream>
#include <clocale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
int sum, i, n, num;
sum=0;
cout << "Введите количество чисел: ";
cin >> n;
cout << "\nВведите "<<n<<" чисел\n";
for (i=0; i<n; i++)
{
cin>>num;
if (num>=0)
continue;
sum+=num;
}
cout<<"Сумма отрицательных чисел равна "<<sum<<'\n';
return 0;
}
Составные типы данных
-
Массивы
Массив – это тип данных, который может включать несколько значений одного типа. Объявить массив можно следующим образом
typeName arrayName [arraySize];
Например
short months[12]
создается массив с именем months, который содержит 12 элементов, каждый из которых может хранить значение типа short. Каждый элемент массива можно обрабатывать как обычную переменную. Для обращения к элементам массива используется индекс, который позволяет перечислять элементы. Нумерация элементов массива начинается с нуля. Таким образом, для указания i-го элемента массива нужно использовать команду
months[i]
Существует два варианта объявления массива
-
инициализированный
int cards[4] = {3, 6, 8, 10}
Такую форму можно использовать только при определении массива, после определения применять ее нельзя.
int cards[4];
cards[4] = {3, 6, 8, 10}
-
неинициализированный
В этом случае значения элементам массива можно присвоить индивидуально
int hand[4];
hand[0] = 5;
hand[1] = 3;
hand[2] = 8;
hand[3] = 9;
Если массив инициализируется частично, то транслятор устанавливает для оставшихся элементов нулевые значения. Таким образом, чтобы присвоить всем элементам массива нулевые значения, нужно лишь присвоить первому элементу нуль.
float totals[500] = {0};
При работе с массивами следует также следить, чтобы не выйти за объявленные границы.
Пример. Заполнить массив значениями возраста некоторых людей.
Решение
#include <iostream>
#include <clocale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
int age[4];
for (int j=0; j<4; j++)
{
cout << "Введите возраст: ";
cin >> age[j];
}
for (int j=0; j<4; j++)
cout << "Вы ввели: "<< age[j]<<'\n';
return 0;
}
Описанные выше массивы являются одномерными, т.е. данные массивы можно представить в виде одной строки данных. Двумерный массив схож с таблицей, имеющей строки и столбцы данных. В этом случае создается массив, каждый элемент которого также является массивом.
int mas [4][5];
mas является массивом из 4 элементов, причем каждый элемент данного массива представляет собой массив из 5 целочисленных значений.
Инициализировать двумерный массив можно следующим образом
int mas[4][5] =
{
{25,35,45,85,65},
{10,25,23,65,85},
{87,45,32,65,98},
{65,85,11,23,65}
};
Для того чтобы вывести содержимое всего массива, можно воспользоваться вложенным циклом.
for (int row = 0; row < 4; row++)
{
for (int col = 0; col < 5; col++)
cout << mas[row][col] << '\t';
cout << "\n";
}
-
Строки
Строка – это ряд символов, хранящихся в последовательно расположенных байтах памяти. Рассмотрим С-стиль работы со строками. Из определения следует, что строку можно хранить в массиве символов (char). Однако последний символ строки С – стиля является нулевым символом. Он служит для обозначения конца строки и записывается как \0.
char dog[5] = { 'b', 'e', 'a', 'u', 'x' };
char cat[5] = { 'f', 'a', 't', 's', '\0' };
Здесь первая запись не является строкой, а вторая строка. Объект cout при выводе строки, обрабатывает ее посимвольно, до достижения нулевого символа. Если же мы будет обрабатывать как строку первый массив, то данный объект сначала выведет все символы массива, а дальше будет отображать байт за байтом памяти, пока не будет достигнут нулевой символ. Однако, есть более лучший способ присвоения строки символьному массиву. Он состоит в использовании строковой константы, т.е. строки в кавычках.
char bird[10] = "Mr. Cheep";
char fish[] = "Bubbles";
Любые две строковые константы, разделенные только пробельными символами (пробелами, знаками табуляции и символами новой строки) автоматически объединяются в одну.
cout << "Такое объединение называется "
"конкатенацией строк.\n";
При вводе строки используя объект cin, ввод выполняется до первого пробельного символа. Для ввода строк состоящих из нескольких слов используются функции-элементы getline и get.
cin.getline(name, ArSize);
cin.get(name, ArSize);
Эти функции считывают из входного потока ArSize-1 символов или менее и записывают их в строковую переменную name. Однако при достижении символа перевода строки, первая функция его удаляет, а вторая нет (это бывает полезно для определения была ли строка считана полностью). В конце введенной строки автоматически добавляется нулевой символ. Если введенная строка содержит больше указанного количества символов, то обе функции оставляют оставшиеся символы во входной очереди, однако первая из них устанавливает бит ошибки и прекращает дальнейший ввод. Для того чтобы узнать длину введенной строки можно воспользоваться стандартной функцией strlen(), для чего необходимо включить заголовочный файл cstring.
Пример.
#include <iostream>
#include <clocale>
#include <cstring>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
const int ArSize = 20;
char name[ArSize];
char dessert[ArSize];
cout << "Введите Вашу фамилию и имя:\n";
cin.getline(name, ArSize);
cout << "Введите Ваш любимый десерт:\n";
cin.getline(dessert, ArSize);
cout <<"Размер массива с именем равен "<< strlen(name)+1<<"\n";
cout <<"У меня есть "<< dessert;
cout <<" для "<< name << ".\n";
return 0;
}
Пример.
#include <iostream>
#include <clocale>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
const int ArSize = 80;
cout <<"В каком году был построен Ваш дом?\n";
int year;
(cin >> year).get(); //cin >> year; невозможность ввода адреса
cout <<"По какому адресу находится Ваш дом?\n";
char adres[ArSize];
cin.getline(adres, ArSize);
cout << "Год постройки: "<<year<<"\n";
cout << "Адрес: "<<adres<<"\n";
return 0;
}
-
Структуры
Структура – это составной тип данных, который получается путем объединения компонент, принадлежащих к другим типам данных. Сначала тип структуры надо описать, а затем можно создавать переменные этого нового типа. Описание типа структуры "Name" имеет следующий синтаксис:
struct Name
{
Тип1 Имя1;
Тип2 Имя2;
...
Тип3 Имя3;
};
В качестве типов можно использовать любой тип данных С++, включая массивы и другие структуры. Стоит обратить внимание на точку с запятой в конце описания типа структуры. Переменные типа структуры описываются аналогично переменным встроенных типов. Для обращения к отдельным компонентам структуры применяется операция "." (точка). Сначала указывается имя переменной-структуры, а затем – имя компоненты.
Пример. Опишем структуру видов упаковочной тары.
#include <iostream>
#include <clocale>
using namespace std;
struct packing //Упаковка
{
char name[40]; //Имя
float volume; //Объем
double price; //цена
};
int main()
{
setlocale(LC_ALL, "Russian");
packing box1 =
{ //инициализация с присвоением
"Короб для конфет",
150,
30.75
};
packing box2 =
{ //инициализация с присвоением
"Короб для печенья", //еще одной переменной
250,
49.30
};
cout << "Для приобретения изделий "
<<box1.name<<" и "
<<box2.name<<"\n";
cout << "Вам необходимо "<<box1.price+box2.price<<" рублей\n";
return 0;
}
В данной программе объявление структуры является внешним объявлением, что позволяет использовать данную структуру в других функциях описанных в этой программе. Для структур допускается использования оператора присвоения, чтобы присвоить значение одной структуры другой структуре того же типа. Имеется также возможность создавать массивы структур
packing boxes[100];
Для вывода цены 39 позиции массива нужно поступить следующим образом
cout << boxes[38].price;
Инициализация такого массива сходна с инициализацией двумерного массива.
-
Объединения
Объединение – это формат данных, который может содержать различные типы данных, но только один тип одновременно. Объединение представляет собой частный случай структуры. Синтаксис объявления схож с объявлением структуры, только вместо struct используется union. Объединения применяют для экономии памяти в тех случаях, когда известно, что больше одного поля одновременно не требуется.
Пример. Учет изделий имеющих или числовой или строковый идентификатор.
struct widget
{
char brand[20];
int type;
union id
{
long id_num;
char id_char[20];
} id_val;
};
...
widget prize;
...
if (prize.type == 1)
cin >> prize.id_val.id_num;
else
cin >> prize.id_val.id_char;
-
Перечисления
Перечисления обеспечивают способы создания символических констант, а также могут определять новые типы данных. Синтаксис выглядит следующим образом
enum [имя_типа] {список_констант};
Пример.
enum spectrum {red, orange, yellow, green, blue, violet, indigo, ultraviolet};
В этом примере создается новый тип spectrum. red, orange и т.д определяются как символические константы для целых чисел от 0 до 7. Эти константы называются перечислителями. Переменной типа перечисления без преобразования типов можно присваивать только значения перечислителей. Если планируется использовать только константы и не создавать переменных типа enum, имя типа перечисления можно опустить.
enum {red, orange, yellow, green, blue, violet, indigo, ultraviolet};
Значения перечислителей можно устанавливать явно
enum bits {one=1, two=2, four=4, eight=8};
enum bigstep {first, second=100, third}; //значения перечислителей 0, 100, 101
enum {zero, null=0, one, numer0_uno=1}; //значения перечислителей 0, 0, 1, 1
Итак, если не указано иное, то первый элемент равен нулю, а последующие будут больше предыдущего на единицу.
-
Указатели и динамическая память.
Часто приходится обрабатывать данные, количество которых и их тип заранее не известны. В этом случае удобно использовать динамическую память. Динамическая память (куча) – эта та оперативная память компьютера, которая выделяется программе в процессе её выполнения. Использование динамической памяти позволяет экономить ресурсы памяти компьютера: в начале там могут быть размещены одни переменные, а затем они могут быть удалены и на их месте размещены другие.
Как уже говорилось ранее переменная – это именованная область памяти, в которой хранятся данные определенного типа. Любая ячейка оперативной памяти – байт – имеет собственный адрес (номер). Для того чтобы получить адрес переменной, нужно воспользоваться операцией взятия адреса &. (&x) Переменная специального вида, содержащая в себе значение адреса, называется переменной-указателем или просто указателем. Применяя операцию * к указателю, называемую операцией разыменовывания, можно получить значение, хранящееся по этому адресу.
Переменную типа указатель можно объявить следующим образом
имяТип *имяУказателя;
Тип может быть практически любой, причем он может быть к этому моменту только объявлен, но еще не определен (в структуре может присутствовать указатель на структуру того же типа). Можно также определить указатель на указатель. Звездочка относится непосредственно к имени.
int *a, b, *c;
Данная запись означает, что объявлены два указателя на тип int (a и b) и переменная типа int.
Пример.
#include <clocale>
#include <iostream>
using namespace std;
int main()
{
int updates = 6; //объявление переменной
int * p_updates; //Объявление указателя на значение типа int
p_updates = &updates; //присвоение адреса значения типа int указателю
cout << "Значения: updates = " << updates; //updates = 6
cout << ", *p_updates = " << *p_updates << endl; //*p_updates = 6
cout << "Адреса: &updates = " << &updates; //&updates=0065fd48
cout << ", p_updates = " << p_updates << endl; //p_updates=0065fd48
*p_updates = *p_updates + 1;
cout << "Новое значение updates = " << updates << endl; //7
return 0;
}
Поскольку p_updates указывает на значение updates, выражения *p_updates и updates совершенно эквивалентны. Выражение *p_updates можно использовать точно так же, как переменную типа int. Для инициализации указателя можно использовать оператор объявления. В этом случае инициализируется указатель, а не указываемое значение.
int higgens = 5;
int * pt = &higgens;
Здесь присвоение происходит указателю pt значения &higgens, но не *pt.
Важно помнить, что при создании указателя в С++ компьютер выделяет память для хранения адреса, но не для хранения данных, на которые указывает этот адрес. Поэтому всегда необходимо присваивать указателю определенное и правильное значение адреса до применения к нему операции разыменовывания (*).
Переменная это именованная область памяти, а ценность указателей проявляется, когда для хранения данных выделяется неименованная область памяти во время выполнения программы. В этом случае указатели являются единственным способом доступа к этим областям памяти. Для этого необходим оператор new. Этот оператор ищет блок памяти нужного размера и возвращает адрес этого блока. Присваивая этот адрес указателю, получим желаемое.
имяТипа имя_указателя = new имяТипа
например
int *pn = new int;
Оператор new анализирует тип для вычисления необходимого количества байтов. Затем он отыскивает область памяти и возвращает адрес. И наконец, этот адрес присваивается указателю pn на тип int. Отметим, что память, на которую указывает pn, не является переменной.