Работаем с потоками на C++ ofstream и ifstream . В пример показана программка генерирующая HTML файл, с данными в таблице, которые мы введем в программу. Используем потоковый ввод/вывод.

Потоки для работы с файлами создаются как объекты следующих классов:

  • ofstream - для вывода (записи) данных в файл;
  • ifstream - для ввода (чтения) данных из файла;
  • fstream - для чтения и для записи данных (двунаправленный обмен).

Чтобы использовать эти классы, в текст программы необходимо включить дополнительный заголовочный файл fstream.h . После этого в программе можно определять конкретные файловые потоки, соответствующих типов (объекты классов ofstream, ifstream, fstream ), например, таким образом:

  • ofstream outFile; // Выходной файловый поток.
  • ifstream inFile; // Входной файловый поток.
  • fstream ioFile; // Файловый поток для ввода и вывода.

Создание файлового потока (объекта соответствующего класса) связывает имя потока с выделяемым для него буфером и инициализирует переменные состояния потока. Так как перечисленные классы файловых потоков наследуют свойства класса ios , то и переменные состояния каждого файлового потока наследуются из этого базового класса. Так как файловые классы являются производными от классов ostream (класс ofstream ), istream (класс ifstream ), stream (класс fstream ), то они поддерживают описанный в предыдущих шагах форматированный и бесформатный обмен с файлами. Однако прежде чем выполнить обмен, необходимо открыть соответствующий файл и связать его с файловым потоком .

Открытие файла в самом общем смысле означает процедуру, информирующую систему о тех действиях, которые предполагается выполнять с файлом. Существуют функции стандартной библиотеки языка С для открытия файлов fopen() , open() . Но работая с файловыми потоками библиотеки ввода-вывода языка С++ , удобнее пользоваться компонентными функциями соответствующих классов.

Создав файловый поток, можно "присоединить" его к конкретному файлу с помощью компонентной функции open() . Функция open() унаследована каждым из файловых классов ofstream, ifsream, fstream от класса fstreambase . С ее помощью можно не только открыть файл, но и связать его с уже определенным потоком. Формат функции:

#include
#include
#include
#include
#include

char k;
char name;
char opisanie;
char god;
char kolvo;
main()
{
if ((access("index.html",2))==-1)
{

bat<<""< bat<<"[Каталог Компьютерных дисков]"< bat<<"

"< bat<<"
Каталог Компьютерных дисков.

"< bat<<""< bat<<""< bat<<""< bat<<""< bat<<""< bat.close();
}

do
{
clrscr();
cout<<" !!! Вместо пробелов используйте \"_\" !!! "< cout<<" Disk_List 1.0 - Програма для составлени списка дисков."< cout<<" Вводите все по очереди, и в текущей папке создастся файл HTML."< cout<<" Он и будет вашим списком. Его можно дописать запустив прогу."< cout<<"\nИмя диска: ";
cin>>name;
cout<<"\nОписане диска: ";
cin>>opisanie;
cout<<"\nКоличество томов: ";
cin>>kolvo;
cout<<"\nГод выпуска: ";
cin>>god;
ofstream bat("index.html",ios::app);
bat<<"

"< bat<<""< bat<<""< bat<<""< bat.close();
cout<<"\n\tВыход (для выхода Y)? ";
cin>>k;
}
while (k!="y" || k!="Y" || k!="ф" || k!="?");
}

Большинство компьютерных программ работают с файлами, и поэтому возникает необходимость создавать, удалять, записывать читать, открывать файлы. Что же такое файл? Файл – именованный набор байтов, который может быть сохранен на некотором накопителе. Ну, теперь ясно, что под файлом понимается некоторая последовательность байтов, которая имеет своё, уникальное имя, например файл.txt . В одной директории не могут находиться файлы с одинаковыми именами. Под именем файла понимается не только его название, но и расширение, например: file.txt и file.dat — разные файлы, хоть и имеют одинаковые названия. Существует такое понятие, как полное имя файлов – это полный адрес к директории файла с указанием имени файла, например: D:\docs\file.txt . Важно понимать эти базовые понятия, иначе сложно будет работать с файлами.

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

Файловый ввод/вывод аналогичен стандартному вводу/выводу, единственное отличие – это то, что ввод/вывод выполнятся не на экран, а в файл. Если ввод/вывод на стандартные устройства выполняется с помощью объектов cin и cout , то для организации файлового ввода/вывода достаточно создать собственные объекты, которые можно использовать аналогично операторам cin и cout .

Например, необходимо создать текстовый файл и записать в него строку Работа с файлами в С++ . Для этого необходимо проделать следующие шаги:

  1. создать объект класса ofstream ;
  2. связать объект класса с файлом, в который будет производиться запись;
  3. записать строку в файл;
  4. закрыть файл.

Почему необходимо создавать объект класса ofstream , а не класса ifstream ? Потому, что нужно сделать запись в файл, а если бы нужно было считать данные из файла, то создавался бы объект класса ifstream .

// создаём объект для записи в файл ofstream /*имя объекта*/; // объект класса ofstream

Назовём объект – fout , Вот что получится:

Ofstream fout;

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

Fout.open("cppstudio.txt"); // связываем объект с файлом

Через операцию точка получаем доступ к методу класса open(), в круглых скобочках которого указываем имя файла. Указанный файл будет создан в текущей директории с программой. Если файл с таким именем существует, то существующий файл будет заменен новым. Итак, файл открыт, осталось записать в него нужную строку. Делается это так:

Fout << "Работа с файлами в С++"; // запись строки в файл

Используя операцию передачи в поток совместно с объектом fout строка Работа с файлами в С++ записывается в файл. Так как больше нет необходимости изменять содержимое файла, его нужно закрыть, то есть отделить объект от файла.

Fout.close(); // закрываем файл

Итог – создан файл со строкой Работа с файлами в С++ .

Шаги 1 и 2 можно объединить, то есть в одной строке создать объект и связать его с файлом. Делается это так:

Ofstream fout("cppstudio.txt"); // создаём объект класса ofstream и связываем его с файлом cppstudio.txt

Объединим весь код и получим следующую программу.

// file.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; int main(int argc, char* argv) { ofstream fout("cppstudio.txt"); // создаём объект класса ofstream для записи и связываем его с файлом cppstudio.txt fout << "Работа с файлами в С++"; // запись строки в файл fout.close(); // закрываем файл system("pause"); return 0; }

Осталось проверить правильность работы программы, а для этого открываем файл cppstudio.txt и смотрим его содержимое, должно быть — Работа с файлами в С++ .

  1. создать объект класса ifstream и связать его с файлом, из которого будет производиться считывание;
  2. прочитать файл;
  3. закрыть файл.
// file_read.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include #include using namespace std; int main(int argc, char* argv) { setlocale(LC_ALL, "rus"); // корректное отображение Кириллицы char buff; // буфер промежуточного хранения считываемого из файла текста ifstream fin("cppstudio.txt"); // открыли файл для чтения fin >> << buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку system("pause"); return 0; }

В программе показаны два способа чтения из файла, первый – используя операцию передачи в поток, второй – используя функцию getline() . В первом случае считывается только первое слово, а во втором случае считывается строка, длинной 50 символов. Но так как в файле осталось меньше 50 символов, то считываются символы включительно до последнего. Обратите внимание на то, что считывание во второй раз (строка 17 ) продолжилось, после первого слова, а не с начала, так как первое слово было прочитано в строке 14 . Результат работы программы показан на рисунке 1.

Работа с файлами в С++ Для продолжения нажмите любую клавишу. . .

Рисунок 1 — Работа с файлами в С++

Программа сработала правильно, но не всегда так бывает, даже в том случае, если с кодом всё впорядке. Например, в программу передано имя несуществующего файла или в имени допущена ошибка. Что тогда? В этом случае ничего не произойдёт вообще. Файл не будет найден, а значит и прочитать его не возможно. Поэтому компилятор проигнорирует строки, где выполняется работа с файлом. В результате корректно завершится работа программы, но ничего, на экране показано не будет. Казалось бы это вполне нормальная реакции на такую ситуацию. Но простому пользователю не будет понятно, в чём дело и почему на экране не появилась строка из файла. Так вот, чтобы всё было предельно понятно в С++ предусмотрена такая функция — is_open() , которая возвращает целые значения: 1 — если файл был успешно открыт, 0 — если файл открыт не был. Доработаем программу с открытием файла, таким образом, что если файл не открыт выводилось соответствующее сообщение.

// file_read.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include #include using namespace std; int main(int argc, char* argv) { setlocale(LC_ALL, "rus"); // корректное отображение Кириллицы char buff; // буфер промежуточного хранения считываемого из файла текста ifstream fin("cppstudio.doc"); // (ВВЕЛИ НЕ КОРРЕКТНОЕ ИМЯ ФАЙЛА) if (!fin.is_open()) // если файл не открыт cout << "Файл не может быть открыт!\n"; // сообщить об этом else { fin >> buff; // считали первое слово из файла cout << buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку } system("pause"); return 0; }

Результат работы программы показан на рисунке 2.

Файл не может быть открыт! Для продолжения нажмите любую клавишу. . .

Рисунок 2 — Работа с файлами в С++

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

Режимы открытия файлов

Режимы открытия файлов устанавливают характер использования файлов. Для установки режима в классе ios_base предусмотрены константы, которые определяют режим открытия файлов (см. Таблица 1).

Режимы открытия файлов можно устанавливать непосредственно при создании объекта или при вызове функции open() .

Ofstream fout("cppstudio.txt", ios_base::app); // открываем файл для добавления информации к концу файла fout.open("cppstudio.txt", ios_base::app); // открываем файл для добавления информации к концу файла

Режимы открытия файлов можно комбинировать с помощью поразрядной логической операции или | , например: ios_base::out | ios_base::trunc — открытие файла для записи, предварительно очистив его.

Объекты класса ofstream , при связке с файлами по умолчанию содержат режимы открытия файлов ios_base::out | ios_base::trunc . То есть файл будет создан, если не существует. Если же файл существует, то его содержимое будет удалено, а сам файл будет готов к записи. Объекты класса ifstream связываясь с файлом, имеют по умолчанию режим открытия файла ios_base::in — файл открыт только для чтения. Режим открытия файла ещё называют — флаг, для удобочитаемости в дальнейшем будем использовать именно этот термин. В таблице 1 перечислены далеко не все флаги, но для начала этих должно хватить.

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

Разработаем программу, которая, используя операцию sizeof() , будет вычислять характеристики основных типов данных в С++ и записывать их в файл. Характеристики:

  1. число байт, отводимое под тип данных
  2. максимальное значение, которое может хранить определённый тип данных.

Запись в файл должна выполняться в таком формате:

/* data type byte max value bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 2147483647.00 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 long float = 8 9223372036854775800.00 double = 8 9223372036854775800.00 */

Такая программа уже разрабатывалась ранее в разделе , но там вся информация о типах данных выводилась на стандартное устройство вывода, а нам необходимо программу переделать так, чтобы информация записывалась в файл. Для этого необходимо открыть файл в режиме записи, с предварительным усечением текущей информации файла (строка 14 ). Как только файл создан и успешно открыт (строки 16 — 20), вместо оператора cout , в строке 22 используем объект fout . таким образом, вместо экрана информация о типах данных запишется в файл.

// write_file.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include #include // работа с файлами #include // манипуляторы ввода/вывода using namespace std; int main(int argc, char* argv) { setlocale(LC_ALL, "rus"); // связываем объект с файлом, при этом файл открываем в режиме записи, предварительно удаляя все данные из него ofstream fout("data_types.txt", ios_base::out | ios_base::trunc); if (!fout.is_open()) // если файл небыл открыт { cout << "Файл не может быть открыт или создан\n"; // напечатать соответствующее сообщение return 1; // выполнить выход из программы } fout << " data type " << "byte" << " " << " max value " << endl // заголовки столбцов << "bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "long float = " << sizeof(long float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long float*/ << (pow(2,sizeof(long float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; fout.close(); // программа больше не использует файл, поэтому его нужно закрыть cout << "Данные успешно записаны в файл data_types.txt\n"; system("pause"); return 0; }

Нельзя не заметить, что изменения в программе минимальны, а всё благодаря тому, что стандартный ввод/вывод и файловый ввод/вывод используются абсолютно аналогично. В конце программы, в строке 45 мы явно закрыли файл, хотя это и не обязательно, но считается хорошим тоном программирования. Стоит отметить, что все функции и манипуляторы используемые для форматирования стандартного ввода/вывода актуальны и для файлового ввода/вывода. Поэтому не возникло никаких ошибок, когда оператор cout был заменён объектом fout .

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

Открытие файлов

Наиболее часто применяются классы ifstream для чтения, ofstream для записи и fstream для модификации файлов.

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

Enum open_mode { app, binary, in, out, trunc, ate };

Ниже приведены возможные значения флагов и их назначение.

Например, чтобы открыть файл с именем test.txt для чтения данных в бинарном виде, следует написать:

Ifstream file; file.open ("test.txt", ios::in | ios::binary);

Оператор логического ИЛИ (|) позволяет составить режим с любым сочетанием флагов. Так, чтобы, открывая файл по записи, случайно не затереть существующий файл с тем же именем, надо использовать следующую форму:

Ofstream file; file.open ("test.txt", ios::out | ios::app);

Предполагается, что к проекту подключён соответствующий заголовочный файл:

#include

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

If (!file) { //Обработка ошибки открытия файла }

Операторы включения и извлечения

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

File << "Это строка текста";

Можно также записывать текстовую строку по частям:

File << "Это " << "строка " << "текста";

Оператор endl завершает ввод строки символом "возврат каретки":

File << "Это строка текста" << endl;

С помощью оператора включения несложно записывать в файл значения переменных или элементов массива:

Ofstream file ("Temp.txt"); char buff = "Текстовый массив содержит переменные"; int vx = 100; float pi = 3.14159; file << buff << endl << vx << endl << pi << endl;

В результате выполнения кода образуется три строки текстового файла Temp.txt:

Текстовый массив содержит переменные 100 3.14159

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

Оператор извлечения (>>)производит обратные действия. Казалось бы, чтобы извлечь символы из файла Temp.txt , записанного ранее, нужно написать код наподобие следующего:

Ifstream file ("Temp.txt"); char buff; int vx; float pi; file >> buff >> vx >> pi;

Однако оператор извлечения остановится на первом попавшемся разделителе (символе пробела, табуляции или новой строки). Таким образом, при разборе предложения "Текстовый массив содержит переменные" только слово "Текстовый" запишется в массив buff , пробел игнорируется, а слово "массив" станет значением целой переменной vx и исполнение кода "пойдет вразнос" с неминуемым нарушением структуры данных. Далее, при обсуждении класса ifstream , будет показано, как правильно организовать чтение файла из предыдущего примера.

Класс ifstream: чтение файлов

Как следует из расшифровки названия, класс ifstream предназначен для ввода файлового потока. Далее перечислены основные методы класса. Большая часть из них унаследована от класса istream и перегружена с расширением родительской функциональности. К примеру, функция get , в зависимости от параметра вызова, способна считывать не только одиночный символ, но и символьный блок.

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

Ifstream file("Temp.txt"); char buff; int vx; float pi; file.getline(buff, sizeof(buff)); file >> vx >> pi:

Метод getline прочитает первую строку файла до конца, а оператор >> присвоит значения переменным.

Следующий пример показывает добавление данных в текстовый файл с последующим чтением всего файла. Цикл while (1) используется вместо while(!file2.eof()) по причинам, которые обсуждались в .

#include #include using namespace std; int main() { ofstream file; file.open("test.txt",ios::out|ios::app); if (!file) { cout << "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >> a; if (file2.eof()) break; cout << a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

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

#include #include using namespace std; int main() { ifstream file; // создать поточный объект file file.open("test.txt"); // открыть файл на чтение if (!file) return 1; // возврат по ошибке отрытия char str; // статический буфер строки // Считывать и отображать строки в цикле, пока не eof while (!file.getline(str, sizeof(str)).eof()) cout << str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Этот код под ОС Windows также зависит от наличия в последней строке файла символа перевода строки, надежнее было бы сделать так:

While (1) { if (file.eof()) break; file.getline(str, sizeof(str)); cout << str << endl; }

Явные вызовы методов open и close не обязательны. Действительно, вызов конструктора с аргументом позволяет сразу же, в момент создания поточного объекта file , открыть файл:

Ifstream file("test.txt");

Вместо метода close можно использовать оператор delete , который автоматически вызовет деструктор объекта file и закроет файл. Код цикла while обеспечивает надлежащую проверку признака конца файла.

Класс ofstream: запись файлов

Класс ofstream предназначен для вывода данных из файлового потока. Далее перечислены основные методы данного класса.

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

Ofstream file ("temp.txt"); if (!file) return; for (int i=1; i<=3; i++) file << "Строка " << i << endl; file.close();

Бинарные файлы

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

Первый параметр методов write и read (адрес блока записи/чтения) должен иметь тип символьного указателя char * , поэтому необходимо произвести явное преобразование типа адреса структуры void * . Второй параметр указывает, что бинарные блоки файла имеют постоянный размер байтов независимо от фактической длины записи. Следующее приложение дает пример создания и отображения данных простейшей записной книжки. Затем записи файла последовательно считываются и отображаются на консоли.

#include #include #include using namespace std; struct Notes { // структура данных записной книжки char Name; // Ф.И.О. char Phone; // телефон int Age; // возраст }; int main() { setlocale(LC_ALL, "Russian"); Notes Note1= { "Грозный Иоанн Васильевич", "не установлен", 60 }; Notes Note2= { "Годунов Борис Федорович ", "095-111-2233 ", 30 }; Notes Note3= { "Романов Петр Михайлович ", "812-333-2211 ", 20 }; ofstream ofile("Notebook.dat", ios::binary); ofile.write((char*)&Note1, sizeof(Notes)); // 1-й блок ofile.write((char*)&Note2, sizeof(Notes)); // 2-й блок ofile.write((char*)&Note3, sizeof(Notes)); // 3-й блок ofile.close(); // закрыть записанный файл ifstream ifile("Notebook.dat", ios::binary); Notes Note; // структурированная переменная char str; // статический буфер строки // Считывать и отображать строки в цикле, пока не eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note.Name, Note.Phone, Note.Age); cout << str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

В результате выполнения этого кода образуется бинарный файл Notebook.dat из трех блоков размером по 80 байт каждый (при условии, что символы - однобайтовые). Естественно, вы можете использовать другие поточные методы и проделывать любые операции над полями определенной структуры данных.

Класс fstream: произвольный доступ к файлу

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

Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Notes); ifile.seekg(pos); // поиск 50-й записи Notes Note; //Notes – описанная выше структура "запись" ifile.read((char*)&Note, sizeof(Notes));

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

Ofstream ofilе ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Notes); ofile seekp(pos); // поиск 50-й записи Notes Note50 = {"Ельцин Борис Николаевич", "095-222-3322", 64}; ofile.write((char*)&Note, sizeof(Notes)); // замена

Если не указать флаг ios::ate (или ios::app), то при открытии бинарного файла Notebook.dat его предыдущее содержимое будет стерто!

Наконец, можно открыть файл одновременно для чтения/записи, используя методы, унаследованные поточным классом fstream от своих предшественников. Поскольку класс fstream произведен от istream и ostream (родителей ifstream и ofstream соответственно), все упомянутые ранее методы становятся доступными в приложении.

В следующем примере показана перестановка первой и третьей записей файла Notebook.dat .

#include #include #include using namespace std; struct Notes { char Name; char Phone; int Age; }; int main() { setlocale(LC_ALL, "Russian"); Notes Note1, Note3; // Открыть файл на чтение/запись одновременно fstream file("Notebook.dat", ios::binary | ios::in | ios::out); file.seekg(2 * sizeof(Notes)); // найти и считать Note3 file.read((char*)&Note3, sizeof(Notes)); file.seekg(0); // найти и считать Note1 file.read((char*)&Note1, sizeof(Notes)); file.seekg(0); // Note1 <== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

В конструкторе объекта file надо указать флаги ios::in и ios::out , разрешая одновременное выполнение операций чтения и записи. В результате выполнения этого кода первая и третья записи бинарного файла Notebook.dat поменяются местами.

Дополнительные примеры по теме есть .

В термине оператор сравнения слово «сравнение» относится к значениям операндов. В термине логический оператор слово «логический» относится к способу, которым устанавливаются эти отношения. Поскольку операторы сравнения и логические операторы тесно связаны друг с другом, мы рассмотрим их вместе. Операторы сравнения и логические операторы представлены в таблице 4. В основе операторов сравнения, и логических операторов лежат понятия «истина» и «ложь». В языке С истинным считается любое значение, не равное нулю. Ложное значение всегда равно 0. если результат ложен, и 1, если результат истинен.

В языке С++ истинные и ложные значения различаются точно так же, но, помимо этого, предусмотрен особый тип данных bool и булевые константы true и false .

Таблица 4.

Операторы сравнения и логические операторы

Операторы сравнения и логические операторы имеют более низкий приоритет, чем арифметические операторы. Таким образом, выражение 10 > 1+12 будет вычислено так, будто оно записано следующим образом: 10 > (1+12).

Побитовые операторы

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

Таблица 5.

Побитовые операторы

Контрольные вопросы

1. Объясните, что понимают под программированием.

2. Приведите этапы жизненного цикла ПО?

3. Какие вы знаете методы проектирования ПО.

4. Перечислите операции для создания *.cpp файла?

5. Состав языка в С++.

6. Какова общая структура программы на языке С++?

7. какие вы знаете типы данных в С++?

8. Переменные. Объявление переменных в С++.

9. Есть ли с точки зрения языка С++ разница между числами:

11. Приведите основные операторы в С++?


Лабораторная работа №2

Разработка программы с применением

базовых операторов С++

Цель работы:

1. Изучение основных операторов языка С++;

2. Приобретение навыков работы в ИСП Microsoft Visual C++ 5.0.

Используемое оборудование:

Персональная ЭВМ, совместимая с IBM PC.

Используемое программное обеспечение:

Операционная система Windows;

Интегрированная среда программирования Microsoft Visual C++ 5.0.

Задание по работе

1.1. Загрузить ИСП Microsoft Visual C++ 5.0;

1.2. Изучить основные типы данных, ИСП Microsoft Visual C++ 5.0;

1.3. Выполнить задание преподавателя;

1.4. Записать протокол работы с интегрированной средой.

Порядок выполнения работы

2.1. Составить схему алгоритма (по заданию преподавателя);

2.2. Запустить Microsoft Visual C++ 5.0;

2.3. Создать *.cpp файл в рабочем каталоге;

2.5. Записать схему алгоритма и текст программы в протокол работы с интегрированной средой;

2.6. Закончить работу с Microsoft Visual C++ 5.0 и запустить программу.

3.1. Наименование лабораторной работы.

3.2. Цель работы.

3.3. Теоретическую часть.

3.4. Алгоритм программы.

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

3.6. Вывод.

Краткое описание

Оператор – это часть программы, которую можно выполнить отдельно, иными словами, оператор определяет некое действие. Операторы языка С и С++ разделяются на следующие категории:

Ø условные операторы (оператор условия if и оператор выбора switch);

Ø операторы цикла (for, while, do while);

Ø операторы перехода (break, continue, return, goto);

Ø другие операторы (оператор "выражение ", пустой оператор).

Операторы в программе могут объединяться в составные операторы с помощью фигурных скобок. Любой оператор в программе может быть помечен меткой, состоящей из имени и следующего за ним двоеточия. Все операторы языка C/C++, кроме составных операторов, заканчиваются точкой с запятой ";".

Оператор выражение

Любое выражение, которое заканчивается точкой с запятой, является оператором. Выполнение оператора выражение заключается в вычислении выражения.

Примеры:

Этот оператор представляет выражение, которое увеличивает значение переменной i на единицу.

a=cos(b*5);

Этот оператор представляет выражение, включающее в себя операции присваивания, умножения и вызова функции.

Fun(x,y);

Этот оператор представляет выражение, состоящее из вызова функции.

Пустой оператор

Пустой оператор состоит только из точки с запятой ";". При выполнении этого оператора ничего не происходит.

Составной оператор

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

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

Оператор if

Формат оператора:

if (выражение) оператор1;

else оператор 2;

Выполнение оператора if начинается с вычисления выражения. Далее выполнение осуществляется по следующей схеме:

Если выражение истинно (т.е. отлично от 0), то выполняется оператор1;

Если выражение ложно (т.е. равно 0),то выполняется оператор2;

Если выражение ложно и отсутствует оператор2 (в квадратные скобки заключена необязательная конструкция), то выполняется следующий за if оператор.

Следующий фрагмент иллюстрирует вложенные операторы if :

Char sign;

Int x,y,z;

if (sign == ’-’)

x = y - z;

else if (sign == ’+’)

x = y + z;

else if (sign == ’*’)

x = y * z;

else if (ZNAC == ’/’)

x = y / z;

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

if(j) оператор 1;

if(k) оператор2; /* данный if */

else оператор3; /* связан с данным оператором else */

else оператор4; /* связан с оператором if (i) */

Последний раздел else связан не с оператором if(j) , который находится в другом блоке, а с оператором if (i). Внутренний раздел else связан с операторомif(k) , потому что этот оператор if является ближайшим.

Оператор switch

Оператор switch предназначен для организации выбора из множества различных вариантов.

Формат оператора следующий:

Switch (выражение)

{ [объявление]

[ case константное-выражение1]: [список-операторов1]

[ case константное-выражение2]: [список-операторов2]

[ default: [список операторов]]

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

Все константные выражения в операторе switch должны быть уникальны. Кроме операторов, помеченных ключевым словом case , может быть, но обязательно один, фрагмент, помеченный ключевым словом default. Список операторов может быть пустым, либо содержать один или более операторов. Причем в операторе switch не требуется заключать последовательность операторов в фигурные скобки.

Схема выполнения оператора switch следующая:

Вычисляется выражение в круглых скобках;

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

Если одно из константных выражений совпадает со значением выражения, то управление передается на оператор, помеченный соответствующим ключевым словом case ;

Если ни одно из константных выражений не равно выражению, то управление передается на оператор, помеченный ключевым словом default, а в случае его отсутствия управление передается на следующий после switch оператор.

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

Пример:

int i=2;

Switch (i)

case 1: i += 2;

case 2: i *= 3;

case 0: i /= 2;

case 4: i -= 5;

default: ;

Операторы switch могут быть вложены друг в друга, даже если константы разделов case внешнего и внутреннего операторов switch совпадают, проблемы не возникают.

Операторы перехода

Оператор break

Оператор break обеспечивает прекращение выполнения самого внутреннего из объединяющих его операторов switch , do , for , while . После выполнения оператора break управление передается оператору, следующему за прерванным.

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

Функция exit () выглядит следующим образом.

void exit (int код_возврата );

Значение переменной код_возврата передается вызывающему процессу, в роли которого чаще всего выступает операционная система.

Оператор continue

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

Пример:

Int main()

Int a,b;

for (a=1,b=0; a<100; b+=a,a++)

if (b%2) continue;

... /* обработка четных сумм */

Return 0;

Когда сумма чисел от 1 до а становится нечетной, оператор continue передает управление на очередную итерацию цикла for , не выполняя операторы обработки четных сумм. Оператор continue, как и оператор break , прерывает самый внутренний из объемлющих его циклов.

Оператор return

Оператор return завершает выполнение функции, в которой он задан, и возвращает управление в вызывающую функцию, в точку, непосредственно следующую за вызовом. Функция main передает управление операционной системе.

Формат оператора:

return [выражение];

Значение выражения, если оно задано, возвращается в вызывающую функцию в качестве значения вызываемой функции. Если выражение опущено, то возвращаемое значение не определено.

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

Пример:

Int sum (int a, int b)

return (a+b);

Функция sum имеет два формальных параметра a и b типа int, и возвращает значение типа int, о чем говорит описатель, стоящий перед именем функции. Возвращаемое оператором return значение равно сумме фактических параметров.

Пример:


Похожая информация.




  • Beeline
  • Интернет
  • Tele2
  • Полезное
  • IP-Телефония
  • Йота
  • Mts
  • Megafon
cena5.ru - Портал о мобильных операторах
Портал о мобильных операторах Одноклассники Портал о мобильных операторах ВКонтакте Портал о мобильных операторах Facebook Портал о мобильных операторах Twitter Портал о мобильных операторах Google+ Портал о мобильных операторах Pinterest
Портал о мобильных операторах в социальных сетях
Контакты Реклама Вакансии

Copyright © «cena5.ru» 2024 Копирование и видоизменение материалов сайта возможно только после письменного согласия правообладателей.
Статьи защищены законом об авторских и смежных правах, при цитирование материалов проекта «cena5.ru» прямая открытая ссылка на cena5.ru обязательна.
Все права защищены.

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

 
ИмяОписаниеКол-во томовГод
"<"<"<" <

Учебник С++

Содержание частей учебника

Часть 1. Изучение основ.

Урок 1. Создание вашей первой программы.
Урок 2. Более внимательный взгляд на С++.
Урок 3. Вывод сообщений на экран.
Урок 4. Программы хранят информацию в переменных.
Урок 5. Выполнение простых операций.
Урок 6. Чтение ввода с клавиатуры.

Урок 8. Повторение одного или нескольких операторов

Часть 2. Создание программ с помощью функций.

Урок 9. Знакомство с функциями.
Урок 10. Изменение значений параметров.
Урок 11. Преимущества использования библиотеки этапа выполнения.
Урок 12. Локальные переменные и область видимости.
Урок 13. Перегрузка функций.
Урок 14. Использование ссылок в С++.
Урок 15. Значения параметров по умолчанию.

Часть 3. Хранение информации с помощью массивов и структур.

Урок 16. Хранение значений в массивах.
Урок 17. Символьные строки.
Урок 18. Хранение связанной информации в структурах.
Урок 19. Объединения.
Урок 20. Указатели.

Часть 4. Использование классов в С++.

Урок 21. Знакомство с классами в С++.
Урок 22. Частные и общие данные.
Урок 23. Конструктор и деструктор.
Урок 24. Перегрузка операторов.
Урок 25. Статические функции и элементы данных.

Часть 5. Наследование и шаблоны.

Урок 26. Наследование.
Урок 27. Множественное наследование.
Урок 28. Частные элементы и друзья.
Урок 29. Использование шаблонов функций.
Урок 30. Использование шаблонов классов.

Часть 6. Расширенные возможности С++.

Урок 31. Использование свободной памяти в С++.
Урок 32. Управление свободной памятью.
Урок 33. Дополнительные возможности cin и cout.
Урок 34. Файловые операции В/В в С++.
Урок 35. Встроенные функции и ассемблерные коды.
Урок 36. Использование аргументов командной строки.
Урок 37. Использование констант и макрокоманд.
Урок 38. Полиморфизм.
Урок 39. Использование исключительных ситуаций С++ для обработки ошибок.


Урок 1. Создание вашей первой программы.

Для начала надо определиться с некоторыми ключевыми понятиями. Итак.

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

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

Язык программирования - это язык инструкций для компьютера, например С++.

Исходный файл - это текстовый файл, хранящий инструкции (команды).

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

Создание простой программы

Сегодня большинство программистов на С++ программируют в среде для Windows, таких как Visual C++ или Borland C++. Для примеров в учебнике будет использоваться интегрированная среда фирмы Borland.
После запуска программы выберите File > New > TextEdit. Появится окно текстового редактора в которое вы будете вводить текст программы.



Создайте на диске папку в которой вы будете сохранять ваши программы, например C:\MyProgs. По умолчанию файл в Borland C++ имеет название NONAME00.CPP . Расширение СРР указывает на то, что этот файл содержит программу на С++. Наша первая программа будет называться FIRST.CPP , для изменения названия выберите File > Save as.. В диалоговом окне введите название файла FIRST (расширение можно не вводить) и нажмите "Сохранить".

В окно редактора введите следующие операторы программы С++:

#include
void main(void)
{
cout << "Учимся программировать на языке С++!";
}

Примечание. Если вместо русских букв у вас появляются непонятные символы, выберите Options > Environment..


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

Компиляция вашей программы

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

Итак, чтобы откомпилировать программу выберите Project > Make All или нажмите F9, программа произведет компиляцию и если вы не допустили ошибок в исходном тексте выведет сообщение об успешной компиляции.

Теперь можно запустить вашу программу. Для этого в сеансе MS-DOS в командной строке введите имя программы, т.е. FIRST. Так, если ваша программа находится в каталоге C:\MyProgs , то вам в ответ на командную подсказку C:\> надо ввести MyProgs\FIRST.

Создание второй программы

Для создания новой программы выберите File > New > TextEdit, а затем сохраните её под именем EASY.CPP. Введите следующие операторы:

#include
void main(void)
{
cout << "Программировать на С++ просто!";
}

Как и ранее сохраните свои операторы программы в исходном файле и откомпилируйте программу (F9) Компилятор создаст программу с именем EASY.EXE. Когда вы её запустите, на вашем экране появится следующее сообщение:



Cout <<"Программировать на C++ очень просто!";

Сохраните ваше изменение в исходном файле и откомпилируйте программу. После этого запустите программу.

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

Изучение синтаксических ошибок.

Синтаксис - это набор правил, которым вы должны следовать, когда используете какой-либо язык.

Если вы допускаете ошибку при написании программы, компилятор С++ выводит на экран сообщение об ошибке, которое описывает ошибку и соответствующий ей номер строки в исходном файле.

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

#include

Void main(void)
{
cout << "Заключайте сообщения в кавычки;
}

При компиляции программы компилятор выведет сообщение о синтаксических ошибках.


Отредактируйте файл, заключив предложение в кавычки.

Cout << "Заключайте сообщения в кавычки";

Теперь можете успешно откомпилировать программу и запустить файл.

Урок 2. Более внимательный взгляд на С++.

В уроке 1 вы создали программу FIRST.CPP, которая содержала следующие операторы:

#include

Void main(void)
{
cout << "Учимся программировать на языке С++!";
}

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

Представление об операторе #include

При компиляции программы оператор #include заставляет компилятор включать содержимое заданного файла в начало вашей программы. В примерах из первого урока это файл iostream.h

Файлы с расширением h, которые вы включаете в начало (или заголовок ) вашей программы, называются заголовочными файлами. Если вы посмотрите в котолог, содержащий файлы вашего компилятора, то найдете подкаталог с именем INCLUDE, в котором находятся заголовочные файлы. Содержимое этих файлов можно вывести на экран или принтер.

Примечание: Никогда не изменяйте содержимое заголовочных файлов. Это может привести к ошибкам компиляции в каждой создаваемой вами программе.

Что такое void main(void)

Каждая программа на С++ имеет один вход, с которого начинается выполнение программы, - главную программу. В программах на С++ оператор void main(void) указывает стартовую точку вашей программы.

По мере усложнения ваших программ вы будете делить их на несколько небольших частей. При этом оператор void main(void) указывает на часть программы, которая выполняется первой.

Использование void

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

Каждая функция в программе имеет уникальное имя, а каждая программа имеет по крайней мере одну функцию. Каждая программа из урока 1 имела одну функцию с именем main .

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

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

Void main(void)

Представление о группирующих операторах { }.

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

Использование cout для отображения вывода на экран.

Чтобы вывести сообщение, программы используют cout и двойной знак меньше (<<), как показано ниже:

Cout << "Привет, С++!";

Слово cout представляет собой выходной поток , который С++ назначает на стандартное устройство вывода операционной системы (по умолчанию - монитор).

Урок 3. Вывод сообщений на экран.

До сих пор созданные вами программы использовали cout для вывода символьных строк (букв и чисел, взятых в кавычки). Но cout также можно использовать для вывода чисел (без кавычек). Следующая программа 1001.CPP выводит число 1001 на ваш экран:

#include

Void main(void)
{
cout << 1001;
}

Откомпилируйте и запустите эту программу. На вашем экране будет отображено число 1001, как показано ниже:

Кроме отображения целых чисел , cout также позволяет отображать числа с плавающей точкой , например 1.2345. Следующая программа FLOATING.CPP использует cout для вывода числа 0.12345 на экран:

#include

Void main(void)
{
cout << 0.12345;
}

Вывод нескольких значений одновременно

Как вы уже знаете двойной знак "меньше" является операцией вставки . С помощью оператора cout вы можете использовать несколько операций вставки в пределах одного оператора. Например, следующая программа 1001TOO.CPP использует эту операцию четыре раза для отображения числа 1001 на вашем экране:

#include

Void main(void)
{
cout << 1 << 0 << 0 << 1;
}

Каждый раз, когда в С++ встречается операция вставки, число или символы просто добавляются к тем, что находятся в настоящее время в выходном потоке. Следующая программа SHOW1001.CPP с помощью cout выводит символьную строку и число:

#include

Void main(void)
{
cout << "Мое любимое число равно " << 1001;
}

Обратите внимаение, что пробел, следующий за словом равно , служит для отделения числа 1001 от этого слова. Без пробела число сливается со следующим словом (равно1001).

Использование специальных символов вывода

Все программы, созданные вами до сих пор, отображали свой вывод в одну строку. Если необходимо переместить курсор в начало следующей строки, можно поместить символ новой строки (\n) в выходной поток. В С++ имеется два разных способа создания новой строки. Первый - это помещение символа \n внутри символьной строки. Например, следующая программа TWOLINES.CPP отображает свой вывод в виде двух строк, используя символ новой строки:

#include

Void main(void)
{
cout << "Это строка один\nЭто строка два";
}

Если вы не выводите символьную строку, можете поместить символ новой строки внутри одинарных кавычек. Например, следующая программа NEWLINES.CPP выводит числа 1, 0, 0 и 1, каждое на своей собственной строке:

#include

Void main(void)
{
cout << 1 << "\n" << 0 << "n" << 0 << "n" << 1;
}

Кроме символа новой строки для продвижения в начало следующей строки вы можете использовать символ endl (конец строки). Следующая программа ENDL.CPP иллюстрирует использование endl для продвижения курсора в начало новой строки:

#include

Void main(void)
{
cout << "А теперь..." << endl
<< "Учимся программировать на языке С++";
}

Другие специальные символы

Вывод восьмеричных и шеснадцатеричных значений

В зависимости от назначения ваших программ вам, возможно, потребуется выводить числа в восьмеричном или шеснадцатеричном виде. Для этого необходимо разместить модификаторы dec , oct и hex внутри выходного потока. Следующая программа OCTHEX.CPP использует эти модификаторы для вывода значений в десятичном, весьмеричном и шеснадцатеричном виде:

#include

Void main(void)
{
cout << "Восьмеричный: " << oct << 10 << " " << 20 << endl;
cout << "Шеснадцатеричный: " << hex << 10 << " " << 20 << endl;
cout << "Десятичный: " << dec << 10 << " " << 20 << endl;
}

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

Управление шириной вывода

При выводе на cout ваши программы могут указать ширину вывода каждого числа, используя модификатор setw (установка ширины). С помощью setw программы указывают минимальное число символов, занимаемое числом. Например, следующая программа SETW.CPP использует модификаор setw для выбора ширины 3, 4, 5 и 6 для числа 1001. Чтобы использовать модификатор setw, ваша программа должна включать заголовочный файл iomanip.h:

#include
#include

Void main(void)
{
cout << "Мое любимое число равно" << setw(3) << 1001 << endl;
cout << "Мое любимое число равно" << setw(4) << 1001 << endl;
cout << "Мое любимое число равно" << setw(5) << 1001 << endl;
cout << "Мое любимое число равно" << setw(6) << 1001 << endl;
}

Если вы указываете ширину с помощью setw, вы указываете минимальное количество символьных позиций, занимаемых числом. В предыдущей программе модификатор setw(3) указывал минимум три символа. Однако, так как число 1001 потребовало больше трех символов, cout использовал реально требуемое количество, т.е. четыре.

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

Примечание: Предыдущая программа использует заголовочный файл IOMANIP.H. Вы можете исследовать содержимое этого файла, только ничего не изменяйте. Как и заголовочный файл IOSTREAM.H данный файл находится в подкаталоге INCLUDE.

Урок 4. Программы хранят информацию в переменных.

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

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

Тип
char
int
unsigned
long
float
double 		Хранимые значения
Значения в диапазоне от -128 до 127
Значения в диапазоне -32768 до 32767
Значения в диапазоне 0 до 65535
Значения в диапазоне от -2147483648 до 2147483647
Значения в диапазоне от -3.4 x 10^-38 до 3.4 x 10^38
Значения в диапазоне от 1.7 x 10^-308 до 1.7 x 10^308

Прежде чем вы сможете использовать переменную ваша программа должна её объявить, т.е. представить её компилятору С++. Чтобы объявить переменную, вам следует указать тип переменной и её имя, по которому программа будет обращаться к данной переменной. Выбираемое вами имя переменной может быть произвольным, но лучше, если оно будет иметь смысл, который описывает использование переменной. Например могут быть такие имена: name, age.

В С++ объявление перменной считается оператором, поэтому за именем переменной следует ставить точку с запятой.

Фрагмент следующей программы объявляет три переменные, используя типы int, float и long :

#include

Void main(void)
{
int test_score;
float salary;
long distance_to_mars;
}

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

Float salary, income_tax, retirement_fund;

Слова, которые нельзя использовать для имен переменных.

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

Asm auto break case catch char class const continue default delete do double else enum extern float for friend goto if inline int long new operator private protected public register return short signed sizeof static struct switch template this throw try typedef union unsigned virtual void volatile while

Присваивание значения переменной

После объявления переменной вы используете оператор присваивания С++ (знак равно), чтобы присвоить значение переменной. Следующие операторы присваивают значения нескольким разным переменным:

Age = 32;
salary = 25000.75;
distance_to_the_moon = 238857;

Примечание: Значения, присваиваемые переменным, не должны содержать запятые! Если вы включаете запятые, компилятор С++ будет выводить сообщения о синтаксических ошибках.

Присваивание значения при объявлении

При объявлении переменной часто удобно присваивать её начальное значение как показано ниже:

Int age = 32;
float salary = 25000.75;

Использование значения переменной

Следующая программа SHOWVARS.CPP присваивает значения переменным и затем выводит значение каждой переменной, используя cout:

#include

Void main(void)
{
int age = 32;
float salary = 25000.75;
long distance_to_the_moon = 238857;

Cout << "Служащему " << age << " года (лет)" << endl;
cout << "Оклад служащего составляет $" << salary << endl;
cout << "От земли до луны " << distance_to_the_moon
<< " миль" << endl;
}

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

Превышение диапазона значений переменной

Как вы уже знаете, тип переменной определяет набор значений, которая переменная может хранить. Например, переменная типа int может хранить значения в диапазоне от -32768 до 32767. Если вы присваиваете переменной значение, которое находится вне этого диапазона, возникает ошибка переполнения . Например, следующая программа OVERFLOW.CPP иллюстрирует, как превышение диапазона значений переменной приводит к ошибке:

#include

Void main(void)
{
int positive = 40000;
long big_positive = 4000000000;
char little_positive = 210;

Cout << "Сейчас positive содержит " << positive << endl;
cout << "Сейчас big_positive содержит " << big_positive << endl;
cout << "Сейчас little_positive содержит " << little_positive << endl;
}

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

Использование комментариев для улучшения чтения ваших программ

Прот создании программ включайте комментарии, которые объясняют работу программы. Если другим программистам понадобится изменить вашу программу, они смогут воспользоваться комментариями. В программах на С++ комментарии начинаются с двойного слеша:

// Это комментарий С++

Когда компилятор С++ встречает двойной слеш, он игнорирует весь текст оставшийся в текущей строке, который следует за слешем.

Урок 5. Выполнение простых операций.

Основные математические операции

Независимо от назначения большинство ваших программ на С++ будут складывать, вычитать, умножать или делить. Ниже перечислены основные математические операции:

#include

Void main(void)
{
cout << "5 + 7 = " << 5 + 7 << endl;
cout << "12 - 7 = " << 12 - 7 << endl;
cout << "1.2345 * 2 = " << 1.2345 * 2 << endl;
cout << "15 / 3 = " << 15 / 3 << endl;
}

Обратите внимание, что каждое выражение сначала появляется в кавычках, которые обеспечивают вывод символов (например, 5 + 7 =)на экран. Затем программа выводит результат операции и символ новой строки.

Следующая программа MATHVARS.CPP выполняет арифметические операции, используя переменные:

#include

Void main(void)
{
float cost = 15.50;
float sales_tax = 0.06;
float amount_paid = 20.00;
float tax, change, total;

Tax = cost * sales_tax;
total = cost + tax;
change = amount_paid - total;

Cout << "Стоимость покупки: $" << cost <<
"\tНалог: $" << tax << "\tОбщий счет: $" << total << endl;

Cout << "Сдача покупателю: $" << change << endl;
}

Увеличение значения переменной на 1

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

Count = count + 1;

Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):

#include

Void main(void)
{
int count = 1000;

Cout << "начальное значение count равно" << count << endl;
count = count + 1;
cout << "конечное значение count равно" << count << endl;
}

Увеличение значения переменной представляет собой обычную операцию в программах, поэтому в С++ есть операция увеличения - двойной знак плюс (++). Операция увеличения обеспечивает быстрый способ прибавления единицы к значению пременной. Следующая программа INC_OP.CPP использует операцию увеличения для наращивания значения переменной count на 1:

#include

Void main(void)
{
int count = 1000;

Cout << "начальное значение count равно" << count << endl;
count++;
cout << "конечное значение count равно" << count << endl;
}

Представление о префиксной (до) и постфиксной (после) операциях увеличения.

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

Variable; variable++;

Так как первый оператор появляется до переменной, он называется префиксным оператором увеличения . Аналогично этому, второй оператор появляется после переменной и называется постфиксным оператором увеличения . Например, рассмотрим следующий оператор присваивания:

Current_count = count++;

Этот оператор присваивания указывает С++ присвоить текущее значение count переменной current_count и увеличивает текущее значение count. В данном случае постфиксный оператор увеличение эквивалентен следующим операторам:

Current_count = cont;
count = count + 1;

Рассотрим префиксный оператор увеличения:

Current_count = ++count;

В этом случае оператор присваивания указывает С++ сначала увеличить значение count, а затем присвоить результат переменной current_count. Использование префиксного оператора эквивалентно следующим оператором:

Count = cont + 1;
current_count = count;

Следующая программа PRE_POST.CPP показывает использование префиксной и постфиксной операций увеличения:

#include

Void main(void)
{
int small_count = 0;
int big_count = 1000;

Cout << "small_count равно " << small_count << endl;
cout << "small_count++ производит " << small_count++ << endl;
cout << "конечное значение small_count равно " << small_count << endl;

Cout << "big_count равно " << big_count << endl;
cout << "++big_count производит " << ++big_count << endl;
cout << "конечное значение big_count равно " << big_count << endl;
}

С переменной small_count программа использует постфиксную операцию увеличения. В результате программа выводит текущее значение переменной (0), а затем увеличивает его на 1. С переменной big_count программа использует префиксную операцию увеличения. В результате программа сначала увеличивает значение переменной (1000 + 1), а затем выводит результат (1001).

С++ обеспечивает также операции уменьшения

В С++ двойной знак минус (--) соответствует оператору уменьшения , который уменьшает значение переменной на 1. Как и в случае с операцией увеличения, С++ поддерживает префиксный и постфиксный операторы уменьшения. Следующая программа DECCOUNT.CPP иллюстрирует использование оператора ументшения С++:

#include

Void main(void)
{
int small_count = 0;
int big_count = 1000;

Cout << "small_count равно " << small_count << endl;
cout << "small_count-- производит " << small_count-- << endl;
cout << "конечное значение small_count равно " << small_count << endl;

Cout << "big_count равно " << big_count << endl;
cout << "--big_count производит " << --big_count << endl;
cout << "конечное значение big_count равно " << big_count << endl;
}

Другие операторы С++

Старшинство операций

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

Операция :: .
->
()
sizeof
sizeof ++
++
--
--
&
*
new
delete

Delete
~
!
+
-
()

.*
->
*
% +
- 		Имя Разрешение области видимости
Глобальное разрешение Выбор элемента
Выбор элемента
Индексация
Вызов функции
Построение значения
Размер объекта
Размер типа Приращение после
Приращение до
Уменьшение после
Уменьшение до
Адрес объекта
Разыменование
Создание (размещение)
Уничтожение (освобождение)
Уничтожение массива
Дополнение
Логическое НЕ
Унарный плюс
Унарный минус
Приведение Выбор элемента
Выбор элемента Умножение
Деление
Взятие по модулю Сложение (плюс)
Вычитание (минус) 		Пример class_name::class_member_name

::variable name

object.member_name
pointer->member_name
pointer
expression(parameters)
type(parameters)
sizeof expression
sizeof(type) variable++
++variable
variable--
--variable
&variable
*pointer
new type
delete pointer

Delete pointer
~expression
!expression
+1
-1
(type)expression

object.*pointer
object->*pointer expression*expression
expression/expression
expression%expression expression+expression
expression-expression

Управление порядком, в котором С++ выполняет операции

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

Cost = price_a + price _b * 1.06;

В этом случае С++ сначала выполнит умножение, а затем прибавит значение price_a.

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

Result = (2 + 3) * (3 + 4);


Урок 7. Программа принимает решение.

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

Сравнение двух значений

Когда ваши программы принимают решение, они выполняют определенный вид проверки. Например, одна программа может проверять, равны ли тестовые очки студента 100, в другая программа - составляет ли стоимость покупки больше $50.00. Для выполнения подобных проверок ваши программы будуть использовать операции сравнения С++, перечисленные ниже:

Результат сравнения может быть истиной (TRUE) или ложью (FALSE), т.е. два значения или равны(истина), или нет (ложь).