Язык прораммирования С++

Лекция 1. Структура программы

1. Простейшая программа на языке С++

Программа на языке С++, как и на уже знакомом вам Паскале, содержит две основные части:

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

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

Объявление переменной содержит описание ее типа и имя переменной. Приведем примеры объявления.

Cтрока объявления

int R;

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

В строке

float S;

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

Операторная часть программы обязательно содержит так называемую «главную функцию»:

void main(void)

{

}

Функция начинается с заголовка void main(void), вид которого пока можно просто запомнить. Между фигурными скобками находятся операторы программы, каждый из которых обязательно заканчивается точкой с запятой. Оператор задает действия, которые надо выполнить с одной или несколькими переменными.

Объявления переменных могут размещаться как до главной функции, так и внутри нее, после фигурной скобки.

Рассмотрим пример первой программы на языке С++:

int R1;

int R2;

int Sum;

void main(void) {

R1=5;

R2=230;

Sum=3*R1+R2;

}

Можно считать, что при запуске программы ее работа начинается с выполнения первого из этих операторов - оператора присваивания R1=5; При его выполнении в переменную R1 записывается число 5. Это число будет храниться в R1 до тех пор, пока какой-нибудь другой оператор не запишет туда другое число. Операторы выполняются один за другим в порядке их записи:

второй оператор занесет число 230 в R2;

при выполнении оператора Sum=3*R1+R2; вычислится арифметическое выражение 3*5+230 и полученное значение 245 запишется в переменную Sum. При записи арифметических выражений используются общепринятые обозначения операций: + сложение,- вычитание, * умножение и / деление как целых, так и вещественных чисел.

Рассмотрение первого примера закончим следующими замечаниями.

1. Язык С++ создан в результате развития языка С. Эти языки настолько близки, что рассмотренная выше программа выглядит одинаково на обоих языках. Для перехода от языка С++ к С достаточно изменить в исходном файле расширение СPP на C. Приведенный пример скомпилируется без ошибок тем же компилятором, но как программа на C. В дальнейшем мы будем считать, что изучаем язык C++, но будем указывать, какие из изучаемых элементов и синтаксических правил различны для С и С++.

2. Имя переменной - это последовательность букв и цифр, начинающаяся с буквы. Таким образом, Ab32 - это допустимое имя языка, а 1А - недопустимое, т.к. начинается не с буквы. В С и С++ прописная и строчная буквы считаются различными, поэтому Ab32 и ab32 это разные имена двух разных переменных.

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

int R1,R2;.

При объявлении переменных им можно сразу присваивать начальные значения:

int R1=10,R=21;.

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

4. Как и в языке Паскаль, вещественные и целочисленные переменные имеют различное представление в памяти машины, но данные вещественных и целых типов совместимы по присваиванию. Это означает, что применение в программе оператора R1=2.51; не будет считаться ошибкой. Если в программе объявлена вещественная переменная

float V,

то можно выполнить присваивание R1=V1.

Замечание. Компилятор Visual С++, разработанный фирмой Microsoft, выводит в таких ситуациях предупреждение

warning C4244: '=': conversion from 'float' to 'int', possible loss of data

Компилятор BC.exe фирмы Borland не выводит даже предупредительных сообщений.

Если оператор присваивания

R1=V1

записывает в целочисленную переменную вещественное число, то компилятор автоматически организует вызов функции преобразования представления числа, которая получает целое число отбрасыванием дробной части вещественного. Таким образом, значение V1 равное 3.1, преобразуется в 3. Из 3.9 также будет получено число 3.

2. Вывод данных на экран

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

Для ввода исходных данных в программе можно использовать оператор вызова функции форматного ввода scanf(), а для вывода - оператор вызова функции форматного вывода printf().

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

#include <stdio.h>

int Sum, Mul, R1,R2;

void main(void)

{ printf("Введите два числа ");

scanf(“ %d %d”, &R1,&R2);

Sum=R1+R2;

Mul=R1*R2;

printf(“Сумма равна %d Произведение равно %d”, Sum,Mul);

}

Рассмотрим пример более подробно.

Оператор printf("Введите два числа "); выводит на экран заключенную в кавычки строку текста. Эта строка задает формат вывода данных. Кроме обычного текста в строке формата могут присутствовать записанные после знака % латинские буквы d, f, i, s и другие.

В последнем операторе программы

printf(“Сумма равна %d Произведение равно %d”, Sum,Mul);

знаками % в строке отмечаются те места, где программа вставит в строку значения переменных, причем записанная после процента буква d указывает, что это будут целые числа. В этом же операторе после строки формата перечислены через запятую выводимые переменные. На месте первого процента будет выведено значение из переменной Sum, а на месте второго - из переменной Mul.

