C++. Сборник рецептов

10.2. Форматирование вывода чисел с плавающей точкой

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

Используйте стандартные манипуляторы, определенные в

Пример 10.3. Форматирование числа «пи»

#include 

#include 

#include 

using namespace std;

int main() {

 ios_base::fmtflags flags = // Сохранить старые флаги

 cout.flags();

 double pi = 3.14285714;

 cout << "pi = " << setprecision(5) // Обычный (стандартный) режим;

  << pi << '\n';           // показать только 5 цифр в сумме

                   // по обе стороны от точки.

 cout << "pi = " << fixed // Режим чисел с фиксированной точкой;

  << showpos        // выдать "+" для положительных чисел.

  << setprecision(3)   // показать 3 цифры *справа* от

 << pi << '\n';      // десятичной точки.

 cout << "pi = " << scientific // Режим научного представления;

  << noshowpos         // знак плюс больше не выдается

  << pi * 1000 << '\n';

 cout.flags(flags); // Восстановить значения флагов

}

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

pi = 3.1429

pi = +3.143

pi = 3.143е+003

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

Обычный (стандартный)

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

3.14286

314.286

Фиксированный

В этом формате фиксировано количество цифр, отображаемое справа от десятичной точки, а количество цифр слева не фиксировано. В этом случае при стандартной точности, равной шести, число «пи» будет отображаться в виде

3.142857

314.285714

Научный

Значение начинается с цифры, затем идет десятичная точка и несколько цифр, количество которых определяется заданной точностью; затем идет буква «е» и степень 10, в которую надо возвести предыдущее значение. В этом случае число «пи», умноженное на 1000, будет отображаться как

3.142857е+003

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

Табл. 10.2. Манипуляторы, работающие с любыми числами и числами с плавающей точкой

fixed

pi = 3.142857

scientific

pi = 3.142857е+003

setprecision

pi = 3.14

pi = 3.143

pi = 3.143е+000

showpos noshowpos

+3.14

showpoint noshowpoint

cout << showpoint << 2.0

2.00

showbase noshowbase

32

040

0x20

dec oct hex

uppercase nouppercase

0X

E

Все манипуляторы, кроме

setprecision

cout << "pi = " << setprecision(2) << pi << '\n';

В результате вы получите

pi = 3.1

Для сравнения представим, что вам требуется отобразить число «пи» в формате чисел с плавающей точкой.

cout << "pi = " << fixed << setprecision(2) << pi << '\n';

Теперь результат будет таким.

pi = 3.14

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

cout << "pi = " << fixed << setprecision(2) << pi * 1000 << '\n';

выдает в результате:

pi = 3142.86

Это хорошо, потому что вы можете задать точность, установить ширину своего поля при помощи

setw

right

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

Рецепт 10.3.

10.3. Написание своих собственных манипуляторов потока

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

Чтобы создать манипулятор, который не имеет аргументов (типа

left

ios_base

Пример 10.4. Простой манипулятор потока

#include 

#include 

#include 

using namespace std;

// вывести числа с плавающей точкой в обычном виде

inline ios_base& floatnormal(ios_base& io) {

 io.setf(0, ios_base::floatfield);

 return(io);

}

int main() {

 ios_base::fmtflags flags = // Сохранить старые флаги

  cout.flags();

 double pi = 22.0/7.0;

 cout << pi = " << scientific // Научный режим

  << pi * 1000 << '\n';

 cout << "pi = " << floatnormal << pi << '\n';

 cout.flags(flags);

}

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

Прочитав рецепт 10.1, вероятно, вы поняли, что существует три формата вывода чисел с плавающей точкой и только два манипулятора для выбора формата. Для используемого по умолчанию формата не предусмотрен манипулятор; вам придется соответствующим образом установить флаг для потока, чтобы вернуться к стандартному формату:

myiostr.setf(0, ios_base::float field);

Но для удобства вы можете добавить свой собственный манипулятор, делающий то же самое. Именно это сделано в примере 10.4. Манипулятор

floatnormal

Компилятор знает, что делать с вашей новой функцией, потому что в стандартной библиотеке определен следующий оператор для

basic_ostream

basic_ostream

ostream

wostream

basic_ostream& operator<<

 (basic_ostream& (* pf)basic_ostream&))

