/ РазрПрогрПрилож / С++ / 1С++
Структурное программирование
Традиционная технология программирования складывалась в условиях, когда
основными потребителями программ были научные учреждения, вычислительные ресурсы были ограничены, а проблемы сопровождения по существу неизвестны. Основными критериями качества программы считались ее узко понимаемая эффективность и компактность. Со временем сложность программ возросла настолько, что на их разработку уходили годы труда большого коллектива, а в результате системы появлялись с опозданием и содержали тысячи ошибок.
Кризис программного обеспечения привел к необходимости создания нового способа создания программ, который снижал бы общие затраты на протяжении всего цикла программы, — от замысла до завершения эксплуатации. Такая технология появилась в начале 70-х годов и была названа структурным программированием.
В его основе лежит сочетание теории программирования и личного опыта высококвалифицированных программистов, а также учет современных требований к программам и промышленного характера их производства. Главное требование, которому должна удовлетворять программа, — работать полном соответствии со спецификацией и адекватно реагировать на любые действия пользователя. Кроме этого, программа должна быть выпущена точно к заявленному сроку и допускать оперативное внесение необходимых изменений и дополнений.
Объем занимаемой памяти и эффективность алгоритмов при этом отходят на второй план. Иными словами, современные критерии качества программы — это, прежде всего, надежность, а также возможность точно планировать производство программы и ее сопровождение. Для достижения
этих целей программа должна иметь простую структуру, быть хорошо читаемой и легко модифицируемой.
Структурный подход к программированию позволил успешно создавать достаточно крупные проекты, но сложность программного обеспечения продолжала возрастать, и требовались все более развитые средства ее преодоления. Идеи структурного программирования получили свое дальнейшее развитие в объектно-ориентированном программировании (ООП) — технологии, позволяющей достичь простоты структуры и управляемости очень крупных программных систем.
Основные типы данных
Основные {стандартные) типы данных часто называют арифметическими, поскольку их можно использовать в арифметических операциях. Для описания основных типов определены следующие ключевые слова:
• int (целый);
• char (символьный);
• wchar_t (расширенный символьный);
• bool (логический);
• float (вещественный);
• double (вещественный с двойной точностью).
Первые четыре типа называют целочисленными (целыми), последние два — типами с плавающей точкой.
Существует четыре спецификатора типа, уточняющих внутреннее представление и диапазон значений стандартных типов:
• short (короткий);
• long (длинный);
• signed (знаковый);
• unsigned (беззнаковый).
Кроме перечисленных, к основным типам языка относится тип void, но множество значений этого типа пусто. Он используется для определения функций, которые не возвращают значения, для указания пустого списка аргументов функции.
Структура программы
Программа на языке C++ состоит из функций, описаний и директив препроцессора. Одна из функций должна иметь имя main. Выполнение программы начинается с первого оператора этой функции. Простейшее определение функции имеет следующий формат:
директивы препроцессора
описания
int main(){
операторы главной функции
}
int f1(){
операторы функции f1
}
int f2(){
операторы функции f2
}
В языке C++ нет встроенных средств ввода/вывода — он осуществляется с помощью функций, типов и объектов, содержащихся в стандартных библиотеках. Используется два способа: функции, унаследованные из языка С, и объекты C++.
Основные функции ввода/вывода в стиле С:
int scanf (const char* format. ... ) // ввод
int printf(const char* format. ... ) // вывод
Пример программы, использующей функции ввода/вывода в стиле С:
#include
int main(){
int i:
printf("Введите целое число\n"):
scanf(“%d", &1):
printf("Вы ввели число %d, спасибо!", i):
return 0:
}
Функция scanf заносит введенное с клавиатуры целое число в переменную
i (знак & означает операцию получения адреса).
Та же программа с использованием библиотеки классов C++:
#include
int main(){
int i:
cout « "Введите целое число\n":
cin »i;
cout « "Вы ввели число " « i « ". спасибо!":
return 0;
}
Заголовочный файл содержит описание набора классов для управления вводом/выводом. В нем определены стандартные объекты-потоки сin для ввода с клавиатуры и cout для вывода на экран, а также операции помещения в поток « и чтения из потока ».
Переменные
Переменная — это именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменять. Перед использованием любая переменная должна быть описана.
Пример описания целой переменной с именем а и вещественной переменной х:
int а; float х;
Общий вид оператора описания переменных:
[класс памяти] [const] тип имя [инициализатор];
Необязательный класс памяти может принимать одно из значений auto, extern, static и register. Модификатор const показывает, что значение переменной изменять нельзя. Такую переменную называют именованной константой, или просто константой. При описании можно присвоить переменной начальное значение, это называется инициализацией. Инициализатор можно записывать в двух формах — со знаком равенства:
= значение или в круглых скобках: ( значение ).
Константа должна быть инициализирована при объявлении. В одном операторе можно описать несколько переменных одного типа, разделяя их запятыми.
Примеры:
short int а = 1; // целая переменная а
const char С = ' С’ ; // символьная константа С
char s, sf = 'f’ ; // инициализация относится только к sf
char t (54);
float с = 0.22, x(3), sum;
Область действия идентификатора — это часть программы, в которой его можно использовать для доступа к связанной с ним области памяти. В зависимости от области действия переменная может быть локальной или глобальной. Если переменная определена внутри блока (ограничен фигурными скобками), она называется локальной, область ее действия — от точки описания до конца блока, включая все вложенные блоки. Если переменная определена вне любого блока, она называется глобальной и областью ее действия считается файл, в котором она определена, от точки описания до его конца.
Класс памяти определяет время жизни и область видимости программного объекта (в частности, переменной). Если класс памяти не указан явным образом, он определяется компилятором исходя из контекста объявления. Время жизни может быть постоянным (в течение выполнения программы) и временным (в течение выполнения блока).
Областью видимости идентификатора называется часть текста программы, из которой допустим обычный доступ к связанной с идентификатором областью памяти. Чаще всего область видимости совпадает с областью действия. Исключением является ситуация, когда во вложенном блоке описана переменная с таким же именем. В этом случае внешняя переменная во вложенном блоке невидима, хотя он и входит в ее область действия. Тем не менее, к этой переменной, если она глобальная, можно обратиться, используя операцию доступа к области видимости ::.
Для задания класса памяти используются следующие спецификаторы:
auto — автоматическая переменная. Память под нее выделяется в стеке и при необходимости инициализируется каждый раз при выполнении оператора, содержащего ее определение. Освобождение памяти происходит при выходе из блока, в котором описана переменная. Время ее жизни — с момента описания до конца блока. Для глобальных переменных этот спецификатор не используется, а для локальных он принимается по умолчанию, поэтому задавать его явным образом большого смысла не имеет.
extern — означает, что переменная определяется в другом месте программы
(в другом файле или дальше по тексту). Используется для создания переменных, доступных во всех модулях программы, в которых они объявлены.
static — статическая переменная. Время жизни — постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной. В зависимости от расположения оператора описания статические переменные могут быть глобальными и локальными. Глобальные статические переменные видны только в том модуле, в котором они описаны.
register — аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.
int а; //1 глобальная переменная а
int main(){
int b; // 2 локальная переменная b
extern int X: //3 переменная x определена в другом месте
static int с; // 4 локальная статическая переменная с
а = 1; //5 присваивание глобальной переменной
int а; // 6 локальная переменная а
а = 2; //7 присваивание локальной переменной
::а = 3; //8 присваивание глобальной переменной
return 0;
}
int X = 4; // 9 определение и инициализация х
Переменные b и с — локальные, область их видимости — блок, но время жизни различно: память под b выделяется в стеке при входе в блок и освобождается при выходе из него, а переменная с располагается в сегменте
данных и существует все время, пока работает программа.
Если при определении начальное значение переменных явным образом не задается, компилятор присваивает глобальным и статическим переменным нулевое значение соответствующего типа. Автоматические переменные не инициализируются.
Имя переменной должно быть уникальным в своей области действия (например, в одном блоке не может быть двух переменных с одинаковыми именами).
Операции
Операция определения размера sizeof предназначена для вычисления размера объекта или типа в байтах, и имеет две формы:
sizeof выражение
sizeof ( тип )
Пример:
#include
int main(){
float x = 1;
cout « "sizeof (float) :" « sizeof (float):
cout « "\nsizeof x :" « sizeof x;
cout « "\nsizeof (x + 1.0) :" « sizeof (x +1.0):
return 0:
}
Результат работы программы:
sizeof (float) : 4
sizeof x : 4
sizeof (x + 1.0) : 8
Последний результат связан с тем, что вещественные константы по умолчанию имеют тип doublе, к которому, как к более длинному, приводится тип переменной X и всего выражения.
Операции отрицания (-,!и ~).
Логическое отрицание (!) дает в результате значение 0, если операнд есть истина (не нуль), и значение 1, если операнд равен нулю. Операнд должен быть целого или вещественного типа, а может иметь также тип указатель. Поразрядное отрицание (~), часто называемое побитовым, инвертирует каждый разряд в двоичном представлении целочисленного операнда.
Деление (/) и остаток от деления (%). Операция деления применима к операндам арифметического типа. Если оба операнда целочисленные, результат операции округляется до целого числа, в противном случае тип результата определяется правилами преобразования. Операция остатка от деления применяется только к целочисленным операндам. Знак результата зависит от реализации.
#include
int main(){
int x = 11, у = 4;
float z = 4;
printf("Результаты деления: %d %f\n". x/y. x/z):
printf("Остаток: %d\n". x/y):
return 0;
}
Результат работы программы:
Результаты деления: 2 2.750000
Остаток: 3
Операции сдвига ( « и » ) применяются к целочисленным операндам. Они
сдвигают двоичное представление первого операнда влево или вправо на количество двоичных разрядов, заданное вторым операндом. При сдвиге влево ( « ) освободившиеся разряды обнуляются. При сдвиге вправо (>>) освободившиеся биты заполняются нулями, если первый операнд беззнакового типа, и знаковым разрядом в противном случае. Операции сдвига не учитывают переполнение и потерю значимости.
Операции отношения (. >=. = . !=) сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. Результатом операции является значение true или false (любое значение, не равное нулю, интерпретируется как true). Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.
Поразрядные операции (&, |, ^) применяются только к целочисленным операндам и работают с их двоичными представлениями. При выполнении операций операнды сопоставляются побитово (первый бит первого операнда с первым битом второго, второй бит первого операнда со вторым битом второго, и т д.). При поразрядной конъюнкции, или поразрядном И (операция обозначается &) бит результата равен 1 только тогда, когда соответствующие биты обоих операндов равны 1.
При поразрядной дизъюнкции, или поразрядном ИЛИ (операция обозначается |) бит результата равен 1 тогда, когда соответствующий бит хотя бы одного из операндов равен 1.
При поразрядном исключающем ИЛИ (операция обозначается ^) бит результата равен 1 только тогда, когда соответствующий бит только одного из операндов равен 1.
#inclucle
int main()
cout « "\n 6 & 5 = " «
cout « "\n 6
Результат работы программы:
6 & 5 = 4
6 | 5 = 7
6 ^ 5 = 3
Логические операции (&& и ||). Операнды логических операций И (&&) и ИЛИ (||) могут иметь арифметический тип или быть указателями, при этом операнды в каждой операции могут быть различных типов. Преобразования типов не производятся, каждый операнд оценивается с точки зрения его эквивалентности нулю. Результатом логической операции является true или false. Результат операции логическое И имеет значение true только если оба операнда имеют значение true. Результат операции логическое ИЛИ имеет значение true, если хотя бы один из операндов имеет значение true. Логические операции выполняются слева направо. Если значения первого операнда достаточно, чтобы определить результат операции, второй операнд не вычисляется.
Операции присваивания (=, +=, -=, *= и т.д.). Мнемоническое правило: «присваивание — это передача данных "налево"». При присваивании производится преобразование типа выражения к типу L- значения, что может привести к потере информации. В сложных операциях присваивания ( +=, *=, /= и т п.) при вычислении выражения, стоящего в правой части, используется и L- значение из левой части. Например, при сложении с присваиванием ко второму операнду прибавляется первый, и результат записывается в первый операнд, то есть выражение а += b является более компактной записью выражения а = а + b.
Условная операция (?:). Эта операция тернарная, то есть имеет три операнда. Ее формат:
Операнд_1 ? операнд_2 : операнд_3
Первый операнд может иметь арифметический тип или быть указателем. Он оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как false, не равный нулю — как true). Если результат вычисления операнда 1 равен true, то результатом условной операции будет значение второго операнда, иначе — третьего операнда. Вычисляется всегда либо второй операнд, либо третий. Их тип может различаться. Условная операция является сокращенной формой условного оператора if .
#include
int main(){
int a = 11, b = 4, max;
max = (b > a)? b : a;
printfC"Наибольшее число: М". max);
return 0;
}
Результат работы программы:
Наибольшее число: 11
Другой пример применения условной операции. Требуется, чтобы некоторая целая величина увеличивалась на 1, если ее значение не превышает n, а иначе принимала значение 1:
i = (1 < n) ? i + 1: 1;
Базовые конструкции структурного программирования
Условный оператор if
Условный оператор if используется для разветвления процесса вычислений на два направления. Формат оператора:
i f ( выражение ) оператор_1; [else оператор_2;]
Если в какой-либо ветви требуется выполнить несколько операторов, их необходимо заключить в блок, иначе компилятор не сможет понять, где заканчивается ветвление.
Примеры:
i f (а
i f (ad || a==0)) b++; else {b *- a: a = 0;} //2
i f (a
i f (a++) b++; // 4
i f (b>a) max = b; else max = a; //5
Если требуется проверить несколько условий, их объединяют знаками логических операций. Например, выражение в примере 2 будет истинно в том случае, если выполнится одновременно условие аОператор в примере 3 вычисляет наименьшее значение из трех переменных. Фигурные скобки в данном случае не обязательны, так как компилятор относит часть else к ближайшему if.
Пример 4 напоминает о том, что хотя в качестве выражений в операторе if чаще всего используются операции отношения, это не обязательно. Конструкции, подобные оператору в примере 5, проще записывать в виде условной операции (в данном случае: max = (b > а) ? b : а;).
Пример. Производится выстрел по мишени. Определить количество очков.
#include
int main(){
float x, у; int kol;
cout « "Введите координаты выстрела\n";
cin » x » у;
if ( x*x + y*y < 1 ) kol = 2;
else if( x*x + y*y < 4 ) kol = 1;
else коl = 0;
cout « "\n Очков:”
return 0;
}
Чтобы проверить условие 0
Даже такую простую программу можно еще упростить с помощью промежуточной переменной и записи условия в виде двух последовательных, а не вложенных, операторов if (в первом варианте значение переменной kol
присваивается один раз, а во втором — от одного до трех раз в зависимости
от выполнения условий):
#inc!ucle
int main(){
float x, у, temp; int коl;
cout « "Введите координаты выстрела\n";
cin » x » у;
temp = x
коl = 0:
i f (temp < 4 ) коl = 1;
i f (temp < 1 ) kol = 2:
cout « "\n Очков: " « kol;
return 0;
}
Если какая-либо переменная используется только внутри условного оператора, рекомендуется объявить ее внутри скобок, например:
i f (int i = fun(t)) a -= i; else a += i;
Объявление переменной в тот момент, когда она требуется, то есть когда ей необходимо присвоить значение, является признаком хорошего стиля и позволяет избежать случайного использования переменной до ее инициализации. Объявлять внутри оператора if можно только одну переменную. Область ее видимости начинается в точке объявления и включает обе ветви оператора.
Оператор switch
Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений. Выполнение оператора начинается с вычисления выражения (оно должно быть целочисленным), а затем управление передается первому оператору из списка, помеченного константным выражением, значение которого совпало с вычисленным.
После этого, если выход из переключателя явно не указан, последовательно
выполняются все остальные ветви. Выход из переключателя обычно выполняется с помощью операторов break или return. Оператор break выполняет выход из самого внутреннего из объемлющих его операторов switch, for, while и do. Оператор return выполняет выход из функции, в теле которой он записан.
Пример калькулятора на 4 действия
#include
int main(){
int a, b, res;
char op;
cout « "n\Введите 1й операнд : "; cin » a;
cout « "n\Введите знак операции : "; cin » op;
cout « "n\Введите 2й операнд : "; cin » b;
bool f = true;
switch (op){
case '+': res = a + b; break;
case '-': res = a – b; break;
case '*': res = a * b; break;
case’ /’: res = a / b; break;
default cout: «"n\Неизвестная операция”; f = false;
}
If (f) cout: « "\nРезультат : " « res;
return 0;
}
Операторы цикла
Цикл с предусловием (while)
Пример печати таблицы значений функции г/=х2+1 во введенном диапазоне:
#include
int main()\n"); // шапка таблицы
float X = Xn; // установка параметра цикла
while (X
printf ('l ^5.2f I ^5.2f
return 0;
Пример: найти все делители целого положительного числа:
#include
int main(){
int num;
cout « "\nВведите число : "; cin » num;
int half = num / 2; // половина числа
int div = 2; // кандидат на делитель
while (div
i f (!(num % div))cout « div « " \ n ";
div++;
}
return 0;
}
В круглых скобках после ключевого слова while можно вводить описание переменной. Областью ее действия является цикл:
while (int х = 0){ ... / * область действия х */ }
Цикл с постусловием (do while)
Сначала выполняется простой или составной оператор, составляющий тело цикла, а затем вычисляется выражение. Если оно истинно (не равно fаlse), тело цикла выполняется еще раз. Цикл завершается, когда выражение станет равным false или в теле цикла будет выполнен какой- либо оператор передачи управления.
Тип выражения должен быть арифметическим или приводимым к нему.
Пример (программа осуществляет проверку ввода):
#include
int main(){
char answer;
do{
cout « "\nКупи слоника! "; cin » answer;
}while (answer != 'y');
return 0;
}
Пример. Программа вычисляет квадратный корень вещественного аргумента X с заданной точностью Eps по итерационной формуле:
Уn = ½* (уn-1 + X/yn-1), где Уn-1 — предыдущее приближение к корню (в начале вычислений выбирается произвольно), Уn — последующее приближение. Процесс вычислений прекращается, когда приближения станут отличаться друг от друга по абсолютной величине менее, чем на величину заданной точности. Для вычисления абсолютной величины используется стандартная функция fabs(), объявление которой находится в заголовочном файле .
#include
int main(){
double X, Eps; // аргумент и точность
double Yp, Y = 1; // предыдущее и последующее приближение
printf ("Введите аргумент и точность: " );
scanf (“%l f%lf, &Х, &Eps);
do{
Yp = Y;
Y = (Yp + X/Yp)/2;
}while (fabs(Y - Yp) >= Eps);
printf("\nKopeнь из %If равен %If",X, Y);
return 0;
}
Цикл с параметром (for)
Инициализация используется для объявления и присвоения начальных значений величинам, используемым в цикле. Можно записать несколько операторов, разделенных запятой, например:
for (int 1 = 0, j = 2; ...
int k, m;
for (k = 1, m = 0; ...
Областью действия переменных, объявленных в части инициализации цикла, является цикл. Инициализация выполняется один раз в начале исполнения цикла. Выражение определяет условие выполнения цикла: если его результат, приведенный к типу bool, равен true, цикл выполняется. Цикл с параметром реализован как цикл с предусловием.
Модификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла. Можно записать несколько операторов через запятую. Простой или составной оператор представляет собой тело цикла. Любая из частей оператора for может быть опущена (но точки с запятой надо оставить на своих местах!).
Пример (оператор, вычисляющий сумму чисел от 1 до 100):
for (int 1 = 1, s = 0; i
Пример программы, печатающей таблицу значений функции y=x^2+1 во введенном диапазоне):
#inclucle
int main()\n");
for (X = Xn; X
printfC'l %5.2f I %5.2f
Пример (программа находит все делители целого положительного числа):
#include
int main(){
int num, half, div;
cout « "\nВведите число : "; cin » num;
for (half = num / 2, div = 2; div
if (!(num % div))cout « div «"\n";
return 0;
}
Два последних примера выполняют те же действия, что и примеры для цикла с предусловием, но записаны более компактно и наглядно: все действия, связанные с управлением циклом, локализованы в его заголовке. Любой цикл while может быть приведен к эквивалентному ему циклу for и наоборот по следующей схеме:
for (b1;b2;bЗ) операторы;
while (b2){
оператор; bЗ;}
Чтобы избежать ошибок, рекомендуется:
• проверить, всем ли переменным, встречающимся в правой части операторов
присваивания в теле цикла, присвоены до этого начальные значения (а также
возможно ли выполнение других операторов);
• проверить, изменяется ли в цикле хотя бы одна переменная, входящая в условие выхода из цикла;
• предусмотреть аварийный выход из цикла по достижению некоторого количества итераций;
• если в теле цикла требуется выполнить более одного оператора, нужно заключать их в фигурные скобки.
Оператор do while обычно используют, когда цикл требуется обязательно выполнить хотя бы раз.
Оператором while удобнее пользоваться в случаях, когда число итераций заранее не известно, очевидных параметров цикла нет или модификацию параметров удобнее записывать не в конце тела цикла.
Оператор for предпочтительнее в большинстве остальных случаев (однозначно — для организации циклов со счетчиками).
Операторы передачи управления
Оператор break
Оператор break используется внутри операторов цикла или switch для обеспечения перехода в точку программы, находящуюся непосредственно за оператором, внутри которого находится break.
Пример. Вычисляем значение гиперболического синуса вещественного аргумента х с заданной точностью eps с помощью разложения в бесконечный
ряд.
sh X = 1 + xV3! + xV5! + xV7! + ...
Вычисление заканчивается, когда абсолютная величина очередного члена ряда, прибавляемого к сумме, станет меньше заданной точности.
#include
int main(){
const 1nt MaxIter = 500; // ограничитель количества итераций
double X, eps;
cout « "\nВведите аргумент и точность: ";
сin » X » eps;
bool flag = true; // признак успешного вычисления
StudFiles.ru
1.3 Переменные
Каждая переменная перед ее использованием в программе должна быть определена, т.е. для переменной должна быть выделена память. Размер участка памяти, выделяемого для переменной, и интерпретация содержимого зависят от типа, указанного в определении переменной.
В соответствии с типами значений, допустимых в языке Си, рассмотрим символьные, целые и вещественные переменные автоматической памяти. Переменные автоматической памяти существуют в том блоке, где они определены. В наиболее распространенном случае таким блоком является текст основной (main) функции программы.
Простейшая форма определения переменных:
тип список_имен_переменных;
где имена переменных - это выбранные программистом идентификаторы, которые в списке разделяются запятыми;
тип - один из типов.
Определены целочисленные типы:
char- целый длиной не менее 8 бит;
shortint- короткий целый (допустима аббревиатура short);
int- целый;
long- длинный целый.
Каждый из целочисленных типов может быть определен либо как знаковый signedлибо как беззнаковый unsigned(по умолчанию signed).
Различие между этими двумя типами - в правилах интерпретации старшего бита внутреннего представления. Спецификатор signedтребует, чтобы старший бит внутреннего представления воспринимался как знаковый; unsignedозначает, что старший бит внутреннего представления входит в код представляемого числового значения, которое считается в этом случае беззнаковым. Выбор знакового или беззнакового представления определяет предельные значения, которые можно представить с помощью описанной переменной. Например, на IBM PC переменная типа unsignedintпозволяет представить числа от 0 до 65535, а переменной типа signedint(или просто int) соответствуют значения в диапазоне от -32768 до +32767.
Примеры определений целочисленных переменных:
char symbol, cc;
unsigned char code;
int number, row;
unsigned long long_number;
Обратите внимание на необходимость символа "точка с запятой" в конце каждого определения.
Стандартом языка введены следующие вещественные типы:
float - вещественный одинарной точности;
double - вещественный удвоенной точности;
long double- вещественный максимальной точности.
Значения всех вещественных типов в ЭВМ представляются с "плавающей точкой", т.е. с мантиссой и порядком,
Примеры определений вещественных переменных:
floatх, X, ссЗ, pot_8;
doublea, Stop, B4;
Инициализация переменных. В соответствии с синтаксисом языка переменные автоматической памяти после определения по умолчанию имеют неопределенные значения. Надеяться на то, что они равны, например, 0, нельзя. Однако переменным можно присваивать начальные значения, явно указывая их в определениях:
тип имя_ переменной=начальное значение;
Этот прием назван инициализацией. В отличие от присваивания, которое, осуществляется в процессе выполнения программы, инициализация выполняется при выделении для переменной участка памяти. Примеры определений с инициализацией:
floatpi=3.1415, cc=1.23;
unsignedint. year=1997;
Именованные константы. В языке Си, кроме переменных, могут быть определены константы, имеющие фиксированные названия (имена). В качестве имен констант используются произвольно выбираемые программистом идентификаторы, не совпадающие с ключевыми словами и с другими именами объектов. Традиционно принято, что для обозначений констант выбирают идентификаторы из больших букв латинского алфавита и символов подчеркивания. Такое соглашение позволяет при просмотре большого текста программы на языке Си легко отличать имена переменных от названий констант.
Первая возможность определения именованных констант, это перечисляемые константы, вводимые с использованием служебного слова enum.
Вторую возможность вводить именованные константы обеспечивают определения такого вида:
constтип имя_константы=значение_константы;
Здесь const - квалификатор типа, указывающий, что определяемый объект имеет постоянное значение, т.е. доступен только для чтения;
тип - один из типов объектов;
имя константы -идентификатор;
значение_константы должно соответствовать ее типу. Примеры:
const double Е=2.718282;
const long M=99999999;
const F=765;
В последнем определении тип константы не указан, по умолчанию ей приписывается тип int.
Третью возможность вводить именованные константы обеспечивает препроцессорная директива
#define имя_константы значение константы
Обратите внимание на отсутствие символа "точка с запятой" в конце директивы.
Отличие определения именованной константы
const double Е=2.718282;
от определения препроцессорной константы с таким же значением
#define EULER 2.718282
состоит внешне в том, что в определении константы Е явно задается ее тип, а при препроцессорном определении константы EULER ее тип определяется "внешним видом" значения константы. Например, следующее определение
#define NEXT 'Z'
вводит обозначение NEXT для символьной константы 'Z'. Это соответствует такому определению:
const char NEXT = 'Z';
Однако различия между обычной именованной константой и препроцессорной константой, вводимой директивой #define, гораздо глубже и принципиальнее. До начала компиляции текст программы на языке Си обрабатывается специальным компонентом транслятора - препроцессором. Если в тексте встречается директива
#define EULER 2.718282
а ниже ее в тексте используется имя константы EULER, например, в таком виде:
double mix = EULER;
d = alfa*EULER;
то препроцессор заменит каждое обозначение EULER на ее значение и сформирует такой текст:
double mix = 2.718282;
d = alfa*2.718282;
Далее текст от препроцессора поступает к компилятору, который уже "и не вспомнит" о существовании имени EULER, использованного в препроцессорной директиве #define. Константы, определяемые на препроцессорном уровне с помощью директивы #define, очень часто используются для задания размеров массивов, что будет продемонстрировано позже. Подстановка не выполняется в комментариях и в строковых константах.
Именно с помощью набора именованных препроцессорных констант стандарт языка Си рекомендует авторам компиляторов определять предельные значения всех основных типов данных. Для этого в языке определен набор фиксированных имен, каждое из которых является именем одной из констант, определяющих то или иное предельное значение. Например:
FLT_MAX - максимальное число с плавающей точкой типа float;
CHAR_BIT- количество битов в байте;
INT_МIN - минимальное значение для данных типа int.
Чтобы использовать в программе указанные именованные препроцессорные константы, недостаточно записать их имена в программе. Предварительно в текст программы необходимо включить препроцессорную директиву такого вида:
#include
где в качестве имени заголовочного_файпа подставляются:
limits.h - для данных целых типов;
float.h - для вещественных данных.
#include
StudFiles.ru
Переменные
17
после цифры 0 записана буквах (заглавная или строчная), то следующее далее число записано в шестнадцатеричной системе счисления, например:
31 десятичное число;
031 восьмеричное число (равно десятичному числу
25);
0х31 шестнадцатеричное число (равно десятичному числу49).
Константы, соответствующие символам управления можно задавать в апострофах, но в коде должна быть записана обратная косая черта, и буква или цифра, задающая управляющий символ. Например, символ перевода на новую строку записывают как '\n', а символ признака конца строки'\0'.
Переменными называются величины, которые в процессе выполнения программы могут изменять свои значения. Каждая переменная имеет имя. Имя может содержать строчные и заглавные буквы латинского алфавита, символ знака подчеркивания ('_') и цифры. Первым символом не может быть цифра. В языке С++ при написании имени переменной учитывается регистр. Поэтому одно и то же имя, записанное строчными буквами и заглавными буквами, компилятор воспринимает, как разные имена.
Обычно принято заглавными буквами обозначать имена констант, задаваемых директивой #define, а имена обычных переменных строчными буквами. Если в состав имени переменной входит слово, то его желательно начинать с заглавной буквы. Длина имени не должна превышать31 символа. В качестве имен переменных нельзя использовать ключевые слова языка С++:'for', 'if', double и т.д.
Имя переменной может относиться к одиночной величине. Такую переменную называют скалярной. Но имя переменной может также обозначать совокупность величин. Такие переменные называются агрегатными. Некоторые агрегатные переменные имеют названия,
18
уточняющие принципы группировки величин. Например: "массив", "структура", "файл" и т.д.
Каждая скалярная переменная имеет строго определенный тип для величины, которую она представляет (целое число, указатель, число с плавающей точкой и т. д.). Агрегатные переменные могут состоять из величин одного и того же типа (массивы) или из величин разных типов (структуры, классы).
Все переменные должны быть объявлены в программе явно. Никакой тип величины для любых имен переменных по умолчанию не назначается. Транслятор языка С++ обнаруживает отсутствие объявления типа переменной и расценивает это как грубую ошибку. Это позволяет увидеть такие трудно обнаруживаемые ошибки, как описки.
Примеры объявления типов переменных:
double x, y; int n;
Вместе с объявлением можно присвоить переменной начальное значение:
int count = 0;
В языке С++ предусмотрены перечисленные ниже типы величин, каждый из которых определен ключевым словом. Ключевое слово описания типа, кроме самого типа, определяет также диапазон изменения величины, а для чисел с плавающей точкой задается также точность представления числа. В некоторых случаях для описания переменной могут применяться два и более ключевых слова, уточняющие диапазон изменения величины и/или указывающие на класс памяти (класс памяти задает либо способ хранения величины, либо место хранения).
Основные ключевые слова описания типа переменной:
int- целое число
double - число с плавающей точкой двойной точностиchar- символьная величина.
19
Для описания целочисленных переменных могут использоваться дополнительные ключевые слова:
long - длинное целое числоunsigned - целое число без знака
Эти ключевые слова могут использоваться без основного ключевого слова int, например, записиlong int иlong равнозначны.
Для описания целых чисел можно использовать всего три слова: int,long иunsigned. Причем словоunsigned по умолчанию относится к словуint, а для того, чтобы переменная типаlong рассматривалась как целое число без знака, следует записатьunsigned long.
Для объявления символьной переменной в однобайтовой кодировке используется атрибут char, а символы в двухбайтовой кодировке объявляются с атрибутомwchar_t.
По определению символьные переменные типа char предназначены для хранения символьной информации, например, текстовой. Но эти переменные могут также рассматриваться как целые числа без знака длиной в1 байт с диапазоном значений от0 до255 или как числа со знаком в диапазоне от+127 до-128,и они могут использоваться в арифметических операциях. (Для типаwchar_t соответственно2 байта и диапазон значение от-32768 до32767).
Целые числа типа int в старом языке С занимали2 байта и имели диапазон значений от+32767 до-32768.В современных компьютерах эти числа занимают4 байта и совпадают с типомlong.
Целые числа типа long занимают32 двоичных разряда (4 байта) Самый старший двоичный разряд выделен для знака числа (0 - число положительное,1 - число отрицательное).и имеют диапазон зна-
чений от +2147483647до -2147483648.
Целые числа без знака (тип unsigned) используют то же количество байт, что и числа типаint иlong, но поскольку они рассматриваются как числа без знака, то их диапазон значений составляет4294967295. Хотя числа типаunsigned и рассматриваются как числа без знака, однако в программе им разрешается присваивать от-
20
рицательные значения. При этом следует не забывать о последствиях, поскольку числа в компьютере представляются в виде двоичных чисел, и весь диапазон представления чисел данного типа разбивается на две части. Первая часть в самом старшем раз ряде содержит 0. Эти числа рассматриваются как положительные. Вторая часть диапазона чисел имеет в старшем разряде единицу, и эти числа рассматриваются как отрицательные (в действительности это так называемый дополнительный код числа). Из такого представления чисел следует, во-первых,что целочисленный нуль имеет различное значение для+0 (число, состоящее из одних нулей) и-0 (1 в самом старшем разряде, а остальные разряды равны0), а, вовторых, отрицательные числа физически больше положительных. При обработке числовой информации внутри компьютера такая форма представления чисел учтена, и ошибок не возникает, но при присвоении отрицательных значений переменным, имеющим типunsigned, этот факт вскрывается. Для переменной типаunsigned long число-1 соответствует+4294967295.
Числа типа double внутри компьютера всегда представлены в форме двоичного числа с плавающей точкой и имеют диапазон значе-
ний от -1.7Е+308до +1.7Е+308.
Во время выполнения арифметических операций с числами с плавающей точкой возможны две ошибки: переполнение и исчезновение порядка. Переполнение, т.е. получение числа больше максимально возможного, может возникнуть, например, при делении на число, близкое к 0 (при переполнении порядок достигает значений, равных максимально возможному). При исчезновении порядка его значение становится равным минимально возможному.
Переменная может быть описана с атрибутом const, который позволяет запретить изменение значения переменной в процессе выполнения программы. Переменные, объявленные с атрибутомconst, называются константными. Другими словами, если переменная записана с атрибутомconst, то имя такой переменной не может появиться с левой стороны от знака равенства после объявления
StudFiles.ru
/ A
Хотя разрешается использовать имена переменных, начинающиеся со знака под- черкивания, например, this и _that, все же этого лучше избегать, потому что это чревато потенциальными конфликтами со стандартными системными переменными, имеющими такую же форму. По той же причине следует избегать применения имен переменных, начинающихся с двух знаков подчеркивания.
Ниже представлены примеры хороших имен переменных.
Имена вроде 8_Ball, 7Up и б_раск не допускаются, равно как и Hash! или МагS-Ann. Последний пример демонстрирует распространенную ошибку, хотя имя MaryAnn со знаком подчеркивания вместо тире вполне приемлемо. Конечно, Магу Ann — тоже неправильно, поскольку пробелы в именах переменных не разрешены. Обратите внимание, что имена переменных republican и Republican трактуются как различные, потому что имена переменных зависят от регистра, то есть символы верхнего и нижнего регистра различаются. Конечно, пробельные символы вообще не могут появляться в именах, и если вы нечаянно включите пробельные символы, то получите два или более имен вместо одного, что обычно заставляет компилятор выдавать соответствующее сообщение.
Обычное соглашение, принятое в С++, заключается в том, что имена, начинающи- еся с заглавных букв, резервируются для именования классов, а начинающиеся с про- писных — для именования переменных. О классах речь пойдет в главе 8.
58 Глава 2
Ключевые слова в С++
В С++ присутствуют зарезервированные слова, которые называются ключевыми словами и имеют специальное значение внутри языка. Редактор Visual С++ 2005 под- свечивает их определенным цветом, когда вы вводите текст программы — в моей систе- ме по умолчанию они окрашены в синий цвет. Если ключевое слово, которое вы ввели, не окрашивается соответствующим образом — значит, вы ввели его неправильно.
Помните, что ключевые слова, как весь язык С++, зависят от регистра. Например, программа, которую вы набирали ранее, содержит ключевые слова int и return. Если бы вы написали Int или Return, то это не считалось бы ключевыми словами, и компилятор не распознал бы их как таковые. В процессе дальнейшего изучения вы познакомитесь и со многими другими ключевыми словами С++. Необходимо обеспе- чивать, чтобы имена, которые вы выбираете для сущностей в своих программах, не совпадали ни с одним ключевым словом С++. Полный список ключевых слов Visual С++ 2005 приведен в приложении А.
Объявление переменных
Как вы уже видели, объявление переменной — это оператор программы, который специфицирует имя переменной данного типа, например:
int value;
Это объявляет переменную по имени value для хранения целых чисел. Тип дан- ных, который может быть сохранен в переменной value, указан ключевым словом int, поэтому value вы можете применять только для хранения данных типа int. Поскольку int — ключевое слово, его нельзя использовать в качестве имени ни одной из ваших переменных.
Обратите внимание, что объявление переменной всегда завершается точкой с запятой.
В одном объявлении можно указать имена нескольких переменных, но, как я уже говорил, обычно лучше их объявлять в отдельных операторах — по одному в строке. В этой книге я иногда отклоняюсь от этого правила, но лишь для того, чтобы не рас- тягивать код на слишком много страниц.
Чтобы хранить данные (например, значение целого числа), недостаточно про- сто определить имя переменной. С этим именем также необходимо ассоциировать некоторый участок компьютерной памяти. Этот процесс называется определением переменной. В С++ объявление переменной также является ее определением (за ис- ключением некоторых специальных случаев, с которыми вы позже познакомитесь в этой книге). В отдельном операторе вы указываете имя переменной, и это связывает его с участком памяти определенного размера.
Таким образом, оператор:
одновременно является и объявлением, и определением. Здесь использовано имя пе- ременной value, которое объявляется, для доступа к участку компьютерной памяти, который здесь же определяется, и который может хранить отдельное значение типа int.
Термин объявление вы будете применять для представления имени вашей программе, вместе с информацией о том, для чего это имя используется. Термин определение описывает вы- деление компьютерной памяти, связанной с этим именем. В случае переменных вы можете
Данные, переменные и вычисления 60
совместить объявление и определение в одном операторе, как показано в предыдущей строке кода. Причина столь педантичного различия между объявлением и определением состоит в том, что позднее вы столкнетесь с операторами, которые являются объявлениями, но не определениями.
Вы должны объявлять переменную в некоторой точке, находящейся между нача- лом вашей программы и тем местом, где она будет впервые задействована. В С++ хо- рошим тоном считается объявлять переменную поближе к тому месту, где она первый раз используется.
Начальные значения переменных
Объявляя переменную, вы тут же можете присвоить ей начальное значение. Объявление переменной, которое присваивает ей начальное значение, называется инициализацией. Чтобы инициализировать переменную, когда вы объявляете ее, вам просто нужно написать знак равенства, за которым следует инициализирующее значение. Вы можете написать следующие операторы, чтобы присвоить каждой пере- менной начальное значение:
В данном случае value получает значение 0, count — значение 10, a number — зна- чение 5.
Существует и другой способ указания начальных значений переменных С++, ко- торый называется функциональной нотацией. Вместо знака равенства и значения вы просто указываете значение в скобках, следующих за именем переменной. То есть предыдущие объявления можно переписать следующим образом:
Если вы не присваиваете переменной начального значения, то, как правило, она обычно содержит произвольный мусор, который находился в том участке памяти, ко- торый для нее выделен (есть исключение из этого правила, и позднее в этой главе вы о нем узнаете). Поэтому, где только возможно, вы должны инициализировать пере- менные при их объявлении. Если переменные изначально содержат известные значе- ния, то гораздо проще разобраться, когда что-то идет не так. А уж в чем можно быть абсолютно уверенным, так это в том, что что-нибудь обязательно пойдет не так.
Фундаментальные типы данных
Разновидность информации, которую может содержать переменная, называется ее типом данных. Все данные и переменные в вашей программе должны относиться к определенному типу данных. Стандарт С++ ISO/ANSI предоставляет набор фунда- ментальных типов данных, специфицированных определенными ключевыми слова- ми. Фундаментальные типы данных называются так потому, что они хранят значения типов, представляющих фундаментальные данные на вашем компьютере — по сути, числовые значения, в которые входят и символы, потому что они представлены чис- ловыми кодами. Вы уже видели ключевое слово int, применяемое для определения целочисленных переменных. C++/CLI также определяет фундаментальные типы дан-
62 Глава 2
ных, которые не являются частью ISO/ANSI С++, и позднее в этой главе я расскажу о них.
Как часть объектно-ориентированных аспектов языка, предусмотрена возмож- ность определения ваших собственных типов данных, и конечно, разнообразные би- блиотеки, поставляемые с Visual С++ 2005 также определяют свои типы данных. Но пока мы ограничимся элементарными числовыми типами данных, представленными в ISO/ANSI С++. Фундаментальные типы подразделяются на три категории — типы, содержащие целые числа, типы, содержащие не целочисленные значения, и тип void, указывающий пустое множество значений или отсутствие типа.
Целочисленные переменные
Как уже говорилось, целочисленные переменные — это переменные, которые со- держат только значения целых чисел. Количество игроков футбольной команды — целое число, по крайней мере, в начале игры. Вы уже знаете, что целочисленные переменные можно объявлять с ключевым словом int. Переменные типа int зани- мают 4 байта памяти, и могут сохранять как положительные, так и отрицательные целые значения. Верхний и нижний пределы значений переменных типа int соот- ветствуют максимальному и минимальному двоичному значению со знаком, которое может быть представлено 32 битами. Верхний предел переменной типа int — 231 - 1,
что равно 2 147 483 647, а нижний предел (231), что соответствует -2 147 483 648.
Ниже показан пример определения переменной типа int.
В Visual С++ 2005 ключевое слово short также определяет целые переменные, но занимающие 2 байта в памяти. Ключевое слово short эквивалентно short int, и вы можете определить две переменных типа short с помощью следующих операторов:
Обе переменных относятся к одному и тому же типу, потому что short означает то же самое, что short int. Здесь я использовал обе формы названия типа, чтобы продемонстрировать их применение, но при написании программ лучше ограничи- ваться одним вариантом, и short встречается более часто.
В С++ также предусмотрен другой целочисленный тип — long, который также можно записывать как long int. Вот как объявляются переменные типа long:
Эти операторы объявляют переменные bigNumber и largeValue с начальными значениями 1000000 и 0 соответственно. Буква L, добавленная в конец литералов, указывает на то, что это — целые типа long. Для той же цели можно также применять и прописную букву 1, но ее недостаток в том, что ее легко спутать с цифрой 1. Целые литералы без добавленной буквы L имеют тип int.
При написании больших чисел в программе вы не должны вставлять в них запятые или про- белы в качестве разделителей групп. В тексте можно написать 12,245,678либо 12 245 678, но в коде программы следует писать 12345678.
Целочисленные переменные, объявленные как long, в Visual С++ 2005 занимают 4 байта, и могут принимать значения от -2 147 483 648 до 2 147 483 647. Тот же диа- пазон могут принимать переменные типа int.
Данные,переменныеивычисления63
В других компиляторах С++ переменные типа long (то же самое, что и тип long int) могут отличаться от типа int, поэтому, если вы собираетесь компилировать свои программы в других средах, не полагайтесь на то, что long и int эквивалентны. При написании действительно переносимого кода вы даже не должны рассчитывать на то, что int занимает 4 байта (например, в старых 16-разрядных версиях Visual С++ переменные int были двухбайтными).
Символьныетипыданных
Тип данных char служит двум целям. Он специфицирует однобайтную пере- менную, в которой можно сохранять целые числа в пределах определенного диапа- зона значений, или же код отдельного символа ASCII (American Standard Code for Information Interchange — американский стандартный код обмена информацией). Набор кодов символов ASCII приведен в приложении Б. Вы можете объявить пере- менную char с помощью следующего оператора:
Этот код объявляет переменную по имени letter, инициализированную констан- той 1 А1. Обратите внимание, что значение указывается как отдельный символ в оди- ночных кавычках, а не в двойных, которые вы использовали ранее для определения строк символов с целью отображения на экране. Строка символов — это последова- тельность значений типа char, которая сгруппирована в единое целое, называемое массивом. Массивы и обработка строк в С++ рассматриваются в главе 4.
Поскольку символ 'А' в кодировке ASCII представлен десятичным значением 65, вы могли бы написать этот оператор следующим образом:
Это дало бы тот же результат, что и предыдущий оператор. Диапазон целых, которые могут быть сохранены в переменных типа char, в Visual С++ составляет от -128 до 127.
Обратите внимание, что стандарт ISO/ANSIС++ не требует, чтобы тип charпредстав- лял однобайтные целые со знаком. Это выбор реализации компилятора: представлять charкак целые со знаком в диапазоне от-128 до 127либо как целые без знака в диапазоне от 0 до 255. Следует иметь это в виду, если вы собираетесь переносить свой код С++ в другую среду.
Тип wchar_t назван так, поскольку это расширенный символьный тип (wide char type), и переменные этого типа сохраняют 2-байтные символьные коды со значения- ми от 0 до 65 535. Ниже показан пример определения переменной типа wchart.
Этот оператор определяет переменную letter, инициализированную 16-битным кодом буквы Z. Символ L, предшествующий символьной константе ' Z ', сообщает компилятору, что это 16-битное значение кода символа.
Для инициализации переменных char (как и других целых типов) вы также мо- жете использовать шестнадцатеричные константы, что во многих случаях удобнее. Шестнадцатеричное число записывается с применением стандартного представления шестнадцатеричных цифр: от 0 до 9 и от А до F (или от а до f), означающие в деся- тичном эквиваленте цифры от 0 до 15. Кроме того, они предваряются сочетанием Ох (или ОХ) для того, чтобы отличать их от десятичных значений. Таким образом, чтобы получить тот же результат, вы могли бы переписать оператор, приведенный выше, следующим образом:
65 Глава 2
Не записывайте десятичные целочисленные значения с ведущим нулем. Компилятор интер- претирует их как восьмеричные, поэтому значение, записанное как 065, равно 53 в десятич- ной нотации.
Обратите также внимание, что в Windows ХР имеется утилита Character Map (Таб- лица символов), которая позволяет находить символы в любых шрифтах, доступных в Windows. Она показывает коды символов в шестнадцатеричном виде и сообщает, на какие клавиши нужно нажать для их ввода. Утилиту Character Map можно найти, если щелкнуть на кнопке Start (Пуск) и заглянуть в папку System Tools (Системные), находящуюся внутри папки Accessories (Стандартные).
Модификаторы целочисленных типов
Переменные целочисленных типов char, int, short или long сохраняют по умол- чанию целые значения со знаком (signed), поэтому вы можете применять их как для хранения положительных, так и отрицательных значений. Это объясняется тем, что для этих типов по умолчанию принят модификатор типа signed. Поэтому когда вы пишете int или long, то это означает signed int или signed long соответственно.
Вы также можете использовать ключевое слово signed отдельно для специфика- ции типа переменной. В этом случае оно означает signed int, например:
Но такое написание не очень распространено, и я предпочитаю применять int, что выглядит более очевидно.
Диапазон значений, которые могут быть сохранены в переменной типа char, на- ходится в пределах от -128 до +127, что совпадает с диапазоном допустимых значе- ний переменных типа short char. Но как это ни прискорбно, тип char и тип signed char трактуются как разные типы, поэтому вы не должны допускать ошибку, думая, что это одно и то же.
Если вы уверены, что вам не нужно хранить в переменной отрицательные зна- чения (например, если собираетесь записывать в нее количество миль, которые вы проезжаете за рулем в неделю), то вы можете специфицировать переменную как unsigned:
Минимальное значение, которое можно записать в переменную mileage, равно нулю, а максимальное — 4 294 967 295 (то есть 232 - 1). Сравните это с диапазоном от -2 147 483 648 до 2 147 483 647 для signed long. Один бит, который в перемен- ных signed служит для указания знака, в unsigned является частью числового значе- ния. Как следствие, переменные unsigned имеют больший диапазон положительных значений, но не могут представлять отрицательных. Обратите внимание на букву U (или и), добавленную к константе unsigned. В предыдущем примере я также добавил к ней L, чтобы указать, что константа — long. Вы можете использовать эти симво- лы-модификаторы констант в любом регистре и любой последовательности. Однако при указании таких значений желательно придерживаться какого-то согласованного стиля.
Вы также можете применять в качестве спецификатора типа unsigned отдельно, что подразумевает unsigned int.
Помните, что и signed, и unsigned—ключевые слова, поэтому их нельзя применять в качестве имен переменных.
Данные, переменные и вычисления 66
Булевский тип
Булевские переменные — это такие переменные, которые могут хранить только два значения: true и false. Тип таких логических переменных называется bool, по имени Джорджа Буля (Gerorge Boole), который разработал булеву алгебру. Тип bool трактуется как целый. Булевские переменные также называют логическими перемен- ными. Переменные типа bool используются для сохранения результата проверок, ко- торые могут принимать значения либо "истина" (true), либо "ложь" (false), напри- мер, как в случае проверки равенства одного значения другому.
Имя переменной типа bool объявляется с помощью следующего оператора:
Конечно, вы можете сразу инициализировать переменные типа bool при их объ- явлении:
Вы обнаружите, что достаточно часто в коде можно встретить значения TRUEи FALSEкак значения числовых типов — в частности, int.Это наследие тех времен, когда в С++ еще не был реализован тип bool,и для представления логических значений обычно применялись переменные типа int.При этом нулевые значения трактовались как "ложь", а ненулевые— как "истина Символы TRUEи FALSEвсе еще применяются в MFC, где они представляют ненулевые целые и 0, соответственно. Обратите внимание, что TRUEи FALSE, записанные заглавными буквами, не являются ключевыми словами в С++; это просто символы, опреде- ленные внутри MFC. Помните также, что TRUEи FALSEне являются допустимыми значе- ниями типа bool, а потому не путайте TRUEи true.
Типы с плавающей точкой
Числовые переменные, не относящиеся к целым, хранятся как числа с плавающей точкой. Число с плавающей точкой может быть выражено в виде десятичного значе- ния наподобие 112,5 либо в экспоненциальном виде, таком как 1Д25Е2, где десятич- ная часть умножается на 10 в степени, указанной после Е (экспонента). Таким обра- зом, последнее число — это 1Д25х102, что равно 112,5.
Константы с плавающей точкой должны включать десятичную точку, либо экспоненту, либо и то, и другое. Если вы записываете числовое значение без них, то получаете целое.
Вы можете специфицировать переменную с плавающей точкой, используя ключе- вое слово double, как в следующем операторе:
double in_to__mm = 25.4;
Переменная типа double занимает 8 байт памяти и сохраняет значения, точность которых определяется примерно 15 десятичными знаками. Диапазон их значений на- много шире, чем можно выразить 15-ю знаками — начиная от 1,7х10-308 и заканчивая 1,7х10308, положительные и отрицательные.
Если вам не требуется 15-значная точность и не нужны очень большие диапазоны значений, которые обеспечивает тип double, можете воспользоваться ключевым сло- вом float для объявления переменных с плавающей точкой, занимающих 4 байта.
67 Глава 2
Например:
Этот оператор определяет переменную pi с начальным значением 3,14159. Символ f в конце константы указывает, что она имеет тип float. Без f константа имела бы тип double. Переменные, объявленные с типом float, имеют точность примерно в 7 десятичных знаков и допускают значения от 3,4х10-38 до 3,4х1038, положительные и отрицательные.
Стандарт С++ ISO/ANSI также определяет тип с плавающей точкой long double, который в Visual С++ 2005 реализован с тем же диапазоном и точностью, что и
double.
Фундаментальные типы ISO/ANSIC++
В табл. 2.1 представлен список всех фундаментальных типов ISO/ANSI С++, а так- же диапазоны их допустимых значений в Visual С++ 2005.
Литералы
Я уже использовал в этой книге множество явных значений для инициализации переменных. В С++ фиксированные значения любого рода называются литералами. Литерал — это значение определенного типа, поэтому 23, 3.14159, 9. 5f и true — примеры литералов типа int, типа double, типа float и типа bool, соответственно. Литерал "Samuel Beckett" — это пример строкового литерала, но обсуждение этого типа мы отложим до главы 4. В табл. 2.2 представлены примеры записи литералов различных типов.
Данные, переменные и вычисления 68
Вы можете специфицировать литерал как относящийся к типу short или unsigned short, но компилятор примет начальные значения, являющиеся литера- лами типа int для переменных этого типа, если значение литерала находится в до- пустимом диапазоне для типа переменной.
Часто вам нужно будет использовать литералы в процессе вычислений внутри про- граммы, например, преобразуя значения вроде 12 футов в дюймы, или 25,4 дюймов в миллиметры, или же для спецификации строк сообщений об ошибках. Однако вы должны избегать явного применения литералов в программах, когда их смысл не оче- виден. Вовсе не всем и не всегда ясно, что когда вы указываете значение 2,54, то это означает число сантиметров в дюйме. Лучше объявить переменную с фиксированным значением, равным литералу. Например, вы можете назвать ее inchesToCentimeters. Тогда всякий раз, когда в коде встретится переменная inchesToCentimeters, ее смысл будет достаточно очевиден. Чуть позже в этой главе вы увидите, как можно за- фиксировать значение переменной.
Определение синонимов длятипов данных
Ключевое слово typedef позволяет определить ваше собственное имя для существу- ющего типа данных. Используя typedef, вы можете определить имя типа BigOnes как эквивалент стандартного типа long int, применив следующее объявление:
Это определяет BigOnes как альтернативное имя для long int, поэтому вы сможе- те объявить переменную mynum типа long int таким объявлением:
При этом не будет никакой разницы между таким объявлением и тем, что исполь- зует встроенное имя типа. То есть следующий оператор эквивалентен предыдущему:
Фактически, если вы определяете ваше собственное имя типа, такое как BigOnes, то можете применять оба спецификатора типа в одной и той же программе для объяв- ления различных переменных, которые в итоге будут восприняты компилятором как однотипные.
69 Глава2
Поскольку typedef лишь определяет синоним для существующего типа, это может показаться излишним, однако это вовсе не так. Позднее вы увидите, что это средство играет очень важную роль в упрощении сложных объявлений за счет определения одного имени, представляющего сложную спецификацию типа, что может сделать ваш код более читабельным!
Переменные с определенным набором значений
Иногда у вас будет возникать потребность в переменных, которые могут прини- мать значения лишь из ограниченного набора допустимых значений, ссылаться на ко- торые удобно было бы по каким-то меткам — дни недели, например, или месяцы года. В С++ предусмотрено специальное средство для таких ситуаций, называемое перечис- лением (enumeration). Возьмем пример, который я упомянул — переменная, которая должна принимать значения, соответствующие дням недели. Вы можете определить ее следующим образом:
Этот оператор объявляет тип перечисления по имени Week и переменную thisWeek, являющуюся экземпляром перечислимого типа Week, которая может принимать толь- ко константные значения, указанные между фигурными скобками. Если вы попытае- тесь присвоить thisWeek что-то такое, что не входит в указанный набор, то это вызо- вет ошибку. Эти символические имена, перечисленные между скобками, называются перечислителями (enumerators). Фактически каждое из названий дней автоматиче- ски представляется компилятором как фиксированное целое значение. Первое имя в списке — Моп — получает значение 0, Tues будет 1 и так далее.
Вы можете присвоить одну из перечисленных констант в качестве значения пере- менной thisWeek:
Обратите внимание, что вам не нужно квалифицировать перечйслимые констан- ты именем перечисления. Значение thisWeek будет равно 3,потому что определен- ным в перечислении символическим константам присваиваются значения типа int по умолчанию, начиная с 0.
По умолчанию каждый последующий перечислитель на единицу больше значения предыдущего, но если вы предпочитаете явно указать начальное значение, отличное от 0, вы можете просто написать так:
Теперь константы перечисления будут равны от 1 до 7. Перечислители даже не обязаны иметь уникальные значения. Вы можете определить, что и Моп, и Tues долж- ны, например, иметь значение 1, с помощью следующего оператора:
StudFiles.ru
Переменные
Переменная – это именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя (идентификатор) и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменять. Перед использованием любая переменная должна быть описана.
Пример описания целой переменной с именем а и вещественной переменной х:
int a;
float x;
Общий вид оператора описания переменных:
[класс памяти] [const] тип имя [инициализатор];
Здесь и далее на общем виде квадратные скобки [] указывают на необязательные составные части объектов и структур.
Рассмотрим правила задания составных частей этого оператора.
Необязательный класс памяти может принимать одно из значений auto, extern, static и register. О них рассказывается чуть ниже.
Модификатор const показывает, что значение переменной изменять нельзя. Такую переменную называют именованной (типизированной) константой, или просто константой.
При описании можно присвоить переменной начальное значение, это называется инициализацией. Инициализатор можно записывать в двух формах:
- со знаком равенства:
= значение, например:
short int а = 1; const char С = 'С';
- или в круглых скобках:
( значение ), например:
float x(3); char t (54);
Константа обязательно должна быть инициализирована при описании.
В одном операторе можно описать несколько переменных одного типа, разделяя их запятыми, например:
float с = 0.22, x(3), sum;
Описание переменной явно или по умолчанию задает ее область действия.
Область действия переменной – это часть программы, в которой ее можно использовать для доступа к связанной с ней области памяти. В зависимости от области действия переменная может быть локальной или глобальной.
Если переменная определена внутри блока (блок ограничен фигурными скобками {}), она называется локальной, область ее действия – от точки описания до конца блока, включая все вложенные блоки. Если переменная определена вне любого блока, она называется глобальной и областью ее действия считается файл (файл иногда называют модулем (Unit)), в котором она определена, от точки описания до его конца.
Класс памяти определяет время жизни и область видимости программного объекта (в частности, переменной).
Время жизни может быть постоянным (в течение выполнения программы) и временным (в течение выполнения блока). Это поясняется ниже, при описании классов.
Областью видимости идентификатора называется часть текста программы, из которой допустим обычный доступ к связанной с идентификатором областью памяти. Чаще всего область видимости совпадает с областью действия. Исключением является ситуация, когда во вложенном блоке описана переменная с таким же именем. В этом случае внешняя переменная во вложенном блоке невидима, хотя он и входит в ее область действия. Тем не менее, к этой переменной, если она глобальная, можно обратиться, используя операцию доступа к области видимости два двоеточия, например ::a=1.
Для задания класса используются следующие спецификаторы:
auto – автоматическая переменная. Память под нее выделяется в стеке и при необходимости инициализируется каждый раз при выполнении оператора, содержащего ее определение. Освобождение памяти происходит при выходе из блока, в котором описана переменная. Время ее жизни – с момента описания до конца блока. Для глобальных переменных этот спецификатор не используется, а для локальных он принимается по умолчанию, поэтому задавать его явным образом большого смысла не имеет, что и не делается в программе. Таким образом, по умолчанию все переменные автоматические.
extern – означает, что переменная определяется в другом месте программы (в другом файле или дальше по тексту). Используется для создания переменных, доступных во всех модулях программы, в которых они объявлены. Если переменная в том же операторе инициализируется, спецификатор extern игнорируется (переменная уже не может быть внешней).
static – статическая переменная. Время жизни – постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной. В зависимости от расположения оператора описания статические переменные могут быть глобальными и локальными. Глобальные статические переменные видны только в том модуле, в котором они описаны.
register – аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.
volatile – применяется для объявления переменных, которые можно назвать нестабильными. Спецификатор volatile сообщает компилятору, что значение переменной может изменяться как бы само по себе, например, некоторым фоновым процессом или аппаратно. Поэтому компилятор не должен пытаться как-либо оптимизировать выражения, в которые входит переменная, – предполагая, например, что ее значение не менялось с предыдущего раза и потому выражение не нужно заново пересчитывать. Есть и другой момент. В программе могут быть так называемые критические участки кода, во время исполнения которых изменение значения нестабильной переменной приведет к абсурдным результатам. (Возьмите случай оценки “А или не-А”, если А нестабильно!) Для таких критических участков компилятор должен создавать копию, например, в регистре, и пользоваться этой копией, а не самой переменной.
Можно написать такое объявление:
volatile const int vciVar = 10;
Другими словами, “нестабильная константа” типа int. В этом нет никакого противоречия – компилятор не позволит вашей программе изменять переменную, но и не будет предполагать ее значение известным априори, так как оно может меняться в силу внешних причин.
Примеры описания переменных:
int a; // 1 глобальная переменная а
int main()
{
int b; // 2 локальная переменная b
extern int x; // 3 переменная х определена в другом месте
static int с; // 4 локальная статическая переменная с
а = 1; //5 присваивание глобальной переменной
int а; //6 локальная переменная а
а = 2; //7 присваивание локальной переменной
::а = 3; //8 присваивание глобальной переменной
return 0;
}
int x = 4; //9 определение и инициализация х
В этом примере глобальная переменная «а» определена вне всех блоков. Память под нее выделяется в сегменте данных в начале работы программы, областью действия является вся программа. Область видимости – вся программа, кроме строк 6-8, так как в первой из них определяется локальная переменная с тем же именем, область действия которой начинается с точки ее описания и заканчивается при выходе из блока. Переменные «b» и «с» – локальные, область их видимости – блок, но время жизни различно: память под «b» выделяется в стеке при входе в блок и освобождается при выходе из него, а переменная «с» располагается в сегменте данных и существует все время, пока работает программа.
Если при определении начальное значение переменных явным образом не задается, компилятор присваивает глобальным и статическим переменным нулевое значение соответствующего типа. Автоматические переменные в этом случае не инициализируются (содержимое переменной будет произвольным).
Имя переменной должно быть уникальным в своей области действия (например, в одном блоке не может быть двух переменных с одинаковыми именами). Не жалейте времени на придумывание подходящих имен. Имя должно отражать смысл хранимой величины, быть легко распознаваемым и, желательно, не содержать символов, которые можно перепутать друг с другом, например, 1,1 (строчная L) или I (прописная i). Для разделения частей имени можно использовать знак подчеркивания. Не давайте переменным имена, демонстрирующие знание иностранного слэнга. Как правило, переменным с большой областью видимости даются более длинные имена (желательно с префиксом типа), а для переменных, вся жизнь которых проходит на протяжении нескольких строк исходного текста, хватит одной буквы с комментарием при объявлении.
Описание переменной может выполняться в форме объявления или определения. Объявление информирует компилятор о типе переменной и классе памяти, а определение содержит, кроме этого, указание компилятору выделить память в соответствии с типом переменной. В C++ большинство объявлений являются одновременно и определениями. В приведенном выше примере только описание внешней переменной 3 по счету является объявлением, но не определением.
Переменная может быть объявлена многократно, но определена только в одном месте программы, поскольку объявление просто описывает свойства переменной, а определение связывает ее с конкретной областью памяти.
studopedia.ru
Циклические вычислительные процессы
Большинство задач, решаемых в инженерной практике, имеют циклическую структуру. Циклический вычислительный процесс – это процесс, в котором предусмотрено неоднократное выполнение одной и той же последовательности действий при различных значениях входящих в них величин.
Многократно повторяющиеся участки называют циклами. Циклическая структура позволяет существенно сократить объём алгоритма и программы. Переменная алгоритма, которая при каждом выполнении цикла принимает новое значение, называется параметром цикла.
Для организации цикла необходимо: задать начальное значение параметра цикла; задать изменение значения параметра перед каждым новым повторением цикла и проверку условий окончания повторений и переход к началу цикла, если повторения не окончены.
Существуют различные типы циклов. Тип определяется по способу контроля окончания. Для инженерных задач наиболее характерен тип арифметической прогрессии. В этих циклах параметр изменяется от заданного начального до заданного конечного значения, получая при каждом выполнении цикла постоянное приращение (цикл с известным числом итераций).
Если в цикле изменяется простая переменная, то параметром цикла является эта переменная. Для переменных с индексом (массивов) параметром цикла является индекс переменной.
В контрольном задании №3 представлены задачи циклической структуры типа арифметической прогрессии.
Рассмотрим наиболее типичные алгоритмы циклической структуры.
Пример 4. Задан массив по имени А, состоящий из 20 элементов, Ai , i=1,..,20. Составить схему вычисления суммы и произведения элементов этого массива.
При вычислении суммы используется приём накопления – новое слагаемое прибавляется к сумме предыдущих. При выполнении при каждом цикле нужно накапливать сумму, прибавляя очередное слагаемое к этой сумме. Для этого необходимо перед циклом задать начальное значение суммы равное 0. В данном примере параметром цикла будет индекс i, который изменяется от 1 до 20 с шагом равным 1.
Тот же приём используется и при накоплении произведения. В алгоритмических языках Фортран и Бейсик, если переменная не определена, то ей присваивается значение 0, следовательно, произведение значений функции вычисляться не будет, поэтому перед циклом задаётся начальное значение произведения, равное 1. Внутри цикла вычисляется очередной сомножитель и умножается на произведение.
В соответствии со смыслом описываемых величин выбираем имя переменных: для суммы – S, произведения – P.
Схема вычисления будет состоять из следующих символов действий.
1. Начало.
2. Вводмассива Ai, i=1,..,20.
3. Процесс. Переменным S и P задаются начальные значения S=0, P=1.
4. Начало цикла. Указывается параметры цикла: начальное и конечное значение параметра i и шаг цикла, равный 1.
5. Процесс. Происходит накопление суммы S и произведения P.
S=S+Ai
P=P*Ai
6. Конец цикла по параметру i. Цикл, т.е. вычисление S и P выполняется до тех пор, пока параметр i меньше или равен конечному значению. Как только параметр будет больше конечного значения, то цикл заканчивается и следующим будет выполняться печать результатов.
7. Документ, который выводит на печать вычисленные сумму S и произведение P.
Останов.
Схема вычисления представлена на рис. 4.
 |
Рис. 4. Схема вычисления суммы и произведения элементов массива.
Пример 5.Задан массив по имени Х, состоящий из 10 элементов, Хj, j=1,..,10. Составить схему вычисления произведения положительных элементов этого массива.
Для вычисления произведения используем приём накопления, который был подробно описан выше. Но в данном примере вычисляется произведение только положительных элементов, поэтому внутри цикла нужно выполнить проверку очередного элемента массиваХjна знак. Если элемент положителен, то он умножается на произведение, если нет – то он не рассматривается.
Параметром цикла будет индекс j, который изменяется от 1 до 10 с шагом равным 1. Переменную произведения обозначим через P.
Схема вычисления будет состоять из следующих символов действий.
1. Начало.
2. Вводмассива Хj, j=1,..,10.
3. Процесс. Переменной P задаётся начальное значение равное 1.
4. Начало цикла. Указывается начальное и конечное значение параметра цикла j и шаг цикла.
5. Решение. Очередной элемент массива проверяется на знак. Хj >0?
6. Процесс, вычисляющий произведение P=P*Хj
7. Конец цикла по параметру j. Цикл выполняется до тех пор, пока параметр j меньше или равен конечному значению, иначе цикл будет закончен и следующим будет выполняться Документ.
8. Документ, выводящий на печать вычисленное произведение Р.
9. Останов.
Схема вычисления представлена на рис. 5.
 |
Рис. 5. Схема вычисления произведения положительных элементов.
При вычислении произведения отрицательных элементов массива в схеме изменится только содержание п.5 Решение.
Пример 6. Задан массив Х, состоящий из 20 элементов, Хi, i=1,..,20. Составить схему вычисления суммы и количества положительных элементов массива.
Приём вычисления суммы S описан в примере 4. тот же приём используется и при вычислении количества элементов. Обозначим через k – накопленное количество элементов. Такую переменную k называют счётчиком. Перед входом в цикл k нужно «почистить», т.е. присвоить 0. И при каждом цикле увеличивать счётчик на 1.
В данном примере вычисляется сумма и количество только положительных элементов, следовательно, внутри цикла нужно сделать проверку очередного элемента массива Хi на знак, как это было сделано в примере 5. Параметр цикла – индекс i, изменяющийся от 1 до 20 с шагом 1.
Схема вычисления будет состоять из следующих символов действий.
1. Начало.
2. Вводмассива Хi , i=1,..,20.
3. Процесс. Переменным S и K задаются начальные значения S=0, K=0.
4. Начало цикла. Задаётся начальное и конечное значение параметра i и шаг цикла.
5. Решение. Проверяется положительность очередного элемента массива, т.е. Хi >= 0?
6. Процесс. Происходит процесс накопления суммы S и увеличения счетчика К на 1, т.е. S=S+Xi , К=К+1.
7. Конец цикла по параметру i. Цикл повторяется до тех пор, пока параметр i меньше или равен 20. Если i больше, то следующим выполняется Документ.
8. Документ. Печатаются значения S и К.
9.Останов
Схема вычисления представлена на рис.6
Пример 7.Для массива Х, описанного в примере 6, вычислить среднее арифметическое значение положительных элементов.
Схема вычисления будет совпадать с предыдущей до п.7. Конец цикла.
Среднее арифметическое значение элементов – это сумма этих элементов, деленная на их количество. Возможен такой набор данных, когда все элементы массива Xi имеют отрицательное значение, тогда переменная, в которой хранится значение количества положительных элементов массива, примет значение равное нулю. Возникает ситуация деления на нуль, а это системная ошибка, по которой программа завершается аварийно. Для устранения деления на нуль, проверяется количество этих элементов. И если количество равно нулю, то на печать выводится сообщение об этом.
Обозначим среднее арифметическое значение положительных элементов через переменную R. Схема вычисления, начиная с п.8 состоит из следующих действий.
8. Решение. Проверка числа элементов К=0? Если Да – печать с сообщением ‘K=0’, если Нет – переход на вычисление R.
9. Документ, в котором на печать выводится сообщение ‘Положительных элементов нет’, и переход к символу Останов.
 |
Рис. 6. Схема вычисления суммы и количества положительных элементов массива.
10. Процесс. Вычисляется R=S:K.
11. Документ, в котором печатается значение R.
12. Останов.
Схема вычисления представлена на рис.7.
Если будет вычисляться среднее арифметическое всех элементов массива, то в схеме не будет проверки очередного элемента массива на знак, т.е. не будет п.5 Решение.
При вычислении среднего арифметического отрицательных элементов массива в п.5 Решение будет проверка условия Хi
Пример 8. Заданы два массива Аi , i=1,…,25 и Вj , j=1,…,30 . Составить схему вычисления положительных элементов в каждом массиве. Определить в каком массиве больше положительных элементов.
Схема вычисления количества положительных элементов описана в примере 6. В данном примере нужно вычислить количество элементов в двух массивах А и В, имеющих разные размерности, т.е. содержащих разное количество элементов. Поэтому нужно организовать два цикла: первый для массива А с параметром цикла i, второй для массива В с параметром цикла j.
 |
Рис.7. Схема вычисления среднего арифметического значения положительных элементов массива.
Обозначим через КА–количество положительных элементов в массиве А, КВ–количество положительных элементов в массиве В.
Схема вычисления будет состоять из следующих действий.
1. Начало.
2. Вводмассивов Аi , i=1,…,25 и Вj , j=1,…,30 .
3. Процесс. “Обнуление” счетчиков КА и КВ, т.е. КА=0, КВ=0.
Пункты 4-7 организуют цикл по обработке массива А, подсчитывая количество положительных элементов этого массива. Структурно эти пункты совпадают с п.4-7 примера 7.
Пункты 8-11 организуют цикл по обработке массива В. Подсчитывается количество положительных элементов этого массива. Структурно эти пункты совпадают с п.4-7 примера 7.
12. Документ. Печать КА и КВ.
13. Решение. Проверка, где больше положительных элементов в массиве А и В. Или количество элементов совпадает? Если КА>КВ, то выполняется п.14, если КА
14. Документ. Печать сообщения ‘В массиве А больше положительных элементов’. Переход на п.17. Останов.
15. Документ. Печать сообщения ‘ В массиве В больше положительных элементов’. Переход на п.17. Останов.
16. Документ. Печать сообщения ‘Количество элементов совпадает’.
17. Останов
Схема вычисления представлена на рис.8
Пример 9. Задан массив Yj, j = 1,..,30. Найти максимальный (наибольший) элемент этого массива.
Нахождение максимального (наибольшего) элемента массива выполняется в цикле путем сравнения значения текущего элемента массива с максимальным из всех предыдущих. При этом если значение текущего элемента больше максимального из всех предыдущих, то максимуму присваивается значение текущего элемента. Внутри цикла для выбора максимального значения используется следующая формула.
После окончания цикла значение Ymax будет максимальным из всех рассмотренных значений Yj.
Для применения указанной формулы необходимо перед началом цикла задать начальное значение Ymax. Обычно в качестве Ymax берут очень маленькое число. Тогда после первого выполнения цикла Ymax примет значение Y1. При втором выполнении цикла Ymax будет сравниваться с Y2 и находится наибольшее из Y1 и Y2 и т.д.
Если выбирается максимальный элемент массива, как в нашем примере, то в качестве наибольшего значения Ymax берется значение первого элемента массива, а в цикле поиск максимального элемента начинается со второго элемента массива.
Схема вычисления будет состоять из следующих действий.
1. Начало
2. Вводмассива Yj; j = 1,..,30
3. Процесс. Присвоение начального значения Ymax = Y1.
4. Начало цикла. Задается начальное и конечное значение параметра цикла j и шаг цикла.
5. Решение. Сравнение значения j-го элемента массива и Ymax, т. е. Yj > Ymax? Если значение Yj больше значения Ymax, то следующим будет выполнятся п. 6. Процесс. Если – нет, то переход на Конец цикла.
6. Процесс. Присвоим Ymax значение j –го элемента
7. Конец цикла по параметру j.
8. Документ. Печать Ymax.
9. Останов.
Схема вычислений представлена на рис. 9.
 |
Рис. 8. Схема вычисления положительных элементов двух массивов и определение их числового соотношения.
 |
Рис.9. Схема вычисления максимального элемента массива.
Если надо найти минимальный (наименьший) элемент массива, то для выбора минимального элемента используется формула
И алгоритм выбора аналогичен рассмотренному выше.
Как и в предыдущем примере в качестве начального значения Yminберётся значение первого элемента массива и цикл начинается со второго элемента массива.
Пример 10. для массива Y, заданного в примере 9, найти минимальный элемент Ymin и его порядковый номер.
Особенностью данного примера является то, что нужно найти не только минимальный элемент, но и его порядковый номер. Для этого каждый раз, когда в цикле будет выполняться условие Yj < Ymin, нужно будет выполнить два присвоения: Yminприсвоить значение j-го элемента Yj, и переменной jmin,обозначающий порядковый номер Ymin, присвоить значение параметра j, т.е. jmin= j.
Так как цикл начнёт выполнятся со второго элемента, то может оказаться, что первый элемент Y1 будет минимальным. Поэтому перед циклом нужно задать не только начальное значение Ymin = Y1 , но и jmin = 1.
На печать в п. Документ следует выводить jmin и Ymin. Схема вычисления аналогична схеме на рис.9 с соответствующими дополнениями.
studopedia.ru
Читайте также
![Переменные значения которых задаются извне это]( "Переменные значения которых задаются извне это")
Переменные значения которых задаются извне это![Значением логической переменной может быть]( "Значением логической переменной может быть")
Значением логической переменной может быть![Аутентичность значение слова]( "Аутентичность значение слова")
Аутентичность значение слова![Чувак значение слова с еврейского]( "Чувак значение слова с еврейского")
Чувак значение слова с еврейского- 7 Треф значение
![Славянские имена мальчиков и их значение]( "Славянские имена мальчиков и их значение")
Славянские имена мальчиков и их значение![Барыга значение слова википедия]( "Барыга значение слова википедия")
Барыга значение слова википедия![Амбициозный значение слова]( "Амбициозный значение слова")
Амбициозный значение слова![Старинные русские слова и их значение]( "Старинные русские слова и их значение")
Старинные русские слова и их значение![Амир значение имени характер и судьба]( "Амир значение имени характер и судьба")
Амир значение имени характер и судьба![Балда значение слова]( "Балда значение слова")
Балда значение слова![Бит может принимать значения]( "Бит может принимать значения")
Бит может принимать значения
Переменные значения которых задаются извне это
Значением логической переменной может быть
Аутентичность значение слова
Чувак значение слова с еврейского
Славянские имена мальчиков и их значение
Барыга значение слова википедия
Амбициозный значение слова
Старинные русские слова и их значение
Амир значение имени характер и судьба
Балда значение слова
Бит может принимать значения