Кстати, то же самое средствами языка С++ можно записать компактнее с использованием операции вывода в поток:

cout<<“Сумма равна=”<< Sum <<”Произведение равно=”<<Mul;

Если в программе объявлена вещественная переменная, пусть

float fVar=3.5;,

то при выводе значения fVar на экран в строке формата после процента указывают букву f: printf(“ %f”,fVar);.

При вводе данных, как и при выводе, указывают строку формата и имена переменных, в которые занесутся введенные с клавиатуры значения. В операторе

Scanf (“ %d %d”, &R1,&R2);

из строки формата “ %d %d” видно, что далее будут указаны имена двух переменных целого типа. Следует только заметить, что перед именами переменных нужно записывать значки & - операции получения адреса.

Замечание.

Если в программе используются вызовы функций ввода-вывода (таких, как scanf() или printf()) то для их правильной обработки компилятором в программу надо включить строку #include <stdio.h>.

Для использованием операции ввода и вывода в поток необходимо вставить в программу следующую строку:

#include <iostream.h>

В интегрированной среде Си есть подкаталог include, в котором находятся текстовые файлы с расширением h. Они называются заголовочными файлами, среди них находится и файл stdio.h. Перед компиляцией исходный текст программы на языке Си просматривается специальной программой, которая называется препроцессором.

Встретив строку #include <stdio.h> препроцессор находит на диске файл stdio.h и включает его целиком в нашу программу вместо этой строки. А уже после этого файл обрабатывается компилятором и переводится в машинные коды.

Если просмотреть содержимое файла stdio.h, в нем можно найти строки

int _Cdecl printf(const char _FAR *__format,...);

int _Cdecl scanf (const char _FAR *__format,...);,

ради которых stdio.h был включен в исходный текст программы.

Это так называемые прототипы функций, которые нужны компилятору, чтобы правильно сформировать вызовы функций printf() и scanf(). Кроме них stdio.h содержит константы, описания типов данных, прототипы других функций, применяемых при стандартном вводе или выводе данных. (Потому он так и называется - сокращение от standard input output).

3. Стандартные функции

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

float Res,V1=9;

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

Res = 2*sqrt(V1);

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

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

log(V1) - вычисления натурального логарифма,

log10(V1) - вычисления десятичного логарифма,

exp(V1) - вычисления показательной функции с основанием e,

asin(V1), atan(V1) - вычисления арксинуса и арктангенса.

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

Функция может иметь несколько параметров. Например, функция atan2(y,x), которой передается два вещественных аргумента, вычисляет арктангенс угла, лежащего в прямоугольном треугольнике с катетами x,y против стороны y, причем второй аргумент x может быть равным нулю (при этом арктангенс будет равен р/2).

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

#include <math.h>.

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

R1=floor(V1); или с избытком r=ceil(S);.

Для округления до ближайшего целого нет стандартной функции, но можно выполнить оператор

R1=floor(V1+0.5);

Как и в Паскале, можно узнать, сколько байтов требуется для хранения переменной, применив к ней операцию sizeof(). Объявим переменные

int A,B;

float C;

Операторы

A=sizeof(int);

A=sizeof(B);

дадут одинаковый результат - размер переменной типа int.

Оператор A=sizeof(C); запишет в A число 4 - размер переменно типа float.

4. Реализация функций в тексте программы

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

Любая функция, как и главная функция main() состоит из заголовка и заключенного в фигурные скобки тела функции. Пусть, например, нам необходима функция area (l,w) вычисления площади прямоугольного участка по его длине l и ширине w. Эта функция может быть реализована следующим образом

float area(int x, int y)

{float s;

s= x*y;

return s;

}

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

В фигурных скобках, как и в главной функции, находятся объявления переменных и операторы, реализующие вычисление функции. Вычисления должны обязательно заканчиваться оператором return, возвращающим вычисленное значение. В данном примере оператор возвращает значение, помещенное в переменную s. Но вместо переменной можно также записывать выражение, например, приведенную выше функцию можно было реализовать так:

float area(int x, int y)

{return x*y;

}

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

void main(void)

{float A,B;

int b,R;

b = 4;

A = area(5,b);

B = area(20,30);

}

При выполнении программы сначала оператором b=4; в переменную b занесется число четыре. Следующий оператор вызовет вычисление функции area (5,b); для того, чтобы записать ее значение 25 в переменную A.

Выполнение операции вызова функции area(5,b) заключается в следующем:

