Добавил:

Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Санкт-Петербургский государственный университет телекоммуникаций им. проф. М.А. Бонч-Бруевича

Предмет:

Информатика

Файл:

Информатика.doc

Скачиваний:

Добавлен:

15.03.2015

Размер:

2.58 Mб

Скачать

☆

1 / 41 2 3 4 > Следующая >>>

Все трудно до тех пор,

пока не станет легким

Т.Фуллер

Введение

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

Для решения поставленной задачи специалисту часто приходится использовать компьютер. Можно написать программу, реализующую алгоритм решения поставленной задачи, на разных языках программирования, но в любом случае этот язык должен быть понятным человеку. Поэтому были созданы так называемые императивные языки высокого уровня ( Pascal, C/C++, Ada, Java и др). Название «императивные» произошло от латинского imperativus, что означает – повелительный. Императивный стиль программирования предполагает, что компьютеру указывается что и в какой последовательности он должен делать, чтобы от исходных данных прийти к конечному результату. (Такие языки называют еще алгоритмическими или процедурными языками).

Написанную человеком программу компьютер должен выполнить. Но компьютер умеет исполнять только такие программы, которые написаны в машинных кодах. Других языков компьютер не понимает. Поэтому написанную на языке высокого уровня программу необходимо перевести на язык, понятный процессору – в машинные коды. Специальные программы, осуществляющие перевод с языков высокого уровня в коды машины, называются компиляторами. Для того чтобы программа стала исполняемым файлом (файлом, имеющим расширение .exe), она должна быть обработана еще одной специальной программой, называемой компоновщиком (редактор связей). Именно на этапе компоновки будут подключены библиотеки функций, которые хранятся в уже откомпилированном виде.

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

Рис.В.1. Путь прохождения программы в компьютере

Для облегчения работы компилятор, компоновщик, а также редактор текста программ, отладчик и другие средства объединяют в так называемые интегрированные среды программирования (IDE – Integrated Development Environment). Различные среды программирования создаются под различные платформы и имеют различный интерфейс.

Вам предлагается работать в интегрированной среде Net Beans IDE 6.8. NetBeans работает на многих платформах, например, Unix,Linux,Windows,Mac OS X, Solaris. Легко устанавливается и используется.

Именно в среде NetBeans вам предстоит научиться создавать программы на языке С/С++. Эти программы должны иметь достаточно простую структуру, определенную иерархическую упорядоченность, хорошо воспринимаемую при чтении, возможность быстрой модификации, легкое сопровождение и высокую надежность. Будем для этого использовать технологию создания программ, которая носит название структурное программирование.

Особенностью структурного программирования является:

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

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

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

Машина фон-Неймана – это однородная, состоящая из ячеек память и процессор, имеющий локальную память в виде регистров. Процессор может загружать данные из памяти в регистры, выполнять арифметические и логические операции над содержимым регистров и отсылать значения из регистров в память.

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

Учебное пособие посвящено изучению основ программирования на базе языков C/C++. Будут рассмотрены возможности языка С++ в рамках структурной парадигмы написания программ. Слово парадигма означает стиль программирования.

Существует более 3000 языков программирования. Какое место среди других языков программирования занимает язык С/С++?

С – универсальный язык, эффективный и удобный для решения самых различных задач. Первоначально автором его был Денис Ритчи. Язык тесно связан с системой UNIX,так как был в этой системе и разработан.

Однако язык не привязан к какой-либо системе, он универсален. Определение современного языка С дано в соответствии со стандартом ANSI (American National Standards Institute). В начале 80 годов Бьерн Страуструп вместе с коллегами из AT&T Bell Laboratories разработал С++, который является расширенной версией языка С с подключенными средствами поддержки объектно-ориентированного программирования(ООП). В настоящее время этот язык продолжает непрерывно развиваться. Это гибкий, мощный, имеющий эффективный объектный код язык. С++ поддерживает как структурное программирование, так и ООП. Стандартом языка С++ является ISO/IEC 14882 «Standard for the C++ Programming Language»(1998) .