Здесь

pf

basic_ostream

basic_ostream

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

myostream << myManip << "foo";

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

operator<<

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

myostream << myFancyManip(17) << "apple";

Как это будет работать? Если вы считаете, что

myFancyManip

myostream << myFancyManip(17, myostream) << "apple";

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

operator<<

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

operator<<

operator<<

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

setWidth

setw

class WidthSetter {

public:

 WidthSetter(int n) : width_(n) {}

 void operator()(ostream& os) const {os.width(width_);}

private:

 int width_;

};

Этот класс содержит простую функцию. Предусмотрите в ней целочисленный аргумент и, когда

operator()

WidthSetter

WidthSetter setWidth(int n) {

 return(WidthSetter(n)); // Возвращает инициализированный объект

}

Эта функция всего лишь возвращает объект

WidthSetter

operator<<

myostream << setWidth(20) << "banana";

Но этого недостаточно, потому что

setWidth

WidthSetter

operator<<

operator<<

WidthSetter

ostream& operator<<(ostream& os, const WidthSetter& ws) {

 ws(os);   // Передать поток объекту ws

 return(os); // для выполнения реальной работы

}

Это решает проблему, но не в общем виде. Вам не захочется писать класс типа

WidthSetter

ManipInfra

operator<<

Пример 10.5. Инфраструктура манипуляторов

#include 

#include 

using namespace std;

// ManipInfra - это небольшой промежуточный класс, который помогает

// создавать специальные манипуляторы с аргументами. Вызывайте его

// конструктор с предоставлением указателя функции и значения из основной

// функции манипулятора

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

// делает реальную работу. См. примеры ниже

template

class ManipInfra {

public:

 ManipInfra(basic_ostream& (*pFun) (basic_ostream&, T), T val) :

  manipFun_(pFun), val_(val) {}

 void operator()(basic_ostream& os) const {

  manipFun_(os, val_);

 }    // Вызовите функцию, задавая ее указатель и

private: // передавая ей поток и значение

 T val_;

 basic_ostream<С>& (*manipFun_) (basic_ostream&, T);

};

template

basic_ostream& operator<<(basic_ostream& os,

 const ManipInfra& manip) {

 manip(os);

 return(os);

}

// Вспомогательная функция, которая вызывается в итоге в классе ManipInfra

ostream& setTheWidth(ostream& os, int n) {

 os.width(n);

 return(os);

}

// Собственно функция манипулятора. Именно она используется в клиентском

// программном коде

ManipInfra setWidth(int n) {

 return(ManipInfra(setTheWidth, n));

}

// Ещё одна вспомогательная функция, которая принимает аргумент типа char

ostream& setTheFillChar(ostream& os, char с) {

 os.fill(c);

 return(os);

}

ManipInfra setFill(char c) {

 return(ManipInfra(setTheFillChar, c));

}

int main() {

 cout << setFill('-')

  << setWidth(10) << right << "Proust\n";

}

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

10.4. Создание класса, записываемого в поток

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

Перегрузите

operator<<

Пример 10.6. Запись объектов в поток

#include 

#include 

using namespace std;

class Employer {

 friend ostream& operator<<       // Он должен быть другом для

  (ostream& out, const Employer& empr); // получения доступа к неоткрытым

public:                 // членам

 Employer() {}

 ~Employer() {}

 void setName(const string& name) {name_ = name;}

private:

 string name_;

};

class Employee {

friend ostream& operator<< (ostream& out, const Employee& obj);

public:

 Employee() : empr_(NULL) {}

 ~Employee() {if (empr_) delete empr_;}

 void setFirstName(const string& name) {firstName_ = name;}

 void setLasttName(const string& name) {lastName_ = name;}

 void setEmployer(Employer& empr) {empr_ = &empr;}

 const Employer* getEmployer() const {return(empr_);}

private:

 string firstName_;

 string lastName_;

 Employer* empr_;

};

// Обеспечить передачу в поток объектов

Employer... ostream& operator<<(ostream& out, const Employer& empr) {

 out << empr.name_ << endl; return(out);

}

// Обеспечить передачу в поток объектов Employee...

ostream& operator<<(ostream& out, const Employee& emp) {

 out << emp.firstName_ << endl;

 out << emp.lastName_ << endl;

 if (emp.empr_) out << *emp.empr_ << endl;

  return(out);

}

int main() {

 Employee emp;

 string first = "William";

 string last = "Shatner";

 Employer empr;

 string name = "Enterprise";

 empr.setName(name);

 emp.setFirstName(first);

 emp.setLastName(last);

 emp.setEmployer(empr);

 cout << emp; // Запись в поток

}

Прежде всего, необходимо объявить оператор

operator<<

friend

operator<<

writeToStream(ostream& os)

После этого определите версию

operator<<

ostream

wostream

friend

out << emp.firstName_ << endl;

out << emp.lastName_ << endl;

В примере 10.6 я записал в поток объект, на который ссылается указатель

empr_

operator<<

if (emp.empr_)

 out << *emp.empr << endl;

Я могу так делать, потому что

empr_

Employer

Employee

operator<<

После записи в поток членов вашего класса ваш оператор

operator<<

operator<<

cout << "Here's my object. " << myObj << '\n';

Описанный мною подход достаточно прост, и если вы собираетесь записывать класс с целью его дальнейшего восприятия человеком, он будет хорошо работать, но это только частичное решение проблемы. Если вы записываете объект в поток, это обычно делается по одной из двух причин. Либо этот поток направляется куда-то, где он будет прочитан человеком (

cout

stringstream

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

Рецепт 10.5.

10.5. Создание класса, считываемого из потока

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

Используйте

operator>>

Пример 10.7. Чтение данных из потока в объект

#include 

#include 

#include 

#include 

using namespace std;

class Employee {

 friend ostream& operator<<       // Они должны быть друзьями,

  (ostream& out, const Employee& emp); // чтобы получить доступ к

 friend istream& operator>>       // неоткрытым членам

  (istream& in, Employee& emp);

public:

 Employee() {}

 ~Employee() {}

 void setFirstName(const string& name) {firstName_ = name;}

 void setLastName(const string& name) {lastName_ = name;}

private:

 string firstName_;

 string lastName_;

};

// Передать в поток объект Employee...

ostream& operator<<(ostream& out, const Employee& emp) {

 out << emp.firstName_ << endl;

 out << emp.lastName_ << endl;

 return(out);

}

// Считать из потока объект Employee

istream& operator>>(istream& in, Employee& emp) {

 in >> emp.firstName_;

 in >> emp.lastName_;

 return(in);

}

int main() {

 Employee emp;

 string first = "William";

 string last = "Shatner";

 emp.setFirstName(first);

 emp.setLastName(last);

 ofstream out("tmp\\emp.txt");

 if (!out) {

  cerr << "Unable to open output file.\n";

  exit(EXIT_FAILURE);

 }

 out << emp; // Записать Emp в файл

 out.close();

 ifstream in("tmp\\emp.txt");

 if (!in) {

  cerr << "Unable to open input file.\n";

  exit(EXIT_FAILURE);

 }

 Employee emp2;

 in >> emp2; // Считать файл в пустой объект

 in.close();

 cout << emp2;

}

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

Во-первых, вам необходимо объявить

operator>>

istream

ostream

operator>>

operator<<

Рецепт 10.4.

10.6. Получение информации о файле

Требуется получить информацию о файле, например о его размере, номере устройства, времени последнего изменения и т.п.

Используйте вызов системной C-функции

stat

Пример 10.8. Получение информации о файле

#include 

#include 

#include 

#include 

#include 

#include 

int main(int argc, char** argv) {

 struct stat fileInfo;

 if (argc < 2) {

  std::cout << "Usage: fileinfo \n";

  return(EXIT_FAILURE);

 }

 if (stat(argv[1], &fileInfo) != 0) { // Используйте stat() для получения

                    // информации

  std::cerr << "Error: " << strerror(errno) << '\n';

  return(EXIT_FAILURE);

 }

 std::cout << "Type::";

 if ((fileInfo.st_mode & S_IFMT) == S_IFDIR) { // Из sys/types.h

  std::cout << "Directory\n";

 } else {

  std::cout << "File\n";

 }

 std::cout << "Size : " <<

 fileInfo.st_size << '\n';        // Размер в байтах

 std::cout << "Device : " <<

  (char)(fileInfo.st_dev + 'A') >> '\n'; // Номер устройства

 std::cout << "Created : " <<

  std::ctime(&fileInfo.st_ctime);     // Время создания

 std::cout << "Modified : " <<

  std.:ctime(&fileInfo.st_mtime);     // Время последней модификации

}

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

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

struct

stat

stat.

stat

struct stat {

 dev_t  st_dev;  /* устройство */

 ino_t  st_ino;  /* номер inode */

 short  st_mode;  /* вид */

 short  st_nlink  /* число ссылок на файл */

 short  st_uid;  /* пользовательский идентификатор владельца */

 short  st_gid;  /* групповой идентификатор владельца */

 dev_t  st_rdev;  /* для особых файлов */

 off_t  st_size;  /* размер файла в символах */

 time_t st_atime; /* время последнего доступа */

 time_t st_mtime; /* время последней модификации */

 time_t st_ctime; /* время последнего изменения inode */

};

Смысл каждого члена

stat

st_uid

st_gid

В примере 10.8 показано, как можно отображать на экране некоторые переносимые члены

stat

st_mode

st_ size

size_t

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

st_dev

'A'

ustat

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

10.7. Копирование файла

Требуется скопировать файл, причем так, чтобы эта операция была переносимой, т.е. без использования зависящего от ОС программного интерфейса.

Используйте файловые потоки С++, определенные в

Пример 10.9. Копирование файла

#include 

#include 

const static int BUF_SIZE = 4096;

using std::ios_base;

int main(int argc, char** argv) {

 std::ifstream in(argv[1], 

  ios_base::in | ios_base::binary);  // Задается двоичный режим, чтобы

 std::ofstream out(argv[2],      // можно было обрабатывать файлы с

  ios_base::out | ios_base::binary), // любым содержимым

 // Убедитесь, что потоки открылись нормально...

 char buf[BUF_SIZE];

 do {

  in.read(&buf[0], BUF_SIZE);    // Считать максимум n байт в буфер,

  out.write(&buf[0], in.gcount()); // затем записать содержимое буфера

 } while (in.gcount() > 0);     // в поток вывода.

 // Проверить наличие проблем в потоках...

 in.close();

 out.close();

}

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

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

read

write

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

read

operator<<

getc

ofstream

operator<<

do/while

out << in.rdbuf();

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

operator<<

rdbuf

operator<<

operator<<

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

copy_file

Пример 10.10. Копирование файла при помощи Boost

#include 

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверка параметров...

 try {

  // Преобразовать аргументы в абсолютные пути, используя «родное»

  // форматирование

  path src = complete(path(argv[1], native));

  path dst = complete(path(argv[2], native));

  copy_file(src, dst);

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

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

path

path

path

complete

path src = complete(path(argv[1], native));

Первый аргумент — это текстовая строка, представляющая путь, например «

tmp\\foo.txt

string

Boolean

native

portable_posix_name

windows_name

portable_name

portable_directory_name

portable_file_name

no_check

Функция

complete

path src = complete(path("tmp\\foo.txt", native));

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

complete

c:\myprograms

path src = complete(path("c:\\windows\\garbage.txt", native));

Многие функции из библиотеки Boost Filesystem будут выбрасывать исключения, если не удовлетворяется некоторое предусловие. Это подробно описано в документации, но хорошим примером является сама функция

copy_file

copy_file

10.8. Удаление или переименование файла

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

Это сделают стандартные C-функции

remove

rename

Пример 10.11. Удаление файла

#include 

include 

#include 

using namespace std;

int main(int argc, char** argv) {

 if (argc != 2) {

  cerr << "You must supply a file name to remove." << endl;

  return(EXIT_FAILURE);

 }

 if (remove(argv[1]) == -1) { // remove() возвращает при ошибке -1

  cerr << "Error: " << strerror(errno) << endl;

  return(EXIT_FAILURE);

 } else {

  cout << "File '" << argv[1] << "' removed." << endl;

 }

}

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

errno

strerror

perror

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

remove

if (rename(argv[1], argv[2])) {

 cerr << "Error: " << strerror(errno) << endl;

 return(EXIT_FAILURE);

}

Библиотека Boost Filesystem также предоставляет средства для удаления и переименования файла. В примере 10.12 показана короткая программа по удалению файла (или каталога, однако см. обсуждение, приводимое после этою примера).

Пример 10.12. Удаления файла средствами Boost

#include 

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверить параметры...

 try {

  path p = complete(path(argv[1], native));

  remove(p);

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

Важную часть примера 10.12 составляет функция

remove

path

path

complete

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

try

path src = complete(path(argv[1], native));

path dst = complete(path(argv[2], native));

rename(src, dst);

В результате

src

dst

src

dst

dst

Рецепт 10.7.

10.9. Создание временного имени файла и временного файла

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

Используйте функцию

tmpfile

tmpnam

tmpfile

FILE*

tmpnam

tmpfile

Пример 10.13. Создание временного файла

#include 

#include 

int main() {

 FILE* pf = NULL;

 char buf[256];

 pf = tmpfile(); // Создать и открыть временный файл

 if (pf) {

 fputs("This is a temp file", pf); // Записать в него некоторые данные

 }

 fseek(pf, 5, SEEK_SET); // Восстановить позицию в файле

 fgets(buf, 255, pf);   // Считать оттуда строку

 fclose(pf);

 std:cout << buf << '\n';

}

Создать временный файл можно двумя способами; в примере 10.13 показан один из них. Функция

tmpfile

FILE*

NULL

FILE*

fread

fwrite

fgets

puts

tmpfile

tmpfile

Такой подход может как подойти, так и не подойти для вас — все зависит от того, что вы хотите делать. Заметив, что

tmpfile

tmpnam

tmpnam

tmpnam

char*

char*

char

L_tmpnam

tmpnam

NULL

tmpfile

tmpnam

Пример 10.14. Создание имени временного файла

#include 

#include 

#include 

#include 

int main() {

 char* pFileName = NULL;

 pFileName = tmpnam(NULL);

 // Здесь другая программа может получить то же самое имя временного

 // файла.

 if (!pFileName) {

  std::cerr << "Couldn't create temp file name.\n";

  return(EXIT_FAILURE);

 }

 std::cout << "The temp file name is: " << pFileName << '\n';

 std::ofstream of(pFileName);

 if (of) {

  of << "Here is some temp data.";

  of.close();

 }

 std::ifstream ifs(pFileName);

 std::string s;

 if (ifs) {

  ifs >> s;

  std::cout << "Just read in \"" << s << "\"\n";

  ifs.close();

 }

}

Однако одну важную особенность необходимо знать о функции

tmpnam

tmpname

tmpname

10.10. Создание каталога

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

На большинстве платформ вы сможете использовать системный вызов

mkdir

Пример 10.15. Создание каталога

#include 

#include 

int main(int argc, char** argv) {

 if (argc < 2) {

  std::cerr << "Usage: " << argv[0] << " [new dir name]\n";

  return(EXIT_FAILURE);

 }

 if (mkdir(argv[1]) == -1) { // Созвать каталог

  std::cerr << "Error: " << strerror(errno);

  return(EXIT_FAILURE);

 }

}

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

mkdir

Пример 10.15 работает в системах Windows, но не в Unix. В Windows

mkdir

В Unix

mkdir

chmod

chmod

#include 

#include  

#include 

int main(int argc, char** argv) {

 if (argc < 2) {

  std::cerr << "Usage: " << argv[0] << " [new dir name]\n";

  return(EXIT_FAILURE);

 }

 if (mkdir(argv[1], 0777) == -1) { // Создать каталог

  std::cerr << "Error: << strerror(errno);

  return(EXIT_FAILURE);

 }

}

Если вам требуется обеспечить переносимость, не следует самому писать операторы

#ifdef

сreate_directory

Пример 10.16. Создание каталога средствами Boost

#include 

#include 

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверка параметров...

 try {

  path p = complete(path(argv[1], native));

  create_directory(p);

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

Функция

create_directory

path

filesystem_error

path

complete

Рецепт 10.12.

10.11. Удаление каталога

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

На большинстве платформ вы сможете воспользоваться системным вызовом

rmdir

rmdir

Пример 10.17. Удаление каталога

#include 

#include 

using namespace std;

int main(int argc, char** argv) {

 if (argc < 2) {

  cerr << "Usage: " << argv[0] << " [dir name]" << endl;

  return(EXIT_FAILURE);

 }

 if (rmdir(argv[1]) == -1) { // Удалить каталог

  cerr << "Error: " << strerror(errno) << endl;

  return(EXIT_FAILURE);

 }

}

Сигнатура

rmdir

errno

strerror

perror

Если целевой каталог не пустой,

rmdir

Если вам требуется обеспечить переносимость, не следует самому писать операторы

#ifdef

remove

Функция

removeRecurse

remove

boost::filesystem::remove

path

Пример 10.18. Удаление каталога средствами Boost

#include 

#include 

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

void removeRecurse(const path& p) {

 // Сначала удалить содержимое каталога

 directory_iterator end;

 for (directory_iterator it(p); it != end; ++it) {

  if (is_directory(*it)) {

  removeRecurse(*it);

  } else {

  remove(*it);

  }

 }

 // Затем удалить сам каталог

 remove(p);

}

int main(int argc, char** argv) {

 if (argc != 2) {

  cerr << "Usage: " << argv[0] << " [dir name]\n";

  return(EXIT_FAILURE);

 }

 path thePath = system_complete(path(argv[1], native));

 if (!exists(thePath)) {

  cerr << "Error: the directory " << thePath.string()

  << " does not exist.\n";

  return(EXIT_FAILURE);

 }

 try {

  removeRecurse(thePath);

 } catch (exception& e) {

  cerr << e.what() << endl;

  return(EXIT_FAILURE);

 }

 return(EXIT_SUCCESS);

}

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

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

Рецепт 10.12.

10.12. Чтение содержимого каталога

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

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

Пример 10.19. Чтение каталога

#include 

#include 

#include 

using namespace boost::filesystem;

int main(int argc, char** argv) {

 if (argc < 2) {

  std::cerr << "Usage: " << argv[0] << " [dir name]\n";

  return(EXIT_FAILURE);

 }

 path fullPath = // Создать полный, абсолютный путь

  system_complete(path(argv[1], native));

 if (!exists(fullPath)) {

  std::cerr << "Error: the directory " << fullPath.string()

  << " does not exist.\n";

  return(EXIT_FAILURE);

 }

 if (!is_directory(fullPath)) {

  std::cout << fullPath.string() << " is not a directory!\n";

  return(EXIT_SUCCESS);

 }

 directory_iterator end;

 for (directory_iterator it(fullPath);

  it != end; ++it) {     // Просматривать в цикле каждый

              // элемент каталога почти

 std::cout << it->leaf(); // так же, как это делалось бы для

  if (is_directory(*it))  // STL-контейнера

  std::cout << " (dir)";

  std::cout << '\n';

 }

 return(EXIT_SUCCESS);

}

Как и при создании и удалении каталогов (см. рецепты 10.10 и 10.11), не существует стандартного, переносимого способа чтения содержимого каталога. Чтобы облегчить жизнь в C++, библиотека Filesystem проекта Boost содержит ряд переносимых функций по работе с файлами и каталогами. Она также содержит много других функций; дополнительную информацию вы найдете при описании других рецептов этой главы или на веб-странице библиотеки Boost Filesystem сайта www.boost.com.

В примере 10.19 приводится простая программа просмотра каталога (наподобие команды

ls

dir

path fullPath = complete(path(argv[1], native));

Тип данных переменной, содержащей путь, называется, естественно,

path

path::string

exists

is_directory

Файловая система имеет класс с именем

directory_iterator

end

vector::end

directory_iterator

directory_iterator end;

Затем вы можете создать итератор для вашего пути и следующим образом сравнивать его с маркером конца.

for (directory_iterator it(fullPath); it != end; ++it) {

 // выполнить любые действия с *it

 std::cout << it->leaf();

}

Функция-член

leaf

string

Если вам требуется обеспечить переносимость, но по каким-то причинам вы не можете использовать библиотеки Boost, обратите внимание на исходный код Boost. Он содержит операторы

#ifdef

Рецепты 10.10 и 10.11.

10.13. Извлечение расширения файла из строки

Имеется имя файла или полный путь и требуется получить расширение файла, которое является частью имени файла, расположенной за последней точкой. Например, в именах файлов src.cpp, Window.class и Resume.doc расширениями файла являются соответственно .cpp, .class и .doc.

Преобразуйте имя файла или путь к нему в строку

string

rfind

Пример 10.20. Получение расширения файла из его имени

#include 

#include 

using std::string;

string getFileExt(const string& s) {

 size_t i = s.rfind('.', s.length());

 if (i ! = string::npos) {

  return(s.substr(i+1, s.length() - i));

 }

 return("");

}

int main(int argc, char** argv) {

 string path = argv[1];

 std::cout << "The extension is \"" << getFileExt(path) << "\"\n";

}

Для получения расширения из имени файла достаточно лишь найти позицию последней точки «.» и выделить все, что находится справа от нее. Стандартный класс

string

rfind

substr

rfind

char

rfind

string::npos

substr

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

Рецепты 4.9 и 10.12.

10.14. Извлечение имени файла из полного пути

Имеется полный путь к файлу, например d:\apps\src\foo.с, и требуется получить имя файлa, foo.с.

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

rfind

substr

Пример 10.21. Извлечение имени файла из полного пути

#include 

#include 

using std::string;

string getFileName(const string& s) {

 char sep = '/';

#ifdef _WIN32

 sep = '\\';

#endif

 size_t i = s.rfind(sep.s.length());

 if (i ! = string::npos) {

  return(s.substr(i+1, s.length( ) - i));

 }

 return("");

}

int main(int argc, char** argv) {

 string path = argv[1];

 std::cout << "The file name is \"" << getFileName(path) << "\"\n";

}

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

rfind

substr

#ifdef

Класс

path

path::leaf

Пример 10.22. Получение имени файла из пути

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверка параметров

 try {

  path p = complete(path(argv[1], native));

 cout << p.leaf() << " is a "

  << (is_directory(p) ? "directory" : "file") << endl;

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

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

path

Рецепт 10.15.

10.15. Извлечение пути из полного имени файла

Имеется полное имя файла (имя файла и путь доступа к нему), например

d:\apps\src\foo.с

d:\apps\src

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

rfind

substr

Пример 10.23. Получение пути из полного имени файла

#include 

#include 

using std::string;

string getPathName(const string& s) {

 char sep = '/';

#ifdef _WIN32

 sep = '\\';

#endif

 size_t i = s.rfind(sep, s.length());

 if (i != string::npos) {

  return(s.substr(0, !));

 }

 return("");

}

int main(int argc, char** argv) {

 string path = argv[1];

 std::cout << "The path name is \"" << getPathName(path) << "\"\n";

}

Пример 10.23 тривиален, особенно если вы уже знакомы с двумя предыдущими рецептами, поэтому дополнительные пояснения не требуются. Однако, как и во многих других рецептах, библиотека Boost Filesystem позволяет извлекать с помощью функции

branch_path

Пример 10.24. Получение базового пути

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверка параметров...

 try {

  path p = complete(path(argv[1], native));

  cout << p.branch_path().string() << endl;

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

Результат выполнения примера 10.24 может выглядеть следующим образом.

D:\src\ccb\c10>bin\GetPathBoost.exe с:\windows\system32\1033

с:/windows/system32

Рецепты 10.13 и 10.14.

10.16. Замена расширения файла

Имеется имя файла (возможно, с путем доступа к нему) и требуется заменить расширение файла. Например, имя файла

thesis.tex

thesis.txt

Используйте функции-члены

rfind

replace

string

Пример 10.25. Замена расширения файла

#include 

#include 

using std::string;

void replaceExt(string& s, const string& newExt) {

 string::size_type i = s.rfind('.', s.length());

 if (i != string::npos) {

  s.replace(i+1, newExt.length(), newExt);

 }

}

int main(int argc, char** argv) {

 string path = argv[1];

 replaceExt(path, "foobar");

 std::cout << "The new name is \"" << path << "\"\n";

}

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

replace

replace

Рецепт 4.9.

10.17. Объединение двух путей в один

Имеется два пути и требуется их объединить в один путь. Например, вы имеете в качестве первого пути

/usr/home/ryan

utils/compilers

/usr/home/ryan/utils/compilers

Рассматривайте пути как строки и используйте оператор добавления в конец строки,

operator+=

Пример 10.26. Объединение путей

#include 

#include 

using std::string;

string pathAppend(const string& p1, const string& p2) {

 char sep = '/';

 string tmp = p1;

#ifdef _WIN32

 sep = '\\';

#endif

 if (p1[p1.length()] != sep) { // Необходимо добавить

  tmp += sep;          // разделитель

  return(tmp + p2);

 } else

  return(p1 + p2);

}

int main(int argc, char** argv) {

 string path = argv[1];

 std::cout << "Appending somedir\\anotherdir is \""

  << pathAppend(path, "somedir\\anotherdir") << "\"\n";

}

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

Для многих других рецептов данной главы я включил примеры по использованию библиотеки Boost Filesystem, и при работе с путями такой подход имеет много преимуществ. Как я говорил при обсуждении рецепта 10.7, библиотека Boost Filesystem содержит класс

path

path

path

Пример 10.27. Объединение путей средствами Boost

#include 

#include 

#include 

#include 

#include 

using namespace std;

using namespace boost::filesystem;

int main(int argc, char** argv) {

 // Проверка параметров...

 try {

  // Составить путь из значений двух аргументов path

  p1 = complete(path(argv[2], native),

  path(argv[1], native));

  cout << p1.string() << endl;

  // Создать путь с базовой частью пути текущего каталога path

  p2 = system_complete(path(argv[2], native));

  cout << p2.string() << endl;

 } catch (exception& e) {

  cerr << e.what() << endl;

 }

 return(EXIT_SUCCESS);

}

Результат выполнения программы примера 10.27 может иметь такой вид.

D:\src\ccb\c10>bin\MakePathBoost.exe d:\temp some\other\dir

d:/temp/some/other/dir

D:/src/ccb/c10/some/other/dir

Или такой.

D:\src\ccb\c10>bin\MakePathBoost.exe d:\temp с:\WINDOWS\system32

c:/WINDOWS/system32

c:/WINDOWS/system32

Из этого примера видно, что функции

complete

system_complete

complete

complete

d:\temp

system_complete

Однако эти пути не согласуются с требованиями файловой системы. Вам придется самому проверить объекты

path

exists

path p1 = complete(path(argv[2], native),

path(argv[1], native));

if (exists(p1)) {

 // ...

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

is_directory

is_empty

file_size

last_write_time

Рецепт 10.7.