- программа перестает выполнять операторы главной функции main() и переходит к выполнению функции area(), при этом ей передаются указанные при вызове значения параметров - в параметр x запишется число 5, а в параметр y значение переменной b - число четыре;

- выполняется первый оператор, записанный в теле функции area(), то есть строка s= x*y;. При этом функция вычислит произведение 5*4 и запишет его в переменную s.

- у нас очень короткая функция, но в общем случае операторы функции выполняются до тех пор, пока не встретится оператор выхода из функции return;

- в этом операторе после слова return помещается выражение, определяющее значение функции. Выполнение оператора заключается в вычислении выражения и возврате в то место, откуда функция вызывалась, но уже с результатом - значением функции.

Как видим, из описания самой функции нельзя увидеть, чему равны параметры x и y. Они потому и называются формальными, что получают фактические значения только во время выполнения программы - в момент вызова функции. Так, при следующем вызове B=area(20,30); формальные параметры x и y получат значения 20 и 10. Как мы помним из предыдущих глав, процедуры и функции тем и хороши, что позволяют проделывать одни и те же действия, но с разными исходными данными.

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

R=area(20,30,70);

B=area(2.5,10);

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

Если мы запишем функцию area() после главной, то во время обработки оператора A=area(5,b); у компилятора еще не будет информации для проверки правильности вызова.

Так что же, мы не можем поместить функцию вычисления площади после главной функции? Можем, но заголовок функции area() придется написать еще раз, как показано ниже:

float area(int x, int y);

void main(void) {

float A,B;

int b,R

b=4; A=area(5,b); B=area(20,30);

}

float area(int x, int y){

float s;

s= x*y;

return s;

}

В первой строке программы записан заголовок float area(int x, int y);. Точка с запятой в конце заголовка говорит о том, что ниже не будет тела функции. Это только предописание, или прототип функции, позволяющий проверить правильность ее вызова. Сама функция описана после главной программы.

Прототипы написанных в программе нестандартных функций тоже можно поместить в заголовочный файл, например, myproto.h. Он обычно имеет расширение h и называется (от слова header) заголовочным файлом. В исходный текст программы помещают строку #include “myproto.h”.

Напомним, что перед компиляцией программы ее исходный текст подвергается предварительной обработке - прекомпиляции. Прекомпилятор (он же препроцессор) просматривает текст файла, находит строчки, которые начинаются со слова #include (чтобы их легче находить, в строке перед этим словом нельзя писать ничего, кроме пробелов) и заменяет строчку текстом из указанного в ней заголовочного файла. Файл stdio.h препроцессор должен искать в подкаталоге include среды разработки, а файл myproto.h обычно находится в текущем каталоге - там же, где исходный текст программы. Чтобы указать, где следует искать заголовочный файл, имя stdio.h пишется в угловых скобках, а имя myproto.h в кавычках.

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

#define ABC 32.5

Препроцессор просмотрит весь следующий за ней текст и везде, где встретится имя ABC заменит его на 32.5.

Рассмотрим в качестве примера следующую задачу:

Ввести с клавиатуры радиус круга и вывести на экран его площадь. Вычисление площади оформить в виде функции.

Для решения задачи создадим заголовочный файл round.h следующего содержания:

#define Pi 3.141592653

float Round(int);

Тогда текст программы будет иметь следующий вид:

#include <stdio.h>

#include “round.h”

int r;

float S;

void main(void)

{

printf("Введите радиус ");

scanf("%d",&r);

S=Round(r);

printf("Радиус %d \n площадь %g \n", r, S);

}

float Round(int p)

{ return Pi*p*p;

}

Строка #include “round.h” включит в текст этой программы прототип функции и константу Pi.

Замечания

1. В настоящее время различные фирмы предлагают разные версии компиляторов для языка C++. Для проверки приводимых примеров в среде MS DOS мы будем использовать компилятор фирмы Borland а для среды Windows - Visual С++ фирмы Microsoft. Создатели языков высокого уровня стремятся к тому, чтобы написанная на данном языке программа одинаково выполнялась под управлением разных операционных систем и на компьютерах с различной архитектурой. Но идеально переносимого (мобильного) текста программ обычно не получается. Например, при использовании компилятора Borland C++ объявлять константу Pi нет необходимости. В файле math.h значения ?,?/2,1/? и прочие определены следующим образом:

#define M_PI 3.14159265358979323846

#define M_PI_2 1.57079632679489661923

#define M_PI_4 0.785398163397448309616

#define M_1_PI 0.318309886183790671538

#define M_2_PI 0.636619772367581343076

#define M_1_SQRTPI 0.564189583547756286948

#define M_2_SQRTPI 1.12837916709551257390.