Без хорошего знания языка невозможно воспользоваться современными технологиями разработки приложений в одной из операционных систем (ОС). Без современных технологий разработки приложений вы не сможете гибко и эффективно управлять средствами ввода данных и вывода результатов работы ваших программ на экран монитора, то есть способом представления информации.

Тема 1. Линейные вычислительные процессы

Теоретический материал

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

Язык состоит из алфавита (перечень элементарных символов) и синтаксиса, который определяет правила построения выражений из этих символов. Минимальная единица языка - лексема. Она имеет самостоятельный смысл.

Выражение определяет правило вычисления некоторого значения.

Оператор задает законченное описание некоторого действия.

Символы, лексемы, выражения, операторы

Символы алфавита С++ :

строчные и прописные латинские буквы и знак подчеркивания;
арабские цифры от 0 до 9;
cпециальные символы :

( ) [ ] { } + - / % * . \ ‘ “ , : ; < = > & # ^ | ! ?

пробелы, табуляция, переход на новую строку.

Лексемы языка:

идентификаторы;
ключевые слова (зарезервированные);
знаки операций;
константы;
разделители (скобки, точка, запятая, пробелы)

Идентификатор (имя программного объекта)

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

Ключевые слова

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

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof virtual

do if static while и др.

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

Знаки операций -

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

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

Константы

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

Целые константы могут задаваться в десятичном, восьмеричном и шестнадцатеричном форматах. В восьмеричном формате целая константа начинается с 0, за которым следуют восьмеричные цифры (от 0 до 7) в шестнадцатеричном формате целая константа начинается с 0x или 0X, за которым следуют шестнадцатеричные цифры (от 0 до 9,A,B,C,D,E,F).

Вещественная константа в экспоненциальной форме представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (E или e), порядок – справа от знака. Пробелы внутри числа недопустимы, отделение целой части числа от дробной выполняется с помощью точки, а не запятой (0.35e-01, 3E7).

Символьная константа содержит один или два символа, заключенные в апострофы (одинарные - 'A', '\n').

Строковая константа – это последовательность символов, заключенная в кавычки (”Изучаем С/С++”).

Escape оследовательности

(управляющие последовательности) начинаются с обратной косой черты :

новая_строка \n (при выводе на экран или принтер переводит строку);

горизонтальная табуляция \t;

вертикальная табуляция \v;

возврат каретки \r;

сигнал звонок \a;

знак вопроса \?;

одиночная кавычка \’;

двойная кавычка \”

Комментарии.

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

Договоримся каждую строку комментариев начинать с двух символов “косая черта” - //.

Для временного исключения блоков при отладке программы будем заключать блок с двух сторон символами /* */.

Концепция типов данных

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

Тип данных определяет:

множество значений, которые могут принимать величины этого типа;
внутреннее представление данных в памяти ПК;
функции и операции, которые могут применяться к величинам этого типа

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

Есть несколько основных ( базовых) типов:

сhar - символьный ;

int- целый;

float - вещественный ;

double – вещественный с двойной точностью;

void - пустой, не имеющий значения.

Понятие ТИП – фундаментальное для всех языков программирования.

Структура программы

Программа состоит из функций, описаний и директив препроцессора.

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

Определение любой функции имеет вид:

тип имя_функции ([параметры]) {

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

}

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

Примечания:

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

Структура программы

директивы препроцессора

описания

int main(){

операторы главной функции

}

int f1(){

операторы функции f1

}

int f2(){

операторы функции f2

} и т.д.

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

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

# include <имя заголовочного файла >

Директива # include (включить файл) может стоять в любом месте программы, но обычно программа с нее начинается.

Потом заголовочный файл будет найден, и строка #include будет заменена на все содержимое этого заголовочного файла. Эффект такой, как если бы вы набрали содержимое заголовочного файла непосредственно в программе.

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

Переменные и выражения

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

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

int x; //целая переменная x

float y; // вещественная переменная y

char z; //символьная переменная z

const int k=5; // для сравнения константа целого //типа k должна быть инициализирована при объявлении, она не может //изменить свое значение в процессе выполнения программы.

Тип объявляется при декларации переменных:

тип список_переменных;

Например, int x,y,z; //переменные x,y,z целого типа

double m, n; // переменные m, n типа double

Компилятор выделяет место в памяти компьютера в соответствии с декларацией. Важное значение имеет то, в каком месте программы эта декларация стоит (правило видимости - scope rules). В Си++ есть три места, где переменная может быть объявлена. Если переменная объявлена вне функций (в том числе и вне функции main),то она называется глобальной(global) и видна из любого места программы (то есть может быть использована везде). Переменная может быть объявлена внутри блока, в том числе внутри тела функции, тогда она называется локальной(local) и может использоваться только внутри этого блока. Переменная может быть объявлена как формальный параметр функции, тогда переменная по сути локальна и служит для передачи информации в эту функцию. Формальным параметром называется параметр, стоящий в круглых скобках в заголовке определения функции. Важно помнить следующие правила:

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

Пример использование глобальных, локальных и формальных параметров:

#include<stdio.h>

char ch; //глобальная переменная ch

main() {

int n; //локальная переменная n

printf(“введи символ ch:”);

scanf(“%c”,&ch);//использование глобальной переменной

printf(..);

. . . . . .

}

funct(int m) { // формальный параметр

int h; //локальная переменная h

printf(“%c\n”,ch); //использование глобальной

// переменной ch

. . . . . .

}

Примечание. Еще раз вернитесь к записи const int k=5 на предыдущей странице. Модификатор const показывает, что значение переменной целого типа k изменить нельзя. Такую переменную называют именованной константой или просто константой.

Операции. Приоритеты операций и порядок их выполнения

Таблица 1.1

Приоритет	Название оператора	Символ операции	Порядок выполнения (ассоциативность)
1 (высший)	Обращение к функции	( )	левосторонняя
	Выделение элемента массива	[ ]
	Инкремент постфиксный	++
	Декремент постфиксный	--
2	Логическое отрицание	!	правосторонняя
	Инкремент префиксный	++
	Декремент префиксный	--
	Унарное сложение	+
	Унарное вычитание	-
	Разименование	*
	Взятие адреса	&
	Приведение типа	(type)
	Размер объекта	sizeof
3	Умножение	*	левосторонняя
	Деление	/
	Вычисление остатка от деления	%
4	Сложение бинарное	+
4	Вычитание бинарное	-
5	Меньше	<
	Не меньше	>=
	Больше	>
	Не больше	<=
6	Логическое И	&&
7	Логическое ИЛИ	\| \|
8	Операция условия	?:	правосторонняя
9	Присваивание	= += -= *= %= /=	правосторонняя

Операции задают действия, которые необходимо выполнить. Операции, которые распознает компилятор, упорядочены по приоритету. Приоритет определяет порядок интерпретации выражений (правила предшествования). Приоритет можно изменить с помощью круглых скобок. При наличии нескольких операций одного приоритета компилятор учитывает еще и порядок выполнения операций, например, слева направо или справа налево. Будем называть это левосторонней и правосторонней ассоциативностью (смотри таблицу 1.1). Если скобок несколько, то первым будет выполняться выражение в “самых глубоких” скобках.

Арифметические операции

+ сложение

- вычитание

* умножение

/ деление

% деление по модулю

++ инкремент ( увеличение операнда на единицу)

- - декремент (уменьшение операнда на единицу)

Операции инкремента и декремента могут применяться только к переменным.

(Например, запись (a+b)++ недопустима, так как (a+b)является выражением))

Существуют две формы записи:

префиксная ++a , в которой сначала выполняется увеличение операнда на единицу, а затем это увеличенное значение используется в выражении;

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

Пример

#include<stdio.h>

int main() {

int m=0,n=1,p;

p=m++;

printf("m=%d p=%d\n",m,p);

p=++m;

printf("m=%d p=%d\n",m,p);

p=++n;

printf("n=%d p=%d\n\n",n,p);

//----------------------------

int x=10, y=10;

x++;

++y;

printf("x=%d y=%d\n",x,y);

printf("x=%d y=%d\n\n",x++,++y);

//------------------------------------

int a=5,b=2;

printf("%d\n",a/b);

printf("%d\n",b-a);

printf("%d\n",a%b);

return 0;

}

Протокол работы

m=1 p=0

m=2 p=2

n=2 p=2

x=11 y=11

x=11 y=12

-3

Внимательно ознакомьтесь с примером. Работа с переменными m, n, и p , а также с переменными x и y демонстрирует различия в использовании постфиксного и префиксного инкрементов.

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

Операции отношений

> больше

>= не меньше

< меньше

<= не больше

= = равно

! = не равно

Операции отношений используются в условных выражениях, в которых проводится проверка некоторого условия на истинность (true) или ложность(false).

Логические операции

&& (and) логическое И

|| (or) логическое ИЛИ

! (not) отрицание

Операции присваивания

= простое присваивание

дополнительные операции присваивания:

+ =

- =

* =

/ =

% =

Пример

m - =20 (m=m-20)

m * =20 (m=m*20)

m / =10 (m=m/10)

m % =10 (m=m%10)

m+=50 (m=m+50) - аддитивная операция присваивания, в результате выполнения которой величина, стоящая справа от знака присваивания, прибавляется к значению переменной, стоящей слева от знака присваивания. Операция m+=50 выполняется быстрее, чем m=m+50.

Примечание .

Разрешается использовать многократное присваивание:

a=b=c=x*y.

В этом случае работает правосторонняя ассоциативность(x*y->c=x*y->b=c->a=b). В левой части (a) должно стоять выражение (может быть просто переменная), которому можно присвоить значение, но не может стоять константа.

Математические функции

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

Прототипы некоторых математических функций приведены в таблице 1.2

Таблица 1.2

Имя функции	прототип	действие
abs	Int abs(int num);	Возвращает модуль числа.(<stdlib.h>)
ceil	double ceil(double num);	Округляет вверх
cos	double cos(double num);	Вычисляет косинус
exp	double exp(double num)	Возвращает степень числа e
fabs	double fabs(double num)	Возвращает модуль числа
floor	double floor(doudle num)	Округляет вниз
log	double log(double num)	Вычисляет натуральный логарифм
log10	double log10(double num)	Вычисляет логарифм по основанию 10
pow	double pow(double base,double x)	Возводит число в степень
sin	double sin(double num)	Вычисляет синус
sqrt	double sqrt(double num)	Вычисляет квадратный корень
tan	double tan(double num)	Возвращает тангенс аргумента

Ввод/вывод информации

Форматированный ввод/вывод

Для элементарного ввода-вывода информации используются библиотечные функции scanf() и printf(). Эти функции позволяют осуществить форматированный ввод-вывод. За одно обращение к этим функциям можно обработать несколько элементов, при этом функции способны выполнить преобразования данных. В качестве первых аргументов эти функции имеют форматную строку, которая задает способ преобразования данных.

Функция scanf() принимает с клавиатуры все символы до нажатия клавиши ‘Enter’ и помещает их в буфер. Форматная строка определит способ преобразования введенных символов в соответствии с заданной спецификацией. Преобразованное число будет помещено по адресу переменной.

Функция printf() выдает на экран монитора всю форматную строку, в которой знак % и все символы после него, включая тип переменной, будут заменены символами выводимой информации. Символы после % до первого разделителя рассматриваются как спецификация преобразования значения выводимой переменной.

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

Для переменных типа int будем использовать в формате буквы d и i , которые для функции printf() преобразуют аргумент к десятичному виду.

Для переменных типа float – буквы f , e , g, которые рассматривают аргумент как переменные типа float. Спецификатор формата g применяется для вывода вещественных чисел в широком диапазоне. При этом число выводится либо в формате f, либо в формате e(с порядком), в зависимости от того, какой из них получится короче.

Возьмем маленькую программу на Си:

#include<stdio.h>

int main() {

int year;

printf(“Enter year:\n”);

scanf(“%d”,&year);

printf(“You enterd %d year\n”,year);

return 0;

}

Протокол работы

Enter year:

2012 <Enter>

you enterd 2012 year

Примечания:

Каждый оператор заканчивается точкой с запятой.

Прежде чем запустить программу, ее надо сохранить, чтобы не “зависнуть”.

Анализ программы

<stdio.h> -заголовочный файл, в котором хранятся прототипы функций ввода-вывода. Например, форматный вывод printf()имеет прототип:

int printf(char*format,arg1,arg2,….)

Первый вызов функции printf(“Enter year”) содержит только форматную строку с отсутствующей в ней спецификацией преобразования. На экран будет выведено содержимое всей форматной строки – интерфейсная подсказка, необходимая для того, чтобы пользователь знал, что ему сейчас необходимо сделать. Пользователю предлагают ввести год.

Далее следует вызов функции scanf(“%d”,&year), с помощью которой пользователь введет с клавиатуры целое число, соответствующее году, например, 2012. Эта функция имеет два аргумента. Первый аргумент – форматная строка “%d”, которая говорит о том, что вводиться с клавиатуры будет одно число, и это число целого типа. Второй аргумент &year назначает адрес оперативной памяти, куда будет помещено введенное пользователем число c учетом указанного им формата.

Вызов последней функции printf(“You enterd %d year\n”, year) выводит результат работы данной программы. Функция имеет два аргумента. Первый аргумент – форматная строка. До и после спецификации формата %d стоят символы, которые будут выведены на экран в том виде, в каком вы их видите, кроме двух последних символов \n, которые означают перевод курсора на новую строку.

Второй аргумент функции year .Значение year должно быть в виде изображения выведено на экран в формате, заданным спецификацией преобразования %d . Это изображение числа будет помещено вместо спецификации преобразования. Таким образом функция printf() преобразует, форматирует и печатает свои аргументы в стандартном выводе под управлением формата.

Еще одна программа:

#include<stdio.h>

// деление целых чисел - комментарий

int main() {

int a,b,c;

printf(“input a,b,\n”);

scanf(“%d”,&a);

scanf(“%d”,&b);

c=a/b;

printf(“result=%d\n”,c); // вывод в десятичном формате

printf(“result=%o\n”,c); //вывод в восьмеричном формате

printf(“result=%x\n”,c);//вывод в шестнадцатеричном формате

printf(“result=%d\n”,a%b);//остаток от целочисленного деления

return 0;

}

Протокол работы

nput a,b

22 <enter>

2 <enter>

result=11 //десятичный формат

result=13 //восьмеричный формат

result=b //шестнадцатеричный формат

Примечание. Еще раз обратите внимание на унарный оператор

&, который выдает адрес объекта.

(Инструкция p=&c присваивает адрес ячейки с переменной p—говорят, что p указывает на с, или p ссылается на с).

Оператор & применяется только к объектам, расположенным в памяти: к переменным и элементам массивов. Его операндом не может быть ни выражение, ни константа, ни регистровая переменная.

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

Пример:

#include<stdio.h>

void main() {

printf(“тип\tразмер в байтах\n\n”);

printf(“int\t\t\t%d\n”,sizeof(int));

printf(“char\t\t\t%d\n”,sizeof(char));

printf(“float\t\t\t%d\n”,sizeof(float));

}

Протокол работы

тип размер в байтах

int 2

char 1

float 4

Замечание.

Размер в байтах зависит от конкретной машины, на которой вы работаете.

Функции printf() и scanf() унаследованы из библиотеки языка C, поэтому такой ввод/вывод называется вводом/выводом в стиле С. Однако реализовать ввод/вывод можно также с помощью потоков С++. Такой способ называется вводом-выводом в стиле С++. Смешивать эти два стиля в одной программе без специальной синхронизации нельзя, то есть можно пользоваться либо одним стилем, либо другим. У каждого из этих способов есть свои преимущества. Существует большое количество программ, написанных в стиле С, а потом перенесенных на С++, и разработчику придется с ними сталкиваться.

Стиль С++ удобен для простых случаев ввода/вывода, не требующих форматирования. Хорошо, если вы умеете пользоваться и тем, и другим стилями. Функции scanf() и printf() удобно использовать в программах, в которых вы хотите получить тщательно отформатированные результаты. В других случаях для ввода/вывода можно использовать объекты cin и cout cсоответствующих классов.

