Консольный ввод/вывод
Чтобы обеспечить данный ввод/вывод, к программе подключается заголовочный файл <iostream>.
В C++ ввод/вывод выполняется с использованием операторов. Оператор вывода — это << а оператор ввода — >>. Для вывода информации вначале указывается поток, затем – оператор вывода и выводимые данные. Например,
cout<< 243.78;
В данном примере выведено дробное число. В общем случае данные можно получить из переменной или выражения:
int a=47;
cout<< a;
cout<< 5*a+23;
Для считывания значения с клавиатуры, используется оператор ввода >>. Например, в этом фрагменте целая величина вводится в num:
int num;
cin >> num;
Операция ввода осуществляется только в переменные.
До сих пор нами в программах для вывода информации использовалась одна (заранее установленная в С++) форма (один формат). Однако С++ позволяет выводить информацию во множестве вариантов форм. Организация вывода информации в заранее установленной форме и изменение параметров ввода информации называется форматированием ввода/вывода.
Форматирование данных с помощью манипуляторов
Одним из способов форматирования информации в С++ является использование манипуляторов ввода/вывода.
Манипулятор – это ключевое слово языка С++, которое применяется в выражениях ввода/вывода для управления информацией ввода/вывода. Манипуляторы различают с параметрами и без параметров. Например:
dec – установка флага dec (вывод информации в десятичной форме) – манипулятор без параметра
setw(15) – задание ширины поля вывода в 15 позиции – манипулятор с параметром.
Для того, чтобы в программе можно было использовать манипуляторы с параметрами, необходимо в нее включить заголовок <iomanip>. При использовании манипуляторов без параметров это делать необязательно.
Манипуляторы задаются внутри цепочки операций ввода/вывода. Например:
cout <<oct<<100<<hex<<100;
cout<<setw(10)<<100;
Первый манипулятор oct сообщает потоку, что необходимо выводить целые числа в восьмеричной системе счисления и выводит 100 в восьмеричной системе счисления. Затем манипулятор hex сообщает, что следующий вывод необходимо сделать в шестнадцатеричной СС, и выводит 100 в шестнадцатеричной СС. Во второй строке манипулятор sеtw(10) устанавливает ширину поля вывода, равную десяти, и выводит в него 100 в шестнадцатеричной СС.
Некоторые манипуляторы
| endl | Вывод символа новой строки и очистка потока | вывод |
| left | Установка флага left | вывод |
| right | Установка флага right | вывод |
| setprecision (int p) | Задание числа цифр точности, равной р | вывод |
| setw(int w) | Задание ширины поля вывода в w позиций | вывод |
| skipws | Отбрасываются начальные невидимые символы (пробелы, табуляции и символы новой строки) | ввод |
| uppercase | Вывод символов в верхнем регистре | вывод |
| ws | Пропуск начальных пробелов | ввод |
| setfill (int ch) | Задание символа заполнения | вывод |
Пример с использованием манипуляторов.
#include <iostream>
#include <iomanip>
using namespace std;
Int main()
{
cout<<hex <<100 << endl;
cout<<oct <<10 << endl;
cout<<setfill(‘x’)<<setw(10);
cout<<100<<” ИБ-91вп”<<endl;
return 0;
}
После выполнения программы на экран выводится следующее:
ХХХХХХХ100 ИБ-91вп
Файловый ввод/вывод
Под файлом понимается именованная область памяти (обычно на диске: HDD, CD, Flash), которая рассматривается в компьютере как единое целое. Для компилятора файл – это сложный тип данных.
В файл можно записывать данные – вывод в файл; из файла можно считывать данные – ввод из файла.
ввод вывод
 |
Файловый ввод/вывод в С++ организуется с помощью потоков. Имеется три типа потока:
ifstream – поток ввода;
ofstream – поток вывода;
fstream – поток ввода и вывода.
Для реализации файлового ввода/вывода в программу необходимо включить директиву: #include < fstream >.
При работе с файлами следует соблюдать следующий порядок.
1) Вначале необходимо создать поток. Для этого объявляется его имя с соответствующим типом потока. Например:
ifstream in; - создан поток ввода из файла с именем in,
fstream iо – создан поток для ввода и вывода iо.
2) После создания потока, необходимо установить связь файла с потоком. Это производится с помощью функции open().
Например, для того чтобы связать созданный поток in с файлом, допустим с именем test, необходимо записать:
in.open(“test”); - это означает, что файл test связан с потоком in (для ввода данных).
Может оказаться, что такого файла не существует или по каким-либо причинам нет к нему доступа, тогда функция open() завершиться с ошибкой; в этом случае поток in примет значение false (ложь). Поэтому, чтобы убедиться в открытии файла, необходимо
3) сделать проверку типа:
...
if(!in)
cout<<”Error of file opening”;
4) После того, как файл открыт, работа с ним производится с помощью операторов ввода/вывода: “<<” и “>>”, так же, как и со стандартными потоками cin и cout, только вместо этих потоков необходимо использовать созданные потоки. Для нашего примера ввод из файла будет обеспечиваться инструкцией:
in >>...;
Вся информация в файле хранится в том же формате, как если бы она находилась на экране. Поэтому, если информация выводится в файл, то он представляет собой файл с отформатированным текстом.
5) После работы с файлом его необходимо закрыть с помощью функции close(). Для нашего примера это запишется:
in.close();
Имя файла в функции не указывается.
Рассмотрим пример программы работы с файлами, в которой создается файл для вывода и в него записывается информация, после чего он закрывается. Затем файл открывается для ввода и оттуда считывается информация в программу.
#include<iostream>
#include<fstream>
#include<iomanip>
using namespace std;
Int main()
{
ofstream tofile; //создание потока вывода
tofile.open(“first”); //открытие файла
if(!tofile) //проверка открытия файла
cout<<”Error of file opening”;
Else
{
tofile<<”Hello!\n”;
tofile<<100<<’ ‘<<hex<<100<<endl;
tofile.close();
}
//открываем файл для ввода
ifstream fromfile; //создание потока ввода
fromfile.open(“first”); //открытие файла
if(!fromfile) //проверка открытия
cout<<”Error of file opening”;
Else
{
char str[80];
int n;
fromfile>>str>>n;
cout<<str<<’ \n‘<<n<<endl;
fromfile.close();
}
return 0;
}
Новые приемы программирования в данном примере:
1) переменные объявляются не в начале функции main(), а перед местом их использования;
2) вывод символьного массива производится не поэлементно, а строкой путем указания только имени массива.
После завершения работы программы содержимое файла first будет следующим:
Hello!
Функции
До сих пор все рассмотренные программы содержали одну-единственную функцию с именем main. Это отчасти связано с тем, что программы эти были простые.
Создавая непростые программы, важно заботиться о том, чтобы с ними было удобно работать. Одним из основных условий этого является разделение программы на отдельные самостоятельные части. Функция обеспечивает удобный способ отдельно оформить некоторое вычисление и пользоваться им далее, не заботясь о том, как оно реализовано. После того, как функции написаны, можно забыть, как они сделаны, достаточнолишь знать, что они умеют делать. Механизм использования функций в Си++ имеет свои правила и особенности, он удобени эффективен, но, может быть на первый взгляд, не так прост.
Вначале следует отметить, что все функции разделяются на две части. Первую часть составляет большой набор библиотечных функций языка С++. Например, основные математические функции определяются заголовком <cmath>, и подключаются к программе с помощью директивы #include<cmath>. Но в данном случае речь пойдет о второй части функций языка С++, - о функциях, которые разрабатываетсам программист и использует их в своих программах.
Функция – это логически самостоятельная именованная часть программы, в которую может передаваться любое количество значений аргументов, а функция может возвращать значение. Но только одно.
Есть функции, в которые не передаются аргументы, и есть функции, которые не возвращают значений.
Объявление функции
Значение функции – величина переменная, и как всякая переменная она должна быть объявлена. Объявление функции производится до первого ее использования и вне тела любой другой функции, т.к. функции не могут располагаться одна в другой. При объявлении функции указывается (слева направо):
· тип возвращаемого функцией значения;
· имя функции;
· в круглых скобках – типы и имена параметров (переменных).
Как и всякое объявление, конструкция заканчивается точкой с запятой. Рассмотрим несколько примеров объявления функций.
intbuf (inta);
Данное объявление означает, что функция с именем buf будет возвращать целочисленный значение. В скобках указан один целочисленный параметр а, значение которого следует передать в функцию при её использовании.
float fun1 (float b, char ch); - объявлена функция fun1, которая возвращает значение типа float, и у которой в качестве параметров указаны две переменные – b типа float и ch типа char.
Если функция не возвращает никакого значения, то при объявлении на его месте указывается слово void. Например, функция beta, имеющая в качестве параметра массив из десяти дробных чисел и не возвращающая значения, объявляется как
void beta (double m[10]);
Другим частным случаем является отсутствие параметров у функции. Тогда при объявлении в круглых скобках ставится слово void или вообще ничего не ставится. Следующие два объявления совершенно равнозначны:
char sasha (void);
char sasha ();
Объявляя функцию, мы тем самым не только указываем её тип, но и то, как с ней работать. Поэтому формат объявления функции ещё называется заданием её прототипа.
Объявляются все функции программы, кроме функции main().
Определение функции
Определение функции – это описание операций, которые выполняются в ее рамках. Если объявление функции должно предшествовать её использованию, то определение функции может быть сделано в любом месте программы (за исключением случая «функция в функции»).
Определение функции начинается заголовком, в котором указывается её прототип (тип возвращаемого значения, имя функции, список параметров), затем в фигурных скобках описываются действия, которые выполняются функцией (что называется телом функции). Если функция возвращает значение, то последним оператором в теле функции должен стоять оператор return.
Рассмотрим несколько примеров. В первом из них определим функцию, которая выполняет сложение двух чисел и возвращает сумму.
Int summa(int x, inty)
{
int z;
z=x+y;
return z;
}
Прототип функции в данном примере показывает, что функция summa имеет два целочисленных параметра x и y и возвращает результат типа int. Для сохранения суммы чисел внутри функции объявляется переменная z, которой затем присваивается сумма x и y. Так как функции предписано возвращать значение, то последним оператором тела функции является оператор return, который показывает, что возвращаемой является величина z. Тип величины указанной в операторе return и тип возвращаемого значения функции должны совпадать, иначе выдается сообщение об ошибке.
Изменим несколько условие примера и потребуем от функции не возвращения суммы, а вывод её на экран. Теперь у функции не будет возвращаемого значения, и её прототип изменится, а также изменится и тело функции.
Void summa(int x, int y)
{
int z;
z=x+y;
cout<<z;
}
Теперь перед именем функции стоит не int, а void и в теле функции отсутствует оператор return.
И последний пример, который показывает, что в операторе return в качестве возвращаемого значения может стоять выражение языка С++. Опять определим функцию, которая выполняет сложение двух чисел и возвращает сумму.
Int summa(int x, int y)
{
return x+y;
}
Как видно из примера тело функции уменьшилось до одного оператора за счет того, что выражение суммы двух чисел записано непосредственно в операторе return.
Если функция должна возвращать значение, но оператор return в теле функции отсутствует, то она выдает “мусор”.
Вызов функции
Всё что описано выше касается проектировочной части программы. Это – всё проекты и намерения. Всем этим надо воспользоваться, ввести в действие. Чтобы воспользоваться функцией, её необходимо вызвать или ещё говорят – обратиться к функции.
Для вызова функции надо указать 1) ее имя и 2) в скобках – список аргументов в соответствии с прототипом. Ну и конечно закончить вызов точкой с запятой.
Например, для вызова вышеописанной функции summa следует записать: summa(a,b);
Здесь a и b должны иметь значения типа int.
Ещёпример:
function1(a, alpha, dd); - вызывается функция function1, которой передаются три аргумента.
Если функция возвращает значение, и оно дальше будет использоваться в программе, то его необходимо присвоить какой-либо переменной. Например:
w = delta (x, y);
В данном примере вызывается функция delta, которой передаются два аргумента. После выполнения функция возвращает значение, которое присвоится переменной w.
Взаимодействие функций в программе
Любая программа на Си++ начинает выполняться с главной функции main (). Обычно из нее вызываются другие функции. В общем случае любая функция может быть вызвана из любой. Одна из функций становится вызывающей и временно передает управление вызываемой функции, которая, выполнив определенные операции, возвращает управление вызывающей.
Рассмотрим пример программы, в которой используются две функции.
По условию требуется вычислить z = x². Возведение числа в квадрат оформить в виде отдельной функции.
# include<iostream>
using namespace std;
int square (int a); // объявлениефункции square()
Int main ()
{
int z;
int x = 3;
z = square (x);
cout<< ”square =”<<z<<”\n”;
return 0;
}
// определениефункцииsquare
Int square (int a)
{
int b;
b = a*a;
return b; // оператор возврата управления
}
Во второй строчке данной программы указывается прототип используемой функции. Это – функция, содержащая один целочисленный параметр и возвращающая значение типа int. Описание функции square производится в конце программы. В главной функции производится вызов функции square выражением z = square (x); в качестве аргумента функции передаётся x = 3. Управление передается вызываемой функции, которая вычисляет квадрат аргумента и возвращает его значение в место вызова в функции main (), которое будет присвоено переменной z и затем выведено на экран.
Обращение к функции следует рассматривать как выражение. Оно может использоваться всюду, где допускаются выражения. Для демонстрации этого изменим несколько предыдущий пример: вычислить z = x² + y², возведение числа в квадрат оформить в виде отдельной функции.
Программа примет следующий вид.
# include<iostream>
using namespace std;
int square (int a); // объявлениефункции square()
Int main ()
{
int z;
int x = 3;
int y = 4;
z = square (x)+ square (y);
cout<< ”sum =” <<z<< ”\n”;
return 0;
}
// определениефункцииsquare
Int square (int a)
{
int b;
b = a*a;
return b; // оператор возврата управления
}
Изменения в данном примере касаются записи вызова функции внутри выражения z = square (x)+ square (y). Функция square будет вызвана дважды, а возвращаемые её значения суммируются.
Рассмотренные примеры демонстрировали работу с функциями, при которой функции сначала явно объявлялись, а потом описывались. Однако в программах можно избежать объявления функции. Вместо объявления функции её можно сразу определить. Рассмотрим пример.
# include<iostream>
using namespace std;
Void show(char x)
{
cout<< x <<endl;
}
Int main()
{
chara = ‘s’;
show(a);
return 0;
}
В данном коротком примере функция show сразу определяется в начале программы и это заменяет её объявление. Функция ничего не возвращает, а только выводит на экран получаемый символ.