Правда, имена выбраны таким образом, что не каждый найдет эти константы. Но в файле math.h, который использует Visual C++, таких констант нет. В разных версиях могут отличаться не только содержимое, но и состав заголовочных файлов. Например, файл mem.h есть в Borland C++, и отсутствует в Visual C++. Но прототипы функций, описанные в mem.h, можно найти в файле memory.h среды Visual C++.

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

3. В Паскале и многих других языках предусмотрена возможность создания функций и процедур. В языке Си есть только функции. Аналогом процедуры языка Паскаль в Си является функция, не возвращающая никакого значения. Допустим, нам очень часто приходится выводить на экран предложение: ВВЕДИТЕ ЧИСЛО и мы хотим оформить его в виде функции, вызов которой должен иметь вид In();. Следует отметить, что язык Си рассматривает круглые скобки как операцию вызова функции. Поэтому даже при отсутствии параметров оператор вызова функции записывается с круглыми скобками. Реализация такой функции будет иметь вид:

void In(void)

{printf(“ВВЕДИТЕ ЧИСЛО”);

return;

}

Словом void, означающее пустой, не имеющий никакого значения тип данных, здесь указано, что функция In не получает параметров и не возвращает значения. Строчку return в этой функции можно было не писать - функция завершится, когда вычислительный процесс дойдет до закрывающей фигурной скобки.

Лекция 2. Технология разработки программ

1. Создание программ для выполнения в среде MS DOS

Рассмотрим минимальные сведения о среде разработки фирмы Borland, необходимые для построения программы и ее отладки. Пусть на компьютере уже установлено необходимое программное обеспечение в каталоге BC. Обычно активизация среды разработки выполняется запуском находящейся в подкаталоге Bin этого каталога программы BC.exe. При этом на экран выводится главное окно среды, показанное на рис. 1.

Рис. 1 - Главное окно интегрированной среды Borland C