Потоковый ввод/вывод

Язык С++ добавляет новые элементы языка – объекты. Например, такими объектами являются объекты для ввода/вывода данных cin и cout. Это позволяет нам вместо форматированного ввода/вывода, использующего функции scanf() и printf() из библиотеки С, доступных при подключении заголовочного файла stdio.h, использовать потоки библиотеки С++, доступной при подключении заголовочного файла iostream.h. ( При использовании библиотек нельзя обойтись без заголовочных файлов. Это единственный способ предоставления программе информации о функциях, хранящихся в библиотеках.)

В библиотеке iostream представлена объектно-ориентированная версия потоков. Поток служит для переноса данных от источника к приемнику. Обмен с потоком производится через специальную область ОП – буфер. Это помогает значительно повысить скорость передачи информации. Поток всегда относится к какому-либо классу. Для поддержки потоков библиотека С++ содержит иерархию классов, построенных на основе двух базовых классов – ios и streambuf. Потоки, связанные с клавиатурой и экраном, называются стандартными. Стандартному потоку ввода соответствует класс istream( класс входных потоков, по умолчанию связанный с клавиатурой). Стандартному потоку вывода соответствует класс ostream(класс выходных потоков, по умолчанию связанный с экраном монитора). Есть еще класс iostream - класс двунаправленных потоков ввода/вывода.

Класс является абстрактным типом данных и определяется пользователем. Конкретные переменные типа класс называются объектами. Объекты будут изучаться нами в курсе «Современные методы программирования», а пока будем просто использовать стандартные объекты cin и cout и операции чтения с клавиатуры >> и вывода на экран <<.

объект	Класс	Описание
cin	istream	Связывает с клавиатурой (стандартный буферизованный ввод)
cout	ostream	Связывает с экраном (стандартный буферизованный вывод)

Эти объекты создаются при включении в программу заголовочного файла <iostream.h>. При этом программе автоматически становятся доступными объекты cin и cout, а также связанные с ними средства ввода/вывода: >> - ввод данных с клавиатуры, << - вывод на экран изображения полученного результата. В потоковых классах форматирование выполняется по умолчанию или с помощью манипуляторов (флагов) – функций, которые можно включать в цепочку операций помещения и извлечения для форматирования данных. Например, setw(5) устанавливает для очередного выводимого значения ширину поля в 5 позиций; setprecision(5) устанавливает точность вывода числа на экране. Это означает максимальное количество цифр в дробной части для вещественных чисел в форме с фиксированной точкой, или общее количество значащих цифр для чисел в форме с мантиссой и порядком. Для использования манипуляторов надо подключить заголовочный файл iomanip.h.

Например, пусть величина x -целого типа.

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

cout<<setw(5)<<x<<endl;

Замечание:

-при использовании стандартной библиотеки С++(ISO/IEC 14882) заголовочные файлы указываются без расширения .h, но используется директива using namespace std; (использование стандартного пространства имен), так как все имена в стандартной версии библиотек принадлежат пространству std. В случае использования более старой версии заголовочный файл пишется с расширением h, а using namespace std не используется.

Рис. 1.2. Различные стили ввода – вывода информации

При потоковом вводе-выводе используется объект cin для связи с клавиатурой, операция ввода с клавиатуры >>; объект cout используется для связи с монитором, операция вывода на экран <<.

Рассмотрим маленькую программу:

#include<iostream.h>

int main() {

int x,y,z;

cout<<”input x=”;

cin>>x;

cout<<”input y=”;

cin>>y;

z=x+y;

cout<<”x=”<<x<<” y=”<<y<<” z=”<<z<<endl;

return 0;

}

В программе надо вычислить сумму двух чисел x и y, введенных с клавиатуры, и результат поместить в переменную z.

Первая строка программы - это директива препроцессора, в соответствии с которой к исходному тексту программы подключается заголовочный файл <iostream.h>, который содержит описания элементов стандартной библиотеки, с помощью которых будет выполнен ввод/вывод информации в стиле С++. В этом файле описаны стандартные объекты cin для ввода с клавиатуры и cout для вывода на экран, а также операции ввода с клавиатуры >> и вывода на экран <<.

Программа состоит из единственной функции и поэтому должна иметь имя main. Перед этим именем стоит тип int. Это значит, что функция main должна возвратить во внешнюю среду целочисленное значение. Так как наша функция ничего не возвращает во внешнюю среду, то в конце программы стоит return 0. После имени main стоят пустые скобки. Обычно в скобках пишется список передаваемых функции параметров, но в данном случае таких параметров нет, но пустые скобки обязательны, чтобы компилятор понимал, что речь идет именно о функции. Сразу после фигурной скобки, открывающей тело функции, следует строка, в которой декларируются три переменные x,y,z – все три целого типа. В соответствии с декларацией на этапе компиляции в оперативной памяти будет выделено место под все три переменные. Задекларировав переменные, вы не только позволили компилятору выделить место в памяти, но указали ему, как необходимо интерпретировать значения этих переменных (представление внутри компьютера), а также дали возможность компилятору проверять правильность выбираемых вами действий с этими величинами.

Строки cout<<”input x=” и cout<<”input y=” являются интерфейсными подсказками для того, чтобы пользователь знал, что от него требуется ввести с клавиатуры в данный момент и что будет выведено на экран монитора. Стандартный объект cout связывает нас с экраном. Именно этому объекту мы с помощью операции << передаем то, что хотим вывести на экран. При выводе все символы внутри кавычек выводятся без изменений. Но при выводе значений переменных будет выполнено преобразование из внутреннего представления в изображение этих чисел на экране.

Два оператора cin>>x и cin>>y выполняют ввод с клавиатуры, используя стандартный объект cin и операцию чтения >>. В процессе ввода оба вводимых числа преобразуются из последовательности символов, набранных на клавиатуре, во внутренне представление целых чисел и помещаются в ячейки памяти, зарезервированные на этапе компиляции для переменных x и y.

Обратите внимание, тело функции обрамлено фигурными скобками.

Общие выводы и рекомендации

Хороший стиль программирования требует, чтобы тело функции, заключенное в фигурные скобки, писалось с отступом от заголовка функции.
Тип переменных программист выбирает самостоятельно. При этом он должен учитывать и диапазон изменения переменных и требуемую точность представления данных.
Имена переменным выбирает также сам программист. Желательно давать эти имена осмысленно, исходя из их назначения.
Не забывайте об интерфейсных подсказках. Это корректно по отношению к пользователям. Они не должны сидеть перед пустым экраном.
До запуска программы подготовьте тесты с вашими исходными данными и ожидаемыми результатами. Иначе трудно будет определить, насколько корректно работает ваша программа. Нелишним будет проверить реакцию вашей программы на неверно введенные исходные данные.
Старайтесь как можно меньше использовать глобальные переменные. Чем меньше будет область действия переменной, тем легче отследить возможные ошибки.
При написании программы прибегайте к отладке программы, используя те средства отладки, которые предоставляет вам конкретная среда разработки.

Пример линейной программы

Постановка задачи

Вычислить значения функций у=иz=

для рабочего набора данных x=2,2; a=3,2; b=6,8.

Анализ задачи

Для решения поставленной задачи необходимо ввести в компьютер рабочий набор данных. В качестве исходных данных имеем три вещественных числа: x,a,b. Результатом решения задачи являются два других вещественных числа –значения функций y и z.

Текст программы

#include<stdio.h> //(1)

#include<math.h> //(2)

int main() { //(3)

float x,y,z,a,b; //(4)

printf("enter x,a,b:\n"); //(5)

scanf("%f%f%f",&x,&a,&b); //(6)

y=(4*sin(x)*sin(x)+3)/2; //(7)

float m=sin(a*(3*y*y-1.0/3)); //(8)

z=(m*m+11.75)/(m*m+b); //(9)

printf("y=%f z=%f",y,z); //(10)

return 0; //(11)

}

Протокол работы.

enter x,a,b:

2.2 3.2 6.8

y=2.807333 z=1.676159

Перед постановкой программы на счет, провели контрольный расчет в одной из математических систем – в системах Maxima , MathCAD или любой другой. Контрольный расчет дал результат: y=2.807333, z=1.676159. Проверка подтвердила правильность работы программы.

Пояснения к программе

Первые две строки начинаются со знака #. Следом за этим знаком всегда идут директивы препоцессора. Директива #include<имя файла> вставляет содержимое файла в точку исходного файла, где она записана. Файлы stdio.h и math.h называются заголовочными файлами и обычно имеют расширение h(от слова header).

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

Стоящие следом фигурные скобки открывают тело функции.

Тело функции состоит из операторов. Строка (4) декларирует пять переменных вещественного типа. Это необходимо компилятору для выделения достаточного количества оперативной памяти для хранения значений этих переменных. Именно для этого в декларации указывается тип переменных. Отвечает за это сам программист, решающий конкретную задачу.

Строка(5) является интерфейсной подсказкой, которая говорит пользователю, какие именно переменные и в какой последовательности надо ввести в компьютер. Вывод подсказки на экран производится с помощью функции printf().

Строка (6) работает с функцией scanf(), которая ожидает ввода с клавиатуры переменных x,a, b. Они будут введены в формате вещественных чисел (%f) и отправлены по адресам(&),по которым на этапе компиляции было выделено место для переменных x,a,b в соответствии с декларацией.

Строки (7), (8) и (9) с помощью оператора присваивания вычисляют выражения и помещают результаты вычислений в оперативную память в переменные y, m и z. Обратите внимание на строку (8). Мы ввели некоторую промежуточную переменную m , причем задекларировали ее прямо в том месте программы, где она нам понадобилась (float m). Язык С++ это позволяет. С помощью переменной m мы упростили слишком длинное выражение, определяющее функцию z(y,a,b):

m=sin(a*(3*y²-1/3)).Обратите внимание на величину 1/3. Если бы мы написали ее именно так, то в результате деления получили бы ноль, так как результат должен быть целочисленным при делении целого на целое. Округления при этом не произошло бы, дробная часть была бы отброшена. В конечном итоге мы получили бы неправильный результат, поэтому при написании выражения надо использовать запись 1.0/3, или 1.0/3.0, или 1/3.0.

Строка (10) выводит на экран изображения содержимого ячеек памяти y и z в формате вещественных чисел.

Последняя строка (11) нужна потому, что функция должна вернуть во внешний мир величину целого типа, но наша функция ничего во внешний мир не возвращает, поэтому мы пишем return 0.

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

Общие требования к выполнению лабораторных работ и написанию отчетов:

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

Программа должна быть написана на языке C++, который мы используем в рамках структурной парадигмы.
Контрольные расчеты должны быть выполнены до запуска программы (на калькуляторе, в системе Maxima,в системе MathCAD или любым другим способом); контрольные расчеты предполагают набор некоторых проверочных исходных данных и получение соответствующих этим наборам результатов. При тех же исходных данных результаты работы программы должны совпасть с контрольными расчетами.
Ввод/вывод исходных данных и результатов в работах с линейными, разветвляющимися и циклическими программами должен производиться в стиле С; в работах с массивами – в стиле С++.
Обработка данных в соответствии с заданием;
Отладка программы, то есть процесс исправления синтаксических ошибок.
Тестирование, то есть проверка правильности работы программы для всех ветвей алгоритма. Желательно проверить, как программа реагирует на ошибочные исходные данные.

Варианты заданий к работе 1

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

Варианты заданий предлагают решить задачу вычисления и вывода значений функций y=f1(x) и z=f2(y,a,b). Варианты заданий представлены в таблице 1.3

Таблица 1.3

N	Функция	Функция	Рабочий набор
N	Функция	Функция	x	a	b
1			3,5	1,8	3,7
2			8,2	2,2	8,2
3			8,1	0,8	1,2
4			4,7	7,6	8,1
5			3,4	82	2,5
6			-8	8,7	1,3
7			2,5	8,7	1,8
8			2,7	17	11