Верхняя строка окна занята основным меню, выбор в нем каждого из пунктов File, Edit, Search и др. приводит к появлению подменю, пункты которого позволяют вызывать выполнение группы близких по назначению операций. На рисунке отображена ситуация, когда вызвано подменю ведения программных проектов. (Далее, для указания выбранной операции будем указывать пункт основного меню и пункт подменю, разделяя их знаком /. Например, Project/Open project - создать новый проект или открыть существующий.

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

Для того, чтобы объединить несколько файлов в единую программу, в среде Borland С++ создается проект - отдельный файл с расширением PRJ. Чтобы открыть существующий проект или создать новый следует выбрать пункт меню Project, а в нем подпункт Open Project.

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

В меню есть пункты Project/Add Item и Project/Delete Item при помощи которых можно добавить или удалить файл из проекта.

(Замечание - я давно не работал в DOS, открыл подменю проект, а пункты в нем серые, неактивные, я не могу добавить в проект еще один файл. Чтобы пользоваться этими пунктами, должно быть открыто показанное в нижней части рисунка окно проекта со списком входящих в него файлов. Если на экране этого окна нет, оно открывается выбором в меню пункта Windows/Project).

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

в заголовочный файл iRound.h поместим определение числа р и предописание функции вычисления площади круга:

#define Pi 3.141592653

double Round(int);

В файл fRound.cpp выделим исходный текст функции вычисления площади:

#include "iRound.h"

double S;

double Round(int p)

{

return Pi*p*p;

}

Главна функция будет находиться в файле mRound.cpp:

#include <stdio.h>

#include "Round.h"

int r;

double S;

void main(void)

{printf("Введите радиус ");

scanf("%d",&r);

S=Round(r);

printf("Радиус %d \n площадь %g \n", r, S);

getchar();

getchar();

}

Для создания проекта, включающего файлы mRound.cpp и fRound.cpp необходимо выполнить следующую последовательность действий:

подготовить показанные выше файлы с исходными модулями проекта. Для этого можно использовать любой текстовый редактор, но удобно пользоваться редактором среды разработки (Пунктом File/New создать пустой файл и ввести текст файла, пользуясь при необходимости копирования блоков текста других операций редактирования возможностями подменю Edit);

выбором пункта Project/Open Project создать новый проект (для этого в открывшемся диалоговом окне следует ввести имя нового проекта);

при помощи пункта Project/Add Item включить в проект модули fRound.cpp и

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

используя пункт Compile/Make получить исполняемый модуль программы. Вместо обращения к пунктам меню можно использовать быстрый вызов функций среды разработки при помощи “горячих клавиш”. Если проект открыт, то по нажатию клавиши F9 модули проекта файлы скомпилируются (на диск запишутся результаты компиляции - объектные файлы mRound.obj и fRound.obj). Далее эти файлы скомпонуются в один exe-файл (исполняемый модуль).

выбором пункта Run/Run программа запускается на выполнение. Если исполняемый модуль надо скомпоновать и сразу же выполнить, нажимают сочетание клавиш Ctrl/F9.

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

Кроме того, в проект можно включать подготовленные отдельно объектные модулю (без включения исходных). Отдельные модули проекта могут быть написаны на языке ассемблера (при этом в составе среды должен быть tasm.exe и необходимо правильно настроить пункты меню Transfert).

2. Создание программ для выполнения в среде Windows

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

Чтобы изучать основы программирования лучше создавать консольные приложения Windows. Консольное приложение, это программа, осуществляющая вывод в текстовое окно, аналогичное экрану дисплея при работе с MS DOS, работа которой возможна без применения специфических средств взаимодействия с операционной системой.

Покажем последовательность действий для создания консольного приложения в среде Visual С++ версии 6.

При запуске среды разработки на экран выводится главное окно среды (рис 2) с пунктами меню, позволяющими, выполнять основные действия по разработке приложения:

читать, редактировать и записывать на диск текстовые файлы;

создавать проекты из нескольких исходных модулей;

компилировать файлы проекта и создавать исполняемый модуль;

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



Рис. 2 - Окно среды Visual C++

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

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

компиляцию исходного текста и получение объектного модуля;

компоновку исполняемого модуля из объектных;

прерывание и отмену выполняемой операции (компиляции, компоновки или отладки программы);

выполнение исполняемого модуля в автоматическом режиме - восклицательный знак;

выполнение исполняемого модуля в отладочном режиме (с остановкой на контрольных точках);

установку контрольных точек - значок в виде ладони.

Программист может перемещать панели инструментов с пиктограммами по экрану, изменять по своему вкусу состав пиктограмм, вынесенных на панель инструментов. Эти операции выполняются выбором пункта Customize подменю Tools.

При выборе пункта меню File появляется показанное на этом же рисунке подменю, содержащее пункты New, Open, Close, Open WorkSpaсe и др. Для создание нового проекта и новой рабочей области (подкаталога с файлами проекта) необходимо выбрать пункт New, при этом появится диалоговое окно New.

Как видно из рис 2, в этом окне можно выбрать одну из нескольких вкладок. В частности, для создания и включения в проект новых файлов, надо выбрать вкладку Files. На рисунке показана ситуация, когда пользователь создает новую рабочую область и проект. Имя Console0 нового проекта и подкаталога для его размещения записано в поле Project Name, путь к создаваемому подкаталогу задан в поле Location. В основном поле вкладки цветом выделен тип создаваемого проекта. Выделена строкаWin32 Console Application, при выборе которой создается проект приложения, работающего в текстовом окне, аналогичном экрану MS DOS, и использующему для вывода на экран и ввода с клавиатуры стандартные операторы языка С++. (Для создания оконного приложения следовало выбрать пункт Win32 Application, а один из двух последних пунктов выбирается при создании библиотек). После нажатия не поместившейся на рисунке кнопки OK и ответа на два дополнительных вопроса будет создан пустой проект, в который надо включить файлы с исходными текстами программ на языке С++.

После этого можно заново выбрать пункты меню File/New но в появившемся окне New уже выбрать вкладку File. Из множества предложенных вариантов, часть из которых показана на рис. 3 нам потребуется указывать заголовочные файлы C/C++ Header File или файлы с исходным текстом С++ Source File. В данном случае выбран исходный модуль и задано его имя main. По нажатию кнопки OK модуль будет не только создан, но и (как показывает флажок Add Project) включен в состав проекта.

Рис. 3 - Типы файлов

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

Рис. 4 - Отображение состава проекта

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

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

На рисунке 4 показана ситуация, когда пользователь навел на восклицательный знак курсор мыши, пиктограмма выделилась в виде рельефной кнопки и под ней появилась подсказка Execute Program, объясняющая назначение кнопки. Если щелчком по этой кнопке запустить выполнение программы в автоматическом режиме, мы получим результат ее работы в консольном окне, показанный на рис 5.

Это текстовое окно, имитирующее работу программы с символьным дисплеем в среде MS DOS.

Рис. 5 - Вид консольного окна

Следует заметить, что при выводе на экран строки текста, например, операторами

char s=”Пример текста”;

printf (s);

мы увидим непонятные символы. Причина в том, что для полноты имитации текстового режима оператор printf(s) использует принятую в MS DOS кодовую страницу CP866. Это можно проверить, вызвав стандартную функцию Res = GetConsoleOutputCP() (о кодовых страницах см. лекции по Паскалю). Но поскольку компилятор при кодировании строки применяет страницу 1251 русифицированной ОС Windows, на экран невозможно вывести русский текст. Чтобы вывести русские буквы абвгд, строку придется закодировать так:

char s[]={0xa0,0xa1,0xa2,0xa3,0xa4,10,0};

Обратите внимание, на подсказка на рис. 1.4. Она сообщает, что действия, выполняемые щелчком по кнопке с восклицательным знаком, продублированы горячими клавишами Ctrl/F5. Аналогичные подсказки закреплены за каждой световой кнопкой, со средой разработки поставляется также обширная справочная документация, в результате процесс разработки и отладки программ осваивается значительно быстрее при практической работе за компьютером, чем при чтении учебника. Поэтому здесь отметим только, что пошаговое выполнение программы без захода в процедуры выполняется по нажатию функциональной клавиши F10, с заходом в процедуры F11, а автоматическое выполнение до строки, в которой установлен курсор, запускается сочетанием клавиш Ctrl/F10.

Лекция 3. Знакомство с операторами языка

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

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

Пусть, например, необходимо вычислить подоходный налог с заработка, размер которого хранится в переменной Z. Сотрудник имеет право на льготы по налогу, суммарный размер которых хранится в переменной L.

Если заработок больше суммы льгот (то есть Z>L), налог берется в размере N=13*(Z-L)/100. Когда сумма разрешенных льгот больше, чем заработок, применение этого выражения даст отрицательный Поэтому они могут участвожения результат. Это означает, что налог не взимается, то есть, при Z<L, значение N=0.

Заметим, что в С++ знаки <, меньше и >,больше - это операции, дающие целочисленный результат.. Если условие, заданное операцией сравнения, выполняется, результат операции равен единице, если не выполняется - нулю. То есть, при вычислении выражения Z>L получим единицу, если Z больше, чем L. В С++ нет логического типа данных, поэтому вполне допустимо написать выражение (Z>5)+(Z>L). В зависимости от значений переменных вычисление этого выражения даст значения 0, 1 или 2.

Рассмотрим программу, которая вводит значения Z и L с клавиатуры и вычисляет сумму налога условным оператором:

#include <stdio.h>

int Z,L,N;

void main(void)

{

printf(“\n Введите сумму заработка и размер льгот”);

scanf("%d%d ",&Z,&L);

if(L<Z) N=13*(Z-L)/100;

else N=0;

printf(“ Налог равен %d руб.”, N);

getchar();

getchar();

}

Для сравнения посмотрите, как тот же ввод с клавиатуры выполнить с использованием потока:

cin>>Z>>L;

Выполнение оператора if(L<Z) N=13*(Z-L)/100; else N=0;

заключается в следующем:

- вычисляется выражение, записанное в скобках;

- если результат не равен нулю, выполняется оператор после скобок, если равен нулю - оператор, записанный после else.

Замечания

1. Выше мы использовали запись условного оператора в виде

if(<выражение>) <оператор1> else <оператор2>.

Можно использовать также краткую форму условного оператора if(<выражение>) <оператор>. Здесь отсутствует ветвь else, поэтому при равенстве выражения нулю не выполняется никаких действий.

2. В языке Паскаль точка с запятой является разделителем между операторами, а в С++ она является неотъемлемой частью оператора. Поэтому в Паскале знак `;' перед else не ставится (слово else само по себе является хорошим разделителем), а в данном примере точка с запятой перед else указана, так как она часть оператора N=13*(Z-L)/100;.

3.В языке С++ строчная и соответствующая ей прописная буквы - это разные символы. Поэтому в рассмотренном примере нельзя объявить переменные int Z, L, N;, а потом записать оператор n=13*(z-l)/100;.

4. Мы помним, что происходит при завершении программы вычисления площади, приведенной в параграфе 1. Завершаясь, главная функция main() возвращает управление тому, кто ее запускал. Если программу запускали из оболочки типа Norton Commander, на экране очень быстро промелькнут выводимые программой числа и мы опять увидим окна Norton Commander, если программа запускается из среды разработки, появится окно редактора с исходным текстом. Чтобы пользователь видел на экране результат, в конце программы вставляется дополнительный оператор ввода символа. При выполнении этого оператора программа не завершается, пока пользователь не нажмет кнопку клавиатуры и на экране видны результаты вычислений.

Среди функций стандартного ввода-вывода есть функция getchar();, которая вводит один символ. В предыдущем примере, чтобы приостановить программу она записана дважды. Один оператор не приостановит программу по следующей причине:

В начале программы функция scanf("%d%d ",&Z,&L); вводит с клавиатуры два числа Z и N. Ее особенностью является то, что при вводе числа функция отбрасывает все предшествующие первой цифре коды пробела, табуляции, перевода строки и возврата каретки, потом вводит цифры числа, пока не будет нажата клавиша Enter. Код этой клавиши функция scanf() использует как признак конца ввода числа, но оставляет во входном потоке. Это значит, что код Enter функция как бы и не вводила - он поступит следующему оператору ввода данных.

Следующим оператором ввода является вызов getchar(). Он получит и введет код Enter, оставшийся не обработанным функцией scanf(), и только второй оператор getchar() будет ожидать ввода человеком следующего символа.

Два оператора getchar() не украшают нашу программу, кроме того, как любая функция стандартного ввода, getchar() отображает символ на экране, и после нажатия клавиши, например, буквы А, ждет еще и нажатия клавиши Enter, как признака завершения ввода. Поэтому в дальнейшем мы будем пользоваться функцией консольного ввода символа getch().

Покажем применение консольного ввода на примере применения краткой формы условного оператора для определения наибольшего из трех чисел. Ниже представлена программа, которая вводит с клавиатуры три числа a, b, c, большее из них записывает в переменную max, после чего ожидает нажатия любой клавиши:

#include <stdio.h>

#include <conio.h>

int a,b,c;

void main(void)

{

clrscr();

scanf("%d%d%d",&a,&b,&c);

int max=a;

if(a<b) max=b;

if(c>max) max =c;

printf("%d",max);

getch ();

}

В среде Borland C оператор #include <conio.h> вставляет в исходный текст программы прототипы всех функций консольного ввода-вывода. Мы с ними знакомы - это те функции, которые в Паскале реализованы модулем Crt. Надо только записывать их имена строчными буквами: clrscr() - очистить экран, gotoxy(x,y) -переместить курсор и т.д.

Только паскалевским функциям проверки нажатия клавиши KeyPressed и ввода символа ReadKey в С++ даны другие имена - здесь они называются kbhit() и getch(). Функция getch() вводит символ без эхо-отображения и не ожидает нажатия Enter.

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

2. Оператор цикла в форме for

Объявим целочисленную переменную I и рассмотрим оператор цикла на примере вывода на экран десяти чисел, кратных трем:

int I;

for(I=1;I<=10;I=I+1)

printf(“%d”,3*I);

Как и в Паскале, оператор состоит из:

- заголовка цикла for(I=1;I<=10;I=I+1)

- многократно повторяемого тела цикла - оператора printf(“%d”,3*I).

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

Первое выражение I=1 выполнится один раз (до первого выполнения тела цикла) и определит начальное значение параметра цикла.

Перед каждым выполнением тела цикла вычисляется второе выражение (обычно там помещается проверка какого-то условия) и если условие не выполняется (значение выражения равно нулю), цикл завершается. Если условие выполнено (результат вычисления выражения не равен нулю), выполняется тело цикла.

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

Как видим, в данном случае параметр I будет изменяться от одного до 10, при этом выводимое на экран значение 3*I, будет кратно трем. Результаты экзаменов показывают, что иногда у студентов вызывают затруднения даже такие простые задачи. Поэтому рассмотрим несколько похожих примеров.

1. Те же числа, но в обратном порядке можно вывести оператором

for(I=10;I;I=I-1)

printf(“%d”,3*I);

Оператор интересен тем, что вторым выражением является не проверка условия, а просто переменная I. Когда она станет равной нулю, цикл завершится.

2. Язык С++ предоставляет большую по сравнению с Паскалем свободу при реализации заголовка цикла. В частности, параметр цикла может быть вещественным числом, разрешено пропускать в заголовке цикла любое из выражений (а может, это называется записывать пустое выражение, потому что символы; пишутся обязательно). Следующий фрагмент показывает решение задачи с пропущенным первым выражением:

float I=1;

for(;I<=10;I=I+1)

printf(“%f”,3*I);.

3. Можно пропустить также третье выражение и изменять переменную I в теле цикла:

float I=1;

for(;I<=10;)

{I=I+1;

printf(“%d”,3*I);

}.

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

{

I=I+1;

Printf (“%d”,3*I);

} - это блок операторов. Блок языка С отличается от составного оператора Паскаля тем, что в блоке после открывающей фигурной скобки можно размещать объявления переменных. Такие переменные остаются видимыми только в пределах того блока, где они объявлены (с понятиями области видимости и времени жизни переменных мы знакомились при изучении Паскаля).

В отличие от С, язык С++ разрешает объявлять переменные в любом месте, кроме управляющих конструкций операторов. Например, нельзя объявлять переменную в условном операторе (в круглых скобках после if).

Но параметр цикла можно объявлять непосредственно в заголовке (хотя заголовок - это управляющая конструкция цикла):

for(int i=0; i<10;i=i+1) printf(“%d”,I);

При этом переменная i будет доступна не только в этом цикле, но и во всех последующих операторах до конца блока.

4. Если опустить в заголовке все три выражения, результат вычисления второго пустого выражения считается ненулевым и мы получаем бесконечный цикл. В этом случае для решения задачи можно применить оператор принудительного завершения оператора цикла - break:

int I=1;

for(;;) //Такой заголовок приводит к бесконечному повторению тела цикла.

{ if (I>10) break; //Выполнение оператора break вызывает завершение цикла

// и переход к следующему после цикла оператору.

I=I+1;

printf(“%d”,3*I);

}.

Знакомясь с оператором break языка Паскаль, мы отмечали, что его не было в авторской версии языка, его заимствовали из языка Си.

5. При решении данной задачи студенты часто пытаются в теле цикла дополнительно изменять значения I, чтобы они были кратны трем. В теле цикла при этом выводится значение I а не 3*I, например, так:

int I;

for(I=1;I<=10;I=I+1)

{ printf(“%d”, I);

I=I+3;}

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

Если не хочется применять длинную операцию умножения, цикл следует записать так: for(I=3;I<=30;I=I+3) printf(“%d”, I);.

6. Выведем на экран первые десять элементов последовательности

Ѕ,1/4, 1/6, 1/8...

Типичная ошибка при решении этой задачи приводит к выводу на экран значения 2^-n. Элементы данной последовательности вычисляются оператором

float I

for(I=1;I<10;I=I+1) printf(“%f”, 1/(2*I));

или, без использования умножения:

float I, s=0;

for(I=1;I<10;I=I+1)

{ s=s+2;

printf(“%f”, 1/s);

}.

Чтобы выводить на экран значения 2^-n, следует делить на 2 предыдущее вычисленное значение степени:

float I, s=1;

for(I=1;I<10;I=I+1)

{ s=s/2;

printf(“%f”, s);

}

Несколько замечаний по форматированию вывода

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

Запишем программу вывода значений 2^-n полностью и будем выводить показатель и три варианта значения степени, использующие различные спецификации вывода

#include <stdio.h>

#include <conio.h>

int i;

float s=1;

void main(void)

{ clrscr();

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

{

printf("\n -%d cтепень \

равна %06.2f %6.2e %-6.3g ",i-1,s,s,s);

s=s/2;

}

getch();

}

При пуске программа выведет на экран следующий текст:

-0 cтепень равна 001.00 1.00e+00 1

-1 cтепень равна 000.50 5.00e-01 0.5

-2 cтепень равна 000.25 2.50e-01 0.25

-3 cтепень равна 000.12 1.25e-01 0.125

-4 cтепень равна 000.06 6.25e-02 0.0625

-5 cтепень равна 000.03 3.12e-02 0.0312

-6 cтепень равна 000.02 1.56e-02 0.0156

-7 cтепень равна 000.01 7.81e-03 0.00781

-8 cтепень равна 000.00 3.91e-03 0.00391

-9 cтепень равна 000.00 1.95e-03 0.00195

-10 cтепень равна 000.00 9.77e-04 0.000977

-11 cтепень равна 000.00 4.88e-04 0.000488

12 cтепень равна 000.00 2.44e-04 0.000244

-13 cтепень равна 000.00 1.22e-04 0.000122

-14 cтепень равна 000.00 6.10e-05 6.1e-05

-15 cтепень равна 000.00 3.05e-05 3.05e-05

Здесь каждое вычисленное значение выводится с новой строки. Мы знаем, что для перевода курсора на следующую строку на экран следует вывести символ с кодом 10, а для перемещения в начало строки - символ с кодом 13. Но у этих символов нет изображения, которое можно вставить текстовым редактором в выводимую строку. Если мы напишем printf(“10строка”), то в начале строки будут два символа `1','0'с кодами 49 и 48, а не символ перевода строки с кодом 10. Для включения в строку специальных символов в С++ используют букву, перед которой записан знак \. Например, \n понимается компилятором, как символ с кодом 10, \r - символ с кодом 13, \а - символ с кодом 7 (звонок) и т.д. Чтобы включить в строку знак \, его приходится записать дважды \\. Из-за этого путь к файлу filename.dat, который находится в каталоге ABC, на языках С, С++ приходилось задавать так: