Manual

Введение

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

Язык С изобрел Дэнис Ритчи (Dennis Ritchie) в начале 70-х годов. С относится к языкам среднего уровня, поскольку в нем управляющие структуры языков высокого уровня сочетаются со способностью манипулировать битами, байтами и указателями (адресами). Таким образом, С предоставляет программисту возможность практически полностью управлять компьютером. В 1989 году Американским национальным институтом стандартов (American National Standards Institute - ANSI) был принят стандарт для языка С. Эту версию языка С обычно называют С89. Кроме того, этот же стандарт был принят и Международной организацией стандартов (International Standards Organization - ISO). В 1995 году стандарт С89 был немного улучшен.

Язык C++ создан Бьярни Страуструпом (Bjarne Stroustrup), и годом создания считается 1979-й. Разработка и усовершенствование языка C++ потребовали от создателя больших усилий на протяжении 80-х и большей части 90-х годов. Наконец, в 1998 году был принят ANSI/ISO-стандарт для языка C++. Говоря в самых общих словах, язык C++ является объектно-ориентированной версией языка С. C++ построен на основе версии С89, включающей все усовершенствования 1995 года, и теперь эту версию С89 называют С-подмножеством языка C++. Несмотря на то что язык C++ был задуман как набор объектно-ориентированных расширений для языка С, вскоре он развился в самостоятельный язык программирования. В настоящее время его новые средства почти удвоили объем исходного языка. Вряд ли стоит доказывать, что C++ - один из самых мощных компьютерных языков, разработанных до сих пор.

В 1999 году был принят новый ANSI/ISO-стандарт для языка С. Эта версия называется С99. Она включает ряд усовершенствований и несколько новых средств. Одни из этих "новых" средств заимствованы из языка C++, а другие предоставляют совершенно новые возможности. Следовательно, отдельные элементы, добавленные в версии С99, несовместимы с языком C++. Это означает, что с появлением версии С99 стандарт языка С больше не является чистым подмножеством языка C++. К счастью, многие "несовместимости" связаны со средствами специального назначения, которые можно легко обойти. Таким образом, и новый вариант языка С позволяет создавать программы, совместимые с языком C++. На момент написания этой книги большинство компиляторов не принимали все новшества версии С99, но, безусловно, ситуация вскоре изменится.

В следующей таблице демонстрируются отношения между версиями С89, С99 и языком C++.

С89 | Оригинальный стандарт ANSI/ISO языка С, который большинство программистов считают "настоящим" языком С
C++ | Объектно-ориентированная версия языка С. Действующий в данный момент стандарт ANSI/ISO для языка C++ построен на основе версии С89. Следовательно, С89 является подмножеством языка C++
С99 | Последний стандарт языка С. Включает в полном объеме вариант С89, но с несколькими новыми средствами. Причем некоторые из них не поддерживаются текущим стандартом языка C++

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

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


if управляющие структуры

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

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

Копировать
if(условие) {
    блок_операторов_1
}
else {
    блок_операторов_2
}

Если блок_операторов состоит только из одного оператора, в фигурных скобках необходимость отпадает. Оператор else необязателен.

В качестве элемента условие можно использовать любое выражение. Если это выражение имеет значение, оцениваемое как истинное (любое значение, отличное от нуля), будет выполнен блок_операторов_1; в противном случае будет выполнен блок_операторов_2, если таковой существует.

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

Копировать
if(x > 10}
    cout << "x больше 10.";
else
    cout << "x меньше или равен 10.";

Оператор выбора switch

Оператор switch — это С/С++-оператор многоканального ветвления. Он используется для организации работы программы по одному из нескольких направлений. Общая форма записи этого оператора имеет следующий вид.

Копировать
switch (выражение) {
    case константа_1:
        последовательность_операторов_1;
    break;
    case константа_2:
        последовательность_операторов_2;
    break;
    ...
    case константа_N:
        последовательность_операторов_N;
    break;
    default: default-операторы;
}

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

Работа оператора switch заключается в сравнении элемента выражение с константами. При обнаружении совпадения выполняется соответствующая последовательность операторов. Если в выполняемой последовательности операторов нет оператора break, программа перейдет к выполнению операторов, относящихся к следующей директиве case. Другими словами, начиная с точки совпадения элемента выражение и константы, выполнение операторов будет продолжаться до тех пор, пока либо не обнаружится оператор break, либо не закончится оператор switch. Если не обнаружится никакое совпадение, то при наличии директивы default будет выполняться последовательность операторов, относящаяся к этой директиве. В противном случае(при отсутствии директивы default) никакие действия выполнены не будут. В следующем примере анализируется и выполняется команда меню.

Копировать
switch(ch) {
    case 'e': enter();
    break;
    case '1' : list();
    break;
    case 's': sort();
    break;
    case 'q': exit(0);
    break;
    default:
        cout << "Неизвестная команда!\n";
        cout << "Попробуйте еще раз.\n";
}

Оператор default

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

Оператор break

Оператор break используется для выхода из циклов do, for и while в обход обычного условия выхода из цикла. Оно также используется для выхода из блока оператора switch.

Ниже показан пример оператора break в цикле.

Копировать
do {
    х = getx();
    if(x < 0) break; //выход из цикла, если значение х отрицательно
    process(х);
} while(!done);

На этом работа цикла завершается, если значение переменной х оказалось отрицательным.

В операторе switch оператор break не позволяет программе выполнять набор операторов, относящихся к следующему оператору case.(За подробностями обращайтесь к разделу "switch", приведенному ниже в этой главе.)

Оператор break прекращает работу только тех циклов for, do(), while и оператора switch, которые его содержат. Он не прервет работу ни одного из вложенных циклов или операторов switch.

Оператор continue

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

Копировать
while(ch = getchar()) {
    if(ch != 's') continue; // читаем следующий символ
    process(ch);
}

Обращение к функции process() не произойдет до тех пор, пока переменная ch не будет содержать символ s.

Оператор безусловного перехода goto

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

Копировать
goto метка;
...
метка:

Совет программисту

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

Копировать
int i, j, k;
int stop = 0;

for(i=0; i<100 && istop; i++) {
    for(j=0; j<10 && istop; j+ + ) {
        for(k=0; k<20; k++) {
            // ...
            if(something()) {
                stop = 1;
                break;
            }
        }
    }
}

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

Копировать
int i, j, k;

for(i=0; i<100; i++) {
    for(j=0; j<10; j + +) {
        for(k=0; k<20; k++) {
            // . ..
            if(something()) {
                goto done;
            }
        }
    }
}

done: // ...

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

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

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

Цикл for

Цикл for позволяет выполнить автоматическую инициализацию и инкрементирование переменной счетчика. Общая форма записи такова.

Копировать
for (инициализация; условие; инкремент) {
    //блок_операторов
}

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

Несмотря на то что цикл for допускает ряд отклонений, как правило, инициализация устанавливает переменную управления циклом равной ее начальному значению. Элемент условие обычно представляет собой оператор отношения, сравнивающий значение переменной цикла с ее конечным значением, а элемент инкремент инкрементирует (или декрементирует) значение переменной цикла. Если условие дает ложное значение сразу после инициализации, тело цикла for ни разу не будет выполнено.

При выполнении следующего оператора сообщение "Привет" будет выведено десять раз.

Копировать
for(t=0; t<10; t + +) cout << "Привет\n";

Цикл while

Для цикла while используется следующая общая форма.

Копировать
whi1е(условие) {
    блок_операторов
}

Если блок_операторов цикла while состоит только из одного оператора, фигурные скобки можно опустить.

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

Ниже приведен пример цикла while, который читает 100 символов и сохраняет их в массиве символов.

Копировать
char s[256];
t = 0;
while(t<100) {
    s[t] = stream.get();
}

Цикл do

Общая форма записи цикла do имеет такой вид.

Копировать
do {
    блок_операторов
} while(условие);

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

Цикл do — это единственный цикл в языке C++, который будет всегда иметь по крайней мере одну итерацию, поскольку условие проверяется после выполнения тела цикла.


Основные типы

В версии C89 определенны следующие основные типы данных.

Тип данных | Ключевое слово
Символьный | char
Целочисленный | int
С плавующей запятой | float
С плавающей запятой двойной точности | double
Пустой | void

К перечисленным выше типам в версии C99 добавленны следующие.

Тип данных | Ключевое слово
Логический, или булев (истина/ложь) | _Bool
Комплексный | _Complex
Мнимый | _Imaginary

В языке C++ к типам, что определенны в версии C89 добавленны следующие.

Тип данных | Ключевое слово
Логический, или булев (true/fase) | bool
Символьный двухбайтовый | wchar_t

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

Примечание: ключевые слова для обозначения логического типа данных в версии C99 и языке C++, отличаються одно от другого: _Bool (C99) и bool (C++). В версии C89 логический тип данных вобще отсутствует.

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

  • signed - знаковый
  • unsigned - безхнаковый
  • short - короткий
  • long - длинный

Если при объявлении переменных используеться один модификатор (без наименования типа), то предпологаеться использование типа int. Например две следующии записи эквивалентны.

Копировать
unsigned int i;
unsigned i;

Тип | Размер в байтах | Диапазон
char | 1 | -128 - 127
unsigned char | 1 | 0 - 255
signed char | 1 | -128 - 127
int | 2 | -32 768 - 32 767
unsigned int | 2 | 0 - 65 535
signed int | 2 | Аналогично int
short int | 2 | Аналогично int
unsigned short int | 2 | 0 - 65 535
signed short int | 2 | Аналогично int
long int | 4 | -2 147 483 648 - 2 147 483 647
signed long int | 4 | Аналогично long int
unsigned long int | 4 | 0 - 4 294 967 295
long long int | 8 | -263 - (263-1) (только в C99)
signed long long int | 8 | Аналогично long long int (только в C99)
unsigned long long int | 8 | 0 - 264-1 (только в C99)
float | 4 | 3.4E-38 - 3.4E+38 (6 значищих цифр)
double | 8 | 1.7E-308 - 1.7E+308 (10 значищих цифр)
long double | 10 | 34E-4932 - 3.4E+4932 (10 значищих цифр)
wchar_t | 2 | Аналогично unsigned int


Массивы

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

Копировать
тип Имя_массива[размер];
Здесь тип определяет тип данных для каждого элемента в массиве, а размер указывает количество элементов в массиве. Например чтобы определить массаив x из 100 элементов, запишите следуюющее.
Копировать
int x[100];
Эта запись создаёт массив, содержащий 100 элементов, причём номер первого элемента — 0, а последнего — 99.

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

Копировать
int x[10][20];

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

Копировать
int mass[3][2] = {{1, 2},
                  {3, 4},
                  {5, 6},
                 }

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

Копировать
int mass[][3] = {1, 2, 3,
                 4, 5, 6,
                 7, 8, 9};

Смотрите также

Указатели — массивы и указатели


Типы данных, определяемые пользователем

Кроме стандартных типов пользователю допускаетьсяопределять 6 следующих дополнительных типов:

  • struct - структуры
  • union - объеденения
  • enum - перечислимый тип
  • поля битов
  • typedef - создание нового имени
  • class - классы


Структуры

Структура создаёться с помощью ключегого слова struct. В языке C++ структура также определяет класс. Единственное различие между class- и struct- объектами состоит в том, что по умолчанию все членны структуры являються открытыми. Чтобы сделать член закрытым, необходимо использовать ключевое слово private. Общяя форма объявления структуры имеет следующий вид.

Копировать
struct имя_структуры: список_наследования {
    //Открытые членны.
protected:
    //Закрытые членны, которые могут быть унаследованы.
private:
    //Закрытые членны.
} список_объектов;
Например:
Копировать
struct student{
    char *name;
    char kurs;
    int stip;
    student(char studentkurs){
        kurs = studentkurs;
    }
} stud1, stud2;

Смотрите также

union - объеденения
enum - перечислимый тип
поля битов
typedef - создание нового имени


Объеденения

Объеденения — это тип класса, в котором все данные разделяют одну и туже область памяти. В языке c++ объеденение может включать как функции-, так и данные- члены. Все члены объеденения открыты по умолчанию. Для создания закрытых элементов необходимо использовать ключевое слово private. Общая форма объявления объеденения выглядит следующим образом.

Копировать
union имя_класса {
    //Открытые членны по умолчанию.
private:
    //Закрытые члены.
} список_объектов;

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

Элементы объеденения перекрывают друг друга. Нипример, в записи

Копировать
union tom {
    char ch;
    int x;
} t;
объявляеться объеденение tom, которое предпологает следуюющее расположение памяти (при использовании двухбайтовых целых).

Как и в классе, на отдельные переменные, состовляющие объеденение, можно ссылаться с помощью оператора "точка". Оператор "стрелка" используеться для доступа к объеденению с помощью указателя.

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

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

Копировать
union {
    int a;
    float f;
};

//...

a =10;	//доступ к переменной a
cout << f;	//доступ к переменной f
Анонимные оъеденения должны содержать только данные, никакие функции-члены не допускаються. Анонимное объединение, действующее в области видимости, определённой с заданным пространством имён (namespace), должно быть объявленно с использованием модификатора типа данных static.

Смотрите также

struct - структуры
enum - перечислимый тип
поля битов
typedef - создание нового имени


Перечесления

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

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

Копировать
enum имя_перечесления {список_имён} список_переменных;
Здесь имя_перечесления — имя типа данного перечесления. В списке имён, как и в списке переменных, элементы списка отделяються один от другого запятыми.

Нипример, в следующем фрагменте программы сначала определяються перечесления городов, именуемое cities, и переменная c типа cities, а затем переменной c присваеваеться значение Houston.

Копировать
enum cities {Houston, Austin, Amarillo} c;
c = Houston;

В любом перечеслении значение первого по (крайнего слева) имени умолчанию равно 0, значение второго имени равно 1 и т.д. Вобще каждому имени присваеваеться значение, на еденицу больше значения предедущего имени. Добавив инициализатор, можно придать имени некоторое конкретное значение. Например, в следующем перечеслении имя Austin будет иметь значение 10.

Копировать
enum cities {Houston, Austin=10, Amarillo}
В этом примере имя Amarillo будет иметь значение 11.

Смотрите также

struct - структуры
union - объеденения
поля битов
typedef - создание нового имени


Поля битов

Один из методов, встроенных в язык C и позволяющих иметь доступ к биту — это поля битов. Поля битов — это спечиальный тип членов структуры. Формат определения размера переменной в битах следующий.

Копировать
тип имя_переменной:длина_в_битах;
Где длина_в_битах — размер переменной в битах. Например.
Копировать
struct version{
    int major : 3;
    int minor : 3;
    int :6;		//не используеться
    unsigned int x:3;
};
Под переменную типа version выделиться 2 быйта.

Элемент |  | x |  |  | Не используеться |  |  |  |  |  | minor |  |  | major
Биты | 15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0

Для знаковых полей старший левый бит из общего числа битов, выделяемых под данное битовое поле, интерпритируеться как знак. Например битовое значение 101 для поля major будет восприниматься как -1, а значение 101 для поля x — как 5.

Смотрите также

struct - структуры
union - объеденения
enum - перечислимый тип
typedef - создание нового имени


typedef

С помощью ключегого слова typedef можно создать новое имя для уже существуещего типа. Общая форма записи такова.

Копировать
typedef тип новое_имя_типа;
Например следующий фрагментсообщает компилятору, что feet — это ещё одно имя типа int и создаёт целую переменную distance.
Копировать
typedef int feet;
feet distance;

Смотрите также

struct - структуры
union - объеденения
enum - перечислимый тип
поля битов


Указатели

Указатель — это переменная, которая содержит адрес некоторого объекта. Здесь имееться в виду адрес в памяти компьютера. Указатели определяються следующим образом.

Копировать
тип *имя_переменной

С указателями связано два оператора:

  • &
    • — взятие адреса
  • *
    • — возврат значения по указаному адресу

Расмотрим пример кода.

Копировать
int x=10;
int *p, *g;	//определение указателей
p = &x;	//берём адрес переменной x
g = p;	//создаём ещё один указатель который тоже указывает на x
cout << *g;	//печатаем значение переменной x

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

Копировать
int **point;
Указатель |  | Указатель |  | Переменная
Адрес | ---> | Адрес | ---> | Значение
Соответственно чтобы получить значение переменной, необходимо написать: **point.

Инициализация указателей

После того как указатель был объявлен, но до того как ему было присвоено какое либо значение, указатель содержит неизвестное значения. Поэтому попытка использовать указатель до присвоения ему знасения являеться непринятной ошибкой, так как она может нарушить работу программы но и систамы. Обычно в таких случаях система, если не зависает, выдаёт сообщение: "Null pointer assignement".

Принято считать, что указатель который указывает в никуда должен иметь значение null или 0.

Операции над указателями

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

Копировать
int *p, x;
p = &x;
p++;	//увеличиваем значение расположеное по адресу p
В этом примре p увеличиться не на 1, а на 2, т.к. x носит переменную типа int. И это правильно т.к. новое значение должно указывать не на следующий адрес в памяти, а на адрес следующего целого.

Над указателема можно применять основные операции сравнения. Например p < g означает что адрес находащися в p меньше адреса находящеся в g

Общая формула для вычесления значения указателя после выполнения операции сложения следующая: p = p+n*киличество_байт_памяти_базового_типа_указателя, где p — указатель, n — число на которое происходит увеличение.

Преобразование типов в указателях

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

Копировать
float int;
int *p;
p = (int*)&x;
При подобных присвоениях необходимо следить за размерами переменных. Если переменная с более длинного типа будет преобразоввываться на тип с меньшими размерами, то значенее переменной будет урезаться. Например предыдущий код будет неверен, так как истенное значение переменной теряеться (float = 4 байтам, а int = 2 байта).

Тип void и указатели

Нельзя создавать переменую типа void, но можно создавать указатель на тип void. Указателю на void можно присвоють указатель любого другого типа. Однако при обратном присваивании необходимо использовать явное преобразование указателя на void.

Копировать
void *pv;
float f, *pf;
pf = &f;
pv = pf;
pf = (float*)pv;

Массивы и указатели

В языке C существует связ между указателеми и массивами. Имя массива — это адрес памяти с которого расположен массив, т.е. адрес первого элемента массива. Например.

Копировать
int plus[10];
Здесь переменная plus являеться указателем на массив, точнее на первый элемент массива. Следующие две операции идеентичны.
Копировать
p = plus;
p = &plus[0];

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

Копировать
plus[5];
*(plus+5);

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

Копировать
int *a = new int[N];
if (a == 0) {cout << "out of memory" << endl; rturn 0;}
Также память можно выделять и под много мерные массивы, например.
Копировать
int **malloc2d (int r, int c){
    int **t= new int*[r];
    for (int i = 0; i < r; i++)
        t[i] = new int[c];
    return t;
}

int *a = malloc2d (M*N*sizeof(int));
приведённый выше код создайт массив как массив указателей на массивы. После создания переменной с помощью созданной функции будет возможность ссылаться на элемент массива как a[i][j].

Строки и указатели

Строчная константа в языке C ассоциируеться садресом начала строки в памяти, тип строки получаеться char* (указатель на тип char). Поэтому возможно активно использовать следующее присваивание.

Копировать
char *pc;
pc = "Hello world";

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

Копировать
while (*str++) cout<<str;


Спецификаторы классов памяти

Спецификаторы классов памяти extern, auto, register, static и mutable используються для изменения способа создания памяти для переменных в языках C и C++. Эти спецификаторы ставяться перед типом, который они модифицируют.

extern

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

auto

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

register

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

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

static

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

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

В языке C++ использование спецификатора ststic для данных-членов класса приводит к созданию только одной копии этих членнов, совместно используемой всеми объектами класса.

mutable

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


Квалификаторы типов

Квалификаторы const, volatile и restrict предостовляют дополнительную информацию о переменных, перед именами которых они стоят.

const

Объекты типа const не могут быть изменены программой во время её выполнения. Кроме того, объект, адресуемый с помощью указателя, который определён как const, также не может быть модифицирован. Компилятор волен поместить переменную этого типа в память, предназначенную только для чтения (read-only mem — ROM). Переменная, определённая как const, получит своё значение либо из явной инициализации, либо по средством применения аппаратно-зависимых методов.

Копировать
const int a = 10;

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

Копировать
class my {
    void fl() const;
    const void sl();
}

volatile

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

restrict

В версию С99 добавлен квалификатор типа restrict, который применяется только к указателям. Указатель с атрибутом restrict является изначально единственным средством, позволяющим получить доступ к объекту, на который он указывает. Доступ к этому объекту с помощью другого указателя возможен только в том случае, если второй указатель основан на первом. Таким образом, доступ к объекту ограничивается выражениями, основанными на restrict-квалифицированном указателе. Указатели, определенные с помощью квалификатора restrict, используются, главным образом, как параметры функций или для указания на память, выделенную с помощью функции malloc().

Если указатель квалифицирован с помощью ключевого слова restrict, компилятор имеет шанс лучше оптимизировать определенные типы программы на том основании, что restrict-указатель является единственным средством доступа к объекту. Например, если функция задает два параметра-указателя, квалифицированных как restrict, компилятор может предположить, что эти указатели отсылают к различным объектам(которые не перекрываются). Рассмотрим следующий пример использования квалификатора restrict (который стал классическим), а именно — функцию memcpy(). В версии С89 и языке C++ ее прототип имеет следующий вид.

Копировать
void *memcpy(void *strl, const void *str2, size_t размер);

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

В версии С99 квалификатор restrict можно использовать для явного заявления в прототипе функции memcpy() о том, что в версии С89 и языке C++ приходится разъяснять словами. Вот как выглядит прототип функции memcpy() в версии С99.

Копировать
void *memcpy(void * restrict str1, const void * restrict str2, size_t размер);

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


Константы

Чтобы задать точный тип числовой константы, необходимо использовать соответствующий суфикс.

Суфикс | Тип
F | float
U | unsigned
L | long

Например.

Тип данных | Пример констант
int | 1, 123, 21000
long int | 3500L, -34L
unsigned int | 10000U, 987U
float | 123.23F, 4.34e-3F
double | 123.23, 12312333, -0.0999
long double | 1001.2L

Шестнадцатеричнае и восмеричные константы

Шестнадцетиричные константы начинаються с 0x или 0X, а восмеричные — с нуля.

Копировать
int hex = 0x80;
int oct = 012;

Строковые константы

Строковые константы заключаються в двойные кавычки, например "hello", а символьные в одинарные, наприменр 'a'. Строковые константы автоматически завершаються нулевым символом при компиляции. Язык C++ поддерживает класс string.

Логически константы

В языке C++ определены две логические константы: true и false. В заголовка <stdbool.h> определенны макросы true и false.

Комплексные константы

Во время работы в версии C99, если в программу включить заголовок <complex.h>, будут определенны следующие константы, позволяющие работать с комплексными числами.

_Complex_I | (const float _Complex)i
_Imaginary_I | (const float _Imaginary_I)i
I | Imaginary_I (или _Complex_I, если типы не поддерживаються)

Здесь элемент i представляет мнимое значение, которое равно квадратному корню из -1.

Специальные (упрафляющие) символьные константы

Константа | Значение
\b | Возврат на одну позицию
\f | Подача бланка
\n | Новая строка
\r | Возврат каретки
\t | Горизонтальная табуляция
\" | Двойная кавычка
\' | Одинарная кавычка
\\ | Обратная косая черта
\v | Вертикальная табуляция
\N | Восмеричная константа (где N — Это сама восмиричная константа)
\xN | Шестнадцатиричная константа (где N — Это сама шестнадцатиричная константа)
\? | Вопрсительный знак

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

Копировать
cout << "\n\tHello";

Примечание: в системах windows и unix новая строка начинаеться по разному. В windows это символ \r\n, а в unix — \n.


Логические типы данных

Спецификатор типа bool

Спецификатор типа bool используется для объявления в языке C++ логических значений(т.е. истина/ложь).

Ключевое слово true

Ключевое слово true в языке C++ представляет собой логическую константу, имеющую значение "истина".

Ключевое слово false

Ключевое слово false в языке C++ представляет собой логическую константу, имеющую значение "ложь".

Спецификатор типа _Bool

Версия С99 включает тип данных _Вооl, который позволяет хранить значения 1 и 0 (т.е. истина/ложь). _Bool означает целый тип, который отличается от ключевого слова bool, определенного в языке C++. Таким образом, языки С99 и C++ несовместимы по этому типу. Кроме того, в языке C++ определены логические константы true и false, а в версии С99 - нет. Но вместе с тем в версию С99 добавлен заголовок <stdbool.h>, который определяет макросы bool, true и false. Поэтому С/С++-совместимый код можно создать без особых проблем.

Причина того, что в качестве ключевого для версии С99 было определено слово _Воо1, а не bool, состоит в том, что во многих существующих программах уже были определены собственные пользовательские версии слова bool. Поэтому определение логического типа _Вооl позволило избежать приведения уже существующего кода в нерабочее состояние. Однако для новых С-программ лучше включать заголовок <stdbool.h>, а затем использовать макрос bool.


Работа с комплексными числами

В версии С99 содержится два ключевых слова _Imaginary и _Complex, которые поддерживает арифметику комплексных чисел. Однако для работы с мнимыми типами никакой специальной реализации не требуется и никакие независимые реализации (работающие без операционных систем) не обязаны поддерживать комплексные типы.

В версии С99 определены следующие типы _Imaginary.

Копировать
float _Imaginary
double _Imaginary
long double _Imaginary

И следующие типы _Complex.

Копировать
float _Complex
double _Complex
long double _Complex

Причина того, что в качестве ключевого для версии С99 были определены слова _Imaginary и _Complex, а не imaginary и complex, состоит в том, что во многих существующих программах для работы с комплексными числами(и, в частности, с их мнимыми составляющими) уже были определены собственные пользовательские типы данных, применяющие слова imaginary и complex. Поэтому ключевые слова _Imaginary и _Complex позволило избежать приведения уже существующего кода в нерабочее состояние.

Заголовок <complex.h> определяет(кроме всего прочего) макросы imaginary и complex, которым соответствуют значения _Imaginary и _Complex соответственно. Поэтому в новые С-программы лучше включать заголовок <complex.h>, а затем использовать макросы imaginary и complex.


Фуннкции

Определение функций

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

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

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

Прототипы функций

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

Копировать
тип_возврата имя_функции(список_параметров);
Например.
Копировать
float fn(float x);
//или
float fn(float);

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

Возврат значений (оператор return)

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

Копировать
return;
return значение;

В языке C99 и C++ форма оператора return, которая не задаёт возвращаемого значения, должна использоваться только в void-функциях.

Перегрузка функций

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

Копировать
void func (int a){
    cout << "a=" << a << endl;
}
void func (int a, int b){
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
}
void func(int a, double b){
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
}
//вызываем
func (10);	//вызов func (int)
func (12, 24);	//вызов func (int, int)
func (99, 123.23);	//вызов func (int, double)

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

Передача аргументов функции по умолчанию

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

Копировать
void func (int a = 0, int b = 10){}
//вызов
func();
func(-1);
func(-1, 99);

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

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

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

Локальная область видимости определяеться границами блока. Имя объявленное внутри локальной области,известно только внутри этой области. Локальные переменные создаються при входе в блок и разрушаються при выходе из него. Это означает, что локальные переменные не хранять своих значений междувызовами функций. Чтобы сохранить значения переменных между вызовами, можно использовать модификатор static.

Рекурсия

В языках C и C++ функции могут вызывать сами себя. Этот процес называют рекурсией, а функцию, которая сама себя вызывает — рекурсивной. В качестве примера приведём функцию fact(), вычисляющую факториал целого числа.

Копировать
int fact (int n)
{
    int ans;
    if (n == 1) return 1;
    ans = fact (n-1) * n;
    return ans;
}

Функция main()

Выполнение C/C++ программы начинаеться с выполнения функции main(). (Windows-прграммы вызывают функцию WinMain() );

Функция main() не имеет прототипа. Следовательно, можно использовать различные формы функции main(). Как для языка C, так и для языка C++ допустимя следующие варианты функции main().

Копировать
int main();
int main(int argc, char *argv[])

Как видно из второй формы записи, ф. main() поддерживает по крайней мере два параметра. Они называються argc и argv. Эти аргументы будут хранить количество аргументов командной строки и указатель на них соответственно. Параметр argc имеет целый тип, и его значение всегда будет не меньше числа 1, поскольку как предусмотренно в языках C и C++, первым аргументом являеться всегда имя программы. Параметр argv должен быть объявлён как массив символьных указателей, в которых каждый элемент указывает на аргумент командной строки. Ниже приведён пример программы, в которой демонстрируеться использование этих аргументов.

Копировать
#include <iostream.h>
int main (int argc? char *argv[])
{
    if (argc < 2) cout << "Введите своё имя.\n";
    else cout << "привет " << argv[1];
    return 0;
}

Передача указателей

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

Копировать
void swap (int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}
//вызыов
swap (&a, &b);

В языке C++ адрес переменной можно передат функции автоматически. Это реализуеться с помощью параметра-ссылки. При использовании параметра-ссылки функции передаёться адрес аргумента, и функция работает с аргументом, а не с копией. Чтобы создать параметр-ссылку необхадимо перед его именем поставить символ "амперсанда" (&). Внатри ф. этот параметр можно использовать обычным образом, не принибрегая к оператора "звёздочка" (*), например.

Копировать
void swap (int &x, int &y){
    int temp;
    temp = x;
    x = y;
    y = temp;
}
//вызов
swap (a, b);

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

В языке C++ определенны три спецификатора функций:

  • inline
  • virtual
  • explict

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

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

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

Шаблоны функций

Общая форма определения шаблонной функции имеет следующий вид.

Копировать
tetemplate <class тип> тип_возврата имя_функции (список_параметров)
{
    //тело функции
}
Здесь тип означает метку - заполнител для типа данных, с которыми эта функция фактически будет иметь дело. В операторе template можно определить несколько параметров-типов данных, используя форму списка элементов, разделённых запятыми.

Расмотрим пример.

Копировать
template  void swap (X &a, X &b)
{
    X temp;
    temp = a;
    a = b;
    b = temp;
}
//вызов
int a, b;
float x, y;
swap (a, b);
swap (x, y);

Указатели на функцию

На функцию, как и на любой другой объект языка C, Можно создать указатель. Синтаксиз следующий.

Копировать
тип_возврата (*имя_указателя)(описание_переменных);
Данное объявление создаёт указатель на функцию с именем имя_указателя, в которой содержаться переменные описание_переменных и которая возвращает значение типа тип_возврата.

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

Копировать
имя_указателя = имя_функции;
переменная = имя_указателя (переменные);
Здесь первая строка создаёт ссылку на функцию имя_функции. Вторая строка собсвенно производит вызов функции через указатель имя_указателя, в которую передаються переменные переменные, возврат значения происходит в переменную переменная.

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

Копировать
double y;
double (*p)(doublr x);
p=sin;			//создание указателя на функцию sin()
y = (*p)(2.5);	//вызов
y = p(2.5);		//вызов

//передача функции как параметра
double y;
double f(double (*c)(double x), double y){
    return c(y);	//вызываем переданную функцию в указатель c и возвращаем значение
}
y = f(sin, 2.5);	//передаём функции f функцию sin, а также параметр каторая будет обрабатываться

Создавать массивы указателей на функции так же можно.

Копировать
int f1(void);
int f2(void);
int f3(void);
int (*p)(void) = {f1, f2, f3}

y = (*p[1])();	//вызов функции f2
y = p[2]();		//вызов функции f3

Смотрите также

Шаблоны


Основные операторы

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

В языке C и C++ позволяют использовать следующие сем арифмитических операторов.

Оператор | Действие
- | Вычитание, унарный минус
+ | Сложение
* | Умножение
/ | Деление
% | Деление по модулю
-- | Декримент
++ | Инкремент

Оператор % возвращает остаток от деления нацело.

Эти операторы подченяються следующему порядку действий.

Приоретет | Операторы
Наивысший | ++ -- - (унарный минус) * / %
Низший | + -

Операторы отношений и логические операторы

Оператор | Значение
> | Больше
>= | Больше или равно
< | Меньше
<= | Меньше или равно
== | Равно
!= | Не равно

Определенны следующие логические операторы

Оператор | Значение
&& | И
|| | ИЛИ
! | НЕ

Операторы отношений используються для сравнения, а логические — для объеденения двух значений или, в случае оператора !, для реверсирования значения. Преоритет этих операторов показан в следующей таблице.

Приоритет | Операторы
Наивысший | ! > >= < <= == != &&
Низший | ||

Операторы присваивания

В языках C и C++ оператором присваивания служит одиночный знак равенства (=).


Поразрядные операторы

В языках C и C++ реализованы операторы, которые выполняют действия над битами. Поразрядные операторы можно использовать только с целыми типами.

Оператор | Значение
& | И
| | ИЛИ
^ | Исключающее ИЛИ
~ | Дополнение до 1
>> | Сдвиг вправо
<< | Сдвиг в лево

Операторы &, | и ^

Таблица истиности для операторов &, | и ^ имеет следующий вид.

p | q | p & q | p | q | p ^ q
0 | 0 | 0 | 0 | 0
0 | 1 | 0 | 1 | 1
1 | 1 | 1 | 1 | 0
1 | 0 | 0 | 1 | 1

При выполнении этих поразрядных операций эти правила применяються к каждому биту каждоко оператора. Например.

$ | | | ^
0 1 0 1 1 1 0 1 0 0 1 1 1 0 1 1 0 0 0 0 1 0 0 1 | 0 1 0 0 1 1 0 1 0 0 1 1 1 0 1 1 0 1 1 1 1 1 1 1 | 0 1 0 0 1 1 0 1 0 0 1 1 1 0 1 1 0 1 1 1 0 1 1 0

Оператор дополнения до еденицы

Оператор дополнения до еденицы, ~, будет инвентировать все биты операнда. Например если ch имеет двоичный код
0 0 1 1 1 0 0 1 ,
то после выполнения оператора
ch = ~ch;
двоичный код переменной ch будет иметь вид
1 1 0 0 0 1 1 0 .

Операторы сдвига

Операторы сдвига вправо (>>) и влево (<<) сдвигают все биты целого значения на заданое число разрядов. Их формат следующий.

Копировать
значение >> количество
значение << количество

Здесь количество означает количество позиций, на которое будет сдвинуто значение.

Если двоичный код значения (в предаоложени, что оно не имеет знака) равен
0 0 1 1 1 1 0 1,
то после сдвига вправо получим
0 0 0 1 1 1 1 0,
а после сдвига влево результатом будет
0 1 1 1 1 0 1 0

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

Далее показан приоритет поразрядных операторов.

Приоритет | Операторы
Наивасший | ~ >> << & ^
Низший | |


Операторы присваивания

В языках С и C++ оператором присваивания служит одиночный знак равенства (=). Присваивая "общее" значение сразу нескольким переменным, можно "связать воедино" несколько присваиваний. Например, программная строка

Копировать
а=b=с=10;

присваивает значение 10 переменным а, b и с.

Языки С и C++ поддерживают "сокращенный" вариант некоторых операторов присваивания. Если "полная" версия оператора присваивания выражается в общей форме записи

Копировать
переменная = переменная оператор выражение;,

то запись такого типа можно "сократить" до следующего
"укороченного" варианта:

Копировать
переменная оператор = выражение;.

Например, операторы присваивания

Копировать
х = х+10;
y = y/z;

можно переписать в таком виде:

Копировать
х += 10;
у /= z;


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

Оператор последовательного вычисления (оператор "запятая") указывает на необходимость выполнения некоторой последовательности операций. Значение всего выражения состоящего из списка выражений, разделённых запятыми, равно значению последовательного выражения в этом списке. Например, после выполнения фрагмента программы

Копировать
y = 15;
x = (y=y-5, 50/y);

переменная x примет значение 5, поскольку исходное значение переменной y, равное числу 15, уменьшено на 5, а затем число 50 разделено на полученную разность (10). В результате имеем число 5, которое и присваивается переменной x. Оператор "запятая" можно представить как инструкцию "сделать это, затем то и т.д.".

Оператор "запятая" чаще всего используется в операторе for, как, например, пеказано ниже.

Копировать
for (z=10, b=20; z<b; z++, b--) { // ...

Здесь переменные z и b инициализируются и модифицируются с использованием списка выражений, разделённых запятыми.


Адресные операторы

Адресными называються операторы * и &. Указатель — это переменная, содержащая адрес другого объекта. Эти операторы носят следующий смысл:

  • &
    • — взятие адреса
  • *
    • — возврат значения по указаному адресу

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

Смотрите также

Указатели


Оператор sizeof

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

Копировать
int x;
cout << sizeof x;
cout << sizeof (int);


Операторы привидения типа

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

Копировать
(тип) выражение

Здесь элемент тип означает желаемый тип данных.

Например после выполнения следующей операции приведения типа результат деления заданых чисел будет иметь тип double.

Копировать
double d;
d = (double) 10/3;

Операторы приведения типа в языке C++

Язык C++ поддерживает дополнительные операторы приведения типа: const_cast, dynamic_cast, reinterpret_cast и static_cast. Их общие формы записи выглядят следующим образом.

Копировать
const_cast<тип> (объект)
dynamic_cast<тип> (объект)
reinterpret_cast<тип> (объект)
static_cast<тип> (объект)

Здесь элемент тип задает новый тип, а элемент объект — объект, который должен приобрести новый тип.

Оператор const_cast используется для явного переопределения модификаторов const и/или volatile. Новый тип должен совпадать с исходным типом, за исключением изменения его атрибутов const или volatile. Чаще всего оператор const_cast используется для удаления атрибута const.

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

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

Оператор reinterpret_cast переводит один тип в совершенно другой. Например, его можно использовать для перевода указателя в целый тип. Оператор reinterpret_cast следует использовать для перевода типов указателей, которые несовместимы по своей природе.

Однако следует помнить, что только оператор const_cast может освободить от "обета постоянства", т.е. ни один из остальных операторов этой группы(dynamic_cast, static_cast, reinterpret_cast) не может "снять" с объекта атрибут const.


Операторы ввода-вывода

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

Копировать
входной_поток >> переменная
выходной_поток << выражение

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

Копировать
int i, j;
cin >> i >> j;

После выполнения следующего оператора будет выведена надпись "Это тест 10".

Копировать
cout << "Это тест " << << 10;


Операторы указания на члены .* и ->*

Язык C++ позваляет генерировать специальный тип указателя, который отсылает не к конкретному экземпляру этого члена в объекте, а к члену классы вобще. Данный вид указателя называеться указателем на член. Указатель на член — это совсем не тоже самое, что обычный указатель, поддерживаемый в языке C++. Указатель на член представляет всего лиш смещение в объекте класса, которому этот член может принадлежать. Поскольну указатели на члены не являються настоящими указателями, к ним нельзя применять операторы . и ->. Для получения доступа к члену класса, заданого указателем, необходимо использовать специальные операторы указания на члены .* и ->*.

При доступе к члену объекта, заданного самим объектом или ссылкой на него, используеться оператор .*. При доступе к члену, заданному указателем на объект, используеться оператор ->*.

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

Копировать
тип имя_класса::*ptr;
Здесь тип представляет собой базовый тип члена, имя_класса задаёт имя класса, а ptr — это имя создоваемой переменной указателя на член. После создания элемент ptr можетотсылать к любому члену класса, который имеет тип, заданый элементом тип.

Ниже приведён короткий пример, демонстрирующий использование оператора .*. Обратите внимание на способ указывания на члены.

Копировать
#include <iostream.h>
class cl {
    public:
        cl (int i){ val = i; }
        int val;
        int double_val(){ return val + val; }
};
int main()
{
    int cl::*data;		//указатель на член с именем data типа int
    int (cl::*func)()	//указатель на член с именем func
    cl ob1(1), ob2(2);	//зоздаём объекты

    data = &cl::val;	//получаем смещение
    func = &cl::double_val;	//получаем смещение

    cout << "Вот исходные значения ";
    cout << ob1.*data << " " << ob2.*data << "\n";

    cout << "А теперь они удвоены ";
    cout << (ob1.*func)() << " ";
    cout << (ob2.*func)() << "\n";

    return 0;
}


Оператор расширения области видимости ::

Оператор расширения области видимости :: задаёт область видимости, которой принадлежит некоторый член. Этот оператор имеет следующую форму записи.

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

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

Копировать
::count


Оператор ?

Оператор ? называеться тернальным оператором (поскольку он имеет дело с тремя выражениями). Общая форма его записи такова.

Копировать
выражение1 ? выражение2 : выражение3;

Если выражение1 истенно, то результатом этой операции будет значение операнда выражение2; в противном случае — значение операнда выражение3.


Операторы new и delete

Оператор new

Оператор new выделяет динамическую память и возвращает указатель соответствующего типа на эту область памяти. Общая форма записи этого оператора такова.

Копировать
p_var = new тип;
Здесь p_var — это переменная указателя, которая будет принимать адресс выделенной памяти, а элемент тип представляет собой тип данных, которые будут храниться в этой памяти. Например.
Копировать
double *p;
p = new double;

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

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

Копировать
p_var = new тип (инициализатор);
Здесь инициализатор — это значение, которое будет присвоено выделеной памяти.

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

Копировать
p_var = new тип[размер];
Здесь элемент размер указывает длину массива. При выделении массивов инициализация на производиться.

Оператор delete

Оператор delete освобождает память, на которую указывает аргумент. Эта память предварительно должна быть выделена с помощью оператора new. Общая форма оператора delete следующая.

Копировать
delete p_var;
Здесь p_var — это указатель на ранее выделеную память.

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

Копировать
delete [] p_var


Оператор typeid

В языке C++ оператор typeid возвращает ссылку на объект type_info, описывающий тип объекта, к которому принадлежит оператор typeid. общая форма записи оператора typeid такова.

Копировать
typeid(объект)

Оператор typeid поддерживает в языке C++ возможность индефикации динамической информации о типе (RTTI).

Класс type_info определяет следующие открытые члены.

Копировать
bool operator == (const type_info &ob) const;
bool operator != (const type_info &ob) const;
bool before (const type_info &ob) const;
const char *name() const;

Перегруженные операторы == и != служат для сравнения типов. Функция before() возвращает значение true, если возвращающий объект в порядке сопоставления стоит перед объектом, используемым в качестве параметра. Эта функция предназначена в основном для внутреннего использования. Её значение возврата не имеет нечего общего с наследованием или иерархией классов. Функция name() возвращает указатель на имя типа.

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

В языке C оператор typeid не поддерживаеться.


Перегрузка операторов

Ключевое слово operator используеться для создания перегруженных функций-операторов. Функции-операторы существуют в двух ипостасях: члена и не члена.

Общая форма записи функции-оператора как члена имеет следующий вид.

Копировать
тип_возврата имя_класса :: operator # (список_параметров)
{
    //...
}
Здесь тип_возврата означает тип значения, фозвращаемого функцией, имя_класса — имя класса, для которого перегружаеться этот оператор, а элемент # — сам перегружаемый оператор. При перегрзке унарного оператора список_параметров пуст. Операнд передаёться неявным образом в указателе this. При перегркзке бинарного оператора список_параметров задаёт операнд справа от оператора. Операнд слева передаёться неявным образом в указателе this. Например, следующий код создаёт тип данных "вектор".
Копировать
class vector{
    int x, y, z;
public:
    vector operator+ (vector t);
    vector operator= (vectort);
    vector operator++ (void);
    void show (void);
    void assign (int mx, int my, int mz);
}
vector vector :: operator+ (vector t)
{
    vector temp;
    temp.x = x + t.x;
    temp.y = y + t.y;
    temp.z = z + t.z;
    return temp;
}
vector vector :: operator= (vector t)
{
    x = t.x;
    y = t.y;
    z = t.z;
    return *this;
}
vector vector :: operator++ (void)
{
    x++;
    y++;
    z++
    return *this;
}
void vector :: show (void)
{
    cout << x << ",";
    cout << y << ",";
    cout << z << " \n";
}
void vector :: assign (int mx, int my, int mz)
{
    x = mx;
    y = my;
    z = mz;
}

main (void)
{
    vector a, b, c;
        a.assign (1, 2, 3);
    b.assign (10, 10, 10);
    a.show();
    b.show();

    c = a + b;
    c.show();
    c = a + b + c;
    c.show();

    c++;
    c.show();
}

Что касаеться функций-не членов, функция-оператор имеет следующую форму.

Копировать
тип_возврата operator # (список_параметров)
{
    //...
}
Здесь список_операторов содержит один параметр при пергрузке унарного оператора. При перегрузке бинарного оператора операнд слева передаёться в первом параметре, а операнд справа — во втором параметре.

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

Копировать
typedef struct { char *str} Item;
int operator < (const Item& a, const Item& b)
{
    return strcmp (a.str, b.str) < 0;
}

Применительно к перегрузке оператортов действет несколько ограничений. Нельзя изменять приоритет оператора. Нельзя также изменять количество операндов, требуемых оператором. Нельзя изменять значение оператора, связоного со встроеннымя типами данных языка C++. Нельзя создавать новый оператор. Операторы препроцессора # и ## не могут быть перегруженны. Нельзя перегружать следуещие операторы: . :: .* ?

Дружественные функции-операторы

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

Копировать
class vrctor{
    int x, y, z;
public:
    friend vector operator+ (vector t1, vector t2);
}
vector operator+ (vector t1, vector t2)
{
    vector tmp;
    tmp.x = t1.x + t2.x;
    tmp.y = t1.x + t2.y;
    tmp.z = t1.x + t2.z;
    return temp;
}

Перегрузка операции индексации []

Операция индексации расматриваеться как бинарная операция, где первый операед — объект класса, а второй — йелочисленный индекс. Например.

Копировать
class vector{
    int v[3];
public:
    int& operator[] (int i);
}
int& vector :: operator[] (int i)
{
    return  v[i];
}
//...
v[0] = 100;	//ссылаемся на приватный член с помощью перегруженого оператора []

Перегрузка операции преобразования типа ()

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

Копировать
struct Item{
    int item;
    Item (int t){
        item = t;
    }
    operator int(){
        return item;
    }
};
Item t (11);
cout << (int)t;	//Напечатает число 11


Таблица приорететов операторов

Приоретет | Операторы
Наивысший | ( ) [ ] -> :: . ! ~ ++ -- - * & sizeof new delete typeid операторы приведения типа .* ->* * / % + - << >> < <= > >= == != & ^ | && || ?: = += -= *= /= %= >>= <<= &= ^= |=
Низший | ,


Спецификация компоновки

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

Копировать
extern "язык" прототип_функции

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

Копировать
extern "язык" {
    прототипы_функций
}

Спецификация компоновки применяется в языке C++ и не поддерживается языком С.


Подставляемые (inline) функции

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


Работа с неопределённым числом параметров

Синтаксиз

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

Копировать
тип_возврата имя_функции(список_основных_параметров,
            тип_данных имя_параметра, ...)

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

Макросы-обработчики

Обработка параметров происходит при помощи следующих макросов
• va_start() — указатель списка параметров
• va_arg() — берёт аргумент из списка параметров
• va_end() — закрывает указатель списка параметров
• va_copy() — копирует список аргументов в объект

Они объявлены в загаловке <stdarg.h> и их синтаксиз следующий

Копировать
type va_arg(va_list argptr, type);
void va_copy(va_list target, va_list source);
void va_end(va_list argptr);
void va_start(va_list argptr, last_parm);

Макросы va_arg, va_start и va_end работают вместе, чтобы сделать возможной передачу функции переменного числа аргументов. Самым распространенным примером функции, которая принимает переменное число аргументов, является функция printf(). Тип va_list определен в заголовке <stdarg.h>(а в среде языка C++ — в заголовке <cstdarg>).

Описание

Общая процедура создания функции, которая может принимать переменное количество аргументов, такова. Функция должна иметь по крайней мере один известный параметр(может и больше), указываемый до переменного списка параметров. Крайний справа известный параметр называется last_parm. Его имя используется в качестве второго параметра в обращении к макросу va_start(). Прежде чем можно будет получить доступ к любому параметру из списка параметров переменной длины, необходимо инициализировать указатель на аргумент argptr, обратившись к макросу va_start(). После этого параметры возвращаются посредством обращения к макросу va_arg() с передачей значения параметра type, которое представляет собой тип следующего параметра. Наконец после прочтения всех параметров до возвращения из функции необходимо вызвать макрос va_end(), чтобы гарантировать корректное восстановление стека. Если макрос va_end() не вызывается, высока вероятность аварийного отказа программы.

Пример

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

Копировать
1     1     1      1          1
-  +  -  +  -  +  ——  ...  +  -
2     4     8     16          2n

Результат равен 0.968750.

Копировать
/* Пример списка аргументов переменной длины сумма ряда . * /

#include <stdio.h>
#include <stdarg.h>

double sum_series(int, ...);

int main(void)
{
    double d;

    d = sum_series(5, 0.5, 0.25, 0.125, 0.0625, 0.03125);
    printf("Сумма ряда равна %f\n",d);

    return 0;
}

double sum_series(int num, ...)
{
    double sum = 0.0, t;
    va_list argptr;

    /* Инициализируем указатель argptr. */
    va_start(argptr, num);

    /* Суммируем ряд. */
    for(; num; num--) {
        t = va_arg(argptr, double);
        sum += t;
    }

    /* Реализуем корректное завершение. */
    va_end(argptr);

    return sum;
}


Шаблоны

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

Шаблоны функций

Общая форма определения шаблонной функции имеет следующий вид.

Копировать
tetemplate <class тип> тип_возврата имя_функции (список_параметров)
{
    //тело функции
}

Здесь тип означает метку - заполнител для типа данных, с которыми эта функция фактически будет иметь дело. В операторе template можно определить несколько параметров-типов данных, используя форму списка элементов, разделённых запятыми.

Расмотрим пример.

Копировать
template <class X> void swap (X &a, X &b)
{
    X temp;
    temp = a;
    a = b;
    b = temp;
}
//вызов
int a, b;
float x, y;
swap (a, b);
swap (x, y);

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

Копировать
<class X, class Y>

Шаблоны классов

Общая форма определения шаблонного класса следующаяя.

Копировать
template <class тип_данных> class имя_класса {
//...
};

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

Копировать
имя_класса<тип_данных> объект;

Расмотрим пример.

Копировать
template <class T>
class My{
    T x;
public:
    void Set();
};

template <class T>
int My<T> :: Set(T mx)
{
    T = mx;
}

My<int> c;	//объявление объекта
c.Set(12);

Ключевое слово export

Ключевое слово export может предварять объявление template. Оно позволяет другим файлам использовать шаблон, объявленнй в другом файле путём задания лиш его объявления (вместо дублирования его полного объявления).

Ключевое слово typename

Язык C++ поддерживает ключевое слово typename, которое можно использовать вместо слючегого слова class в объявлении template или для обозначения неопределённого типа.


ООП

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

ООП оперирует следующими терминами:

  • инкапсуляция
  • наследование
  • полифилизм
  • абстракция типов

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

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

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

Смотрите также


Класс

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

Копировать
class имя_класса : список_наследования {
    //Закрытые члены, установленные по умолчанию.
private:
    //Закрытые члены, установленные по умолчанию.
protected:
    //Закрытые члены которые могут быть унаследованы
public:
    //Открытые членны.
} список_объектов;
Здесь имя_класса — это имя типа класса. После компиляции объявление класса имя_класса становиться именем нового типа данных, который можно использовать для объявления объектов класса. Список_объектов — это список объектов типа имя_класса, разделяемых запятыми.Такой список необязателен. Список_наследования указывает наследуемые классы.

Cсылка на члены класса

При выполнении операций над объектом класса для ссылки на отдельные его члены используеться оператор "точка" (.). Оператор "стрелка" (->) используеться для доступа к объекту с помощью указателя. Например, в следующем фрагменте программы доступ к функции putinfo() объекта ob реализуеться с использованием оператора "точка", а к функции show() — с помощью оператора "стрелка".

Копировать
struct cl_type{
    int x;
    float f;
public:
    void putinfo (int a, float t) { x = a; f = t;}
    void show () { cout << a << ' ' << f << endl;}
};

cl_type ob, *p;

ob.putinfo (10, 0.23);
p = &ob;	// помещаем адрес объекта ob в переменную p
p->show();	// отображаем данные объекта ob

Локальные классы

Клас может быть объявлен внутри функции. Такой класс называеться локальным.

Вложенные классы

При объявлении класса внутри его объявления может быть объявлен другой класс или классы. Такой класс называеться вложенным.

Копировать
class Base{
    class nested{
    public:
        nested();
    };
public:
    Base() {...}
};

Base :: nested :: nested()
{
//...
}

Смотрите также


Наследование

В языке C++ один класс может наследовать сваойства другого. Унаследованый класс называеться базовым классом, а класс-наследник — производным классом. Когда класс наследует другой, формируеться иерархия классов. Общая форма наследования классов имеет следующий вид.

Копировать
class имя_класса : спецификатор_доступа имя_базового_класса {
    //...
}

Здесь спецификатор_доступа определяет способ наследования базового класса и указываеться с помощью одного из трёх ключевых слов: private, public или protected. Его можно опустить, в этом случае предпологаеться использование по умолчанию спецификатора public, если базовый класс являеться структурой (struct), или private, если базовый класс являеться классом (class).

Приватные членны(private) не доступны для клиента, откратые членны(public) доступны для клиента, а защищённый режим доступа (protected) используеться когда необходимо унаследовать приватные членны. При наследовании нескольких классов(множественное наследование) используеться список имён классов, разделённых запятыми. Например.

Копировать
class X{
}
class Y{
}
class Z : public X, private Y{
}

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

Базовый класс | Режим наследования | Производный класс
private protected public | public ---------> | Недоступен protected public
private protected public | protected ---------> | Недоступен protected protected
private protected public | private ---------> | Недоступен private private

Конструкторы с параметрами при наследовании

Иногда требуеться при создании производного объекта в программе передавать параметры конструктора базовому классу. В этом случае в определение конструктора, после имени метода и перечислении его параметров, после двоеточия постапить имя базового конструктора с необходимыми параметрами которые будут передаваться.<.p>

Копировать
имя_класса :: имя_класса (параметра_конструктора) : имя_базового_класса (параметры_конструктора_базового_класса) {
    //...
}

Например.<.p>

Копировать
class X{
protected:
    int x;
public:
    X(int i);
};

class Y : public X{
    int y;
public
    Y(int i, j);
};

X :: X(int i){
    x = i;
}

Y :: Y(int i, j) : X(i){	//передача аргумента базовому классу
    y = j;
}

Виртуальные базовые классы

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

Копировать
class Der: Base, Base {...};

В то же время базовый класс может быть передан производному классу более одного раза косвенно:

Копировать
class X: public Base {...};
class Y: public Base {...};
class Derive: public X, public Y {...};

Этот пример соответствует схеме наследования.

Каждый объект класса Derive будет иметь два подобъекта класса Base. Чтобы избежать неоднозначности при обращении к членам базового объекта Base, можно объявить этот класс виртуальным. Для этого используеться ключевое слово virtual.

Копировать
class X: virtual public Base {...};
class Y: virtual public Base {...};
class Derive: public X, public Y {...};

Теперь класс Derive имеет только один подобъект класса Base. Этот пример соответствует схеме.

Смотрите также


Конструкторы и деструкторы

Конструкторы и деструкторы

Класс может включать функцию конструктора и функцию деструктора. Конструктор вызываеться при первоначальном создании объекта класса, а деструктор — при разрушении. Имя конструктора совпадает с именем класса. Функция деструктора имеет имя совпадающеи с именем класса, но ему предшествует символ тильда (~). Следующий пример создаёт точку на плоскости с координатами по умолчанию (0; 0), а при уничтожении выводит сообщение.

Копировать
class point{
    int x, y;
public:
    point (int mx = 0, int my = 0){
        x = mx;
        y = my;
    }
    ~point (void){
        cout << "точка уничтожана";
    }
};

Спецификатор expliclt

Спецификатор expliclt применяеться только к конструкторам. Конструктор, определённый с помощью спецификатора expliclt, будет использоваться только в том случае, если инициализация в точности совпадает с тем, что задано конструктором. Никаких автоматических преобразований выполнено не будет (т.е. спецификатор expliclt создаёт "неконвертирующий конструктор").

Порядок вызова конструкторов

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

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

Копировать
class B1{
public:
    B1(){ cout << "B1 "; }
};
class B2{
public:
    B2(){ cout << "B2 "; }
};
class D: B1, B2{
public:
    D(){ cout << "D"; }
};

D d;	//создание объекта
Выведет: "B1 B2 D".

Виртуальные деструкторы

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

Копировать
class Base{
public:
    Base(){ cout << "B "; }
    ~Base(){ cout << "B "; }
};
class Derive: Base{
public:
    Derive(){ cout << "D "; }
    ~Derive(){ cout << "~D "; }
};

Base *p = new Derive;
delete p;
Выведет: "B D ~B".

Чтобы не допускать таких ситуаций необходимо использовать виртуальный деструктор. Если при объявлении деструктора базового класса он объявляеться как виртуальный, то все конструкторы производных классов также являються виртуальными. При разрушении объекта с помощью оператора delete через указатель на базовый класс будут коректно вызваны деструкторы производных классов.
Копировать
class Base{
public:
    virtual Base(){ cout << "B "; }
    ~Base(){ cout << "B "; }
};
class Derive: Base{
public:
    Derive(){ cout << "D "; }
    ~Derive(){ cout << "~D "; }
};

Base *p = new Derive;
delete p;
Выведет: "B D ~D ~B".


Перегрузка

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

Смотрите также


Дружественные функции

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

Копировать
friend прототип_функции
Например, в следующих классах функция myfunc(), которая не входит в состав классов, являться дружественной по отношению этих классов.
Копировать
class myclass2;		//предварительное объявление класса myclass2;
class myclass1{
    int x;
public:
    frinde void myfunc(myclass1 c1, myclass2 c2, int val);
};

class myclass2{
    int y
public:
    frinde void myfunc(myclass1 c1, myclass2 c2, int val);
};

void myfunc(myclass1 c1, myclass2 c2, int val){
    c1.x=val;
    c2.y=val;
};

myclass1 c1;
myclass2 c2;
myfunc(c1, c2, 2);	/*устанавливаем значение приватным переменным x и y
            объектов c1 и c2 соответственно, значение 2*/

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

Копировать
class my2;
class my1{
    int x;
public:
    set(my2 c){
        my2.y = x;
    }
};
class my2{
    int y;
public:
    friend int my1::set(my2 c);
};

my1 m1; my2 m2;
m1.set(m2);		/*устанавливаем приватную переменную y класса m2
            значением приватной переменной x класса m1*/

Дружественные классы

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

Копировать
class X{...};
class Y{
public:
    friend class X;
};


Ключевое слово this

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

Копировать
class myclass{
    int i;
public:
    void set(int val){ this->i = val; };
};

myclass my, *myp;
my.set(10);


Виртуальные функции

Спецификатор virtual сздайт виртуальную функцию. Виртуальная функция — это член базавого класса, который может быть переопределён производным классом. Елси функция не переопределяетсся производным классом, используеться определение базового класса.

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

Копировать
virtual тип_возврата имя_функции(список_параметров) = 0;
Элемент "= 0" сообщает компилятору, что эта виртуальная функция не имеет определения, связоного с базовым классом.

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

При вызове метода с использованием указателя на базовый класс действуют следующие правила:

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

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

Копировать
class Base
{
public:
    virtual void VM();
    void M();
};
class Derived: public Base
{
public:
    viod VM();
    void M();
};

Derived D;	//объект производного класса Derived;
Derived *pD = &D;	//указатель на объект D классы Derived
Base *pB = &D;		//указатель на объект D классы Base

pB->VM();	//вызов метода VM класса Derived
pD->VM();	//вызов метода VM класса Derived
pB->M();	//вызов метода M класса Base
pD->M();	//вызов метода M класса Derived

/*если бы ключевое слово virtual не стояло в классе B,
 то вызовы производились бы следующим образом*/
pB->VM();	//вызов метода VM класса B
pD->VM();	//вызов метода VM класса Derived
pB->M();	//вызов метода M класса Base
pD->M();	//вызов метода M класса Derived
Итак, было показоно, что виртуальные методы можно использовать для возможности использования методов созданных в производных классах.

Смотрите также


Статистические членны

В языке C++ использование спецификатора ststic для данных-членов класса приводит к созданию только одной копии этих членнов, совместно используемой всеми объектами класса. Например, следующая переменная count может использоваться как счётчик объектов.

Копировать
class my{
    count;
public:
    my(){ count++ }
    ~my(){ count++ }
    static void cnt()
    {
        cout << "Существует объектов: " << count << endl;
    }
}

my x, y, z;
// следующие два вызова дадут одинаковый результат
my.cnt();
my::cnt();

Функции — члены класса также могут быть объявленны статистическими. Статистические функции-члены класса не получают указатель this, соответсвенно эти функции не могут обращаться к нестатистическим членам класса. К статистическим членам класса статистические функции-члены класса могут обращаться посредством операции тичка или стрелка. Статистическая функция-член не может быть виртуальной. К статистическим данным-членам класса и статистическим функциям-членам класса можно обращаться, даже если не создано ни одного объекта данного класса, надо только использовать полное имя члена класса. Если функция a() являеться статистической функцией-членом класса cl, то можно вызвать эту функцию следующим образом.

Копировать
cl::a();

Смотрите также

Спецификатор класса памяти static


new и delete

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

Копировать
double *p;
p = new double;	//создание объекта
delete p;	//удаление объекта

Дополнительную информацию смотрите в источниках указаных ниже.

Смотрите также

Операторы new и delete


Пространства имён

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

Копировать
namespace имя {
    //Объявления
}

Помимо именованных, можно иметь и безымянные пространства имен.

Копировать
namespace {
    //Объявления
}

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

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

Приведем пример использования ключевого слова namespace.

Копировать
namespace MyNameSpace {
    int i, k;
    void myfunc(int j) { cout << j; }
}

Здесь переменные i, k и функция myfunc() являются частью области видимости, определенной пространством имен MyNameSpace.

Поскольку пространство имен определяет область видимости, для доступа к определенным внутри нее объектам необходимо использовать оператор разрешения видимости. Например, чтобы присвоить значение 10 переменной i, необходимо использовать следующий оператор.

Копировать
MyNameSpace::i = 10;

Оператор using

Если члены пространства имен будут использоваться часто, то для упрощения доступа к ним можно применить директиву using. Оператор using имеет две общие формы записи.

Копировать
using namespace имя;
using имя::член;

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

Копировать
using MyNameSpace::k;		//только переменная k сделана видимой
k = 10;				//OK, поскольку переменная k видима
using namespace MyNameSpace;	//все члены MyNameSpace видимы
i = 10;				//OK, поскольку все члены MyNameSpace сейчас видимы


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

В версии С89 определено 32 ключевых слова.

auto — Спецификатор типа для указания компилятору локальной области видимости переменной(по умолчанию)
break — Оператор выхода из цикла
case — Оператор указания варианта выбора(используеться вместе с switch)
char — Символьный тип данных
const — Объекты типа const не могут быть изменены программой во время её выполнения
continue — Оператор продолжения цикла с пропуском оставшися операторов до конца блока
default — Оператор выбора по умолчанию
do — Оператор цикла с постусловием без счётчика
double — Тип данных с плавающей запятой двойной точности
else — Условный оператор "в противном случае"
enum — Пользовательсякий тип данных "перечислеемый тип"
extern — Спецификатор типа для указания компилятору внешней привязки переменной
float — Тип данных с плавающей запятой
for — Оператор цикла с предусловием, с счётчиком
goto — Оператор бузусловного перехода
if — Условный оператор "если"
int — Целочисленный тип данных
long — Модификатор типа данных для определения длинных переменных
register — Спецификатор типа для хранения переменной в регистрах процессора
return — Оператор для возврата из функции значения
short — Модификатор типа данных для определения коротких переменных(обычно не используеться)
signed — Модификатор типа данных для определения знаковых переменных
sizeof — Оператор служащий для определения размера типа данных во время компиляции
static — Указывает компилятору храненить локальную переменную во время всего жизненного цикла программы
struct — Пользовательсякий тип данных "структура"
switch — Оператор выбора
typedef — Оператор для создания нового имени типа данных
union — Пользовательсякий тип данных "объединение"
unsigned — Модификатор типа данных для определения беззнаковых переменных
void — Пустой тип данных
volatile — Квалификатор типа сообщает компилятору, что значение переменной может быть изменено средствами, задаными в програме неявным образом
while — Оператор цикла с предусловием, без счётчика

В языке C++ содержатся все ключевые слова, определен-
ные в версии С89, а также следующие.

asm — Ключевое слово для вставки одной или нескольких инструкций ассемблера
bool — Логический тип данных (версия C++)
catch — Блок программы которая содержит ту часть программы, которая обрабатывает ошибоку
class — Пользовательсякий тип данных "класс"
const_cast — Оператор привидения типа, используется для явного переопределения модификаторов const и/или volatile
delete — Оператор освобождает память на которую указывает аргумент
dynamic_cast — Оператор привидения типа, проверяет законность выполнения заданной операции приведения типа
explicit — Конструктор, определённый с помощью спецификатора expliclt, будет использоваться только в том случае, если инициализация в точности совпадает с тем, что задано конструктором
export — Ключевое слово, позволяющее другим файлам использовать шаблон, объявленнй в другом файле путём задания лиш его объявления.
false — Логическая константа, имеющую значение "ложь".
friend — Ключевое слово определяет дружественные фенкции или классы
inline — Спецификатор используемый для помищения тела функции непосредственно в текст программы
mutable — Спецификатор типа позваляет члену некоторого объекта переопределить свойство постоянства
namespace — Ключевое слово для создания пространства имён
new — Оператор выделяет динамическую память и возвращает указатель соответствующего типа на эту область памяти
operator — Ключевое слово operator используеться для создания перегруженных функций-операторов
private — Спецификатор доступа "приватный", определяющий способ наследования базового класса
protected — Спецификатор доступа "защищённый", определяющий способ наследования базового класса
public — Спецификатор доступа "открытый", определяющий способ наследования базового класса
reinterpret_cast — Оператор привидения типа, переводит один тип в совершенно другой
static_cast — Оператор привидения типа, выполняет неполиморфное приведение типов
template — Ключевое слово template используеться для создания обобщённых функций и классов
this — Используеться для обозначения указателей на объект, который сгенерировал обращение к функции-члену
throw — Оператор throw генерирует исключение
true — Логическая константа, имеющую значение "истина"
try — Блок программы которая содержит ту часть программы, которая предназначена для обработки ошибок
typeid — Оператор typeid возвращает ссылку на объект type_info, описывающий тип объекта, к которому принадлежит оператор typeid
typename — Ключевое слово, которое можно использовать вместо ключегого слова class в объявлении template или для обозначения неопределённого типа
using — Переносит переменную из определённого пространства имён в глобальную область видимости переменных
virtual — Спецификатор типа определяющий виртуальные функции
wchar_t — Символьный двухбайтовый тип данных

В более старых версиях языка C++ было также определено ключевое слово overload, но сейчас оно не используется. Все ключевые слова состоят только из строчных букв.

В версии С99 содержаться все ключевые стлова, определённые в версии C99, а также следующие.

_Bool — Логический тип данных (версия C99)
_Complex — Тип данных для работы с комплексными числами
_Imaginary — Тип данных для работы с комплексными числами
inline — Спецификатор inline сообщает компилятору о намеринии прграммиста поместить тело функции непосредственно в текст программы
restrict — Указатель с атрибутом restrict является изначально единственным средством, позволяющим получить доступ к объекту, на который он указывает


asm

Ключевое слово asm используется для вставки в С++-программу одной или нескольких инструкций ассемблерного кода. Общая форма записи оператора asm имеет следующий вид.

Копировать
asm("инструкция");

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

Многие компиляторы языка C++ позволяют использовать дополнительные формы оператора asm. Например, Borland C++ допускает применение следующих операторов asm.

Копировать
asm инструкция;
asm {
 последовательность_инструкций
}

Здесь последовательность_инструкций означает список инструкций ассемблерного кода.


Обработка исключений

Обработка исключений строится на использовании трех ключевых слов: try, catch и throw. Сначала рассмотрим этот процесс в самых общих чертах. Операторы программы, предназначенные для управления исключениями, содержатся в блоке try. Если исключение (т.е. ошибка) возникает в блоке try, происходит его "выброс" (с помощью оператора throw). "Выброшенное" исключение подхватывается (вернее, перехватывается) с помощью оператора catch и затем обрабатывается. А теперь более детально.

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

Копировать
try{
    //блок_trу
}
catch (тип1 arg) {
    //блок_саtch_l
}
catch (тип2 arg) {
    //блок_catch_2
}
catch (типЗ arg) {
    //блок_сatch_3
}
// . . .
catch (типN arg) {
    //блок_catch_N
}

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

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

Оператор throw генерирует исключение. Вот как выглядит общая форма оператора throw,

Копировать
throw исключение;

Оператор throw должен выполняться либо из самого блока try, либо из любой функции, вызываемой(прямо или косвенно) из блока try. Элемент исключение представляет собой "выбрасываемое" в этот критический момент значение.

Если программа сгенерирует исключение, для которого не найдется соответствующего оператора catch, может произойти аварийное завершение программы. При генерации необработанных исключений будет вызвана функция terminate(). По умолчанию функция terminate() вызывает функцию abort(), предназначенную для останова программы. Однако, используя функцию set_terminate(), можно указать свои обработчики таких ситуаций.

Пример

Копировать
#include <iostream>
using namespace std;
int main()
{
    cout << "Начало\n";
    try { // начало блока try
        cout << "Внутри блока try\n";
        throw 100;		// генерируем ошибку
        cout << "Этот оператор выполнен не будет";
    }
    catch (int i) { 		// перехватываем ошибку
        cout << "Перехватываем исключение - ";
        cout << "значение равно: ";
        cout << i << "\n";
    }

    cout << "Конец";

    return 0;
}

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

Копировать
Начало
Внутри блока try
Перехватываем исключение - значение равно: 100
Конец

Как видите, в программе присутствует блок try, содержащий три оператора, и оператор catch (int i), который обрабатывает исключения целого типа. Внутри блока try будут выполнены только два из трех операторов: первый (из двух) оператор cout и оператор throw. Как только будет сгенерировано исключение, управление сразу перейдет к выражению catch и блок try прекратит свою работу, т.е. оператор catch не вызывается: просто ему передается управление программой. (Для реализации этой передачи стек программы автоматически устанавливается должным образом.) Значит, оператор cout, следующий за оператором throw, никогда не будет выполнен.


Препроцессор и комментарии

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

#define | #elif | #else | #endif
#error | #if | #ifdef | #ifndef
#include | #line | #pragma | #undef

Смотрите также

#define
#pragma
#error
#if, #ifdef, #ifndef, #else, #elif и #endif
#include
#line
#undef
Операторы препроцессора # и ##
Зарезервированные имена макросов
Комментарии
Списки с переменным количеством аргументов


#define

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

Копировать
#define имя_макроса последовательность_символов

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

Например, если вы хотите использовать значение 1 для слова TRUE и значение 0 для слова FALSE, объявите эти два макроса с помощью отдельных директив tdef ine.

Копировать
#define TRUE 1
#define FALSE 0

Данные операторы вынудят компилятор подставлять 1 или 0 каждый раз, когда встретится слово TRUE или FALSE соответственно.

Совет программисту

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

Копировать
ABS(1O-20)

было бы преобразовано в выражение

Копировать
10-20<0 ? -10-20 : 10-20.

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

Директива #define имеет еще один (более сложный) вариант применения: макрос может иметь аргументы. Макрос, который принимает аргументы, действует во многом подобно функции. Он и выглядит как функция, оставаясь при этом макросом, или макроопределением. Каждый раз, когда компилятор обнаруживает такой макрос, его аргументы заменяются реальными аргументами, заданными в программе, как, например, показано ниже.

Копировать
#include <iostream>
using namespace std;

#define ABS(a) ((a)<0 ? -(a) : (a))

int main()
{
    cout << "abs of -1 and 1: " << ABS(-l) << ' ' << ABS(1);

    return 0;
}

При компиляции этой программы переменная а в макроопределении будет заменена значениями -1 и 1.


#pragma

Работа директивы #pragma зависит от конкретной реализации компилятора. Она позволяет выдавать компилятору различные инструкции. Например, компилятор способен поддерживать трассировку выполнения программы. Заставить компилятор работать в режиме трассировки можно именно с помощью оператора #pragma. Для получения подробной информации о возможных вариантах использования директивы ffpragma обратитесь к системной документации по используемому вами компилятору.

Оператор _Pragma в версии С99

Версия С99 включает еще один способ выдачи указаний компилятору с помощью оператора _Pragma. Общая форма записи такова.

Копировать
_Pragma ("директива")

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

Встроенные прагмы версии С99

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

Прагма | Значение
STDC FP_CONTRACT ON/OFF/DEFAULT | Во включенном состоянии (ON) с выражениями с плавающей точкой компилятор обращается, как с неделящимися нацело элементами, которые обрабатываются аппаратными методами. Стандартное состояние определяется конкретной реализацией
STDC FENV_ACCESS ON/OFF/DEFAULT | Сообщает компилятору о возможности доступа к среде вычислений с плавающей точкой. Стандартное состояние определяется конкретной реализацией
STDC CX_LIMITED_RANGE ON/OFF/DEFAULT | Во включенном состоянии (ON) сообщает компилятору, что определенные формулы, содержащие комплексные значения, безопасны для использования. Стандартное состояние - отключенное (OFF)


#error

Директива #error дает указание компилятору остановить компиляцию. Она используется в основном для отладки. Общая форма ее записи такова.

Копировать
#error сообщение

При встрече с директивой #error отображается заданное сообщение и номер строки.


#if, #ifdef, #ifndef, #else, #elif и #endif

Директивы #if, #ifdef, #ifndef, #else, #elif и #endif используются для избирательной компиляции различных фрагментов программы. Главная идея состоит в том, что если выражение, стоящее после директив #if, #ifdef и #ifndef, оказывается истинным, то будет скомпилирован код, расположенный между одной из этих трех директив и директивой #endif; в противном случае данный код будет опущен. Директива #endif используется для обозначения конца блока #if. Директиву #else можно использовать с любой из перечисленных выше директив для предоставления альтернативного варианта компиляции.

Общая форма записи директивы #if выглядит так.

Копировать
#if константное_выражение

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

Общая форма записи директивы #ifdef такова.

Копировать
#ifdef имя_макроса

Если имя_макроса определено в операторе #define, то будет скомпилирован блок кода, следующий за оператором #ifdef.

Общая форма записи директивы #ifndef такова.

Копировать
#ifndef имя_макроса

Если имя_макроса не определено в операторе #define, то будет скомпилирован блок кода, следующий за оператором #ifndef.

Вот пример совместной работы некоторых директив препроцессора.

Копировать
#define ted 10

///...

#ifdef
    ted cout << "Привет, Тэд\n";
#endif
    cout << "Привет, Джон\n";
#if 10<9
    cout << "Привет, Жорж\n";
#endif

В результате выполнения этого фрагмента программы на экран будут выведены фразы "Привет", "Тэд" и "Привет, Джон", а фраза "Привет, Жорж" - нет.

Директива #elif используется для создания оператора if-else-if. Его общая форма имеет такой вид.

Копировать
#elif выражение_константа

Для обработки сразу нескольких альтернатив можно использовать ряд директив #е1if.

С помощью директив #if и #elif и оператора предпроцес-сорной обработки defined можно также выяснить, определено ли имя конкретного макроса директивой препроцессора define. Для этого используется следующая общая форма записи.

Копировать
#if defined имя_макроса
последовательность_операторов
#endif

Если имя_макроса определено, последователь-ность_операторов будет скомпилирована. В противном случае она будет опущена. Например, в следующем фрагменте условный оператор компилируется, поскольку имя макроса DEBUG определено в программе.

Копировать
#define DEBUG
//...
int i=100;
//...
#if defined DEBUG
    cout << "Значение переменной i равно: " << i << endl;
#endif

Можно также оператор defined предварить оператором отрицания (!), и тогда условная компиляция будет выполнена в случае, если заданное имя макроса не определено.


#include

Директива #include заставляет компилятор прочитать и скомпилировать указанный исходный файл. Для записи этой директивы используются следующие общие формы.

Копировать
#include "имя_файла"
#include <имя_файла>

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

Копировать
#include <MyFuncs.h>

заставит компилятор прочитать и скомпилировать файл MyFuncs.h.

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

Помимо включения файлов, С/С++-программы используют директиву #include для включения заголовков. В языках С и C++ определен набор стандартных заголовков, которые предоставляют информацию, необходимую для различных библиотек (т.е. под заголовком может подразумеваться файл, но это совсем необязательно). Таким образом, заголовок - это просто абстракция, которая гарантирует включение соответствующей информации. Однако на практике С-заголовки почти всегда являются файлами, а имена заголовков - действительными именами файлов. Но для языка C++ ситуация совсем иная. Все имена С++-заголовков представляют собой стандартные идентификаторы, которые компилятор может преобразовать в имена файлов или обработать каким-либо другим способом. А поскольку С++-заголовки не являются именами файлов, они не имеют расширения . п. Например, чтобы включить заголовочную информацию для системы ввода-вывода, используйте следующий оператор.

Копировать
#include <iostream>

Здесь <iostream> - стандартный заголовок для классов ввода-вывода.


#line

Директива #line используется для изменения содержимого псевдопеременных __LINE__ и __FILE__, которые являются зарезервированными идентификаторами. Базовая форма записи этой команды имеет следующий вид.

Копировать
#line номер "имя_файла"

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

Идентификатор __LINE__ имеет целый тип, а псевдопеременная __FILE__ определена как строка с завершающим нулевым символом.

Например, следующий фрагмент программы устанавливает текущий счетчик строк равным 10, а имя файла - строке "test".

Копировать
#line 10 "test"


#undef

Директива #undef удаляет определенное ранее имя макроса. Общая форма записи такова.

Копировать
#undef имя_макроса

Например, в фрагменте программы

Копировать
#define LEN 100
#define WIDTH 100

char array[LEN][WIDTH];

#undef LEN
#undef WIDTH

/* С этого момента идентификаторы LEN и WIDTH не
определены.
*/

идентификаторы LEN и WIDTH определены до тех пор, пока не встретятся соответствующие операторы #undef.


Операторы препроцессора # и ##

В языках С и C++ предоставляется возможность работы с двумя операторами препроцессора: # и ##. Эти операторы используются в директиве определения макроса #define.

Оператор # превращает аргумент, которому он предшествует, в строку, заключенную в кавычки. Рассмотрим, например, следующую программу.

Копировать
#include <iostream>
using namespace std;

#define mkstr(s) # s

int main()
{
    cout < mkstr(Я люблю C++);

    return 0;
}

Препроцессор превратит строку

Копировать
cout << mkstr(Я люблю C++);

в строку

Копировать
cout << "Я люблю C++";.

Оператор ## используется для конкатенации двух лексем. Например, в программе

Копировать
#include <iostream>
using namespace std;

#define concat(a, b) a ## b

int main()
{
    int xy = 10;

    cout < concat(x, y);

    return 0;
}

препроцессор превратит строку

Копировать
cout << concat(x, у);

в строку

Копировать
cout << xy;

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


Зарезервированные имена макросов

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

Копировать
__LINE__
__FILE__
__DATE__
__TIME__
__cplusplus

Макросы __LINE__ и __FILE__ описаны при рассмотрении директивы #line выше в этой главе. Остальные приводятся ниже.

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

Время трансляции исходного файла в объектный код содержится в виде строки в макросе __Т1МЕ__. Формат строки следующий: часы:минуты:секунды.

Макрос __cplusplus определяется при компиляции С++-программы. Этот макрос не определяется компилятором языка С. Макрос __STDC__ определяется при компиляции С-программы и может быть определен компилятором языка C++. В обоих случаях за деталями лучше обратиться к системной документации по используемому вами компилятору.

Большинство компиляторов C/C++ определяют несколько других встроенных макросов, которые связаны с конкретной средой и реализацией.

Дополнительные встроенные макросы, определенные в версии С99

В версии С99 к описанным выше макросам добавлены следующие макросы. Они не поддерживаются в языке C++.

__STDC_HOSTED__ | 1, если операционная система присутствует
__STDC_VERSION__ | 199901L или больше: представляет версию языка С
__STDC_IEC_559__ | 1, если поддерживается арифметика с плавающей запятой IEC 60559
__STDC_IEC_559_COMPLEX__ | 1, если поддерживается арифметика комплексных чисел IEC 60559
__STDC_ISO_10646__ | Значение в формате yyyymmL, сообщающее год и месяц поддерживаемой компилятором спецификации ISO/IEC 10646


Комментарии

В языке C++ и версии С99 определены два стиля комментариев. Первый - многострочный. Он начинается с символов /* и завершается символами */. Все, что находится между символами комментария, компилятор игнорирует. Многострочный комментарий может занимать несколько строк.

Второй тип комментария - однострочный. Он начинается с символов // и завершается в конце той же строки.

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


Списки с переменным количеством аргументов

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

Копировать
#define МуМах(...) max(__VA_ARGS__)

оператор

Копировать
МуМах(а, Ь);

преобразуется в оператор

Копировать
max(а, b);

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

Копировать
#define compare(compfunc, ...) compfunc(__VA_ARGS__)

оператор

Копировать
compare(strcmp, "one", "two");

преобразуется в оператор

Копировать
strcmp("one", "two");

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


Стандартные библиотеки С и C++

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

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

Заголовок | Что поддерживает
<assert.h> | Макрос assert()
<ctype.h> | Обработка символов
<errno.h> | Сообщения об ошибках
<float.h> | Значения с плавающей точкой, зависящие от конкретной реализации компилятора
<iso646.h> | Макросы, соответствующие различным операторам, например && и ^. Добавлено в 1995 году (Поправка 1)
<limits.h> | Различные ограничения, зависящие от конкретной реализации компилятора
<locale.h> | Функция setlocale()
<math.h> | Различные определения, используемые библиотекой math
<setjmp.h> | Нелокальные переходы
<signal.h> | Значения сигналов
<stdarg.h> | Списки аргументов переменной длины
<stddef.h> | Распространенные константы
<stdiо.h> | Ввод-вывод файлов
<stdlib.h> | Смешанные объявления
<string.h> | Функции обработки строк
<time.h> | Функции системного времени и даты
<wctype.h> | Функции обработки многобайтовых слов и двубайтовых символов. Добавлено в 1995 году (Поправка 1)
<wchar.h> | Функции классификации многобайтовых слов и двубайтовых символов. Добавлено в 1995 году (Поправка 1)

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

Заголовок | Что поддерживает
<complex.h> | Арифметика комплексных чисел
<fenv.h> | Флажки (признаки) состояния и другие аспекты среды обработки чисел с плавающей точкой
<inttypes.h> | Стандартный переносимый набор имен целочисленных типов; также функции, обрабатывающие целые числа самого широкого формата
<stdbool.h> | Логические типы данных; также определяет макрос bool, способствующий достижению совместимости с языком C++
<stdint.h> | Стандартный переносимый набор имен целочисленных типов. Этот файл включен в заголовок <inttypes.h>
<tgmath.h> | Стандартный переносимый набор имен целочисленных типов. Этот файл включен в заголовок <inttypes.h>

В современной спецификации для языка C++ заголовки указываются с использованием стандартных имен заголовков, которые не имеют расширения .h (т.е. заголовки C++ не означают имена файлов). Это просто стандартные идентификаторы, которые компилятор может обрабатывать так, как считает нужным (т.е. заголовок может быть преобразован в имя файла, но это вовсе необязательно). С++-заголовки приведены ниже. Указанная в скобках аббревиатура STL означает прямую или косвенную связь данного заголовка со стандартной библиотекой шаблонов (Standard Template Library).

Заголовок C++ | Что поддерживает
<algorithm> | Различные операции на контейнерах (STL)
<bitset> | Битовые множества (STL)
<complex> | Комплексные числа
<deque> | Двухсторонние очереди (STL)
<exception> | Обработка исключительных ситуаций
<fstrearn> | Работа с файловыми потоками для чтения и записи в один и тот же файл
<functional> | Различные объекты-функции (STL)
<iomanip> | Манипуляторы ввода-вывода
<ios> | Классы ввода-вывода нижнего уровня
<iosfwd> | Упреждающие объявления для систем ввода-вывода
<iostream> | Стандартные классы ввода-вывода
<istream> | Обработка входных потоков
<iterator> | Доступ к содержимому контейнеров (STL)
<limits> | Различные ограничения реализации
<list> | Линейные списки (STL)
<locale> | Информация, связанная с традициями конкретных стран или географических регионов
<map> | Отображения (ключи и значения) (STL)
<memory> | Распределение памяти с помощью распределителей памяти (STL)
<new> | Выделение памяти с помощью оператора new
<numeriс> | Универсальные операции над числами
<ostream> | Обработка выходных потоков
<queue> | Очереди (STL)
<set> | Множества (STL)
<sstream> | Обработка строковых потоков
<stack> | Стеки(SLT)
<stdexcept> | Стандартные исключительные ситуации
<streambuf> | Буферизированная обработка потоков
<string> | Стандартный класс string (STL)
<typeinfo> | Динамическая информация о типе
<utility> | Шаблоны общего назначения (STL)
<valarray> | Операции над массивами, содержащими значения
<vector> | Векторы (динамические массивы) (STL)

В языке C++ также определены следующие заголовки, которые соответствуют С-заголовкам.

<cassert> | <cctype> | <cerrno>
<cfloat> | <ciso646> | <climits>
<clocale> | <cmath> | <csetjmp>
<csignal> | <cstdarg> | <cstddef>
<cstdio> | <cstdlib> | <cstring>
<ctime> | <cwchar> | <cwctype>

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

Копировать
using namespace std;

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

Совет программисту

Если вы используете более старый компилятор C++, то может оказаться, что он не поддерживает С++-заголовки нового стиля или команду namespace. В этом случае вам придется использовать заголовки более старого традиционного стиля. Это значит, что к тем же самым именам заголовков нужно добавить расширение .h, после чего они будут напоминать С-заголовки. Например, так выглядит включение заголовка <iostream> при использовании традиционного подхода.

Копировать
#include <iostream.h>

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


Ввод-вывод в окне

Некоторые функции равотают только в системе DOS.

Смотрите также

window - создание окна
clreol - очистка строки
clrscr - очистка текущего окна

gotoxy - установка курсора в указаную позицию
wherex - возврат координаты x положения курсора
wherey - возврат координаты y положения курсора

insline - вставка строки
delline - удаление строки

cprintf - форматированый ввод в активное окно
cputs - вывод строки в активное окно
putch - вывод символа в активное окно
getche - ввод символа из активного окна
cgets - ввод строки из активного окна
cscanf - форматированный ввод


cgets()

#include <conio.h>

char* cgets()

Параметры

char *str

Описание

Ввод строки из активного окна

Смотрите также

printf - запись в поток
scanf - чтение из потока
cprintf - форматированый ввод в активное окно
cputs - вывод строки в активное окно
putch - вывод символа в активное окно
getche - ввод символа из активного окна
cscanf - форматированный ввод


cprintf()

#include <conio.h>

int cprintf()

Параметры

const char | *format | строка форматирования
... |  | переменные

Описание

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

Ф. аналогична функции printf() за исключением того, что вывод происходит в текущее окно. Также она не разбивает символ '\n' на '\n\r'.

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

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

Описание спецификации формата приведено в функции printf. В отличие от функций fprintf и printf, cprintf не преобразует символы перевода строки (\n) в последовательность перевода каретки/перевода строки (\r\n).

Пример.

Копировать
#include <conio.h>
int main(void)
{
    /* очистить экран */
    clrscr();
    /* создать текстовое окно */
    window(10,10,80,25);
    /* вывести в него некоторый текст */
    cprintf("Привет !!!\r\n");
    /* ждать нажатия клавиши */
    getch();
    return 0;
}

Смотрите также

printf - запись в поток
scanf - чтение из потока
cputs - вывод строки в активное окно
putch - вывод символа в активное окно
getche - ввод символа из активного окна
cgets - ввод строки из активного окна
cscanf - форматированный ввод


cputs()

#include <conio.h>

int cputs()

Параметры

const char *str выводимая строка

Описание

Вывод строки в активное окно

Ф. выводит строку str, заканчивающуюся нулем, в текущее текстовое окно. К строке не присоединяется символ новой строки.

Строка выводится напрямую в память экрана при помощи вызова BIOS, в зависимости от значения в directvideo.

В отличие от функции puts, cputs не преобразует символы перевода строки (\n) в последовательность перевода каретки/перевода строки (\r\n).

Копировать
#include <conio.h>
int main(void)
{
    /* очистить экран */
    clrscr();
    /* создать текстовое окно */
    window(10,10,80,25);
    /* вывести в него некоторый текст */
    cputs("Вывод в окно \r\n");
    /* ждать нажатия клавиши */
    getch();
    return 0;
}

Смотрите также

printf - запись в поток
scanf - чтение из потока
cprintf - форматированый ввод в активное окно
putch - вывод символа в активное окно
getche - ввод символа из активного окна
cgets - ввод строки из активного окна
cscanf - форматированный ввод


cscanf()

#include <conio.h>

int cscanf()

Параметры

const char | *format | строка форматирования
... |  | переменные

Описание

Форматированный ввод из активного окна

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

Пример.

Копировать
#include <conio.h>
int main(void)
{
    char string(80);
    /* очистить экран */
    clrscr();
    /* запросить ввод от пользователя */
    cprintf("Введите строку:");
    /* считать строку */
    cscanf("%s",string);
    /* вывести введенную строку */
    cprintf("Вы ввели следующую строку: %s",string);
    return 0;
}

Смотрите также

printf - запись в поток
scanf - чтение из потока
cprintf - форматированый ввод в активное окно
cputs - вывод строки в активное окно
putch - вывод символа в активное окно
getche - ввод символа из активного окна
cgets - ввод строки из активного окна


getche()

#include <conio.h>

int getche(void)

Параметры

void

Описание

Ввод символа из активного окна

Смотрите также

printf - запись в поток
scanf - чтение из потока
cprintf - форматированый ввод в активное окно
cputs - вывод строки в активное окно
putch - вывод символа в активное окно
cgets - ввод строки из активного окна
cscanf - форматированный ввод


putch()

#include <conio.h>

int putch()

Параметры

int | c

Описание

Вывод строки в активное окно

Смотрите также

printf - запись в поток
scanf - чтение из потока
cprintf - форматированый ввод в активное окно
cputs - вывод строки в активное окно
getche - ввод символа из активного окна
cgets - ввод строки из активного окна
cscanf - форматированный ввод


window()

#include <conio.h>

void window()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата

Описание

Создание окна

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


directvideo

Синтаксиз:

Копировать
extern int directvideo;

directvideo управляет выводом на консоль (из cputs, например) напрямую через видео RAM (directvideo=1) или через вызов ROM BIOS (directvideo=0). Значением по умолчанию является directvideo=1 (консольный вывод идет напрямую через видео RAM). Чтобы использовать directvideo=1, видео контроллер должен быть идентичным по отношению к IBM. Установка directvideo=0 позволяет выводить на консоль на любом компьютере, совместимом по IBM BIOS.


_wscroll

Разрешает или запрещает скроллинг в функциях ввода/вывода на консоль.

Синтаксиз:

Копировать
_extern int _wscroll;
_wscroll это флаг прокрутки функций ввода/вывода на консоль. По умолчанию он равен 1. Установка флага в 0 запретит прокрутку. Это удобно при выводе у краев экрана, когда прокрутка не нужна.


highvideo()

#include <conio.h>

void highvideo(void)

Параметры

void

Описание

Устанавливает бит интенсивности

Ф. устанавливает, что далее будут выводится символы с высокой интенсивностью. Она делает это, устанавливая бит интенсивности в текущем цвете. Эта функция не влияет на текущее содержимое экрана, а лишь работу функций, осуществляющих прямой вывод на экран в текстовом режиме (типа cprintf).

Копировать
#include <conio.h>
int main(void)
{
    lowvideo();
    cprintf("Текст низкой интенсивности");
    highvideo();
    gotoxy(1,2);
    cprintf("Текст высокой интенсивности");
    return 0;
}

Смотрите также

lowvideo - устанавливает низкую интенсивность выводимых символов


lowvideo()

#include <conio.h>

void lowvideo(void)

Параметры

void

Описание

Устанавливает низкую интенсивность выводимых символов

Ф. обнуляет бит интенсивности в поле атрибутов текущего цвета символов.

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

Копировать
#include <conio.h>
int main(void)
{
    clrscr();
    lowvideo();
    cprintf("Текст низкой интенсивности");
    highvideo();
    gotoxy(1,2);
    cprintf("Текст высокой интенсивности");
    return 0;
}

Смотрите также

highvideo - установка бита интенсивности


textmode()

#include <conio.h>

void textmode()

Параметры

int mode режим

Описание

Изменение текстового режима.

Данная ф. устанавливает указаный режим, который по умолчанию обычно: 80x25.

Имеютсья следующие режимы:

Макрос | Величина | Режим
BW40 | 0 | 40ч25, чёрно-булый
C40 | 1 | 40x25, цветной
BW80 | 2 | 80x25, чёрно-белый
C80 | 3 | 40x25, цветной
MONO | 7 | 80x25, монохромный
LASTMODE | -1 | предедущий режим
C4350 | 64 | EGA 80x43 VGA 80x50, цветной


gotoxy()

#include <conio.h>

void gotoxy()

Параметры

int | x | координата x
int | y | координата y

Описание

Перемещение курсора

Ф. перемещает курсор в текстовом окне в указанную позицию. Если координаты указаны неверно, вызов данной функции игнорируется. Например, это произойдет при вызове gotoxy(40,30) когда окно имеет размеры 35 на 25.

Смотрите также

wherex - возврат координаты x положения курсора
wherey - возврат координаты y положения курсора


wherex()

#include <conio.h>

int wherex(void)

Параметры

void

Описание

Возврат координаты x текущего положения курсора

Смотрите также

gotoxy - установка курсора в указаную позицию
wherey - возврат координаты y положения курсора


wherey()

#include <conio.h>

int wherey(void)

Параметры

void

Описание

Возврат координаты y текущего положения курсора

Смотрите также

gotoxy - установка курсора в указаную позицию
wherey - возврат координаты y положения курсора


_setcursortype()

#include <conio.h>

void _setcursortype()

Параметры

Описание

Определяет вид курсора

Устанавливает вид курсора, в зависимости от значений:

  • _NOCURSOR - выключает курсор
  • _SOLIDCURSOR - курсор в виде блока
  • _NORMALCURSOR - обычный курсор в виде подчеркивания
Копировать
#include <conio.h>
int main(void)
{
    /* вывести обычный курсор */
    cprintf("\r\nНормальный курсор:");
    getch();
    /* выключить курсор */
    _setcursortype(_NOCURSOR);
    cprintf("\r\nНет курсора:");
    getch();
    /* курсор в виде блока */
    _setcursortype(_SOLIDCURSOR);
    cprintf("\r\nКурсор в виде блока:");
    getch();
    /* вернуть обычный курсор */
    cprintf("\r\nНормальный курсор:");
    getch();
    return 0;
}


clreol()

#include <conio.h>

void clreol(void)

Параметры

void

Описание

Очистка строки с текущей позиции курсора до правой границы окна

Смотрите также

clrscr - очистка окна


clrscr()

#include <conio.h>

void clrscr(void)

Параметры

void

Описание

Очищает окно в текстовом режиме

Ф. очищает активное текстовое окно и перемещает курсор в верхний левый угол окна.

Смотрите также

clreol - очистка строки


delline()

#include <conio.h>

void delline(void)

Параметры

void

Описание

Очистка строки в которой находиться курсор

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

Смотрите также

insline - вставка строки


getpass()

#include <conio.h>

char* getpass()

Параметры

char *promt сообщение

Описание

Вводит пароль

Ф. считывает пароль с системной консоли после выдачи на экран специального сообщения - символьной строки с нулевым окончанием (prompt) и отменяет отображение пароля на экране. Возвращаемый в результате работы функции указатель адресует строку символов с нулевым окончанием длиной до 8 символов (не считая нулевое окончание) - пароль.


gettext()

#include <conio.h>

int gettext()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата
void | *destin | область памяти в которую происходит перемещение

Описание

Сохранение содержания части экрана

Смотрите также

puttext() — востановление содержания части экрана
movetext() — перемещение содержания части экрана


insline()

#include <conio.h>

void insline(void)

Параметры

void

Описание

Вставка пустой строки

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

Смотрите также

delline - удаление строки


movetext()

#include <conio.h>

int movetext()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата
int | destleft | новая левая координата
int | desttop | новая правая координата

Описание

Перемещение содержания части экрана

Смотрите также

gettext() — сохранение содержания части экрана
puttext() — востановление содержания части экрана


puttext()

#include <conio.h>

int puttext()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата
void | *source | область памяти из которой происходит востановление

Описание

Востановление содержания части экрана

Смотрите также

gettext() — сохранение содержания части экрана
movetext() — перемещение содержания части экрана


textbackground()

#include <conio.h>

void textbackground()

Параметры

int color цвет

Описание

Установка цвета фона

Ф. устанавливает цвет фона указаный в параметре color. Использовать цвет могут только специальные функции связанные с окном. Такие функции как printf(), для этого не предназначены. Аргумент color может принимать следующие значения.

Макрос | Код
BLACK | 0
BLUE | 1
GREEN | 2
CYAN | 3
RED | 4
MAGENTA | 5
BROWN | 6
WHITE | 15

Смотрите также

textcolor()Изменение цвета выдаваемого текста.


textcolor()

#include <conio.h>

void textcolor()

Параметры

int color цвет

Описание

Изменение цвета выдаваемого текста.

Ф. устанавливает цвет символов указаный в параметре color. Использовать цвет могут только специальные функции связанные с окном. Такие функции как printf(), для этого не предназначены. Аргумент color может принимать следующие значения.

Макрос | Код
BLACK | 0
BLUE | 1
GREEN | 2
CYAN | 3
RED | 4
MAGENTA | 5
BROWN | 6
LIGHTGREY | 7
DARKGREY | 8
LIGHTBLUE | 9
LIGHTGREEN | 10
LIGHTCYAN | 11
LIGHTRED | 12
LIGHTMAGENTA | 13
YELLOW | 14
WHITE | 15
BLINK | 128

Для того чтобы сделать цвет магающим, надо применить побитовую операцию "OR" к цвету и величине BLINK. Например, чтобы выводить текст красныма мигающими символами напишем следующее.

Копировать
textcolor(RED|BLINK);

Смотрите также

textbackground() — установка цвета фона


getch()

#include <conio.h>

int getch(void)

Параметры

void

Описание

Вводит символ с консоли без эхопечати

Функция getch читает один символ, непосредственно с консоли, без вывода его на экран. Ф. уникальна для DOS.

Пример.

Копировать
#include <conio.h>
#include <stdio.h>
int main(void)
{
    int c;
    int extended = 0;
    c = getch();
    if(!c)
        extended = getch();
    if(extended)
        printf("Расширенный символ\n");
    else
        printf("Не расширенный символ\n");
    return 0;
}


kbhit()

#include <conio.h>

int kbhit(void)

Параметры

void

Описание

Производит проверку: есть ли символы в буфере клавиатуры

Ф. проверяет, была ли нажата какая-либо клавиша клавиатуры. Нажатая клавиша может быть определена с помощью функций getch или getche.

Копировать
#include <conio.h>
int main(void)
{
    cprintf("Для продолжения нажмите любую клавишу:");
    while(!kbhit())  /* пустой цикл */
    cprintf("\r\nБыла нажата клавиша ");
    return 0;
}

Смотрите также

getch - ввод символа с консоли без эхопечати
getche - ввод символа из активного окна


Графический режим

Инициализация и обработка ошибок

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима

getdrivername() — возвращает указатель на строку, содержащую имя текущего графического драйвера
getmaxmode() — возвращает максимальный номер режима для текущего драйвера

getaspectratio() — возвращает текущее характеристическое отношение ширины изображения к его высоте графического режима
setaspectratio() — установка коэфициента сжатия

getgraphmode() — возвращает текущий графический режим
getmodename() — возвращает указатель на строку, содержащую имя указанного графического режима
getmoderange() — получает диапазон режимов для данного графического драйвера

graphdefaults() — переустанавливает все графические параметры в их начальные значения

installuserdriver() — добавляет дополнительные драйверы устройств в таблицу драйверов устройств BGI
installuserfont() — загружает файл со шрифтом

Фигуры

line() — рисует линию между двумя указанными точками
linerel() — рисует линию на заданное расстояние от текущей позиции CP
lineto() — рисует линию от текущей позиции

circle() — исует окружность заданного радиуса
ellipse() — элептическая дуга
arc() — дуга окружности
getarccoords() — выдает координаты последнего обращения к функции arc
ellipse() — элептическая дуга

rectangle() — рисует прямоугольник
drawpoly() — рисует контур многоугольника

getx() — возвращает координату x текущей графической позиции
gety() — возвращает координату y текущей графической позиции
moveto() — изменение значения текущего положения пера (CR)

Заполненые фигуры

bar() — прямоугольник
bar3d() —
fillpoly() — рисует и закрашивает многоугольник

fillellipse() — рисует и закрашивает эллипс
sector() — рисует заполненый элептический сектор
pieslice() — рисует заполненый сектор круга

Цвет и заливка

setcolor() — установка цвета
getcolor() — возвращает текущий цвет рисунка
getmaxcolor() — возвращает максимальное значение цвета, которое может быть передано функции setcolor
setbkcolor() — установка цвета фона
getbkcolor() — возвращает текущий цвет фона

putpixel() — установить цвет пикселя
getpixel() — возвращает цвет заданной точки

Работа с палитрой

setpalette() — изменение цвета в палитре
getpalette() — получает информацию о текущей палитре
setrgbpalette() — изменение цвета в палитре по системе RGB
getdefaultpalette() — возвращает структуру определения палитры
getpalettesize() — возвращает размер справочной таблицы цветов палитры

Стиль и заливка

floodfill() — заполняет ограниченную область
setfillstyle() — устанавливает цвет и шаблон заполнения
getfillsettings() — получает информацию о текущем шаблоне и цвете заполнения
setfillpattern() — задаёт шаблон заполнения определяемый пользователем
getfillpattern() — возвращает определенный пользователем шаблон заполнения

setlinestyle() — установка ширины и стиля линии
getlinesettings() — получает текущий цвет линии, шаблон и толщину

Окна и страницы

cleardevice() — очистка активной страницы
setactivepage() — устанавливает номер активной сраницы
setvisualpage() — устанавливает номер выводимой страницы

clearviewport() — очищает текущее окно
setviewport() — создаёт графическое окно
getviewsettings() — вызывает информацию об активном окне

getmaxx() — возвращает максимальную координату х экрана
getmaxy() — возвращает максимальную координату y экрана

Графические образы

getimage() — запоминает в битовый образ некоторой области экрана
imagesize() — возвращает количество байтов, требуемых для хранения битового образа
putimage() — помещает на экран ранее записаный в память образ

Текст

outtext() — выводит строку на экран с текущей позиции
outtextxy() — выводит строку на экран с заданой позицией

settextstyle() — устанавливает шрифт, стиль и коэфициент увеличения шрифта
setusercharsize() — устанавливае пользовательский размер шрифта
settextjustify() — устанавливает режим выравнивания текста

textheight() — возвращает ширину строки в пикселях
textwidth() — возвращает высоту строки в пикселях

Память

_graphfreemem() — освобождает графическую память
_graphgetmem() — ахватывает графическую память


Инициализация, ошибки

Следующий код производит инициализацию графического устройства и обрабатывает ошибки.

Копировать
#include <stdio.h>
#include <graphics.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
    int driver = DETECT, gmode, errorcode;
    initgraph(&driver, &gmode, "");		//инициализация графического устройства
    errorcode = graphresult();		//возврат кода ошибки
    if (errorcode != grOk){			//обработка ошибки
        printf("Error:%s\n", grapherrormsg(errorcode));
        printf("Prss any key");
        getch();
        exit(1);
    }
    getch();
    closegraph();				//закрытие графического устройства
}


closegraph()

#include <graphic.h>

void far closegraph(void)

Параметры

void

Описание

Выход из графического режима

Ф. освобождает всю память,выделенную под графическую систему, затем восстанавливает экран в режим, который был до вызова initgraph. (Графическая система освобождает память, а также драйверы, шрифты и внешние буферы посредством вызова _graphfreemem).

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


detectgraph()

#include <graphics.h>

void far detectgraph()

Параметры

int far | *graphdriver | определяет графический драйвер
int far | *graphmode | определяет начальный графический режим

Описание

Определяет графический драйвер и графический режим при проверке аппаратного обеспечения

Ф. определяет ваш системный графический адаптер и выбирает режим, который обеспечивает самое высокое разрешение для этого адаптера. Если графический адаптер не обнаружен, *graphdriver устанавливается в -2 и graphresult будет также возвращать -2(grNotDetected).

*graphdriver - целое, которое определяет используемый графический драйвер. Вы можете задать его значение, используя константу перечисляемого типа graphics_drivers, определенную в graphics.h и приведенную в следующей таблице.

graphics_drivers | численное значение
DETECT | 0
CGA | 1
MCGA | 2
EGA | 3
EGA64 | 4
EGAMONO | 5
IBM8514 | 6
HERCMONO | 7
ATT400 | 8
VGA | 9
PC3270 | 10

*graphmode - целое, которое определяет начальный графический режим (если *graphdriver не равен DETECT, *graphmode устанавливается в наивысшее разрешение, допустимое для данного драйвера) Вы можете задать значение *graphmode, используя константу перечисляемого типа graphics_modes, определенную в graphics.h и показанную в следующей таблице.

Драйвер | graphics_ modules | Значение | Разрешение | Палитра | Количество страниц
CGA | CGAC0 | 0 | 320 x 200 | C0 | 1
 | CGAC1 | 1 | 320 x 200 | С1 | 1
 | CGAC2 | 2 | 320 x 200 | С2 | 1
 | CGAC3 | 3 | 320 x 200 | С3 | 1
 | CGAHI | 4 | 640 x 200 | 2 цвета | 1
MCGA | MCGAC0 | 0 | 320 x 200 | С0 | 1
 | MCGAC1 | 1 | 320 x 200 | С1 | 1
 | MCGAC2 | 2 | 320 x 200 | С2 | 1
 | MCGAC3 | 3 | 320 x 200 | С3 | 1
 | MCGAMED | 4 | 640 x 200 | 2 цвета | 1
 | MCGAHI | 5 | 640 x 480 | 2 цвета | 1
EGA | EGALO | 0 | 640 x 200 | 16 цветов | 4
 | EGAHI | 1 | 640 x 350 | 16 цветов | 2
EGA64 | EGA64LO | 0 | 640 x 200 | 16 цветов | 1
 | EGA64HI | 1 | 640 x 350 | 4 цвета | 1
EGA-MONO | EGAMONOHI | 3 | 640 x 350 | 2 цвета | 2
HERC | HERCMONOHI | 0 | 720 x 348 | 2 цвета | 2
AT400 | ATT400C0 | 0 | 320 x 200 | C0 | 1
 | ATT400C1 | 1 | 320 x 200 | C1 | 1
 | ATT400C2 | 2 | 320 x 200 | C2 | 1
 | ATT400C3 | 3 | 320 x 200 | C3 | 1
 | ATT400CMED | 4 | 640 x 200 | 2 цвета | 1
 | ATT400CHI | 5 | 640 x 200 | 2 цвета | 1
VGA | VGALO | 0 | 640 x 200 | 16 цветов | 2
 | VGAMED | 1 | 640 x 350 | 16 цветов | 2
 | VGAHI | 2 | 640 x 380 | 16 цветов | 1
PC3270 | PC3270HI | 0 | 720 x 350 | 2 цвета | 1
IBM8514 | IBM8514HI | 0 | 640 x 480 | 256 цветов |
 | IBM8514LO | 0 | 1024 x 768 | 256 цветов |

Замечание. Основная причина вызова непосредственно detectgraph состоит в переопределении графического режима , который detectgraph рекомендовал initgraph.

Копировать
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

/* Имена различных графических адаптеров */
char *gname[] = { "требуется определение",
    "CGA",
    "EGA",
    "EGA с 64K",
    "монохромный EGA",
    "IBM 8514",
    "Hercules монохромный",
    "AT&T 6300 PC",
    "VGA",
    "IBM 3270"
};

int main(void)
{
    int graphdriver, gmode, errorcode;	/* используется для определения
                            графического адаптера */
    detectgraph(&graphdriver,&gmode,"");	/* определение адаптера */
    errorcode = graphresult();	/* получение результата инициализации */
    if(errorcode != grOk)  /* если ошибка */
    {
        printf("Ошибка :%s\n",grapherrormsg(errorcode));
        printf("Для останова нажмите любую клавишу\n");
        getch();
        exit(1);  /* завершение с кодом ошибки */
    }
    /* вывести полученную информацию */
    clrscr();
    printf("Установлена плата: %s",gname[graphdriver]);
    printf("Для завершения нажмите любую клавишу...");
    getch();
    return 0;
}

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


getaspectratio()

#include <graphics.h>

void far getaspectratio()

Параметры

int far | *xasp | фактор y-аспекта
int far | *yasp | фактор x-аспекта

Описание

Возвращает текущее характеристическое отношение ширины изображения к его высоте графического режима

Фактор y-аспекта, *yasp, нормализуется к 10 000; на всех графических адаптерах, кроме VGA, *xasp ( фактор y-аспекта) меньше *yasp, т.к. пиксел больше в высоту,чем в ширину.На VGA, который имеет "квадратный" пиксел, *xasp равно *yasp. В целом, соотношение между *yasp и *xasp следующее:
*yasp = 10000
*xasp <= 10000
getaspectratio передает значения в *xasp и *yasp.

Смотрите также

setaspectratio() — установка коэфициента сжатия


getdrivername()

#include <graphics.h>

char *far getdrivername(void)

Параметры

void

Описание

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

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима
getmaxmode() — возвращает максимальный номер режима для текущего драйвера


getgraphmode()

#include <graphics.h>

int far getgraphmode(void)

Параметры

void

Описание

Возвращает текущий графический режим

Ваша программа должна успешно выполнить вызов initgraph() до вызова getgraphmode(). Перечисляемый тип graphics_mode, определенный в graphics.h задает имена встроенных графических режимов. Для ознакомления с таблицей,отображающей эти значения, следует обратиться к описанию initgraph.

Смотрите также

getmodename() — возвращает указатель на строку, содержащую имя указанного графического режима
getmoderange() — получает диапазон режимов для данного графического драйвера


getmaxmode()

#include <graphics.h>

int far getmaxmode(void)

Параметры

void

Описание

Возвращает максимальный номер режима для текущего драйвера

Ф. позволяет вам найти максимальный номер режима для текущего загруженного драйвера, непосредственно из этого драйвера. Это дает ей преимущество над getmoderange, который работает только с драйверами Borland. Минимальный режим - 0.

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


getmodename()

#include <graphics.h>

char *far getmodename()

Параметры

int mode_number номер графического режима

Описание

Возвращает указатель на строку, содержащую имя указанного графического режима

Ф. принимает номер графического режима как входной параметр и возвращает строку, содержащую имя текущего графического режима. Имена режимов встроены в каждый драйвер. Возвращаемое значение ("320x200 CGA", "640x200 CGA", и т.д.) используется для построения меню или отображения статуса.

Смотрите также

getgraphmode() — возвращает текущий графический режим
getmoderange() — получает диапазон режимов для данного графического драйвера


getmoderange()

#include <graphics.h>

void far getmoderange()

Параметры

int | graphdriver | графический драйвер
int far | *lomode | наименьшее значение драйвера
int far | *himode | наивысшие значение драйвера

Описание

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

Ф. получает диапазон допустимых графических режимов для заданного графического драйвера graphdriver. Наименьшее допустимое значение режима возвращается в *lomode, а наивысшее допустимое значение в *himode. Если graphdriver определяет несуществующий графический драйвер, *lomonade и *himonade устанавливаются в -1. Если значение grapgdriver равно -1, будут возвращены режимы текущего загруженного драйвера.

Смотрите также

getgraphmode() — возвращает текущий графический режим
getmodename() — возвращает указатель на строку, содержащую имя указанного графического режима


graphdefaults()

#include <graphics.h>

void far graphdefaults(void)

Параметры

void

Описание

Переустанавливает все графические параметры в их начальные значения

Ф. переустанавливает все графические параметры в их начальные значения:

  • устанавливает область просмотра в полный экран;
  • перемещает текущую позицию в (0,0);
  • устанавливает начальные цвета палитры, цвет фона и цвет рисования;
  • устанавливает начальный тип и шаблон заполнения;
  • устанавливает начальный шрифт и выравнивание.

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


grapherrormsg()

#include <graphics.h>

char *far grapherrormsg()

Параметры

int errorcode код ошибки

Описание

Возвращает указатель на строку сообщения об ошибке

Ф. возвращает указатель на строку сообщения об ошибке, связанной с errorcode-значением, возвращаемым graphresult.

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
closegraph() — выход из графического режима


graphresult()

#include <graphics.h>

int far graphresult(void)

Параметры

void

Описание

Возвращает код ошибки выполнения последней графической операции

В заголовочном файле graphics.h определенны следующие ошибки.
Копировать
enum graphics_errors {
    grOk		=   0,
    grNoInitGraph	=  -1,
    grNotDetected	=  -2,
    grFileNotFound	=  -3,
    grInvalidDriver	=  -4,
    grNoLoadMem	=  -5,
    grNoScanMem	=  -6,
    grNoFloodMem	=  -7,
    grFontNotFound	=  -8,
    grNoFontMem	=  -9,
    grInvalidMode	= -10,
    grError		= -11,   /* generic error */
    grIOerror	= -12,
    grInvalidFont	= -13,
    grInvalidFontNum	= -14,
    grInvalidVersion	= -18
};

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
restorecrtmode() — востановление текстового режима
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


initgraph()

#include <graphics.h>

void far initgraph()

Параметры

int far | *driver | драйвер
int far | *mode | режим
const char far | *path | путь к драйверу

Описание

Установка видеорежима

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

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

driver | численное значение
DETECT | 0
CGA | 1
MCGA | 2
EGA | 3
EGA64 | 4
EGAMONO | 5
IBM8514 | 6
HERCMONO | 7
ATT400 | 8
VGA | 9
PC3270 | 10
СURRENT_DRIVER | -1

Значение mode должно быть одним из перечисленных ниже.

Драйвер | mode | Значение | Разрешение | Палитра | Количество страниц
CGA | CGAC0 | 0 | 320 x 200 | C0 | 1
 | CGAC1 | 1 | 320 x 200 | С1 | 1
 | CGAC2 | 2 | 320 x 200 | С2 | 1
 | CGAC3 | 3 | 320 x 200 | С3 | 1
 | CGAHI | 4 | 640 x 200 | 2 цвета | 1
MCGA | MCGAC0 | 0 | 320 x 200 | С0 | 1
 | MCGAC1 | 1 | 320 x 200 | С1 | 1
 | MCGAC2 | 2 | 320 x 200 | С2 | 1
 | MCGAC3 | 3 | 320 x 200 | С3 | 1
 | MCGAMED | 4 | 640 x 200 | 2 цвета | 1
 | MCGAHI | 5 | 640 x 480 | 2 цвета | 1
EGA | EGALO | 0 | 640 x 200 | 16 цветов | 4
 | EGAHI | 1 | 640 x 350 | 16 цветов | 2
EGA64 | EGA64LO | 0 | 640 x 200 | 16 цветов | 1
 | EGA64HI | 1 | 640 x 350 | 4 цвета | 1
EGA-MONO | EGAMONOHI | 3 | 640 x 350 | 2 цвета | 2
HERC | HERCMONOHI | 0 | 720 x 348 | 2 цвета | 2
AT400 | ATT400C0 | 0 | 320 x 200 | C0 | 1
 | ATT400C1 | 1 | 320 x 200 | C1 | 1
 | ATT400C2 | 2 | 320 x 200 | C2 | 1
 | ATT400C3 | 3 | 320 x 200 | C3 | 1
 | ATT400CMED | 4 | 640 x 200 | 2 цвета | 1
 | ATT400CHI | 5 | 640 x 200 | 2 цвета | 1
VGA | VGALO | 0 | 640 x 200 | 16 цветов | 2
 | VGAMED | 1 | 640 x 350 | 16 цветов | 2
 | VGAHI | 2 | 640 x 380 | 16 цветов | 1
PC3270 | PC3270HI | 0 | 720 x 350 | 2 цвета | 1
IBM8514 | IBM8514HI | 0 | 640 x 480 | 256 цветов |
 | IBM8514LO | 0 | 1024 x 768 | 256 цветов |

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
restorecrtmode() — востановление текстового режима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


installuserdriver()

#include <graphics.h>

int far installuserdriver()

Параметры

char far | *name | имя файла нового драйвера
int | huge(*detect)(void) | указатель на дополнительную функцию автоопределения

Описание

Добавляет дополнительные драйверы устройств в таблицу драйверов устройств BGI

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

Существует два способа использования драйверов, поставляемых продавцами. Предположим у вас есть новая видеокарта, называющаяся Spiffy Graphic Array (SGA) и производитель этой SGA обеспечивает вас также BGI-драйвером (SGA.BGI). Наипростейший способ использования драйвера состоит в добавлении его с помощью installuserdriver, а затем передаче возвращаемого значения (присвоенный номер драйвера) непосредственно в initgraph.

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

После того как вы добавили имя файла драйвера и SGA-функцию автодетектирования, вы вызываете initgraph и позволяете ему выполнять нормальный процесс автодетектирования. Перед тем как initgraph вызовет встроенную функцию автодетектирования(detectgraph), он вызовет SGA-функцию автодетектирования. Если эта SGA-функция не находит аппаратные средства SGA, она возвращает значение -11 (grError), а initgraph продолжает нормальный процесс автодетектирования, который может включать вызов других поставленных производителем функций автодетектирования в том порядке в каком они были добавлены). Если же, однако, функция определит, что SGA присутствует, она возвращает неотрицательный номер режима; затем initgraph находит и загружает SGA.BGI, переводит аппаратные средства в графический режим, рекомендуемый функцией автодетектирования, и, наконец, передает управление вашей программе.

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

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

Копировать
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int huge detectEGA(void);
void checkerrors(void);

int main(void)
{
    int gdriver,gmode;
    gdriver = installuserdriver("EGA",detectEGA);	/* инсталлировать драйвер,
                            написанный пользователем*/
    gdriver = DETECT;		//инициировать автоопределение
    checkerrors();			//проверить на ошибки инсталляции
    initgraph(&gdriver,&gmode,"");	//инициализация графики и локальных переменных
    checkerrors();			//проверить на ошибки иннициализации
    line(0,0,getmaxx(),getmaxy());	//нарисовать линию
    getch();
    closegraph();
    return 0;
}

/* определение платы EGA или VGA */
int huge detectEGA(void)
{
    int driver, mode, sugmode = 0;
    detectgraph(&driver,&mode);
    if((driver == EGA) || (driver == VGA))
            return sugmode;	//вернуть предполачаемый номер режима
    else
        return grError;	//вернуть код ошибки
}

/* проверка и сообщение о появлении ошибок */
void checkerrors(void)
{
    int errorcode;
    errorcode = graphresult();
    if(errorcode != grOk)
    {
        printf("Ошибка графики %s\n",grapherrormsg(errorcode));
        printf("Для завершения нажмите любую клавишу... ");
        getch();
        exit(1);
    }
}

Смотрите также

installuserfont() — загружает файл со шрифтом


installuserfont()

#include <graphics.h>

int far installuserfont()

Параметры

char far *name полное имя шрифтового файла

Описание

Загружает файл со шрифтом

Ф. загружает файл со шрифтом (.CHR), который не встроен в BGI-систему.name - полное имя шрифтового файла, содержащего штриховые шрифты. Одновременно может быть добавлено до двадцати шрифтов.

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

Смотрите также

installuserdriver() — добавляет дополнительные драйверы устройств в таблицу драйверов устройств BGI


restorecrtmode()

#include <graphics.h>

void far restorecrtmode(void)

Параметры

void

Описание

Востановление текстового режима

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

Смотрите также

detectgraph() — определяет графический драйвер и графический режим при проверке аппаратного обеспечения
initgraph() — установка видеорежима
graphresult() — возвращает код ошибки выполнения последней графической операции
grapherrormsg() — возвращает указатель на строку сообщения об ошибке
closegraph() — выход из графического режима


setaspectratio()

#include <graphics.h>

void far setaspectratio()

Параметры

int | xasp | сжатие по x
int | yasp | сжатие по y

Описание

Установка коэфициента сжатия

Ф. изменяет коэфициент сжатия, установленный по умолчанию.

Смотрите также

getaspectratio() — возвращает текущее характеристическое отношение ширины изображения к его высоте графического режима


arc()

#include <graphics.h>

void arc()

Параметры

int | x | координата x
int | y | координата y
int | stangle | начальный угол
int | endangle | конечный угол
int | radius | радиус

Описание

Рисует дугу окружности

Ф. рисует текущим цветом дугу окружности с центром в точке с координатами (x,y) и радиусом radius. Дуга рисуется от угла stangle до угла endangle. Если stangle равен 0 и endangle равен 360, функция arc нарисует полную окружность.

Угол для arc отсчитывается против часовой стрелки, где 0 градусов соответствует 3 часам на циферблате, 90 градусов - 12 часам и т.д.

Замечание. Параметр linestyle не оказывает воздействие при построении дуг, окружностей, эллипсов и секторов. Используется только параметр thickness.

Замечание. Если вы используете CGA в режиме высокого разрешения или монохромный графический адаптер, примеры на использование графических функций, приведенные в этой книге, могут не дать ожидаемого результата. Если ваша система работает на CGA или монохромном адаптере, передайте значение 1 тем функциям, которые изменяют цвет закрашивания или рисования, (например, setcolor, setfillstyle и setlinestyle) вместо символической константы цвета (определенной в graphics.h).

Смотрите также

circle() — исует окружность заданного радиуса
ellipse() — элептическая дуга
getarccoords() — выдает координаты последнего обращения к функции arc
ellipse() — элептическая дуга


circle()

#include <graphics.h>

void circle()

Параметры

int | x | координата x
int | y | координата y
int | radius | радиус

Описание

Рисует окружность заданного радиуса

Ф. рисует окружность текущим цветом с центром в точке (x,y) и радиусом radius.

Замечание. Параметр linestyle не оказывает воздействие при построении дуг, окружностей, элипсов и секторов. Используется только параметр thickness.

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

Смотрите также

ellipse() — элептическая дуга
arc() — дуга окружности
getarccoords() — выдает координаты последнего обращения к функции arc
ellipse() — элептическая дуга


drawpoly()

#include <graphics.h>

void far drawpoly()

Параметры

int | numpoints | количество точек
int far | *polypoints | массив координат

Описание

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

Ф. рисует многоугольник, имеющий numpoints точек, используя текущие тип линии и цвет.

*polypoints указывает на последовательность из (numpoints x 2) целых чисел. Каждая пара чисел x и y является координатами вершины многоугольника.

Замечание. Для построения замкнутой фигуры, имеющей n вершин, необходимо задавать n+1 координату, где n-ная координатная пара равна 0-ой.

Копировать
int poly[10];
poly[0] = 10;        /* первая точка */
poly[1] = 10;

poly[2] = 15;   /* 2 */
poly[3] = 5;

poly[4] = 20;   /* 3 */
poly[5] = 10;

poly[6] = 15;    /* 4 */
poly[7] = 25;

poly[8] = poly[0];   // возврат в исходную точку
poly[9] = poly[1];

drawpoly(5,poly);	//нарисовать

Смотрите также

drawpoly() — рисует контур многоугольника


ellipse()

#include <graphics.h>

void far ellipse()

Параметры

int | x | координата x
int | y | координата y
int | stangle | начальный угол
int | endangle | конечный угол
int | xradius | радиус по оси x
int | yradius | радиус по оси y

Описание

Рисует эллиптические дуги

Ф. рисует эллиптическую дугу с центром в точке с координатами (x,y), горизонтальной и вертикальной осями радиусом xradius и yradius соответственно,текущим цветом. Дуга рисуется от угла stangle до угла endangle. Если stangle равен 0 и endangle равен 360 ,функция arc нарисует полный эллипс.

Замечание. Параметр linestyle не оказывает воздействие при построении дуг, окружностей, элипсов и секторов.Используется только параметр thickness.

Смотрите также

circle() — исует окружность заданного радиуса
arc() — дуга окружности
getarccoords() — выдает координаты последнего обращения к функции arc
ellipse() — элептическая дуга


getarccoords()

#include <graphics.h>

void far getarccoords()

Параметры

struct arccoordstype far *arccoords структура в которую будет происходить заполнение

Описание

Выдает координаты последнего обращения к функции arc

Ф. заполняет структуру arccoordstype, на которую указывает arccoords, информацией о последнем вызове arc. Структура arccordstype определена в graphics.h следующим образом.

Копировать
struct arccoordstype{
    int x, y;
    int xstart, ystart, xend, yend;
};

Элементы этой структуры используются для определения центра (x,y),начальной (xstart, ystart) и конечной (xend,yend) позиций дуги. Эти значения могут быть использованы если необходимо , чтобы линии пересекались на конце дуги.

Смотрите также

circle() — исует окружность заданного радиуса
ellipse() — элептическая дуга
arc() — дуга окружности
getarccoords() — выдает координаты последнего обращения к функции arc
ellipse() — элептическая дуга


getx()

#include <graphics.h>

int far getx(void)

Параметры

void

Описание

Возвращает координату x текущей графической позиции

Ф. находит координату x текущей графической позиции. Значение берется относительно текущей области просмотра.

Смотрите также

gety() — возвращает координату y текущей графической позиции
moveto() — изменение значения текущего положения пера (CR)


gety()

#include <graphics.h>

int far gety(void)

Параметры

void

Описание

Возвращает координату y текущей графической позиции

Ф. находит координату y текущей графической позиции. Значение берется относительно текущей области просмотра.

Смотрите также

getx() — возвращает координату x текущей графической позиции
moveto() — изменение значения текущего положения пера (CR)


line()

#include <graphics.h>

void far line()

Параметры

int | x1 | начальная координата x
int | y1 | начальная координата y
int | x2 | конечная координата x
int | y2 | конечная координата y

Описание

Рисует линию между двумя указанными точками

Ф. рисует линию, используя текущие цвет, тип и толщину линий, между двумя точками, определенными как (x1, y1) и (x2, y2), не изменяя текущую позицию (CP).

Смотрите также

linerel() — рисует линию на заданное расстояние от текущей позиции CP
lineto() — рисует линию от текущей позиции


linerel()

#include <graphics.h>

void far linerel()

Параметры

int | dx | смещение по оси x
int | dy | смещение по оси y

Описание

Рисует линию на заданное расстояние от текущей позиции CP

Ф. рисует линию от CP до точки, находещейся на расстоянии (dx, dy) от CP. CP перемещается на CP + (dx,dy).

Смотрите также

line() — рисует линию между двумя указанными точками
linerel() — рисует линию на заданное расстояние от текущей позиции CP
lineto() — рисует линию от текущей позиции
moveto() — изменение значения текущего положения пера (CR)


lineto()

#include <graphics.h>

void far lineto()

Параметры

int | x | координата x
int | y | координата y

Описание

Рисует линию от текущей позиции

Ф. рисует линию от (CP) до точки с координатами (x,y), затем переносит (CP) в (x,y).

Следующий пример аналогичен функции line(20,30,100,100).

Копировать
moveto(20,30);		//перемещение указателя CP
lineto(100,100);	//рисование линии

Смотрите также

line() — рисует линию между двумя указанными точками
linerel() — рисует линию на заданное расстояние от текущей позиции CP
moveto() — изменение значения текущего положения пера (CR)


moveto()

#include <graphics.h>

void far moveto()

Параметры

int | x | координата x
int | y | координата y

Описание

Изменение значения текущего положения пера (CR)

Ф. изменяет текущие указателя на координаты (CR) на (x, y). Дальнейшее использование функций на подобии lineto() будут при первом вызове использовать за начальные координаты определённые данной функцией.

Смотрите также

getx() — возвращает координату x текущей графической позиции
gety() — возвращает координату y текущей графической позиции


rectangle()

#include <graphics.h>

void far rectangle()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата

Описание

Рисует прямоугольник

Ф. рисует прямоугольник.

Смотрите также

drawpoly() — рисует контур многоугольника


bar()

#include <graphics.h>

void bar()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата

Описание

Рисует прямоугольник

Ф. рисует двухмерный заполненный прямоугольник. Прямоугольник зарисовывается, используя текущий цвет и шаблон заполнения. Ф. не рисует контур прямоугольника; для того, чтобы нарисовать контур двухмерного прямоугольника, используйте функцию bar3d, с параметром depth равным 0.

Смотрите также

bar3d() —
fillpoly() — рисует и закрашивает многоугольник


bar3d()

#include <graphics.h>

void bar3d()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата
int | depth | глубина столбца
int | topflag | флаг рисования вершины

Описание

Рисует трехмерный столбец

Ф. рисует трехмерный прямоугольный столбец, затем закрашивает его, используя текущий шаблон и цвет заполнения. Трехмерный контур столбца рисуется текущим цветом и типом линии. Глубина столбца в точках экрана задается параметром depth. Параметр topflag определяет, будет ли рисоваться вершина трехмерного столбца. Если topflag не 0, вершина рисуется, в противном случае вершина не рисуется. (создается возможность ставить несколько столбцов друг на друга.)

Для вычисления типичной глубины для bar3d возьмите 25% ширины столбца, например:

Копировать
bar3d(left,top,right,bottom,(right-left)/4,1)

Смотрите также

bar() — прямоугольник
fillpoly() — рисует и закрашивает многоугольник


fillellipse()

#include <graphics.h>

void far fillellipse()

Параметры

int | x | координата x
int | y | координата y
int | stangle | начальный угол
int | endangle | конечный угол
int | xradius | радиус по оси x
int | yradius | радиус по оси y

Описание

Рисует и закрашивает эллипс

Ф. Рисует эллипс с центром в точке (x,y) и горизонтальной и вертикальной осями xradius и yradius соответственно, и закрашивает его текущими цветом закраски, используя текущий шаблон.

Смотрите также

bar() — прямоугольник
bar3d() —
fillpoly() — рисует и закрашивает многоугольник

sector() — рисует заполненый элептический сектор
pieslice() — рисует заполненый сектор круга


fillpoly()

#include <graphics.h>

void far fillpoly()

Параметры

int | numpoints | количество точек
int far | *polypoints | массив координат

Описание

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

Ф. рисует контур многоугольника ,имеющий numpoints точек, используя текущий вид линии и цвет (так же, как это делает drawpoly),а затем закрашивает многоугольник текущим цветом закраски и с помощью текущего шаблона.

polypoints указывает на последовательность из (numpoints x 2) целых чисел. Каждая пара чисел x и y является координатами вершины многоугольника.

Копировать
int poly[10];
poly[0] = 10;        /* первая точка */
poly[1] = 10;

poly[2] = 15;   /* 2 */
poly[3] = 5;

poly[4] = 20;   /* 3 */
poly[5] = 10;

poly[6] = 15;    /* 4 */
poly[7] = 25;

poly[8] = poly[0];   // возврат в исходную точку
poly[9] = poly[1];

fillpoly(5,poly);	//нарисовать

Смотрите также

bar() — прямоугольник
bar3d() —

fillellipse() — рисует и закрашивает эллипс
sector() — рисует заполненый элептический сектор
pieslice() — рисует заполненый сектор круга


pieslice()

#include <graphics.h>

void far pieslice()

Параметры

int | x | координата x
int | y | координата y
int | stangle | начальный угол
int | endangle | конечный угол
int | radius | радиус

Описание

Рисует заполненый сектор круга

Смотрите также

fillellipse() — рисует и закрашивает эллипс
sector() — рисует заполненый элептический сектор


sector()

#include <graphics.h>

void far sector()

Параметры

int | x | координата x
int | y | координата y
int | StAngle | начальный угол
int | EndAngle | конечный угол
int | XRadius | радиус по оси x
int | YRadius | радиус по оси y

Описание

Рисует заполненый элептический сектор

Смотрите также

fillellipse() — рисует и закрашивает эллипс
pieslice() — рисует заполненый сектор круга


getbkcolor()

#include <graphics.h>

int far getbkcolor(void)

Параметры

void

Описание

Возвращает текущий цвет фона

Ф. возвращает текущий цвет фона (cмотри подробности в таблице под setbkcolor).

Смотрите также

setcolor() — установка цвета
getcolor() — возвращает текущий цвет рисунка
getmaxcolor() — возвращает максимальное значение цвета, которое может быть передано функции setcolor
getbkcolor() — возвращает текущий цвет фона


getcolor()

#include <graphics.h>

int far getcolor(void)

Параметры

void

Описание

Возвращает текущий цвет рисунка

Ф. возвращает текущий цвет рисунка. Цвет рисования - это значение в которое устанавливаются пикселы, когда рисуются линии и т.д. Например, в режиме CGACO, палитра содержит 4 цвета : цвет фона, светло зеленый, светло красный и желтый. В этом режиме, если getcolor возвращает 1, текущий цвет рисования - светло-зеленый.

Смотрите также

setcolor() — установка цвета
getmaxcolor() — возвращает максимальное значение цвета, которое может быть передано функции setcolor
setbkcolor() — установка цвета фона
getbkcolor() — возвращает текущий цвет фона


getmaxcolor()

#include <graphics.h>

int far getmaxcolor(void)

Параметры

void

Описание

Возвращает максимальное значение цвета, которое может быть передано функции setcolor

Ф. возвращает наивысшее действительное значение цвета для текущего графического драйвера и режим, который может быть передан setcolor. Например, c 256K EGA, getmaxcolor будет всегда возвращать 15. Это значит, что допустим любой вызов setcolor со значением от 0 до 15.

Смотрите также

setcolor() — установка цвета
getcolor() — возвращает текущий цвет рисунка
setbkcolor() — установка цвета фона
getbkcolor() — возвращает текущий цвет фона


getpixel()

#include <graphics.h>

unsigned far getpixel()

Параметры

int | x | координата x
int | y | координата y

Описание

Возвращает цвет заданной точки

Возвращает цвет заданного пикселя

Смотрите также

putpixel() — установить цвет пикселя


putpixel()

#include <graphics.h>

void far putpixel()

Параметры

int | x | координата x
int | y | координата y
int | color | цвет

Описание

Установить цвет пикселя

Ф. устанавливает цвет пикселя в точке экрана с координатами (x, y).

Смотрите также

getpixel() — возвращает цвет заданной точки


setbkcolor()

#include <graphics.h>

void far setbkcolor()

Параметры

int color цвет

Описание

Установка цвета фона

Цвета которые можно использовать приведены в функции setcolor().

Смотрите также

setcolor() — установка цвета
getcolor() — возвращает текущий цвет рисунка
getmaxcolor() — возвращает максимальное значение цвета, которое может быть передано функции setcolor
setbkcolor() — установка цвета фона


setcolor()

#include <graphics.h>

void far setcolor()

Параметры

int color цвет

Описание

Установка цвета

Палитра EGA по умолчанию соответствует цветам CGA. В файле graphics.h определенны константы, которые цодержит соответствующие цветам аппаратные значения. Для адаптеров определенны следующие цвета.

CGA | Значение | EGA/VGA | Значение
BLACK | 0 | EGA_BLACK | 0
BLUE | 1 | EGA_BLUE | 1
GREEN | 2 | EGA_GREEN | 2
CYAN | 3 | EGA_CYAN | 3
RED | 4 | EGA_RED | 4
MAGENTA | 5 | EGA_MAGENTA | 5
BROWN | 6 | EGA_LIGHTGRAY | 7
LIGHTGRAY | 7 | EGA_BROWN | 20
DARKGRAY | 8 | EGA_DARKGRAY | 56
LIGHTBLUE | 9 | EGA_LIGHTBLUE | 57
LIGHTGREEN | 10 | EGA_LIGHTGREEN | 58
LIGHTCYAN | 11 | EGA_LIGHTCYAN | 59
LIGHTRED | 12 | EGA_LIGHTRED | 60
LIGHTMAGENTA | 13 | EGA_LIGHTMAGENTA | 61
YELLOW | 14 | EGA_YELLOW | 62
WHITE | 15 | EGA_WHITE | 63

Смотрите также

getcolor() — возвращает текущий цвет рисунка
getmaxcolor() — возвращает максимальное значение цвета, которое может быть передано функции setcolor
setbkcolor() — установка цвета фона
getbkcolor() — возвращает текущий цвет фона


getdefaultpalette()

#include <graphics.h>

struct palettetype *far getdefaultpalette(void)

Параметры

void

Описание

Возвращает структуру определения палитры

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

Смотрите также

setpalette() — изменение цвета в палитре
getpalette() — получает информацию о текущей палитре
setrgbpalette() — изменение цвета в палитре по системе RGB
getpalettesize() — возвращает размер справочной таблицы цветов палитры


getpalette()

#include <graphics.h>

void far getpalette()

Параметры

struct palettetype far *palette структура для заполнения информации

Описание

Получает информацию о текущей палитре

Ф. заполняет структуру palettetype, на которую ссылается palette, информацией о размере политры и ее цветах. Константа MAXCOLORS и структура palettype, используемые getpalette, определены в graphics.h следующим образом.

Копировать
#define MAXCOLORS 15
struct palettetype{
    unsigned char size;
    signed char colors[MAXCOLORS+1];
};

size дает количество цветов в палитре текущего драйвера и режима. colors - это массив цветов данной палитры.

Примечание. getpalette нельзя использовать с драйвером для IBM-8514.

Смотрите также

setpalette() — изменение цвета в палитре
setrgbpalette() — изменение цвета в палитре по системе RGB
getdefaultpalette() — возвращает структуру определения палитры
getpalettesize() — возвращает размер справочной таблицы цветов палитры


getpalettesize()

#include <graphics.h>

int far getpalettesize(void)

Параметры

void

Описание

Возвращает размер справочной таблицы цветов палитры

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

Смотрите также

setpalette() — изменение цвета в палитре
getpalette() — получает информацию о текущей палитре
setrgbpalette() — изменение цвета в палитре по системе RGB
getdefaultpalette() — возвращает структуру определения палитры


setpalette()

#include <graphics.h>

void far setpalette()

Параметры

int index номер цвета в палитре

Описание

Изменение цвета в палитре

Данныая ф. устанавливает цвет color в палитре под номером index. В режиме EGA могут использоваться только первые 16 из 64 цветов, причём каждый элемент палитры млжет быть задан пользователем. Все цвета приведены в описании функции setcolor(). Следующий пример переберает все цвета пвлитры.

Копировать
#include <stdio.h>
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <dos.h>
void main()
{
    int driver = DETECT, gmode, errorcode;
    initgraph(&driver, &gmode, "");
    errorcode = graphresult();
    if (errorcode != grOk){
        printf("Error:%s\n", grapherrormsg(errorcode));
        printf("Prss any key");
        getch();
        exit(1);
    }
    for (int i=63; i>-1; i--){
        setpalette(1,i);	//меняем цвет в палитре
        setbkcolor(1);
        delay(1000);
    }
    getch();
    closegraph();
}

Смотрите также

getpalette() — получает информацию о текущей палитре
setrgbpalette() — изменение цвета в палитре по системе RGB
getdefaultpalette() — возвращает структуру определения палитры
getpalettesize() — возвращает размер справочной таблицы цветов палитры


setrgbpalette()

#include <graphics.h>

void far setrgbpalette()

Параметры

int | index | номер цвета в палитре
int | red | красная составляющая
int | green | зелёная составляющая
int | blue | синяя составляющая

Описание

Изменение цвета в палитре по системе RGB

Данныая ф. устанавливает цвет (red, green, blue) в палитре под номером index. В режиме EGA могут использоваться только первые 16, причём каждый элемент палитры млжет быть задан пользователем. Каждая из составляющих может принимать значения в интервале [0,64].

Смотрите также

setpalette() — изменение цвета в палитре
getpalette() — получает информацию о текущей палитре
getdefaultpalette() — возвращает структуру определения палитры
getpalettesize() — возвращает размер справочной таблицы цветов палитры


floodfill()

#include <graphics.h>

void far floodfill()

Параметры

int | x | координата x
int | y | координата y
int | border | цвет границы области

Описание

Заполняет ограниченную область

Ф. заполняет ограниченную область на устройствах с побитовым отображением. (x,y) - произвольная точка внутри закрашиваемой области. Область, граница которой окрашена цветом border, заполняется текущим цветом закраски и шаблоном. Если указанная точка находится внутри ограниченной области, то окрашивается область, а если снаружи, то закрашивается все поле за пределами области. Цвет и шаболон определяються ф. setfillstyle().

Используйте, если это возможно, fillpoly вместо floodfill. Это позволит обеспечить кодовую совместимость с будущими версиями.

Замечание. floodfill не работает с драйвером IBM-8514.

Смотрите также

setfillstyle() — устанавливает цвет и шаблон заполнения
getfillsettings() — получает информацию о текущем шаблоне и цвете заполнения
setfillpattern() — задаёт шаблон заполнения определяемый пользователем
getfillpattern() — возвращает определенный пользователем шаблон заполнения


getfillpattern()

#include <graphics.h>

void getfillpattern()

Параметры

char far *pattern шаблон

Описание

Возвращает определенный пользователем шаблон заполнения

Ф. возвращает шаблон заполнеия, определенный пользователем и установленный с помощью setfillpattern, в 8-битную область, на которую указывает pattern. pattern - это указатель на последовательность из 8 байт, где каждый байт соответствует 8 пикселям шаблона. Всякий раз, когда бит устанавливается в 1, соответствующий пиксель отображается на экране. Например, следующий определенный пользователем образец приведет к поклеточному рисунку.

Копировать
char checkboard[8] = { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55};

Смотрите также

floodfill() — заполняет ограниченную область
setfillstyle() — устанавливает цвет и шаблон заполнения
getfillsettings() — получает информацию о текущем шаблоне и цвете заполнения
setfillpattern() — задаёт шаблон заполнения определяемый пользователем


getfillsettings()

#include <graphics.h>

void far getfillsettings()

Параметры

struct fillsettingstype far *fillinfo указатель на структуру

Описание

Получает информацию о текущем шаблоне и цвете заполнения

Ф. заполняет структуру fillsettingstype, на которую указывает fillinfo информацией о текущем шаблоне и цвете заполнения. fillsettingstype определяется в graphics.h следующим образом:

Копировать
struct fillsettingstype{
    int pattern;	//текущий шаблон заполнения
    int color;	//текущий цвет заполнения
};

Функции bar, bar3d, fillpoly, floodfill и pieslice целиком заполняют область текущим шаблоном заполнения в текущем цвете заполнения. Существует 11 видов шаблонов заполнения (сплошное, крестообразное, точечное и т. д.) Символические имена для встроенных шаблонов обеспечиваются перечисляемым типом fill_patterns в graphics.h. (смотри таблицу, приведенную ниже). Кроме этого, вы можете определить свои собственные шаблоны.

Если pattern равен 12 (USER_FILL), то в данное время используется шаблон, определяемый пользователем; в противном случае pattern задает номер встроенного шаблона. Перечисляемый тип fill_patterns, заданный в graphics.h задает имя встроенного шаблона заполнения и индикатор для шаблона, определяемого пользователем.

Имя | Значение | Описание
EMPTY_FILL | 0 | заполнение цветом фона
SOLID_FILL | 1 | сплошное заполнение цветом заполнения
LINE_FILL | 2 | заполнение ______
LSTLASH_FILL | 3 | заполнение //////
SLASH_FILL | 4 | заполнение /// толстой линией
BKSLASH_FILL | 5 | заполнение \\\ толстой линией
LTBKSLASH_FILL | 6 | заполнение \\\\
HATCH_FILL | 7 | светлая штриховка сеткой
XHATCH_FILL | 8 | крестообразная штриховка
INTERLEAVE_FILL | 9 | тканеобразная штриховка
WIDE_DOT_FILL | 10 | заполнение редкими точками
CLOSE_DOT_FILL | 11 | заполнение частыми точками
USER_FILL | 12 | шаблон заполнения, определяемый пользователем

Все, кроме EMPTY_FILL заполняют текущим цветом заполнения; EMPTY_FILL использует текущий цвет фона.

Смотрите также

floodfill() — заполняет ограниченную область
setfillstyle() — устанавливает цвет и шаблон заполнения
setfillpattern() — задаёт шаблон заполнения определяемый пользователем
getfillpattern() — возвращает определенный пользователем шаблон заполнения


getlinesettings()

#include <graphics.h>

void far getlinesettings()

Параметры

struct linesettingstype far *lineinfo структура для заполнения информации о линии

Описание

Получает текущий цвет линии, шаблон и толщину

Ф. заполняет структуру linesettings, на которую указывает параметр lineinfo информацией, о текущем типе линий, толщине и шаблоне.

Структура linesettingstype определена в graphics.h следующим образом:

Копировать
struct linesettingstype{
    int linestyle;
    unsigned upattern;
    int thickness;
};

linestyle определяет тип линий, который будет использоваться (непрерывная, пунктир, штрихпунктир, штриховая). Перечисляемый тип line_styles, определенный в graphics.h, дает символические имена этим операциям.

Название | Значение | Описание
SOLID_LINE | 0 | сплошная
DOTTED_LINE | 1 | пунктир
CENTER_LINE | 2 | штрихпунктир
DASHED_LINE | 3 | штриховая
USERBIT_LINE | 4 | тип линии, заданный пользователем

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

Название | Значение | Описание
NORM_WIDTH | 1 | толшина в 1 пиксель
THICK_WIDTH | 3 | толщина в 3 пикселя

upattern — это 16-битный шаблон, который используется, только когда linestyle равен USERBIT_LINE (4). В этом случае каждый бит в шаблоне, установленный в 1, соответствует пикселю на линии в текущем цвете. Например, сплошной линии соответстсвует upattern равный 0xFFFF (рисуются все пиксели), а пунктиру соответствует upattern, равный 0x3333 или 0x0F0F. Если же параметр linestyle в setlynestyle не равен USERBIT_LINE, то upattern поддерживается, но игнорируется.

Смотрите также

line() — рисует линию между двумя указанными точками
setlinestyle() — установка ширины и стиля линии


setfillpattern()

#include <graphics.h>

void far setfillpattern()

Параметры

const char far | *upattern | указатель на шаблон
int | color | цвет шаблона

Описание

Задаёт шаблон заполнения определяемый пользователем

Ф. задаёт шаблон заполнеия, определенный пользователем, определённый в 8-битной областью, на которую указывает upattern. pattern - это указатель на последовательность из 8 байт, где каждый байт соответствует 8 пикселям шаблона. Всякий раз, когда бит устанавливается в 1, соответствующий пиксель отображается на экране. Например, следующий определенный пользователем образец приведет к поклеточному рисунку.
Копировать
char checkboard[8] = { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55};

Смотрите также

floodfill() — заполняет ограниченную область
setfillstyle() — устанавливает цвет и шаблон заполнения
getfillsettings() — получает информацию о текущем шаблоне и цвете заполнения
getfillpattern() — возвращает определенный пользователем шаблон заполнения


setfillstyle()

#include <graphics.h>

void far setfillstyle()

Параметры

int | pattern | шаблон
int | color | цвет

Описание

Устанавливает цвет и шаблон заполнения

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

Имя | Значение | Описание
EMPTY_FILL | 0 | заполнение цветом фона
SOLID_FILL | 1 | сплошное заполнение цветом заполнения
LINE_FILL | 2 | заполнение ______
LSTLASH_FILL | 3 | заполнение //////
SLASH_FILL | 4 | заполнение /// толстой линией
BKSLASH_FILL | 5 | заполнение \\\ толстой линией
LTBKSLASH_FILL | 6 | заполнение \\\\
HATCH_FILL | 7 | светлая штриховка сеткой
XHATCH_FILL | 8 | крестообразная штриховка
INTERLEAVE_FILL | 9 | тканеобразная штриховка
WIDE_DOT_FILL | 10 | заполнение редкими точками
CLOSE_DOT_FILL | 11 | заполнение частыми точками
USER_FILL | 12 | шаблон заполнения, определяемый пользователем

Смотрите также

floodfill() — заполняет ограниченную область
getfillsettings() — получает информацию о текущем шаблоне и цвете заполнения
setfillpattern() — задаёт шаблон заполнения определяемый пользователем
getfillpattern() — возвращает определенный пользователем шаблон заполнения


setlinestyle()

#include <graphics.h>

void far setlinestyle()

Параметры

int | linestyle | стиль линии
unsigned | upattern | патерн
int | thickness | толщина линии

Описание

Установка ширины и стиля линии

В загаловочном файле graphics.h определенны следующие стили и размеры линий.

Слиль | Значение
SOLID_LINE | 0
DOTTED_LINE | 1
CENTER_LINE | 2
DASHED_LINE | 3
USERBIT_LINE | 4
Толщина | Значение
NORM_WIDTH | 1
THICK_WIDTH | 3

Смотрите также

getlinesettings() — получает текущий цвет линии, шаблон и толщину


cleardevice()

#include <graphics.h>

void far cleardevice(void)

Параметры

void

Описание

Очищает активную страницу

Ф. стирает (это значит - зарисовывает текущим цветом фона) весь графический экран и переносит CP (текущую позицию) в начало экрана (0,0).

Смотрите также

setactivepage() — устанавливает номер активной сраницы
setvisualpage() — устанавливает номер выводимой страницы


clearviewport()

#include <graphics.h>

void far clearviewport(void)

Параметры

void

Описание

Очищает текущее окно

Ф. очищает текущую область просмотра экрана и переносит CP ( текущую позицию ) в (0,0), относительно области просмотра.

Смотрите также

clearviewport() — очищает текущее окно
getviewsettings() — вызывает информацию об активном окне


getmaxx()

#include <graphics.h>

int far getmaxx(void)

Параметры

void

Описание

Возвращает максимальную координату х экрана

Ф. возвращает максимальное (относительно экрана) значение х для текущего драйвера и режима. Например, в CGA в режиме 320х200, getmaxx возвращает 319. getmaxx неоценимо для центрирования, определения границ в oбласти экрана и т. д.

Смотрите также

getmaxy() — возвращает максимальную координату y экрана


getmaxy()

#include <graphics.h>

int far getmaxy(void)

Параметры

void

Описание

Возвращает максимальную координату y экрана

Ф. возвращает максимальное (относительно экрана) значение y для текущего значения драйвера и режима. Например, в CGA в режиме 320х200, getmaxy возвращает 199. getmaxy неоценимо для центрирования, определения границ в oбласти экрана и т. д.

Смотрите также

getmaxx() — возвращает максимальную координату х экрана


getviewsettings()

#include <graphics.h>

void far getviewsettings()

Параметры

struct viewporttype far *viewport структура для возврата

Описание

Вызывает информацию об активном окне

Ф. возвращает в структуру типа viewporttype информацию об активном окне. Данная сруктура определена в заголовочном файле graphics.h следующим образом.
Копировать
struct viewporttype {
    int left, top, right, bottom;
    int clip;
};

Смотрите также

clearviewport() — очищает текущее окно
setviewport() — создаёт графическое окно


setactivepage()

#include <graphics.h>

void far setactivepage()

Параметры

int page номер страницы

Описание

Устанавливает номер активной сраницы

Смотрите также

cleardevice() — очистка активной страницы
setvisualpage() — устанавливает номер выводимой страницы


setviewport()

#include <graphics.h>

void far setviewport()

Параметры

int | left | левая координата
int | top | верхняя координата
int | right | правая координата
int | bottom | нижняя координата
int | flag | режим выхода за границу окна

Описание

Создаёт графическое окно

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

Смотрите также

clearviewport() — очищает текущее окно
getviewsettings() — вызывает информацию об активном окне


setvisualpage()

#include <graphics.h>

void far setvisualpage()

Параметры

int page номер страницы

Описание

Устанавливает номер выводимой страницы

Смотрите также

cleardevice() — очистка активной страницы
setactivepage() — устанавливает номер активной сраницы


getimage()

#include <graphics.h>

void far getimage()

Параметры

int | left | началная координата по горизонтали
int | top | начальныя координата по вертикали
int | right | конечная координата по горизонтали
int | bottom | конечная координата по вертикали
void far | *bitmap | область в которую будет происходить копирование

Описание

Запоминает в битовый образ некоторой области экрана

Ф. копирует образ c экрана в память. left, top, right и bottom определяют область экрана прямоугольной формы, которая будет скопирована. bitmap указывает на область в памяти, куда записывается битовый образ. Первые два слова этой области задают ширину и высоту прямоугольника, оставшиеся определяют сам образ.

Копировать
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>

void save_screen(void far *buf[4]);
void restore_screen(void far *buf[4]);
int maxx,maxy;

int main(void)
{
    int graphdriver = DETECT, gmode, errorcode;
    void far *ptr[4];

    /*инициализация графического режима*/
    initgraph(&graphdriver,&gmode,"");
    errorcode = graphresult();
    if(errorcode != grOk)  /* если ошибка */
    {
        printf("Ошибка :%s\n",grapherrormsg(errorcode));
        printf("Для останова нажмите любую клавишу\n");
        getch();
        exit(1);  /* завершение с кодом ошибки */
    }

    maxx = getmaxx();
    maxy = getmaxy();

    /* нарисовать на экране изображение */
    rectangle(0,0,maxx,maxy);
    line(0,0,maxx,maxy);
    line(0,maxx,maxy,0)

    save_screen(ptr);    //сохранить экран
    getch();
    cleardevice();        //обнуление экрана
    restore_screen(ptr);    //восстановление экрана
    getch();

    closegraph();
    return 0;
}

void save_screen(void far *buf[4])
{
    unsigned size;
    int ystart=0,yend,yincr,block;
    yincr = (maxy+1)/4;
    yend = yincr;
    size = imagesize(0,ystart,maxx,yend);    //получить размер изображенияв байтах
    for(block = 0; block<=3; block++)
    {
        if(buf[block] = farmalloc(size))== NULL)
        {
            closegraph();
            printf("Ошибка! Не хватает памяти для сохранения экрана\n");
            exit(1);
        }
        getimage(0,ystart,maxx,yend,buf[block]);
        ystart = yend+1;
        yend += yincr+1;
    }
}
void restore_screen(void far *buf[4]);
{
    int ystart=0,yend,yincr,block;
    yincr = (maxx+1)/4;
    yend = yincr;
    for(block=0;block<=3;block++)
    {
        putimage(0,ystart,buf[block],COPY_PUT);
        farfree(buf[block]);
        ystart = yend+1;
        yend += yincr+1;
    }
}

Смотрите также

imagesize() — возвращает количество байтов, требуемых для хранения битового образа
putimage() — помещает на экран ранее записаный в память образ


imagesize()

#include <graphics.h>

unsigned far imagesize()

Параметры

int | left | началная координата по горизонтали
int | top | начальныя координата по вертикали
int | right | конечная координата по горизонтали
int | bottom | конечная координата по вертикали

Описание

Возвращает количество байтов, требуемых для хранения битового образа

Ф. определяет размер области памяти, требуемой для хранения битового образа. Если размер, требуемый для выбранного образа больше или равен 64К-1 байт, imagesize возвращает 0хFFFF(-1).

Смотрите также

getimage() — запоминает в битовый образ некоторой области экрана
putimage() — помещает на экран ранее записаный в память образ


putimage()

#include <graphics.h>

void far putimage()

Параметры

int | left | левая координата вставляемого образа
int | top | верхняя координата вставляемого образа
const void far | *bitmap | область из которой будет происходить вставка
int | op | оператор для заполнения для вставки

Описание

Помещает на экран ранее записаный в память образ

Ф. помещает на экран ранее запомненый образ функцией getimage() образ. bitmap указывает на область в памяти, откуда записывается битовый образ. Первые два слова этой области задают ширину и высоту прямоугольника, оставшиеся определяют сам образ.

op задаёт оператор заполнения. В заголовочном файле graphics.h определенны следующие операторы.

Копировать
enum putimage_ops {
    COPY_PUT,    //MOV
    XOR_PUT,    //XOR
    OR_PUT,        //OR
    AND_PUT,    //AND
    NOT_PUT        //NOT
};

Пример.

Копировать
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>

void save_screen(void far *buf[4]);
void restore_screen(void far *buf[4]);
int maxx,maxy;

int main(void)
{
    int graphdriver = DETECT, gmode, errorcode;
    void far *ptr[4];

    /*инициализация графического режима*/
    initgraph(&graphdriver,&gmode,"");
    errorcode = graphresult();
    if(errorcode != grOk)  /* если ошибка */
    {
        printf("Ошибка :%s\n",grapherrormsg(errorcode));
        printf("Для останова нажмите любую клавишу\n");
        getch();
        exit(1);  /* завершение с кодом ошибки */
    }

    maxx = getmaxx();
    maxy = getmaxy();

    /* нарисовать на экране изображение */
    rectangle(0,0,maxx,maxy);
    line(0,0,maxx,maxy);
    line(0,maxx,maxy,0)

    save_screen(ptr);    //сохранить экран
    getch();
    cleardevice();        //обнуление экрана
    restore_screen(ptr);    //восстановление экрана
    getch();

    closegraph();
    return 0;
}

void save_screen(void far *buf[4])
{
    unsigned size;
    int ystart=0,yend,yincr,block;
    yincr = (maxy+1)/4;
    yend = yincr;
    size = imagesize(0,ystart,maxx,yend);    //получить размер изображенияв байтах
    for(block = 0; block<=3; block++)
    {
        if(buf[block] = farmalloc(size))== NULL)
        {
            closegraph();
            printf("Ошибка! Не хватает памяти для сохранения экрана\n");
            exit(1);
        }
        getimage(0,ystart,maxx,yend,buf[block]);
        ystart = yend+1;
        yend += yincr+1;
    }
}
void restore_screen(void far *buf[4]);
{
    int ystart=0,yend,yincr,block;
    yincr = (maxx+1)/4;
    yend = yincr;
    for(block=0;block<=3;block++)
    {
        putimage(0,ystart,buf[block],COPY_PUT);
        farfree(buf[block]);
        ystart = yend+1;
        yend += yincr+1;
    }
}

Смотрите также

getimage() — запоминает в битовый образ некоторой области экрана
imagesize() — возвращает количество байтов, требуемых для хранения битового образа


outtext()

#include <graphics.h>

void far outtext()

Параметры

const char far *textstring строка

Описание

Выводит строку на экран с текущей позиции

Смотрите также

outtextxy() — выводит строку на экран с заданой позицией


outtextxy()

#include <graphics.h>

void far outtextxy()

Параметры

int | x | координата по x
int | y | координата по y
const char far | *textstring | строка

Описание

Выводит строку на экран с заданой позицией

Смотрите также

outtext() — выводит строку на экран с текущей позиции


settextjustify()

#include <graphics.h>

void far settextjustify()

Параметры

int | horiz | выравнивание по горизонтали
int | vert | выравнивание по вертикали

Описание

Устанавливает режим выравнивания текста

В заголовочном файле graphics.h определенна следующая структура для выравнивания.
Копировать
enum text_just {
    LEFT_TEXT   = 0,
    CENTER_TEXT = 1,
    RIGHT_TEXT  = 2,

    BOTTOM_TEXT = 0,
    /* CENTER_TEXT = 1,  already defined above */
    TOP_TEXT    = 2
};

Смотрите также

outtext() — выводит строку на экран с текущей позиции
outtextxy() — выводит строку на экран с заданой позицией
settextstyle() — устанавливает шрифт, стиль и коэфициент увеличения шрифта
setusercharsize() — устанавливае пользовательский размер шрифта


settextstyle()

#include <graphics.h>

void far settextstyle()

Параметры

int | font | шрифт
int | direction | стиль
int | charsize | коэфициент увеличения шрифта

Описание

Устанавливает шрифт, стиль и коэфициент увеличения шрифта

Значение charsize определякт во сколько раз шрифт будет больше нормального размера.

В заголовочном файле определенны следующие шрифты.

Шрифт | Значение
DEFAULT_FONT | 0
TRIPLEX_FONT | 1
SMALL_FONT | 2
SANS_SERIF_FONT | 3
GOTHIC_FONT | 4
SCRIPT_FONT | 5
SIMPLEX_FONT | 6
TRIPLEX_SCR_FONT | 7
COMPLEX_FONT | 8
EUROPEAN_FONT | 9
BOLD_FONT | 10

Имеються следующие слили вывода текста.

direction | Описание
0 | Нормальный вывод
1 | Строка повёрнута на 90 градусов по часовой стрелке
2 | Буквы в строке повёрнуты на 90 градусов против часовой стрелки

Смотрите также

outtext() — выводит строку на экран с текущей позиции
outtextxy() — выводит строку на экран с заданой позицией
setusercharsize() — устанавливае пользовательский размер шрифта
settextjustify() — устанавливает режим выравнивания текста


setusercharsize()

#include <graphics.h>

void far setusercharsize()

Параметры

int | multx
int | divx
int | multy
int | divy

Описание

Устанавливае пользовательский размер шрифта

Смотрите также

outtext() — выводит строку на экран с текущей позиции
outtextxy() — выводит строку на экран с заданой позицией
settextstyle() — устанавливает шрифт, стиль и коэфициент увеличения шрифта
settextjustify() — устанавливает режим выравнивания текста


textheight()

#include <graphics.h>

int far textheight()

Параметры

const char far *textstring строка

Описание

Возвращает ширину строки в пикселях

Смотрите также

textwidth() — возвращает высоту строки в пикселях


textwidth()

#include <graphics.h>

int far textwidth()

Параметры

const char far *textstring строка

Описание

Возвращает высоту строки в пикселях

Смотрите также

textwidth() — возвращает высоту строки в пикселях


_graphfreemem()

#include <graphics.h>

void far _graphfreemem()

Параметры

void var | *ptr
unssigned | size

Описание

Освобождает графическую память

Графическая библиотека вызывает _graphfreemem для освобождения памяти, ранее занятой с помощью _graphgetmem. Вы можете управлять распределением памяти графической библиотеки посредством простого определения вашей собственной версии _graphfreemem (вы должны определить ее так, как показано в описании). Начальная версия этой программы просто вызывает free.

Нипример.

Копировать
#include <graphics.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#define NONSENSE -50

int main(void)
{
    int graphdriver = NONSENSE, gmode, errorcode;
    initgraph(&graphdriver,&gmode,"");
    line(10, 10, 100, 100);
    getch();
    closegraph();
    return 0;
}

/* вызывается ядром графической системы для выделения памяти */
void far *far _graphgetmem(unsigned size)
{
    printf("Вызвана _graphgetmem для выделения %d байт\n",size);
    printf("Нажмите любую клавишу:");
    getch();
    printf("\n");
    /* выделить память */
    return farmalloc(size);
}

/* вызывается ядром графической системы для освобождения памяти */
void far _graphfreemem(void far *ptr, unsigned size)
{
    printf("Вызвана _graphfreemem для освобождения %d байт\n",size);
    printf("Нажмите любую клавишу:");
    getch();
    printf("\n");
    /* освободить память */
    return farfree(ptr);
}

Смотрите также

_graphgetmem() — захватывает графическую память


_graphgetmem()

#include <graphics.h>

void far _graphgetmem()

Параметры

unsigned size

Описание

Захватывает графическую память

Графическая библиотека вызывает _graphgetmem (но не пользовательская программа) для выделения памяти для внутренних буферов, графических драйверов и шрифтов. Вы можете управлять распределением памяти графической библиотекой посредством простого определения вашей собственной версии _graphgetmem (вы должны определить ее так, как показано в описании). Начальная версия этой прграммы просто вызывает malloc.

Нипример.

Копировать
#include <graphics.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#define NONSENSE -50

int main(void)
{
    int graphdriver = NONSENSE, gmode, errorcode;
    initgraph(&graphdriver,&gmode,"");
    line(10, 10, 100, 100);
    getch();
    closegraph();
    return 0;
}

/* вызывается ядром графической системы для выделения памяти */
void far *far _graphgetmem(unsigned size)
{
    printf("Вызвана _graphgetmem для выделения %d байт\n",size);
    printf("Нажмите любую клавишу:");
    getch();
    printf("\n");
    /* выделить память */
    return farmalloc(size);
}

/* вызывается ядром графической системы для освобождения памяти */
void far _graphfreemem(void far *ptr, unsigned size)
{
    printf("Вызвана _graphfreemem для освобождения %d байт\n",size);
    printf("Нажмите любую клавишу:");
    getch();
    printf("\n");
    /* освободить память */
    return farfree(ptr);
}

Смотрите также

_graphfreemem() — освобождает графическую память


Строковые и символьные функции

Библиотека функций языков С и C++ включает богатый набор функций обработки строк и символов. Строковые функции работают с символьными массивами, завершающимися нулевыми символами. В языке С для использования строковых функций необходимо включить в начало модуля программы заголовочный файл <string.h>, а для символьных — заголовочный файл <ctype.h>. В языке C++ для работы со строковыми и символьными функциями используются заголовки <cstring> и <cctype.h> соответственно. В этой главе для простоты изложения используются имена С-заголовков.

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

В языках С и C++ печатаемыми являются символы, отображаемые на терминале. В ASCII-средах они расположены между пробелом(0x20) и тильдой(OxFE). Управляющие символы имеют значения, лежащие в диапазоне между нулем и Ox1F; к ним также относится символ DEL(Ox7F).

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

В заголовке <string.h> определен тип size_t, который является результатом применения оператора sizeof и представляет собой разновидность целого без знака.

В версии С99 к некоторым параметрам нескольких функций, первоначально определенных в версии С89, добавлен квалификатор restrict. При рассмотрении каждой такой функции будет приведен ее прототип, используемый в среде С89(а также в среде C++), а параметры с атрибутом restrict будут отмечены в описании этой функции.

Список функций

Проверка на принадлежность

isalnum — Проверка на принадлежность символа к алфавитно-цифровым
isalpha — Проверка на принадлежность символа к буквам
isblank — Проверка пустого символа
iscntrl — Проверка на принадлежность символа к управляющим
isdigit — Проверка на принадлежность символа к цыфровым
isgraph — Проверка на принадлежность символа к печатным но не к пробелу
islower — Проверка на принадлежность символа к строчнам
isprint — Проверка на принадлежность символа к печатным
ispunct — Проверка на принадлежность символа к знакам пунктуации
isspace — Проверка на принадлежность символа к пробельным
isupper — Проверка на принадлежность символа к прописным
isxdigit — Проверка на принадлежность символа к шестнадцатиричным

Работа с символьными массивами

memchr — Просматривает массив чтобы отыскать первое вхождение символа
memcmp — Сравнивает оперделённое количество символов в двух массивах
memcpy — Копирует символы из одного массива в другой
memmove — Копирует символы из одного массива в другой с учётом перекрытия массивов
memset — Заполняет определённое количество символов массива заданным

Манипуляции над строками

strcat — Присоеденяет копию одной строки к заданной
strchr — Возвращает указатель на первое вхождение младшего байта заданного параметра
strcmp — Cравнивает в лексикографическом порядке две строки
strcoll — Сравнивает одну строку с другой в соответствии с параметром setlocale
strcpy — Копирует содержимое одной строки в другую
strcspn — Возращает строку в которой отсутствуют заданные символы
strerror — Возвращает указатель на строку содержащую системное сообщение об ошибке
strlen — Возвращает длину строки с завершающим нулевым символом
strncat — Присоеденяет определённое кличество символов одной строки к другой
strncmp — Лексографически сравнивает две строки
strncpy — Копирует определённое количество символов в символьный массив
strpbrk — Возвращает указатель на первый символ в строке который совпадает с заданными
strrchr — Возвращает указатель на последнее вхождение младшего байта заданного параметра в строке
strspn — Возвращает индекс первого символа в заданной строке, который не совпадает с любым из символов в другой строке
strstr — Возвращает указатель на первое вхождение одной строки в другую
strtok — Возвращает указатель на следующую лексему в строке
strxfrm — Преобразует определённое количество символов заданной строки чтобы ее можно было использовать функцией strcmp()

Другие функции

tolower — Переводит символ в нижний регистр
toupper — Переводит символ в верхний регистр


isalnum()

#include <ctype.h>
int isalnum(int ch);

Описание

Проверка на принадлежность символа к алфавитно-цифровым

Функция isalnum() возвращает ненулевое значение, если ее аргумент ch является либо буквой, либо цифрой. Если же тестируемый символ не относится к алфавитно-цифровым, возвращается нуль.


isalpha()

#include <ctype.h>
int isalpha(int ch);

Описание

Проверка на принадлежность символа к буквам

Функция isalpha() возвращает ненулевое значение, если ее аргумент ch является буквой, в противном случае возвращается нуль. Принадлежность символа к буквам зависит от конкретного языка. Для английского языка таковыми являются прописные и строчные буквы от А до Z.


isblank()

#include <ctype.h>
int isblank(int ch);

Описание

Проверка пустого символа

Функция isblank() добавлена в версии С99.

Она возвращает ненулевое значение, если ее аргумент ch является символом, для которого функция isspace() возвращает значение "истина", и используется для разделения слов.

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


iscntrl()

include <ctype.h>
int iscntrl(int ch);

Описание

Проверка на принадлежность символа к управляющим

Функция iscntrl() возвращает ненулевое значение, если ее аргумент ch является управляющим символом, значение которого в ASCII-средах лежит в диапазоне между нулем и Ox1F или равно Ox7F(символ DEL). В противном случае возвращается нуль.


isdigit()

#include <ctype.h>
int isdigit(int ch);

Описание

Проверка на принадлежность символа к цыфровым

Функция isdigit() возвращает ненулевое значение, если ее аргумент ch является цифрой, т.е. попадает в диапазон 0-9. В противном случае возвращается нуль.


isgraph()

#include <ctype.h>
int isgraph(int ch);

Описание

Проверка на принадлежность символа к печатным но не к пробелу

Функция isgraph() возвращает ненулевое значение, если ее аргумент ch является любым печатаемым символом, но не пробелом. В противном случае возвращается нуль. Для ASCII-сред значения печатаемых символов лежат в диапазоне от 0x21 до Ох7Е.


islower()

include <ctype.h>
int islower(int ch);

Описание

Проверка на принадлежность символа к строчнам

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


isprint()

#include <ctype.h>
int isprint(int ch);

Описание

Проверка на принадлежность символа к печатным

Функция isprint() возвращает ненулевое значение, если аргумент ch является печатаемым символом, включая пробел. В противном случае возвращается нуль. В ASCII-средах значения печатаемых символов лежат в диапазоне от 0x20 до Ох7Е.


ispunct()

#include <ctype.h>
int ispunct(int ch);

Описание

Проверка на принадлежность символа к знакам пунктуации

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


isspace()

#include <ctype.h>
int isspace(int ch);

Описание

Проверка на принадлежность символа к пробельным

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


isupper()

#include <ctype.h>
int isupper(int ch);

Описание

Проверка на принадлежность символа к прописным

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


isxdigit()

#include <ctype.h>
int isxdigit(int ch);

Описание

Проверка на принадлежность символа к шестнадцатиричным

Функция isxdigit() возвращает ненулевое значение, если аргумент ch является шестнадцатеричной цифрой. В противном случае возвращается нуль. Шестнадцатеричная цифра должна попадать в один из следующих диапазонов: A-F, a-f или 0-9.


memchr()

#include <string.h>
void *memchr(const void *buffer, int ch, size_t count);

Описание

Просматривает массив чтобы отыскать первое вхождение символа

Функция memchr() просматривает массив, адресуемый параметром buffer, чтобы отыскать первое вхождение символа ch в первых count символах.

Функция memchr() возвращает указатель на первое вхождение символа ch в массиве buffer или нулевой указатель, если символ ch не найден.


memcmp()

#include <string.h>
int memcmp(const void *buf1, const void *buf2, size_t count);

Описание

Сравнивает оперделённое количество символов в двух массивах

Функция memcmp() сравнивает первые count символов массивов, адресуемых параметрами bufl и buf2.

Функция memcmp() возвращает целое значение, которое интерпретируется следующим образом.

Меньше нуля | bufl меньше buf2
Нуль | bufl равен buf2
Больше нуля | bufl больше buf2


memcpy()

#include <string.h>
void *memcpy(void *to, const void * from, size_t count);

Описание

Копирует символы из одного массива в другой

Функция memcpy() копирует count символов из массива, адресуемого параметром from, в массив, адресуемый параметром to. Если заданные массивы перекрываются, поведение функции memcopy() не определено.

В версии С99 к параметрам to и from применен квалифи-катор restrict.

Функция memcpy() возвращает значение указателя to.


memmove()

#include <string.h>
void *memmove(void *to, const void *from, size_t count);

Описание

Копирует символы из одного массива в другой с учётом перекрытия массивов

Функция memmove() копирует count символов из массива, адресуемого параметром from, в массив, адресуемый параметром to. Если заданные массивы перекроются, процесс копирования пройдет корректно, т.е. соответствующее содержимое будет помещено в массив to, но массив from останется модифицированным.

Функция memmove() возвращает значение указателя to.


memset()

#include <string.h>
void *memset(void *buf, int ch, size_t count);

Описание

Заполняет определённое количество символов массива заданным

Функция memset() копирует младший байт параметра ch в первые count символов массива, адресуемого параметром buf. Функция возвращает значение указателя buf.

Чаще всего функция memset() используется для инициализации области памяти некоторым известным значением.


strcat()

#include <string.h>
char *strcat(char *strl, const char *str2);

Описание

Присоеденяет копию одной строки к заданной

Функция strcat() присоединяет копию строки str2 к строке strl и завершает строку strl нулевым символом. Конечный нуль-символ, первоначально завершающий строку strl, перезаписывается первым символом строки str2. Строка str2 в результате этой операции конкатенации не модифицируется. Если заданные массивы перекрываются, поведение функции strcat() не определено.

В версии С99 к параметрам strl и str2 применен квали-фикатор restrict

Функция strcat() возвращает значение указателя strl.

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


strchr()

#include <string.h>
char *strchr(const char *str, int ch);

Описание

Возвращает указатель на первое вхождение младшего байта заданного параметра

Функция strchr() возвращает указатель на первое вхождение младшего байта параметра ch в строке str. Если совпадение не обнаружено, возвращается нулевой указатель.


strcmp()

#include <string.h>
int strcmp(const char *strl, const char *str2);

Описание

Cравнивает в лексикографическом порядке две строки

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

Значение | Результат сравнения строк
Меньше нуля | str1 меньше str2
Нуль | str1 равна str2
Больше нуля | str1 больше str2


strcoll()

#include <string.h>
int strcoll(const char *strl, const char *str2);

Описание

Сравнивает одну строку с другой в соответствии с параметром setlocale

Функция strcoll() сравнивает строку strl со строкой str2. Сравнение выполняется с учетом значения параметра locale, заданного с помощью функции setlocale() (подробности приводятся в разделе "setlocale" главы 10).

Функция strcoll() возвращает целое значение, которое интерпретируется следующим образом.

Значение | Результат сравнения
Меньше нуля | strl меньше str2
Нуль | strl равно str2
Больше нуля | strl больше str2


strcpy()

#include <string.h>
char *strcpy(char *str1, const char *str2);

Описание

Копирует содержимое одной строки в другую

Функция strcpy() копирует содержимое строки str2 в строку strl. Параметр str2 должен указывать на строку с завершающим нулевым символом. Функция strcpy() возвращает значение указателя strl.

Если заданные символьные массивы перекрываются, поведение функции strcpy() не определено.

В версии С99 к параметрам strl и str2 применен квали-фикатор restrict.


strcspn()

#include <string.h>
size_t strcspn(const char *str1, const char *str2);

Описание

Возращает строку в которой отсутствуют заданные символы

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


strerror()

#include <string.h>
char *strerror(int errnum);

Описание

Возвращает указатель на строку содержащую системное сообщение об ошибке

Функция strerror() возвращает указатель на строку, содержащую системное сообщение об ошибке, связанной со значением errnum. Ни при каких обстоятельствах не следует модифицировать эту строку.


strlen()

#include <string.h>
size_t strlen(char *str);

Описание

Возвращает длину строки с завершающим нулевым символом

Функция strlen() возвращает длину строки с завершающим нулевым символом, адресуемой параметром str. Завершающий нулевой символ не учитывается.


strncat()

#include <string.h>
char *strncat(char *str1, const char *str2, size_t count);

Описание

Присоеденяет определённое кличество символов одной строки к другой

Функция strncat() присоединяет не более count символов строки, адресуемой параметром str2, к строке, адресуемой параметром str1, завершая результирующую строку str1 нулевым символом. Конечный нуль-символ, первоначально завершающий строку str1, перезаписывается первым символом строки str2. Строка str2 в результате этой операции конкатенации не модифицируется. Если заданные массивы перекрываются, поведение функции strncat() не определено.

В версии С99 к параметрам strl и str2 применен квали-фикатор restrict.

Функция strncat() возвращает значение указателя str1.

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


strncmp()

#nclude <string.h>
int strncmp(const char *strl, const char *str2, size_t count);

Описание

Лексографически сравнивает две строки

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

Значение | Результат сравнения строк
Меньше нуля | str1 меньше str2
Нуль | str1 равна str2
Больше нуля | str1 больше str2

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


strncpy()

#include <string.h>
char *strncpy(char *str1, const char *str2, size_t count);

Описание

Копирует определённое количество символов в символьный массив

Функция strncpy() копирует до count символов из строки, адресуемой параметром str2, в массив, адресуемый параметром str1. Параметр str2 должен указывать на строку с завершающим нулевым символом.

В версии С99 к параметрам str1 и str2 применен квали-фикатор restrict.

Если заданные символьные массивы перекрываются, поведение функции strncpy() не определено.

Если длина строки, адресуемой параметром str2, меньше значения count, то в конец строки-результата str1 добавляются "недостающие" нулевые символы.

И наоборот, если длина строки, адресуемой параметром str2, больше значения count, результирующая строка, адресуемая параметром str1, автоматически не получит завершающего нулевого символа.

Функция strncpy() возвращает значение указателя str1.


strpbrk()

#include <string.h>
char *strpbrk(const char *str1, const char *str2);

Описание

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

Функция strpbrk() возвращает указатель на первый символ в строке, адресуемой параметром str1, который совпадает с любым символом в строке, адресуемой параметром str2. Завершающие нулевые символы в расчет не берутся. Если совпадение не обнаружено, возвращается нулевой указатель


strrchr()

#include <string.h>
char *strrchr(const char *str, int ch);

Описание

Возвращает указатель на последнее вхождение младшего байта заданного параметра в строке

Функция strrchrO возвращает указатель на последнее вхождение младшего байта параметра ch в строке, адресуемой параметром str. Если совпадение не обнаружено, возвращается нулевой указатель.


strspn()

#include <string.h>
size_t strspn(const char *str1, const char *str2);

Описание

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

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


strstr()

#include <string.h>
char *strstr(const char *str1, const char *str2);

Описание

Возвращает указатель на первое вхождение одной строки в другую

Функция strstr() возвращает указатель на первое вхождение в строке, адресуемой параметром str1, строки, адресуемой параметром str2. Если совпадение не обнаружено, возвращается нулевой указатель.


strtok()

#include <string.h>
char *strtok(char *str1, const char *str2);

Описание

Возвращает указатель на следующую лексему в строке

Функция strtok() возвращает указатель на следующую лексему в строке, адресуемой параметром str1. Символы, образующие строку, адресуемую параметром str2, представляют собой разделители, которые определяют лексему. При отсутствии лексемы, подлежащей возврату, возвращается нулевой указатель.

В версии С99 к параметрам str1 и str2 применен квали-фикатор restrict.

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

При каждом обращении к функции strtok() можно использовать различные наборы разделителей лексем.

Совет программисту

Функция strtok() предоставляет средство, позволяющее сократить строку до составляющих ее частей. Например, следующая программа разделяет на лексемы строку "One, two, and three".

Копировать
#include <stdio.h>
#include <string.h>
int main(void)
    char *p;

    p = strtok("One, two, and three.", ",");
    printf(p);
    do {
        p = strtok(NULL, ",. ");
        if(p) printf("|%s", p);
    } while(p),

    return 0;
}

Результат работы этой программы имеет следующий вид.

Копировать
One | two | and | three

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


strxfrm()

#include <string.h>
size_t strxfrm(char *str1, const char *str2, size_t count);

Описание

Преобразует определённое количество символов заданной строки чтобы ее можно было использовать функцией strcmp()

Функция strxfrm() преобразует первые count символов строки, адресуемой параметром str2, таким образом, чтобы ее можно было использовать функцией strcmp(), и помещает результат в строку, адресуемую параметром str1. После преобразования результат вызова функции strcmp(), использующей параметр str1, будет совпадать с результатом вызова функции strcoll(), использующей исходную строку, на которую указывает параметр str2. В массив, адресуемый параметром str1, записывается не более count символов.

В версии С99 к параметрам str1 и str2 применен квали-фикатор restrict.

Функция strxfrm() возвращает длину преобразованной строки.


tolower()

#include <ctype.h>
int tolower(int ch);

Описание

Переводит символ в нижний регистр

Функция tolower() возвращает строчной эквивалент параметра ch, если ch — буква; в противном случае параметр ch не изменяется.


toupper()

#include <ctype.h>
int toupper(int ch);

Описание

Переводит символ в верхний регистр

Функция toupper() возвращает прописной эквивалент параметра ch, если ch — буква; в противном случае параметр ch не изменяется.


Функции динамического выделения памяти

В этой главе описаны функции динамического выделения памяти C/C++. Самыми популярными из них являются malloc() и free(). При каждом вызове функции malloc() системой выделяется некоторая порция свободной памяти. При каждом вызове функции free() определенная порция памяти возвращается системе. Область свободной памяти, которая расходуется для удовлетворения запросов, называется кучей. Для программ на языке С прототипы функций динамического выделения памяти находятся в заголовке <stdlib.h>, а программы на языке C++ должны использовать заголовок <cstdlib>. В этой главе для простоты изложения употребляются имена С-заголовков, но ссылки на заголовок <stdlib.h> в соответствующей среде нужно заменить ссылками на заголовок <cstdlib>.

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

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

Смотрите также

Операторы new и delete
calloc — Выделяет память для массива содержащего определённое количество объектов
free — Возвращает куче память, адресуемую заданным указателем
malloc — Возвращает указатель на первый байт области памяти, которая была выделена из кучи
realloc — Изменяет размер ранее выделенной памяти, адресуемой параметром, в соответствии с заданным размером


calloc()

#include <stdlib.h>
void *calloc(size_t num, size_t size);

Описание

Выделяет память для массива содержащего определённое количество объектов

Функция calloc() выделяет память, размер которой равен значению выражения num*size, т.е. память, достаточную для массива, содержащего num объектов размером size.

Функция calloc() возвращает указатель на первый байт выделенной области. Если для удовлетворения запроса нет достаточного объема памяти, возвращается нулевой указатель. Важно всегда удостовериться, что возвращаемое значение не является нулевым указателем, причем это нужно сделать еще до попытки его использовать.


free()

#include <stdlib.h>
void free(void *ptr);

Описание

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

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

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


malloc()

#include <stdlib.h>
void *malloc(size_t size);

Описание

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

Функция malloc() возвращает указатель на первый байт области памяти размером size, которая была выделена из кучи. Если для удовлетворения запроса нет достаточного объема памяти, возвращается нулевой указатель. Важно всегда удостовериться, что возвращаемое значение не является нулевым указателем. Попытка использовать нулевой указатель обычно приводит к полному отказу системы.

Совет программисту

Если вы пишете 16-разрядные программы для семейства процессоров 8086(например, 80486 или Pentium), то ваш компилятор, вероятно, предоставляет дополнительные функции выделения памяти, которые учитывают модель сегментированной памяти, используемую этими процессорами при работе в 16-разрядном режиме. Например, это могут быть функции, выделяющие память FAR-кучи(которая находится вне стандартного сегмента данных). Эти функции могут назначать указатели на память, объем которой больше одного сегмента, и освобождать такую память.


realloc()

#include <stdlib.h>
void *realloc(void *ptr, size_t size);

Описание

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

Действие функции realloc() в версии С99 немного отличается от ее работы в языках C++ и С89, хотя основной результат совпадает. В языках C++ и С89 функция realloc() изменяет размер ранее выделенной памяти, адресуемой параметром ptr в соответствии с заданным размером size. Значение параметра size может быть больше или меньше исходного. Функция realloc() возвращает указатель наблок памяти, поскольку не исключена необходимость перемещения этого блока при увеличении размера памяти. В этом случае содержимое старого блока(до size байт) копируется в новый блок.

В версии С99 блок памяти, адресуемый параметром ptr, освобождается, а вместо него выделяется новый блок. Содержимое нового блока совпадает с содержимым исходного(по длине, переданной в параметре size). Функция возвращает указатель на новый блок. Причем разрешается, чтобы новый и старый блоки начинались с одинакового адреса(т.е. указатель, возвращаемый функцией realloc(), может совпадать с указателем, переданным в параметре ptr).

Если указатель ptr нулевой, функция realloc() просто выделяет size байт памяти и возвращает указатель на эту память. Если значение параметра size равно нулю, память, адресуемая параметром ptr, освобождается.

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


Функции времени, даты и геополитической среды

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

В языке С использование функций даты и времени требует включения заголовка <time.h>, а в языке C++ — заголовка <ctime.h>. В этой главе для простоты изложения используются имена С-заголовков, но ссылки на заголовок <time.h> в соответствующей среде нужно заменить ссылками на заголовок <ctime.h>.

В заголовке <time.h> определены три типа данных, связанных с исчислением времени: clock_t, time_t и tin. Типы clock_t и time_t предназначены для представления системного времени и даты в виде некоторого целого значения, называемого календарным временем. Тип структуры tm содержит дату и время в виде разбиения на элементы. Итак, структура tm содержит следующие члены.

struct tm{
    int tm_sec;	//секунды, 0-61
    int tm_min;	//минуты, 0-59
    int tm_hour;	//часы, 0-23
    int tm_mday;	//день месяца, 1-31
    int tm_non;	//месяц, начиная с января, 0-11
    int tm_year;	//год после 1900
    int tm_wday;	//день, начиная с воскресенья, 0-6
    int tm_yday;	//день, начиная с 1-го января, 0-365
    int tm_isdst	//индикатор летнего времени
}

Значение tm_isdst положительно, если действует режим летнего времени(Daylight Saving Time), равно нулю, если не действует, и отрицательно, если информация об этом недоступна.

Кроме того, в заголовке <time.h> определен макрос CLOCKS_PER_SEC, который выдает количество тиканий системных часов в секунду.

Для работы с функциями геополитической среды необходимо использовать в языке С заголовок <locale.h>, а в языке C++ — заголовок <clocale.h>. В этих заголовках определена структура lconv, которая приведена в описании функции localeconv().

Список функций

asctime — Возвращает указатель на строку, которая содержит информацию о дате и времени
clock — Возвращает значение, которое приблизительно соответствует продолжительности времени работы вызывающей программы
ctime — Возвращает указатель на строку, которая содержит информацию о дате и времени
difftime — Возвращает значение разности в секундах между значениями заданных параметров
gmtime — Возвращает указатель на поэлементную форму параметра time в виде структуры tm
localeconv — Возвращает указатель на структуру типа, которая содержит различную информацию о геополитической среде
localtime — Возвращает указатель на поэлементную форму параметра time в виде структуры tm
mktime — Возвращает эквивалент календарного времени на основе времени, заданного в поэлементном виде и хранимого в структуре, которая адресуется параметром time
setlocale — Позволяет запросить или установить определенные параметры, которые зависят от геополитической среды выполнения программы
strftime — Помещает информацию о времени и дате(вместе с другой информацией) в строку
time — Возвращает текущее календарное время системы


asctime()

#include <time.h>
char *asctime(const struct tm *ptr);

Описание

Возвращает указатель на строку, которая содержит информацию о дате и времени

Функция asctime() возвращает указатель на строку, которая содержит информацию, сохраняемую в адресуемой параметром ptr структуре и имеющую следующую форму.

Копировать
день месяц число часы:минуты:секунды год\n\0

Например:

Копировать
Wed Jun 19 12:05:34 2005

Указатель на структуру, передаваемый функции asctime(), обычно получают с помощью либо функции local time(), либо функции gmtime().

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


clock()

#include <time.h>
clock_t clock(void);

Описание

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

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


ctime()

#include <time.h>
char *ctime(const time_t *time);

Описание

Возвращает указатель на строку, которая содержит информацию о дате и времени

Функция ctime() возвращает указатель на строку вида

Копировать
день месяц число часы:минуты:секунды год\n\0,

принимая в качестве параметра указатель на календарное время. Календарное время часто получают с помощью функции time().

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


difftime()

include <time.h>
double difftime(time_t time2, time_t time1);

Описание

Возвращает значение разности в секундах между значениями заданных параметров

Функция difftime() возвращает значение разности в секундах между значениями параметров timel и time2, т.е. возвращается значение выражения time2 - timel.


gmtime()

#include <time.h>
struct tm *gmtime(const time_t *time);

Описание

Возвращает указатель на поэлементную форму параметра time в виде структуры tm

Функция gmtime() возвращает указатель на поэлементную форму параметра time в виде структуры tm. Значение time представлено в виде так называемого всемирного времени (Coordinated Universal Time, или UTC), которое, по сути является временем по Гринвичу(Greenwich mean time). Значение time обычно получают с помощью функции time(). Если система не поддерживает всемирное время, возвращается значение NULL.

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


localeconv()

#include <locale.h>
struct lconv *localeconv(void);

Описание

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

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

char *decimal_point; | Символ десятичной точки для не денежных значений.
char *thousands_sep; | Разделитель тысяч для не денежных значений.
char *grouping; | Задает группирование для не денежных значений.
char int_curr_symbol; | Международный символ валюты.
char *currency_symbol; | Местный символ валюты.
char *mon_decimal_point; | Символ десятичной точки для денежных значений
char *mon_thousands_sep; | Разделитель тысяч для денежных значений.
char *mon_grouping; | Задает группирование для денежных значений.
char *positive_sign; | Индикатор положительных чисел для денежных значений.
char *negative_sign; | Индикатор отрицательных чисел для денежных значений.
char int_frac_digits; | Количество цифр, которые расположены справа от десятичной точки для денежных значений, отображаемых с использованием международного формата.
char frac_digits; | Количество цифр, которые расположены справа от десятичной точки для денежных значений, отображаемых с использованием местного формата.
char p_cs_precedes; | 1, если символ валюты стоит перед положительным значением, и 0, если символ валюты стоит после значения.
char p_sep_by_space; | 1, если символ валюты отделяется от положительного значения пробелом, и 0 в противном случае. В версии С99 содержится значение, которое определяет разделитель.
char n_cs_precedes; | 1, если символ валюты стоит перед отрицательным значением, и 0, если символ валюты стоит после значения.
char n_sep_by_space; | 1, если символ валюты отделяется от отрицательного значения пробелом, и 0 в противном случае. В версии С99 содержится значение, которое определяет разделитель.
char p_sign_posn; | Указывает позицию символа положительного значения.
char n_sign_posn; | Указывает позицию символа отрицательного значения.
Следующие члены были добавлены в версии С99:
char _p_cs_precedes; | 1, если символ валюты стоит перед положительным значением, и 0, если символ валюты стоит после значения. Применяется к значениям, форматируемым по международным правилам.
char _p_sep_by_space; | Означает разделитель между символом валюты, знаком числа и положительным значением. Применяется к значениям, форматируемым по международным правилам.
char _n_cs_precedes; | 1, если символ валюты стоит перед отрицательным значением, и 0, если символ валюты стоит после значения. Применяется к значениям, форматируемым по международным правилам.
char _n_sep_by_space; | Означает разделитель между символом валюты, знаком числа и отрицательным значением. Применяется к значениям, форматируемым по международным правилам.
char _p_sign_posn; | Указывает позицию символа положительного значения. Применяется к значениям, форматируемым по международным правилам.
char _n_sign_posn; | Указывает позицию символа отрицательного значения. Применяется к значениям, форматируемым по международным правилам.

Функция localeconv() возвращает указатель на структуру lconv. Содержимое этой структуры изменять нельзя. Для получения подробной информации, связанной с особенностями реализации структуры lconv, обращайтесь к документации на используемый вами компилятор.


localtime()

#include <time.h>
struct tm *localtime(const time_t *time);

Описание

Возвращает указатель на поэлементную форму параметра time в виде структуры tm

Функция localtime() возвращает указатель на поэлементную форму параметра time в виде структуры tm. Значение time представляет локальное время. Его обычно получают с помощью функции time().

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


mktime()

#include <time.h>
time_t mktime(struct tm *time);

Описание

Возвращает эквивалент календарного времени на основе времени, заданного в поэлементном виде и хранимого в структуре, которая адресуется параметром time

Функция mktime() возвращает эквивалент календарного времени на основе времени, заданного в поэлементном виде и хранимого в структуре, которая адресуется параметром time.

Элементы tm_wday и tm_yday устанавливаются самой функцией, поэтому их не нужно определять при ее вызове.

Если функция mktime() не в состоянии представить информацию в виде допустимого календарного времени, возвращается значение -1.

Совет программисту

Функция mktime() особенно полезна, когда нужно узнать, на какой день недели выпадает конкретная дата. Например, каким днем недели будет 12 января 2012 года? Чтобы выяснить это, вызовите функцию mktime() с этой датой, а затем(после выполнения функции) обратитесь к члену tm_wday структуры tm. Он будет содержать день недели. Этот метод демонстрируется следующей программой.

Копировать
/* Определение дня недели для даты "12 января 2012 года" (January 12, 2012). */
#include <stdio.h>
#include <time.h>
char day[][20] = {
    "Sunday",
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday"
};

int main(void)
{
    struct tm t;

    t.tm_mday = 12;
    t.tm_mon = 0;
    t.tm_year = 112;
    t.tm_hour = 0;
    t.tm_min = 0;
    t.tm_sec = 0;
    t.tm_isdst = 0;

    mktime(&t);	//получаем день недели

    printf("день недели %s.\n", day[t.tm_wday]);

    return 0,
}

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


setlocale()

include <locale.h>
char *setlocale(int type, const char *locale);

Описание

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

Функция setlocale() позволяет запросить или установить определенные параметры, которые зависят от геополитической среды выполнения программы. Если указатель locale нулевой, функция setlocale() возвращает указатель на строку текущей локализации. В противном случае функция попытается использовать заданную строку локализации для установки локальных параметров в соответствии с параметром type. Для задания стандартных С-параметров региональной привязки используйте строку "С", а для задания собственных параметров среды — пустую строку(""). Чтобы получить подробную информацию о строках локализации, поддерживаемых вашим компилятором, обратитесь к документации.

При вызове функции setlocale() в качестве параметра type должен быть использован один из следующих макросов (определенных в заголовке <locale.h>).

LC_ALL
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC TIME

Макрос LC_ALL относится ко всем категориям локализации. Макрос LC_COLLATE оказывает влияние на выполнение функции strcoll(). Макрос LC_CTYPE изменяет характер работы символьных функций. Макрос LC_MONETARY определяет денежный формат. Макрос LC_NUMERIC изменяет символ десятичной точки для функций форматированного ввода-вывода. Наконец, макрос LC_TIME определяет поведение функции strftime().

Функция setlocale() возвращает указатель на строку, связанную с параметром type.


strftime()

#include <time.h>
size_t strftime(char *str, size_t maxsize,
        const char *fmt, const struct tm *time);

Описание

Помещает информацию о времени и дате(вместе с другой информацией) в строку

Функция strftime() помещает информацию о времени и дате(вместе с другой информацией) в строку, адресуемую параметром str, в соответствии с командами форматирования, которые содержатся в адресуемой параметром fmt строке, и используя поэлементно заданное время time. В строку str будет помещено максимум maxsize символов.

В версии С99 к параметрам str, fmt и time применен ква-лификатор restrict.

Работа функции strftime() напоминает работу функции sprintf() в том, что она распознает набор команд форматирования, которые начинаются со знака процента(%), и помещает отформатированный результат в строку. Команды форматирования используются для задания точного способа представления различных данных времени и даты в параметре str. Любые другие символы, содержащиеся в строке форматирования, помещаются в строку str без изменений. Значения времени и даты отображаются в виде локального времени. Команды форматирования перечислены в следующей таблице. Обратите внимание на то, что во многих командах прописные и строчные буквы имеют различную интерпретацию.

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

Команда | Результат форматирования
%а | Сокращенное название дня недели
%А | Полное название дня недели
%b | Сокращенное название месяца
%В | Полное название месяца
%с | Стандартная строка даты и времени
%С | Последние две цифры года
%d | День месяца в виде десятичного числа(1-31)
%D | Дата в виде месяц/день/год(добавлено в версии С99)
%е | День месяца как десятичное число(1-31) в 2-символьном поле(добавлено в версии С99)
%F | Дата в виде год-месяц-день(добавлено в версии С99)
%g | Последние две цифры года с использованием понедельного года(добавлено в версии С99)
%G | Год с использованием понедельного года (добавлено в версии С99)
%h | Сокращенное название месяца(добавлено в версии С99)
%H | Часы(0-23)
%I | Часы(1-12)
%j | День года в виде десятичного числа(1-366)
%m | Месяц в виде десятичного числа(1-12)
%M | Минуты в виде десятичного числа(0-59)
%n | Новая строка(добавлено в версии С99)
%p | Эквивалент индикатора A.M. или P.M. для местного времени
%r | 12-часовое время(добавлено в версии С99)
%R | Время в виде чч:мм(добавлено в версии С99)
%S | Секунды в виде десятичного числа(0-60)
%t | Горизонтальная табуляция(добавлено в версии С99)
%T | Время в виде чч:мм:сс(добавлено в версии С99)
%u | День недели; понедельник — первый день недели(1-7)(добавлено в версии С99)
%U | Неделя года; воскресенье — первый день недели(0-53)
%V | еделя года с использованием понедельного года(добавлено в версии С99)
%w | День недели в виде десятичного числа(0-6, воскресенье — 0-й день)
%W | Неделя года; понедельник — первый день недели(0-53)
%x | Стандартная строка даты
%X | Стандартная строка времени
%y | Год в виде десятичного числа без столетия(0-99)
%Y | Год в виде десятичного числа, включающего столетие
%z | Смещение относительно UTC(добавлено в версии С99)
%Z | Название часового пояса
%% | Знак процента

Понедельный год используется командами форматирования %g, %G и %v. При таком представлении первым днем недели является понедельник, а первая неделя года должна включать день с датой "4 января".


time()

#include <time.h>
time_t time(time_t *time);

Описание

Возвращает текущее календарное время системы

Функция time() возвращает текущее календарное время системы. Если в системе отсчет времени не производится, возвращается значение -1.

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


Стандартные функции ввода вывода языка C

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

В языке С с функциями ввода-вывода связан заголовок <stdio.h>, а в C++ аналогичный заголовок называется <stdio>. Для простоты в этой главе будет использовано имя С-заголовка, но ссылки на <stdio.h> применимы и к заголовку <stdio>.

Заголовок <stdio.h> определяет несколько макросов и типов, требуемых файловой системой в среде С. Тип FILE — самый важный; он используется для объявления указателя на файл. Двумя другими часто используемыми типами являются size_t и fpos_t, которые представляют собой некоторую разновидность целых без знака. Тип size_t определяет объект, который предназначен для хранения размера самого большого файла, разрешенного операционной средой. Тип fpos_t определяет объект, который может хранить всю информацию, необходимую для уникального определения каждой позиции внутри файла. Самым популярным макросом, определенным в этом заголовке, является макрос EOF, значение которого указывает на конец файла. Другие типы данных и макросы, определенные в заголовке <stdio.h>, описаны вместе с функциями, с которыми они связаны.

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

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

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

В начале работы программы автоматически открываются три заранее определенных потока: stdin, stdout и stderr. Их называют стандартными потоками ввода, вывода и ошибок соответственно. По умолчанию они связаны с консолью, но их можно перенаправить на устройство любого другого типа.

В версии С99 введен квалификатор restrict, который применяется к некоторым параметрам нескольких функций, первоначально определенных в версии С89. При рассмотрении каждой такой функции будет приведен ее прототип, используемый в среде С89 (а также в среде C++), а параметры с атрибутом restrict будут отмечены в описании этой функции.

Список функций

Работа с стандартными потоками

getchar — Возвращает следующий символ из стандартного потока stdin
gets — Читает символы из стандартного потока stdin и помещает их в символьный массив
perror — Преобразует значение глобальной переменной errno в строку и записывает эту строку в поток ошибок stderr
printf — Записывает в стандартный поток stdout значения аргументов из заданного списка аргументов в соответствии со строкой форматирования
putchar — Записывает символ, содержащийся в младшем байте параметра в стандартный выходной поток stdout
puts — Записывает строку в стандартное выходное устройство
scanf — Читает поток stdin
vfprintf — Эквивалентно действию функции vprintf() но список аргументов заменен указателем на список аргументов
vfscanf — Аналогично fscanf(), но но список аргументов заменен указателем на список аргументов
vprintf — Эквивалентно действию функции printf() но список аргументов заменен указателем на список аргументов
vscanf — Аналогично scanf(), но но список аргументов заменен указателем на список аргументов
vsnprintf — Эквивалентно действию функции snprintf() но список аргументов заменен указателем на список аргументов
vsprintf — Эквивалентно действию функции sprintf() но список аргументов заменен указателем на список аргументов
vsscanf — Аналогично sscanf(), но но список аргументов заменен указателем на список аргументов

Работа с файловыми потоками

clearerr — Сбрасывает флажок ошибки связанный с потоком
fclose — Закрывает файл, связанный с потоком stream
feof — Проверка конца файла
ferror — Проверка наличия файловой ошибки
fflush — Записывает содержимое выходного буфера в файл
fgetc — Возвращает из указаного входного потока следующий символ
fgetpos — Сохраняет текущее значение индикатора позиции файла в объекте
fgets — Читает символы из указанного файлового потока и помещает в символьный массив
fopen — Открывает файл и возвращает поток, связываемый с этим файлом
fprintf — Выводит в указанный файловый поток значения аргументов
fputc — Записывает символ в заданный поток
fputs — Записывает в заданый поток содержание строки
fread — Читает из указанного потока заданное количество объектов
freopen — Связывает существующий поток с другим файлом
fscanf — Читает указанный поток
fseek — Смещает индикатор позиции файла, связанного с потоком
fsetpos — Перемещает индикатор позиции файла в место, заданное объектом
ftell — Возвращает текущее значение индикатора позиции файла для заданного потока
fwrite — Записывает в указанный поток некоторое количество объектов
getc — Возвращает следующий символ из указаного потока
putc — Записывает символ, содержащийся в младшем байте параметра в указанный выходной поток
rewind — Перемещает индикатор позиции файла в начало заданного потока
setbuf — Задает буфер, которым будет пользоваться заданный поток
setvbuf — Позволяет задать буфер, его размер и режим работы с указанным потоком
tmpfile — Открывает временный двоичный файл для операций чтения/записи
tmpnam — Генерирует уникальное имя файла и сохраняет его в массиве
ungetc — Возвращает символ, заданный младшим байтом

Работа с файловой системой

remove — Удаляет файл
rename — Заменяет имя файла

Другие функции

snprintf — Записывает определёное количество значений аргументов из заданного списка аргументов, в соответствии со строкой форматирования, в массив
sprintf — Записывает в массив значения аргументов из заданного списка аргументов в соответствии со строкой форматирования
sscanf — Читает данные из массива, аналогично scanf()


getchar()

include <stdio.h>
int getchar(void);

Описание

Возвращает следующий символ из стандартного потока stdin

Функция getchar() возвращает следующий символ из стандартного потока stdin. Символ читается с использованием типа unsigned char, после чего преобразуется в целый тип.

При достижении конца файла функция get char() возвращает значение EOF. При обнаружении ошибки функция getchar () также возвращает значение EOF.

Функция getchar() чаще всего реализована как макрос.


gets()

#include <stdio.h>
char *gets(char *str);

Описание

Читает символы из стандартного потока stdin и помещает их в символьный массив

Функция gets() читает символы из стандартного потока stdin и помещает их в символьный массив, адресуемый указателем str. Символы читаются до тех пор, пока не встретится символ новой строки или значение EOF. Символ новой строки не является частью строки, поэтому он преобразуется в нулевой символ, завершающий строку.

При успешном выполнении функция gets() возвращает указатель str; а при сбое возвращается нулевой указатель. Если произошла ошибка, содержимое массива, адресуемого параметром str, не определено. Поскольку функция gets() возвращает нулевой указатель и при возникновении ошибки, и при достижении конца файла, то для выяснения, что же произошло на самом деле, необходимо использовать функцию feof() или ferror().

Не существует способа ограничить число символов, которое прочитает функция gets(), а это значит, что массив, адресуемый указателем str, может переполниться. Следовательно, данная функция опасна по своей природе. Ее следует использовать только в пробных программах или утилитах "внутреннего" назначения, т.е. для себя. Ее не рекомендуется использовать в коммерческих программах.


perror()

#include <stdio.h>
void perror(const char *str);

Описание

Преобразует значение глобальной переменной errno в строку и записывает эту строку в поток ошибок stderr

Функция perror() преобразует значение глобальной переменной errno в строку и записывает эту строку в поток ошибок stderr. Если значение параметра str не равно нулю, то сначала записывается сама строка, за ней — двоеточие, а затем следует сообщение об ошибке, определяемое конкретной реализацией.

Совет программисту

При использовании функции gets() возможно переполнение массива, предназначенного для размещения символов, вводимых пользователем, поскольку эта функция не предусматривает никакой проверки факта нарушения границ. Чтобы обойти эту проблему, можно использовать функцию fgets() и задать в качестве входного потока стандартный поток stdin. Поскольку функция fget() требует задания максимальной длины, можно предотвратить переполнение массива. Вам остается позаботиться лишь о том, чтобы вручную удалить символ новой строки, завершающий ввод, поскольку функция fgets() этого не делает (в отличие от функции gets()). Рассмотрим следующую программу.

Копировать
#include
#include
int main(void)
{
    char str [10];
    int i;
    printf("Введите строку: ");
    fgets(str, 10, stdin);

/* Удаляем символ новой строки, если таковой
существует. */
    i = strlen(str)-1;
    if(str[i]=='\n') str[i] = '\0';
    printf("Вот ваша строка: %s", str);

    return 0;
}

Хотя использование функции fgets() требует приложения чуть больших усилий, ее преимущество перед функцией gets() состоит в том, что она позволяет защитить массив ввода от переполнения.


printf()

#include <stdio.h>
int printf(const char *format, ...);

Описание

Записывает в стандартный поток stdout значения аргументов из заданного списка аргументов в соответствии со строкой форматирования

Функция printf() записывает в стандартный поток stdout значения аргументов из заданного списка аргументов в соответствии со строкой форматирования, адресуемой параметром format.

Строка форматирования состоит из элементов двух типов. К элементам первого типа относятся символы, которые выводятся на экран. Элементы второго типа содержат команды форматирования, которые определяют способ отображения аргументов. Команда форматирования начинается с символа процента, за которым следует код формата. Количество аргументов должно в точности совпадать с количеством команд форматирования, причем совпадение обязательно и в порядке их следования. Например, при вызове следующей функции printf() на экране будет отображено "Hi с 10 there!".

Копировать
printf("Hi %c %d %s", 'с', 10, "there!")

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

Код | Формат
%а | Шестнадцатеричное целое в форме Oxh.hhhhp+d.(только С99)
%А | Шестнадцатеричное целое в форме OXh.hhhhP+d.(только С99)
%с | Символ
%d | Десятичное целое со знаком
%i | Десятичное целое со знаком
%е | Экспоненциальное представление (строчная буква е)
%Е | Экспоненциальное представление (прописная буква Е)
%f | Значение с плавающей точкой
%F | Значение с плавающей точкой (только в С99; при бесконечном результате или когда значение не является числом, выводит INF, INFINITY или NAN; спецификатор %f генерирует строчные эквиваленты)
%g | Использует более короткий из двух форматов: %е или %f (если %е, использует строчную букву е)
%G | Использует более короткий из двух форматов: %Е или %F (если %Е, использует прописную букву Е)
%o | Восьмеричное целое без знака
%s | Строка символов
%u | Десятичное целое без знака
%х | Шестнадцатеричное целое без знака (строчные буквы)
%х | Шестнадцатеричное целое без знака (прописные буквы)
%р | Указатель
%n | Соответствующий аргумент должен быть указателем на целое. Данный спецификатор сохраняет в этом целом число символов, выведенных в выходной поток к текущему моменту (до обнаружения спецификатора %n)
%% | Печатает символ %

Функция printf() возвращает число реально выведенных символов. Отрицательное значение возврата свидетельствует об ошибке.

Команды формата могут иметь модификаторы, которые задают ширину поля, точность и признак выравнивания по левому краю. Целое значение, расположенное между знаком % и командой форматирования, выполняет роль спецификатора минимальной ширины поля. Наличие этого спецификатора приведет к тому, что результат будет заполнен пробелами или нулями, чтобы гарантированно обеспечить для выводимого значения заданную минимальную длину. Если выводимое значение (строка или число) больше этого минимума, оно будет выведено полностью, несмотря на превышение минимума. По умолчанию в качестве заполнителя используется пробел. Для заполнения нулями нужно поместить 0 перед спецификатором ширины поля. Например, строка форматирования %05d дополнит выводимое число нулями (их будет меньше 5), чтобы общая длина была равной 5 символам.

Точное значение модификатора точности зависит от кода формата, к которому он применяется. Чтобы добавить модификатор точности, поставьте за спецификатором ширины поля десятичную точку, а после нее — значение спецификации точности. Для форматов а, А, е, Е, f и F модификатор точности определяет число выводимых десятичных знаков. Например, строка форматирования %10.4f обеспечит вывод числа, ширина которого составит не меньше десяти символов, с четырьмя десятичными знаками. Если модификатор точности применяется к коду формата g или G, то он определяет максимальное число выводимых значащих цифр. Применительно к целым, модификатор точности задает минимальное количество выводимых цифр. При необходимости будут добавлены начальные нули.

Если модификатор точности применяется к строкам, число, следующее за точкой, задает максимальную длину поля. Например, строка форматирования %5.7s отобразит строку длиной не менее пяти, но не более семи символов. Если выводимая строка окажется длиннее максимальной длины поля, конечные символы будут отсечены.

По умолчанию все выводимые значения выравниваются по правому краю: если ширина поля больше выводимого значения, оно будет выровнено по правому краю поля. Чтобы установить выравнивание по левому краю, поставьте знак "минус" сразу после знака %. Например, строка форматирования %-10.2f обеспечит выравнивание вещественного числа (с двумя десятичными знаками в 10-символьном поле) по левому краю.

Существуют два модификатора команд форматирования, которые позволяют функции printf() отображать короткие и длинные целые. Эти модификаторы могут применяться к спецификаторам типа d, i, о, и, х и X. Модификатор l уведомляет о длинном формате значения. Например, строка %ld означает, что выводится длинное целое. Модификатор h сообщает о коротком формате. Следовательно, строка %hu означает, что выводимое данное имеет тип short unsigned integer.

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

Модификатор l можно также поставить перед командами форматирования вещественных чисел а, А, е, Е, f, F, g и G. В этом случае он уведомит о выводе значения типа long double.

Команда n сохраняет в целой переменной, указатель на которую задан в списке аргументов, число символов, которые были записаны в выходной поток к моменту обнаружения спецификатора n. Например, следующий фрагмент программы выведет число 14 после строки "This is a test".

Копировать
int i;
printf("This is a test%n", &i);
printf("%d", i);

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

Символ # имеет специальное значение при использовании с некоторыми кодами формата функции printf(). Символ #, поставленный перед кодами a, A, g, G, f, е и Е, гарантирует присутствие десятичной точки даже в случае, если десятичных цифр нет. Если поставить символ # перед кодами формата х и X, то шестнадцатеричное число будет выведено с префиксом 0х. Если поставить символ # перед кодами формата о и О, то восьмеричное число будет выведено с префиксом O. Символ # нельзя применять ни к каким другим спецификаторам формата.

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

Модификаторы формата, добавленные к функции printf() стандартом С99

В версии С99 добавлено несколько модификаторов формата для использования в функции printf(): hh, l, j, z и t. Модификатор hh можно применять к спецификаторам d, i, о, и, х, X и n. Он означает, что соответствующий аргумент является значением типа signed char или unsigned char, а в случае спецификатора n — указателем на переменную типа signed char. Модификатор llтакже можно применять к спецификаторам d, i, о, и, х, X и n. Он означает, что соответствующий аргумент является значением типа signed long long int или unsigned long long int, а в случае спецификатора n — указателем на переменную типа long long int.

Модификатор формата j, который применяется к спецификаторам d, i, о, и, х, X и п, означает, что соответствующий аргумент имеет тип intmax_t или uintmax_t. Эти типы объявлены в заголовке <stdint.h> и служат для хранения целых самой большой длины.

Модификатор формата z, который применяется к спецификаторам d, i, о, и, х, X и п, означает, что соответствующий аргумент имеет тип size_t. Этот тип объявлен в заголовке <stddef.h> и служит для хранения результата операции sizeof.

Модификатор формата t, который применяется к спецификаторам d, i, о, и, х, X и п, означает, что соответствующий аргумент имеет тип ptrdiff_t. Этот тип объявлен в заголовке <stddef.h> и служит для хранения значения разности между двумя указателями.

В версии С99 также разрешено применять модификатор l к спецификаторам вещественных типов а, А, е, Е, f, F, g и G, но он не работает.


putchar()

include <stdio.h>
int putchar(int ch);

Описание

Записывает символ, содержащийся в младшем байте параметра в стандартный выходной поток stdout

Функция putchar() записывает символ, содержащийся в младшем байте параметра ch, в стандартный выходной поток stdout. По выполняемому действию она эквивалентна функции putc(ch, stdout). Поскольку символьные аргументы возводятся в ранг целого в момент вызова, их вполне можно использовать в качестве аргументов для функции putchar().

При успешном выполнении функция putchar() возвращает записанный символ, а в случае ошибки — значение EOF.


puts()

#include <stdio.h>
int puts(char *str);

Описание

Записывает строку в стандартное выходное устройство

Функция puts() записывает строку, адресуемую параметром str, в стандартное выходное устройство. Завершающий нуль преобразуется в символ новой строки.

При успешном выполнении функция puts() возвращает неотрицательное значение, а в случае сбоя — значение EOF.


scanf()

#include <stdio.h>
int scanf(const char * format, ...);

Описание

Читает поток stdin

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

В версии С99 к параметру format применен квалификатор restrict.

Управляющая строка, задаваемая параметром format, состоит из символов трех категорий:

  • спецификаторов формата;
  • пробельных символов;
  • символов, отличных от пробельных.

Спецификаторы формата - им предшествует знак процента(%) - сообщают, какого типа данное будет прочитано следующим. Например, спецификатор %s прочитает строку, а %d - целое значение. Строка форматирования читается слева направо, и спецификаторы формата по порядку сопоставляются с аргументами, перечисленными в списке аргументов. Эти коды приведены в следующей таблице.

Код | Назначение
%а | Читает значение с плавающей точкой(только С99)
%А | Аналогично коду %a (только С99)
%с | Читает один символ
%d | Читает десятичное целое
%i | Читает целое в любом формате(десятичное, восьмеричное, естнадцатеричное)
%е | Читает вещественное число
%Е | Аналогично коду %е
%f | Читает вещественное число
%F | Аналогично коду %f(только С99)
%g | Читает вещественное число
%G | Аналогично коду %g
%о | Читает восьмеричное число
%s | Читает строку
%х | Читает шестнадцатеричное число
%X | Аналогично коду %х
%р | Читает указатель
%n | Принимает целое значение, равное количеству символов, прочитанных до сих пор
%u | Читает десятичное целое без знака
%[ ] | Просматривает набор символов
%% | Читает знак процента

Чтобы прочитать длинное целое, поставьте перед спецификатором формата модификатор l, а чтобы прочитать короткое целое — модификатор h. Эти модификаторы можно использовать с кодами формата d, i, о, и и х.

По умолчанию спецификаторы а, f, e и g заставляют функцию scanf() присваивать данные переменным типа float. Если поставить перед одним из этих спецификаторов формата модификатор l, функция scanf() присвоит прочитанное данное переменной типа double. Использование же модификатора L означает, что переменная, принимающая значение, имеет тип long double.

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

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

Не пробельный символ в строке форматирования заставляет функцию scanf() прочитать и отбросить соответствующий символ. Например, при использовании строки форматирования %d, %d функция scanf() сначала прочитает целое значение, затем прочитает и отбросит запятую и наконец прочитает еще одно целое. Если заданный символ не обнаружится, работа функции scanf() будет завершена.

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

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

Копировать
scanf("%d%d", &r, &c);

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

Символ *, стоящий после знака % и перед кодом формата, прочитает данные заданного типа, но запретит их присваивание. Следовательно, оператор

Копировать
scanf("%d%*c%d", &х, &у);

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

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

Копировать
scanf("%20s", address);

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

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

Копировать
scanf("%с%с%с", &а, &Ь, &с);

поместит символ х в переменную а, пробел — в переменную Ь и символ у — в переменную с.

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

Копировать
scanf("%st%s", &х, &у);

поместит 10 в переменную х и 20 — в переменную у. Символ t отбрасывается, так как он присутствует в управляющей строке.

Еще один способ использования функции scanf() называется набором сканируемых символов(scanset). В этом случае определяется набор символов, которые могут быть прочитаны функцией scanf() и присвоены соответствующему массиву символов. Для определения такого набора необходимо заключить символы, подлежащие сканированию, в квадратные скобки. Открывающая квадратная скобка должна следовать сразу за знаком процента. Например, следующий набор сканируемых символов говорит о том, что необходимо прочитать только символы А, В и С.

Копировать
%[АВС]

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

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

Многие компиляторы позволяют с помощью дефиса задать диапазон. Например, следующий оператор заставляет функцию scanf() принимать символы от А до Z.

Копировать
%[A-Z]

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

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

Модификаторы формата, добавленные к функции scanf() стандартом С99

В версии С99 добавлено несколько модификаторов формата для использования в функции scanf(): hh, ll, j, z и t. Модификатор hh можно применять к спецификаторам d, i, о, и, х и п. Он означает, что соответствующий аргумент является указателем на значение типа signed char или unsigned char. Модификатор ll также можно применять к спецификаторам d, i, о, и, х и п. Он означает, что соответствующий аргумент является указателем на значение типа signed long long int или unsigned long long int.

Модификатор формата j, который применяется к спецификаторам d, i, о, и, х и n, означает, что соответствующий аргумент является указателем на значение типа intmax_t или uintmax_t. Эти типы объявлены в заголовке <stdint.h> и служат для хранения целых максимально возможной длины.

Модификатор формата z, который применяется к спецификаторам d, i, о, u, x и n, означает, что соответствующий аргумент является указателем на объект типа size_t. Этот тип объявлен в заголовке <stddef.h> и служит для хранения результата операции sizeof.

Модификатор формата t, который применяется к спецификаторам d, i, о, u, x и n, означает, что соответствующий аргумент является указателем на объект типа ptrdiff_t. Этот тип объявлен в заголовке <stddef.h> и служит для хранения значения разности между двумя указателями.


vfprintf()

#include <stdarg.h>
#include <stdio.h>
int vfprintf(FILE *stream, const char *format, va_list arg_ptr);

Описание

Эквивалентно действию функции vprintf() но список аргументов заменен указателем на список аргументов

Действие функции vfprintf() эквивалентно действию функции fprintf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

В версии С99 к параметрам buf и format применен квалификатор restrict.


vfscanf()

#include <stdarg.h>
#include <stdio.h>
int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg_ptr);

Описание

Аналогично fscanf(), но но список аргументов заменен указателем на список аргументов

Действие функции vfscanf() эквивалентно действиям функций fscanf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

Эта функция добавлены в версии С99.


vprintf()

#include <stdarg.h>
#include <stdio.h>
int vprintf(char *format, va_list arg_ptr);

Описание

Эквивалентно действию функции printf() но список аргументов заменен указателем на список аргументов

Действие функции vprintf() эквивалентно действию функции printf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

В версии С99 к параметрам buf и format применен квалификатор restrict.


vscanf()

#include <stdarg.h>
#include <stdio.h>
int vscanf(char * restrict format, va_list arg_ptr);

Описание

Аналогично scanf(), но но список аргументов заменен указателем на список аргументов

Действие функции vscanf() эквивалентно действиям функций scanf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

Эта функция добавлены в версии С99.


vsnprintf()

#include <stdarg.h>
#include <stdio.h>
int vsnprintf(char * restrict buf, size_t num, const char * restrict format, va_list arg_ptr);

Описание

Эквивалентно действию функции snprintf() но список аргументов заменен указателем на список аргументов

Действие функции vsnprintf() эквивалентно действию функции snprintf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

В версии С99 к параметрам buf и format применен квалификатор restrict.

Функция snprintf() добавлена в версии С99.


vsprintf()

#include <stdarg.h>
#include <stdio.h>
int vsprintf(char *buf, char * format, va_list arg_ptr);

Описание

Эквивалентно действию функции sprintf() но список аргументов заменен указателем на список аргументов

Действие функции vsrintf() эквивалентно действию функции psintf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

В версии С99 к параметрам buf и format применен квалификатор restrict.


vsscanf()

#include <stdarg.h>
#include <stdio.h>
int vsscanf(char * restrict buf, const char * restrict format, va_list arg_ptr);

Описание

Аналогично sscanf(), но но список аргументов заменен указателем на список аргументов

Действие функции vsscanf() эквивалентно действиям функций sscanf(), но список аргументов заменен указателем на список аргументов. Этот указатель должен иметь тип va_list, который определен в заголовке <stdarg.h>.

Эта функция добавлены в версии С99.


fgetc()

#include <stdio.h>
int fgetc(FILE * stream);

Описание

Возвращает из указаного входного потока следующий символ

Функция fgetc() возвращает из входного потока stream следующий символ, соответствующий текущей позиции, и инкрементирует индикатор текущей позиции файла. Этот символ читается как значение типа unsigned char, которое преобразуется в целое.

При достижении конца файла функция fgetc() возвращает значение EOF. Однако поскольку значение EOF является действительным целым значением, при работе с двоичными файлами для обнаружения конца файла необходимо использовать функцию feof(). Если функция fgetc() обнаруживает ошибку, возвращается значение EOF. Для выявления ошибок при работе с двоичными файлами необходимо использовать функцию ferror().


fgets()

#include <stdio.h>
char *fgets(char *str, int num, FILE * stream);

Описание

Читает символы из указанного файлового потока и помещает в символьный массив

Функция fgets() читает из входного потока stream не более (num - 1) символов и помещает их в массив символов, адресуемый указателем str. Символы читаются до тех пор, пока не будет прочитан символ новой строки или значение EOF либо пока не будет достигнут заданный предел. По завершении чтения символов сразу за последним прочитанным символом размещается нулевой символ. Символ новой строки сохраняется и остается частью строки, адресуемой элементом str.

При успешном выполнении функция fgets() возвращает значение str, а при неудачном (в случае сбоя) — нулевой указатель. В случае ошибки содержимое массива, к которому отсылает указатель str, не определено. Поскольку функция fgets() возвращает нулевой указатель и при возникновении ошибки, и при достижении конца файла, то для выяснения, что же произошло на самом деле, необходимо использовать функцию feof() или ferror().


fread()

#include <stdio.h>
int fread(void *buf, size_t size, size_t count, FILE stream);

Описание

Читает из указанного потока заданное количество объектов

Функция fread() читает из потока адресуемым указателем stream, count объектов длинной size байт и размещает их в массиве buf, Индикатор позиции файла перемещаеться затем на прочитаное количество символов.

В версии C99 к параметрам buf и stream применён квалификатор restrict.

Функция fread() возвращает число реально прочитанных элементов. Если оказалось, что прочитано меньше елементов, чем затребовано при вызове, значит, либо при выполнении произошла ошибка, либо был достигнут конец файла. Для выяснения действительных причин произошедшего нужно вызвать функцию feof() или ferror().

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


fscanf()

#include <stdio.h>
int fscanf(FILE *stream, const char * format, ...);

Описание

Читает указанный поток

Функция fscanf() работает подобно функции scanf(), но читает информацию из потока, заданного указателем stream, а не из стандартного потока ввода stdin. Подробности приводятся в разделе "scanf" ниже в этой главе.

В версии С99 к параметрам stream и format применен квалификатор restrict.

Функция fscanf() возвращает количество аргументов, которым действительно присвоены значения. Это число не включает опущенные поля. Значение возврата, равное EOF, означает, что до выполнения первого присваивания произошел сбой.


getc()

#include <stdio.h>
int getc(FILE *stream);

Описание

Возвращает следующий символ из указаного потока

Функция getc() возвращает из входного потока stream следующий символ, соответствующий текущему состоянию индикатора позиции файла, а затем инкрементирует этот индикатор. Символ читается с использованием типа unsigned char, после чего преобразуется в целый тип.

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

Функции getc() и fgetc() идентичны, но в большинстве реализаций функция getc() определена как макрос.


fflush()

#include <stdio.h>
int fflush(FILE *stream);

Описание

Записывает содержимое выходного буфера в файл

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

Нулевое значение, возвращаемое функцией, свидетельствует о ее успешном выполнении, а значение EOF — о возникновении ошибки записи.

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


fprintf()

#include <stdio.h>
int fprintf(FILE *stream, const char * format, ...);

Описание

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

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

В версии С99 к параметрам stream и format применен квалификатор restrict.

Операции преобразования, заданные в строке управления форматом, и команды вывода аналогичны операциям и командам, используемым в функции printf(); полное описание приводится в разделе "printf".


fputc()

#include <stdio.h>
int fputc(int ch, FILE *stream);

Описание

Записывает символ в заданный поток

Функция fputc() записывает символ ch в заданный поток stream(в текущую позицию файла), а затем передвигает индефикатор позиции файла. Не смотря что в силу исторических причин символ ch объявлён с помощью типа int, он преобразуеться в функцией fputc() в тип unsigned char. Поскольку символьный аргумент возводиться в ранг целого, в момент вызова, вы можете спокойно использовать в качестве аргументов символьные значения. А если бы вы использовали целое значение, старший байт попросту был бы отброшен.

Значением возвращаемым функцией fputc(), являеться значение записаного символа. При возникновении ошибки возвращаеться значение EOF. Для файлов, открытых для выполнения двоичных операций, значение EOF может оказаться действительным символом, поэтому, чтобы определить реальный факт возникновения ошибки, прийдёться использовать функцию ferror().


fputs()

#include <stdio.h>
int fputs(const chhar *str, FILE *stream);

Описание

Записывает в заданый поток содержание строки

Функция fputs() записывает в заданый поток stream содержание строки, адресуемой указателем str. При этом завершающий нулевой символ не записываеться.

В версии C99 к параметрам str и stream применён квалификатор restrict/

При успешном выполнении функция fputs() возвращает неотрицательное значение, а при неудачном — значение EOF.

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


fwrite()

#include <stdio.h>
int fwrite(const void *buf, size_t size, size_t count, FILE *stream);

Описание

Записывает в указанный поток некоторое количество объектов

Функция fwrite() записывает в поток, адресуемый указателем stream, count объектов длиной size байт каждый из символьного массива, адресуемого указателем buf. Индикатор позиции файла перемещается затем на записанное количество символов.

В версии С99 к параметрам buf и stream применен ква-лификатор restrict.

Функция fwrite() возвращает число реально записанных элементов, которое будет равно числу затребованных элементов, если функция выполнилась успешно. Если же записано меньше элементов, чем затребовано при вызове, значит, при выполнении операции произошла ошибка.


putc()

#include <stdio.h>
int putc(int ch, FILE *stream);

Описание

Записывает символ, содержащийся в младшем байте параметра в указанный выходной поток

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

При успешном выполнении функция putc() возвращает записанный символ, а в случае ошибки — значение EOF. Если выходной поток был открыт в двоичном режиме, EOF может быть вполне нормальным значением для параметра ch. Значит, для установления факта ошибки необходимо в этом случае использовать функцию ferror().


ungetc()

#include <stdio.h>
int ungetc(int ch, FILE *stream);

Описание

Возвращает символ, заданный младшим байтом

Функция ungetc() возвращает символ, заданный младшим байтом параметра ch, в поток ввода stream. Этот символ будет затем получен при последующей операции чтения потока stream. Обращение к таким функциям, как fflush(), fseek() и rewind(), аннулирует операцию ungetc() и сбрасывает этот символ.

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

Попытка вернуть в поток ввода значение EOF игнорируется.

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

Функция возвращает значение ch при успешном завершении и значение EOF в противном случае.


feof()

#include <stdio.h>
int feof(FILE *stream);

Описание

Проверка конца файла

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

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

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


fgetpos()

#include <stdio.h>
int fgetpos(FILE *stream, fpos_t *position);

Описание

Сохраняет текущее значение индикатора позиции файла в объекте

Функция fgetpos() сохраняет текущее значение индикатора позиции файла в объекте, адресуемом элементом-указателем position. Объект, адресуемый элементом position, должен иметь тип fpos_t, определенный в заголовке <stdio.h>. Сохраняемое значение полезно только для последующего обращения к функции fsetpos().

В версии С99 как параметр stream, так и параметр position определяются квалификатором restrict.

При обнаружении ошибки функция fgetpos() возвращает ненулевое значение; в противном случае возвращается нуль.


fseek()

#include <stdio.h>
int fseek(FILE *stream, long offset, int origin);

Описание

Смещает индикатор позиции файла, связанного с потоком

Функция fseek() устанавливает индикатор позиции файла, связанного с потоком stream, в соответствии со значениями смещения offset и исходного положения origin. Назначение этой функции — поддерживать операции ввода-вывода с произвольным доступом. Параметр offset представляет собой количество байтов, на которые будет перемещен внутренний указатель файла (индикатор позиции файла) относительно точки отсчета, заданной параметром origin. В качестве значения для параметра origin должен быть взят один из следующих макросов (определенных в заголовке <stdio.h>).

Имя | Назначение
SEEK_SET | Поиск с начала файла
SEEK_CUR | Поиск с текущей позиции
SEEK_END | Поиск с конца файла

Нулевое значение возврата свидетельствует об успешном выполнении функции fseek(), а ненулевое — о возникновении сбоя.

Вообще говоря, функцию fseek() следует использовать только при работе с двоичными файлами. При использовании же с текстовым файлом параметр origin должен иметь значение SEEK_SET, а параметр offset — значение, полученное в результате вызова функции ftell() для того же файла, или нуль (чтобы установить индикатор позиции файла в начало).

Функция fseek() очищает признак конца файла, связанный с заданным потоком. Более того, она обнуляет любой установленный ранее признак наличия для файла символа, возвращенного в тот же поток посредством вызова функции ungetc() (см. раздел "ungetc" ).


fsetpos()

#include <stdio.h>
int fsetpos(FILE *stream,const fpos_t *position)

Описание

Перемещает индикатор позиции файла в место, заданное объектом

Функция fsetpos() перемещает индикатор позиции файла в место, заданное объектом, к которому отсылает указатель position. Это значение должно быть предварительно получено путем обращения к функции fgetpos(). После выполнения функции fsetpos() индикатор конца файла сбрасывается. Кроме того, обнуляется любой предыдущий результат обращения к функции ungetc().

При неудачном выполнении функции fsetpos() возвращается ненулевое значение, а при успешном — нуль.


ftell()

#include <stdio.h>
long ftell(FILE * stream);

Описание

Возвращает текущее значение индикатора позиции файла для заданного потока

Функция ftell() возвращает текущее значение индикатора позиции файла для заданного потока stream. В случае двоичных потоков это значение равно количеству байтов, которые отделяют индикатор от начала файла. Для текстовых потоков возвращаемое значение может быть не определено за исключением случая, когда оно служит в качестве аргумента функции fseek(). Все дело в возможных преобразованиях символов, когда, например, последовательности символов "возврат каретки"/"перевод строки" заменяются символами новой строки, что, бесспорно, влияет на размер файла.

При возникновении ошибки функция ftell() возвращает значение-1.


clearerr()

#include <stdio.h>
void clearerr(FILE * stream);

Описание

Сбрасывает флажок ошибки связанный с потоком

Функция clearerr() сбрасывает (т.е. устанавливает равным нулю) флажок (признак) ошибки, связанный с потоком, на который указывает элемент stream. При этом также сбрасывается индикатор конца файла.

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


fclose()

#include <stdio.h>
int fclose(FILE * stream);

Описание

Закрывает файл, связанный с потоком stream

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

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


ferror()

#include <stdio.h>
int ferror(FILE *stream);

Описание

Проверка наличия файловой ошибки

Функция ferror() проверяет наличие файловой ошибки для данного потока, определенного элементом stream. Нулевое значение, возвращаемое этой функцией, означает, что не было обнаружено никакой ошибки, а ненулевое значение означает ее наличие.


fopen()

include <stdio.h>
FILE *fopen(const char *fname, const char *mode);

Описание

Открывает файл и возвращает поток, связываемый с этим файлом

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

В версии С99 к параметрам fname и mode применен квалификатор restrict.

mode | Назначение
"r" | Открывает текстовый файл для чтения
"w" | Создает текстовый файл для записи
"а" | Открывает текстовый файл для записи в конец файла
"rb" | Открывает двоичный файл для чтения
"wb" | Создает двоичный файл для записи
"ab" | Открывает двоичный файл для записи в конец файла
"r+" | Открывает текстовый файл для чтения и записи
"w+" | Создает текстовый файл для чтения и записи
"a+" | Открывает текстовый файл для чтения и записи в конец файла
"rb+" или "r+b" | Открывает двоичный файл для чтения и записи
"wb+" или "w+b" | Создает двоичный файл для чтения и записи
"ab+" или "a+b" | Открывает двоичный файл для чтения и записи в конец файла

Если функция fopen() успешно открыла заданный файл, она возвращает указатель FILE. Если файл не удается открыть, возвращается нулевой указатель.

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

В следующем фрагменте программы иллюстрируется корректный способ открытия файла.

Копировать
FILE *fp;
if ((fp = fopenf("test", "w"))==NULL) {
    printf("He удается открыть файл.\n");
    exit(1);
}

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

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

Совет программисту

Любой файл можно открыть либо в текстовом, либо в двоичном режиме. Что в действительности содержит файл, не имеет при этом никакого значения. Например, файл, содержащий текст ASCII, все равно можно открыть и обрабатывать, как двоичный. Различное поведение файловой системы ANSI С при обработке двоичных и текстовых файлов проявляется лишь в том, что при открытии файла в двоичном режиме никаких преобразований символов не происходит.

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

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


freopen()

#include <stdio.h>
int *freopen(const char *fname, const char *mode, FILE *stream);

Описание

Связывает существующий поток с другим файлом

Функция freopen() связывает существующий поток с другим файлом. Имя нового файла задаёться параметром fname, режим доступа — параметром mode, а на переназначаемый поток отсылает указател sream/ Возможные значения строки mode — те же, что и для функции fopen() (полное их описание можно найти в разделе "fopen").

В версии C99 к параметрам fname, mode, и stream применён квалификатор restrict.

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

При успешном выполнении функция freopen() возвращает указатель на поток и нулевой указатель — в противном случае.

Чаще всего функция freopen() используется для перенаправления таких определенных системой файлов, как stdin, stdout и stderr, на другой файл.


rewind()

#include <stdio.h>
void rewind(FILE * stream);

Описание

Перемещает индикатор позиции файла в начало заданного потока

Функция rewind() перемещает индикатор позиции файла в начало заданного потока. Она также очищает признаки конца файла и ошибки, связанные с потоком stream.


setbuf()

#include <stdio.h>
void setbuf(FILE * stream, char *buf);

Описание

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

Функция setbuf() задает буфер, которым будет пользоваться поток stream, либо, если параметр buf установлен равным нулю, отключает буферизацию. Если необходимо задать буфер, определенный программистом, то его длину следует установить равной BUFSIZ символам. Идентификатор BUFSIZ определяется в заголовочном файле <stdio.h>.

В версии С99 к параметрам stream и buf применен квалификатор restrict.


setvbuf()

#include <stdio.h>
int setvbuf(FILE *stream, char *buf, int mode, size_t size);

Описание

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

Функция setvbuf() позволяет программисту задать буфер, его размер и режим работы с указанным потоком. Символьный массив, адресуемый параметром buf, используется в качестве буфера потока для операций ввода-вывода. Размер буфера устанавливается с помощью параметра size, а режим mode определяет, как будет выполняться буферизация. Если параметр buf нулевой, функция setvbuf() выделяет собственный буфер.

В версии С99 к параметрам stream и buf применен квалификатор restrict.

Возможными значениями параметра mode являются константы _IOFBF, _IONBF и _IOLBF, которые определены в заголовочном файле <stdio.h>. Когда параметр mode установлен равным значению _IOFBF, буферизация выполняется в расчете на полный объем буфера. Если mode равен значению _IOLBF, поток будет буферизирован построчно, т.е. буфер будет сбрасываться при каждой записи в выходной поток символа новой строки, а при чтении из входного потока появление символа новой строки приведет к прекращению подкачки в буфер. В любом случае буфер сбрасывается по окончании заполнения. Если установлен режим, определяемый значением _IONBF, поток вообще не буферизируется.

Функция setvbuf() возвращает нуль при успешном выполнении и ненулевое значение в противном случае.


tmpfile()

include <stdio.h>
FILE *tmpfile(void);

Описание

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

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

Функция tmpfile() при неудачном выполнении возвращает нулевой указатель, а при успешном — указатель на поток.

Временный файл, созданный функцией tmpfile(), автоматически удаляется при закрытии файла или по завершении программы.

Количество временных файлов, которые можно открыть, равно значению ТМР_МАХ(которое не превышает предел, определяемый значением FOPEN_MAX).


tmpnam()

#include <stdio.h>
char *tmpnam(char *name);

Описание

Генерирует уникальное имя файла и сохраняет его в массиве

Функция tmpnam() генерирует уникальное имя файла и сохраняет его в массиве с именем name. Длина этого массива должна составлять не меньше L_tmpnam символов.(Константа L_tmpnam определена в заголовочном файле <stdio.h>.) Основное назначение функции tmpnam() — сгенерировать имя временного файла, которое не совпадало бы ни с одним из имен файлов в текущем каталоге диска.

Эту функцию можно вызвать не более ТМР_МАХ раз. Константа ТМР_МАХ определена в заголовочном файле <stdio.h>, и ее значение равно не менее 25. При каждом вызове функция tmpnam() будет генерировать новое имя временного файла.

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


remove()

#include <stdio.h>
int remove(const char *fname);

Описание

Удаляет файл

Функция remove() удаляет файл, заданный параметром fname. При успешном удалении файла функция возвращает нуль, а в случае ошибки — ненулевое значение.


rename()

#include <stdio.h>
int rename(const char *oldfname, const char *newfname);

Описание

Заменяет имя файла

Функция rename() заменяет имя файла, заданное параметром oldfname, именем newfname. Имя newfname не должно совпадать ни с одним из существующих имен файлов в каталоге.

При успешном выполнении функция rename() возвращает нуль, а в случае ошибки — ненулевое значение.


snprintf()

include <stdio.h>
int snprintf(char * restrict buf, size_t num, const char * restrict format,...);

Описание

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

Функция snprintf() добавлена в версии С99.

Она идентична функции sprintf() за исключением того, что в массиве, адресуемом указателем buf, будет сохранено максимум num-1 символов. По окончании работы функции этот массив имеет завершающий нуль-символ. Таким образом, функция snprintf() позволяет предотвратить переполнение буфера buf.


sprintf()

#include <stdio.h>
int sprintf(char *buf, const char * format,...);

Описание

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

Функция sprintf() идентична функции printf() за исключением того, что выходной поток записывается в массив, адресуемый указателем buf, а не в стандартный поток stdout. По окончании работы функции этот массив имеет завершающий нуль-символ. Подробности приводятся в разделе "printf".

В версии С99 к параметрам buf и format применен ква-лификатор restrict.

Возвращаемое значение равно числу символов, действительно помещенных в массив.

Важно понимать, что функция sprintf() не обеспечивает никакой проверки факта переполнения массива, адресуемого указателем buf. Это значит, что массив будет переполнен, если объем выводимых символов превысит длину массива. В качестве альтернативного решения рассмотрите применение функции snprintf() (см. раздел "snprintf", приведенный выше в этой главе).


sscanf()

#include <stdio.h>
int sscanf(const char *buf, const char * format, ...);

Описание

Читает данные из массива, аналогично scanf()

Функция sscanf() идентична функции scanf(), но данные читаются из массива, адресуемого параметром buf, а не из стандартного потока ввода stdin. Подробности приводятся в разделе "scanf".

В версии С99 к параметрам buf и format применен квалификатор restrict.

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


Система ввода вывода старого стиля в языке C++

Поскольку язык C++ полностью включает библиотеку С, он поддерживает и использование системы ввода-вывода языка С. Однако C++ также определяет собственную объектно-ориентированную, основанную на использовании классов систему ввода-вывода, которую называют библиотекой классов потоков ввода-вывода(iostream library). При написании программ на языке C++ вам стоит использовать именно собственную библиотеку C++(iostream-библиотеку), а не С-ориентированную.

На момент написания этой главы существуют две версии iostream-библиотеки, причем обе широко используются программистами: более старая, основанная на оригинальных спецификациях языка C++, и новая, определенная стандартом ANSI/ISO для языка C++. В настоящее время большинство компиляторов C++ поддерживают iostream-библиотеки как старого, так и нового стилей. Однако следует иметь в виду, что iostream-библиотека старого стиля уже устарела и ее не следует использовать при написании новых программ. Новые приложения должны предусматривать использование новых подходов к программированию, определенных стандартом ANSI/ISO для языка C++. Описание iostream-библиотеки старого стиля, приведенное в данной главе, предназначено для тех программистов, которые вынуждены поддерживать старые программы или хотят перевести старый код в новый стандарт. Новый подход к программированию задач ввода-вывода на языке C++ описан в главе "классы ввода-вывода библиотеки стандарта C++".

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

Во-первых, оригинальные классы потоков ввода-вывода были определены в глобальном пространстве имен, а новая библиотека содержится в пространстве имен std.

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

В-третьих, новая iostream-библиотека определяет много новых типов данных.

В-четвертых, для использования старой библиотеки необходимо включать в свои программы заголовочные файлы с расширением .h, например iostream.h. В этих заголовочных файлах определяются потоковые классы старого стиля, которые относятся к глобальному пространству имен. И наоборот, для использования новой библиотеки потоковых классов включите в свою программу заголовок нового стиля <iostream>.

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

Смотрите также

Базовые классы потоков ввода вывода
Встроенные потоки C++
Флаги форматирования
Манипуляторы ввода-вывода
Пример использования потоков
Функции ввода вывода старого стиля в языке C++

Класс ios

Назначение: обеспечивает операции ввода-вывода общего назначения
Заголовок:
Иерархия: базовый класс классов ввода-вывода

Методы

bad - Проверка потока на ошибку
clear - Очищает флаги состояния, связанные с потоком
eof - Проверка конца файла
fail - Проверка на присутствие ошибки ввода-вывода
fill - Проверка на присутствие ошибки ввода-вывода
flags - Работа с флагами
good - Проверка на отутствие ошибок вводв-вывода
precision - Возвращает или устанавливаеттекущее значение точности
rdstate - Возвращает состояние соответствующего потока
setf - Устанавливает флаги форматирования
sync_with_stdio - Позваляет использовать стандартную С-подобную систему ввода-вывода
unsetf - Очистка одного или нескольких флагов форматирования
width - Работа с шириной поля

Класс istream

Назначение: поддерживает операции ввода
Заголовок:
Иерархия: ios -> istream

Методы

eatwhite - Читает и отбрасывает все ведущие пробельные символы
gcount - Возврат количества символов, прочитанных во время последней операции ввода
getline - Читает строку из потока
get - Читает символы из потока
ignore - Чтение и отбрасывание символов из потока ввода
peek - Возвращает следующий символ в потоке или значение EOF
putback - Возвращает символ в соответствующий поток ввода
read - Читает байты из соответствующего потока ввода
seekg - Перемещает указатель ввода
tellg - Определение текужего указателя ввода

Класс ostream

Назначение: поддерживает операции вывода
Заголовок:
Иерархия: ios -> ostream

Методы

flush - Запись содержимого буфера
put - Записывает символ ch в соответствующий поток вывода
seekp - Перемещает указатель вывода
tellp - Определение текужего указателя вывода
write - Записывает из буфера байты в соответствующий поток вывода

Классы fstream, ifstream и ofstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок:
Иерархия:

  • ios -> istream -> ifstream
  • ios -> ostream -> ofstream
  • ios -> iostream -> fstream

Методы

open - Закрывает файл связаный с потоком
open - Связывает файл с потоком
setmode - Устанавливает режим работы соответствующего потока: двоичный или текстовый

Классы strstream, istrstream и ostrstream

Назначение: поддерживают операции ввода-вывода, ввода и вывода ориентированные на использование специальных массивов соответственно
Заголовок:
Иерархия:

  • ios -> istream -> istrstream
  • ios -> ostream -> ostrstream
  • ios -> iostream -> strstream

Методы

str - Фиксирует динамический массив и возвращает на него указатель


Базовые классы потоков ввода вывода

В библиотеке классов потоков ввода-вывода старого стиля используется заголовочный файл iostream.h. Этот файл определяет иерархию фундаментальных классов, которая поддерживает операции ввода-вывода. Тем, кто выполняет файловые операции ввода-вывода, придется также включить в свою программу заголовочный файл fstream.h. А для использования операций ввода-вывода над массивами необходимо включить заголовочный файл strstrea.h.

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

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

Класс | Цель создания
istream | Общие операции ввода
ostream | Общие операции вывода
iostream | Общие операции ввода-вывода
ifstream | Ввод в файл
ofstream | Вывод из файла
fstream | Файловые операции ввода-вывода
istrstream | Ввод, ориентированный на использование специальных массивов
ostrstream | Вывод, ориентированный на использование специальных массивов
strstream | Ввод-вывод, ориентированный на использование специальных массивов


Встроенные потоки C++

Как только программа, написанная на языке C++, начинает выполняться, автоматически открываются четыре перечисленных ниже встроенных потока.

Поток | Значение | Устройство по умолчанию
cin | Стандартный поток ввода | Клавиатура
cout | Стандартный поток вывода | Экран
cerr | Стандартный поток вывода ошибок | Экран
clog | Буферизированная версия потока cerr | Экран

По умолчанию стандартные потоки используются для подключения к консоли. Однако в средах, которые поддерживают возможность перенаправления ввода-вывода(например, в DOS, UNIX и Windows), стандартные потоки могут быть перенаправлены на другие устройства или в файлы.


Флаги форматирования

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

adjustfield
basefield
boolalpha
dec
fixed 		floatfield
hex
internal
left
oct 		right
scientific
showbase
showpoint
showpos 		skipws
unitbuf
uppercase

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

Флаги Назначение
Пробельных символов

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

Выравнивание

Когда установлен флаг left, результат выравнивается по левому краю. А когда установлен флаг right, результат выравнивается по правому краю. Когда установлен флаг internal, числовое значение дополняется пробелами, чтобы заполнить поле между каким-либо знаком или основным символом. Если ни один из этих флагов не установлен, результат выравнивается по правому краю по умолчанию.

Системы счисления

По умолчанию числовые значения выводятся в десятичной системе счисления. Однако основание системы счисления можно изменить. Установка флага oct приведет к выводу результата в восьмеричном представлении, а установка флага hex — в шестнадцатеричном. Чтобы при отображении результата вернуться к десятичной системе счисления, достаточно установить флаг dec.

Основание системы счисления

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

Отображение чисел

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

Установка флага showpos вызывает отображение ведущего знака "плюс" перед положительными значениями.

Установка флага showpoint приводит к отображению десятичной точки и хвостовых нулей для всех чисел с плавающей точкой — нужны они или нет.

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

Разное

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

Если установлен флаг stdio, потоки stdout и stderr сбрасываются после каждой операции вывода.

Флаги форматирования обычно хранятся как длинные целые значения(long int), и их могут устанавливать различные функции-члены класса ios.


Манипуляторы ввода-вывода

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

Манипулятор | Назначение | Функция
dec | Используется для представления десятичных целых | Ввод-вывод
endl | Выводит символ новой строки и сбрасывает поток | Вывод
ends | Вставляет в поток нулевой символ (' \0 ') | Вывод
flush | Сбрасывает поток | Вывод
hex | Используется для представления шестнадцатеричных целых | Ввод-вывод
oct | Используется для представления восьмеричных целых | Ввод-вывод
resetiosflags (long f) | Очищает флаги, заданные впеременной f | Ввод-вывод
setbase (int base) | Устанавливает основание системы счисления равной значению base | Вывод
setfill (int ch) | Устанавливает символ заполнитель равным значению переменной ch | Вывод
setiosflags (long f) | Устанавливает флаги, заданные в переменной f | Ввод-вывод
setprecision (int p) | Устанавливает количество цифр точности (после десятичной точки) | Вывод
setw(int w) | Устанавливает ширину поля равной значению переменной w Пропускает ведущие пробельные символы | Вывод
ws | Пропускает ведущие пробельные символы | Ввод

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


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

Основные используемые функции

unsigned short chunk_id;	//Идентификатор блока
unsigned int chunk_len;		//Смещение

//Переменная типа файловый поток чтения, где ifs просто имя переменной
ifstream ifs;

//Открыть файл с именем fname, как бинарный для чтения и поставить файловый указатель в начало
ifs.open(fname.c_str(), ios_base::in | ios_base::binary | ios_base::beg);

ifs.is_open();	//Файл открыт?

//Считать в переменную  chunk_id 2 байта;
//причем часть кода "(char*)&" является обязательной и преобразует адрес переменной в указатель на символ
ifs.read((char*)&chunk_id,2);

//Пропустить chunk_len-6 байт; перейти на  chunk_len-6 байт вперед
ifs.ignore(chunk_len-6);

//Поставить файловый указатель на позицию ifs.tellg()-6
ifs.seekg(ifs.tellg()-6);

//Получить текущую позицию файлового указателя
ifs.tellg();

//Конец файла?
ifs.eof();

Примечание. Вместо методов read и write можно использовать перегруженные операторы ">>" и "<<" соответственно

Пример Кода

Чтобы выполнить чтение или запись в текстовый файл, достаточно для открытого потока использовать операторы << и >>. Например, следующая программа записывает в файл с именем TEST целое число, значение с плавающей точкой и строку, а затем читает все, что было записано.

Копировать
#include <iostream.h>
#include <fstream.h>

int main()
{
    ofstream out("test");
    if(!out) {
        cout << "He удается открыть файл.\n\";
        return 1;
    }

    // Выводим данные.
    out << 10 << " " << 123.23 << "\n";
    out << "Это короткий текстовый файл.\n";
    out.closet();

    // Теперь читаем все, что было записано,
    char ch;
    int i;
    float f;
    char str [80];

    ifstream in("test");
    if(!in) {
        cout << "He удается открыть файл.\n";
        return 1;
    }

    in >> i ;
    in >> f;
    in >> ch;
    in >> str;

    cout << "Вот эти данные: ";
    cout << i << " " << f <<" " << ch << "\n";
    cout << str;

    in.close();

    return 0;
}

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


Функции ввода вывода старого стиля в языке C++

Класс ios

Назначение: обеспечивает операции ввода-вывода общего назначения
Заголовок: <iostream.h>
Иерархия: базовый класс классов ввода-вывода

Методы

bad — Проверка потока на ошибку
clear — Очищает флаги состояния, связанные с потоком
eof — Проверка конца файла
fail — Проверка на присутствие ошибки ввода-вывода
fill — Проверка на присутствие ошибки ввода-вывода
flags — Работа с флагами
good — Проверка на отутствие ошибок вводв-вывода
precision — Возвращает или устанавливаеттекущее значение точности
rdstate — Возвращает состояние соответствующего потока
setf — Устанавливает флаги форматирования
sync_with_stdio — Позваляет использовать стандартную С-подобную систему ввода-вывода
unsetf — Очистка одного или нескольких флагов форматирования
width — Работа с шириной поля

Класс ostream

Назначение: поддерживает операции вывода
Заголовок: <iostream.h>
Иерархия: ios -> ostream

Методы

flush — Запись содержимого буфера
put — Записывает символ ch в соответствующий поток вывода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
write — Записывает из буфера байты в соответствующий поток вывода

Класс istream

Назначение: поддерживает операции ввода
Заголовок: <iostream.h>
Иерархия: ios -> istream

Методы

eatwhite — Читает и отбрасывает все ведущие пробельные символы
gcount — Возврат количества символов, прочитанных во время последней операции ввода
getline — Читает строку из потока
get — Читает символы из потока
ignore — Чтение и отбрасывание символов из потока ввода
peek — Возвращает следующий символ в потоке или значение EOF
putback — Возвращает символ в соответствующий поток ввода
read — Читает байты из соответствующего потока ввода
seekg — Перемещает указатель ввода
tellg — Определение текужего указателя ввода

Классы fstream, ifstream и ofstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок: <fstream.h>
Иерархия:

  • ios -> istream -> ifstream
  • ios -> ostream -> ofstream
  • ios -> iostream -> fstream

Методы

open — Закрывает файл связаный с потоком
open — Связывает файл с потоком
setmode — Устанавливает режим работы соответствующего потока: двоичный или текстовый

Классы strstream, istrstream и ostrstream

Назначение: поддерживают операции ввода-вывода, ввода и вывода ориентированные на использование специальных массивов соответственно
Заголовок: <strstream.h>
Иерархия:

  • ios -> istream -> istrstream
  • ios -> ostream -> ostrstream
  • ios -> iostream -> strstream

Методы

str — Фиксирует динамический массив и возвращает на него указатель


Класс ios

Назначение: обеспечивает операции ввода-вывода общего назначения
Заголовок: <iostream.h>
Иерархия: базовый класс классов ввода-вывода

Методы

bad — Проверка потока на ошибку
clear — Очищает флаги состояния, связанные с потоком
eof — Проверка конца файла
fail — Проверка на присутствие ошибки ввода-вывода
fill — Проверка на присутствие ошибки ввода-вывода
flags — Работа с флагами
good — Проверка на отутствие ошибок вводв-вывода
precision — Возвращает или устанавливаеттекущее значение точности
rdstate — Возвращает состояние соответствующего потока
setf — Устанавливает флаги форматирования
sync_with_stdio — Позваляет использовать стандартную С-подобную систему ввода-вывода
unsetf — Очистка одного или нескольких флагов форматирования
width — Работа с шириной поля


bad()

#include <iostream.h>
int bad() const;

Описание

Проверка потока на ошибку

Функция является членом класса ios

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

Смотрите также

good — Проверка на отутствие ошибок вводв-вывода


clear()

#include <iostream.h>
void clear(int flags = 0);

Описание

Очищает флаги состояния, связанные с потоком

Функция является членом класса ios

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


eof()

#include <iostream.h>
int eof() const;

Описание

Проверка конца файла

Функция является членом класса ios

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


fail()

#include <iostream.h>
int fail() const;

Описание

Проверка на присутствие ошибки ввода-вывода

Функция является членом класса ios

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


fill()

#include <iostream.h>
char fill() const;
char fill(char ch);

Описание

Указывает символ заполнения поля

Функция является членом класса ios

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

Первая форма функции fill возвращает текущий символ заполнения.


flags()

include <iostream.h>
long flags() const;
long flags(long f);

Описание

Работа с флагами

Функция является членом класса ios

Первая форма функции flags() просто возвращает текущие установки флагов форматирования соответствующего потока.

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


good()

#include <iostream.h>
int good() const;

Описание

Проверка на отутствие ошибок ввода-вывода

Функция является членом класса ios

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


precision()

#include <iostream.h>
int precision() const;
int precision(int p);

Описание

Возвращает или устанавливает текущее значение точности

Функция является членом класса ios

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

Первая версия функции precision() возвращает текущее значение точности.


rdstate()

#include <iostream.h>
int rdstate() const;

Описание

Возвращает состояние соответствующего потока

Функция является членом класса ios

Функция rdstate() возвращает состояние соответствующего потока. Система ввода-вывода C++ поддерживает информацию о состоянии, касающуюся результата выполнения каждой операции ввода-вывода, которая связана с активным потоком. Текущее состояние системы ввода-вывода хранится в виде значения целочисленной переменной, в которой закодированы следующие флаги.

Имя | Значение
ios:goodbit | He обнаружено никаких ошибок
ios::eofbit | Обнаружен конец файла
ios::failbiе | При выполнении операций ввода-вывода обнаружен нефатальный сбой
ios::badbit | При выполнении операций ввода-вывода обнаружена фатальная ошибка

Эти флаги перечислены в классе ios.

Функция rdstate() возвращает нуль(ios::goodbit), когда не обнаружено никакой ошибки; в противном случае устанавливается бит ошибки.


setf()

#include <iostream.h>
long setf(long flags);
long setf(long flagsl, long flags2);

Описание

Устанавливает флаги форматирования

Функция является членом класса ios

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

Копировать
stream.setf(ios::showpos);

В данном случае stream — это поток, на который вы воздействуете.

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

Чтобы установить сразу несколько флагов форматирования, значения этих флагов можно объединить с помощью оператора ИЛИ (OR).

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

Обе версии функции setf() возвращают предыдущие установки флагов форматирования, связанные с потоком.


sync_with_stdio()

#include <iostream.h>
static void sync_with_stdio();

Описание

Позваляет использовать стандартную С-подобную систему ввода-вывода

Функция является членом класса ios

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


unsetf()

#include <iostream.h>
long unsetf(long flags);

Описание

Очистка одного или нескольких флагов форматирования

Функция является членом класса ios

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


width()

#include <iostream.h>
int width() const;
int width(int w);

Описание

Работа с шириной поля

Функция является членом класса ios

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

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


Класс istream

Назначение: поддерживает операции ввода
Заголовок: <iostream.h>
Иерархия: ios -> istream

Методы

eatwhite — Читает и отбрасывает все ведущие пробельные символы
gcount — Возврат количества символов, прочитанных во время последней операции ввода
getline — Читает строку из потока
get — Читает символы из потока
ignore — Чтение и отбрасывание символов из потока ввода
peek — Возвращает следующий символ в потоке или значение EOF
putback — Возвращает символ в соответствующий поток ввода
read — Читает байты из соответствующего потока ввода
seekg — Перемещает указатель ввода
tellg — Определение текужего указателя ввода


eatwhite()

#include <iostream.h>
void eatwhite();

Описание

Читает и отбрасывает все ведущие пробельные символы

Функция является членом класса istream

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


gcount()

#include <iostream.h>
int gcount() const;

Описание

Возврат количества символов, прочитанных во время последней операции ввода

Функция является членом класса istream

Функция gcount() возвращает количество символов, прочитанных во время последней операции ввода.


get()

#include <iostream.h>
int get();
istream &get(char &ch);
istream &get(char *buf, int num, char delim = '\n');
istream &get(streambuf &buf, char delim = '\n');

Описание

Читает символы из потока

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

Функция get(), принимающая в качестве единственного параметра ссылку на символ, читает символ из соответствующего потока и помещает прочитанное значение в переменную ch. Функция возвращает ссылку на поток.(Заметьте, что параметр ch может также иметь тип unsigned char * или signed char *.)

Функция get() в форме, принимающей три параметра, читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num символов, либо не встретится символ ограничителя, заданный параметром delim. После выполнения функции get() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Если параметр delim не задан, то в качестве ограничителя по умолчанию используется символ новой строки. Обнаруженный символ ограничителя из потока ввода не извлекается. Он остается в потоке до следующей операции ввода. Эта функция возвращает ссылку на поток.(Заметьте, что параметр buf может также иметь тип unsigned char * или signed char *.)

Функция get() в форме, принимающей два параметра, читает символы из потока ввода в объект класса streambuf (или производный от него объект). Символы читаются до тех пор, пока не встретится символ ограничителя, заданный параметром delim. Функция возвращает ссылку на поток.


getline()

#include <iostream.h>
istream &getline(char *buf, int num, char delim = '\n');

Описание

Читает символы из потока до ограничителя

Функция является членом класса istream

Функция getline() читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num символов, либо не встретится символ ограничителя, заданный параметром delim. После выполнения функции getline() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Если параметр delim не задан, то в качестве ограничителя по умолчанию используется символ новой строки. Обнаруженный символ ограничителя из потока ввода извлекается, но не помещается в массив buf. Функция возвращает ссылку на поток.(Заметьте, что параметр buf может также иметь тип unsigned char * или signed char *.)


ignore()

#include <iostream.h>
istream &ignore(int num = 1, int delim = EOF);

Описание

Чтение и отбрасывание символов из потока ввода

Функция является членом класса istream

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


peek()

#include <iostream.h>
int peek();

Описание

Возвращает следующий символ в потоке или значение EOF

Функция является членом класса istream

Функция peek() возвращает следующий символ в потоке или значение EOF, если обнаружен конец файла. Ни при каких обстоятельствах функция не удаляет символ из потока.


putback()

#include <iostream.h>
istream &putback(char ch);

Описание

Возвращает символ в соответствующий поток ввода

Функция является членом класса istream

Функция putback() возвращает символ ch в соответствующий поток ввода.

ПРИМЕЧАНИЕ. Параметр ch должен быть последним символом, прочитанным из потока.


read()

#include <iostream.h>
istream &read(char *buf, int num);

Описание

Читает байты из соответствующего потока ввода

Функция является членом класса istream

Функция read() читает num байт из соответствующего потока ввода и помещает их в буфер, адресуемый параметром buf(заметьте, что параметр buf может также иметь тип unsigned char * или signed char *). При достижении конца файла до прочтения num символов функция read() просто прекращает работу, а в буфере содержится столько символов, сколько было прочитано в действительности.(См. раздел "gcount".) Функция read() возвращает ссылку на поток.


seekg()

#include <iostream.h>
istream &seekg(streamof f offset,
        ios::seek_dir origin)
istream &seekg(streampos position);

Описание

Перемещает указатель ввода

Функция является членом класса istream

В системе ввода-вывода C++ с помощью функций seekg() и seekp() выполняется произвольный доступ, т.е. система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода(get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Однако, используя функции seekg() и seekp(), можно получить доступ к файлу непоследовательным образом.

Версия функции seekg() с двумя параметрами перемещает указатель ввода на offset байт от позиции, заданной параметром origin. Параметр offset имеет тип streamoff, который определен в заголовке iostream.h. Объект типа streamoff способен содержать самое большое допустимое значение, которое может иметь параметр offset.

Параметр origin имеет тип ios::seek_dir и представляет собой перечисление, которое имеет следующие значения.

ios::beg | Смещение от начала
ios::cur | Смещение от текущей позиции
ios::end | Смещение от конца

Версия функции seekg() с одним параметром перемещают указатели файлов в позиции, заданные параметром position. Это значение должно быть предварительно получено путем обращения либо к функции tellg(), либо к функции tellp() соответственно. Тип streampos определен в заголовке iostream.h. Объект типа streampos способен содержать самое большое допустимое значение, которое может иметь параметр position. Эти функции возвращают ссылку на соответствующий поток.

Смотрите также

seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
tellg — Определение текужего указателя ввода


tellg()

#include <iostream.h>
streampos tellg();

Описание

Определение текужего указателя ввода

Функция является членом класса istream

Система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода (get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Именно с помощью функций tellg() и tellp() соответственно можно определить текущую позицию указателей ввода и вывода.

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

Значения, возвращаемые функциями tellg() и tellp(), можно использовать в качестве параметров функций seekg() и seekp() соответственно.

Смотрите также

seekg — Перемещает указатель ввода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода


Класс ostream

Назначение: поддерживает операции вывода
Заголовок: <iostream.h>
Иерархия: ios -> ostream

Методы

flush — Запись содержимого буфера
put — Записывает символ ch в соответствующий поток вывода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
write — Записывает из буфера байты в соответствующий поток вывода


flush()

#include <iostream.h>
ostream &flush();

Описание

Запись содержимого буфера

Функция является членом класса ostream

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


put()

#include <iostream.h>
ostream &put(char ch);

Описание

Записывает символ в соответствующий поток вывода

Функция является членом класса ostream

Функция put() записывает символ ch в соответствующий поток вывода. Она возвращает ссылку на этот поток.


seekp()

#include <iostream.h>
ostream &seekp(streamoff offset, ios::seek_dir origin);
ostream &seekp(streampos position);

Описание

Перемещает указатель вывода

Функция является членом класса ostream

В системе ввода-вывода C++ с помощью функций seekg() и seekp() выполняется произвольный доступ, т.е. система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода(get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Однако, используя функции seekg() и seekp(), можно получить доступ к файлу непоследовательным образом.

Версия функции seekp() с двумя параметрами перемещает указатель вывода на offset байт от позиции, заданной параметром origin. Параметр offset имеет тип streamoff, который определен в заголовке iostream.h. Объект типа streamoff способен содержать самое большое допустимое значение, которое может иметь параметр offset.

Параметр origin имеет тип ios::seek_dir и представляет собой перечисление, которое имеет следующие значения.

ios::beg | Смещение от начала
ios::cur | Смещение от текущей позиции
ios::end | Смещение от конца

Версия функции seekp() с одним параметром перемещают указатели файлов в позиции, заданные параметром position. Это значение должно быть предварительно получено путем обращения либо к функции tellg(), либо к функции tellp() соответственно. Тип streampos определен в заголовке iostream.h. Объект типа streampos способен содержать самое большое допустимое значение, которое может иметь параметр position. Эти функции возвращают ссылку на соответствующий поток.

Смотрите также

seekg — Перемещает указатель ввода
tellp — Определение текужего указателя вывода
tellg — Определение текужего указателя ввода


tellp()

#include <iostream.h>
streampos tellp();

Описание

Определение текужего указателя вывода

Функция является членом класса ostream

Система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода (get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Именно с помощью функций tellg() и tellp() соответственно можно определить текущую позицию указателей ввода и вывода.

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

Значения, возвращаемые функциями tellg() и tellp(), можно использовать в качестве параметров функций seekg() и seekp() соответственно.

Смотрите также

seekg — Перемещает указатель ввода
seekp — Перемещает указатель вывода
tellg — Определение текужего указателя ввода


write()

#include <iostream.h>
ostream &write(const char *buf, int num);

Описание

Записывает из буфера байты в соответствующий поток вывода

Функция является членом класса ostream

Функция write() записывает num байт в соответствующий поток вывода из буфера, адресуемого параметром bиf. (Заметьте, что параметр bиf может также иметь тип unsigned char * или signed char *.) Функция возвращает ссылку на поток.


Классы strstream, iststream и ostrstream

Назначение: поддерживают операции ввода-вывода, ввода и вывода ориентированные на использование специальных массивов соответственно
Заголовок: <strstream.h>
Иерархия:

  • ios -> istream -> istrstream
  • ios -> ostream -> ostrstream
  • ios -> iostream -> strstream

Методы

str — Фиксирует динамический массив и возвращает на него указатель

Конструкторы

Копировать
#include <strstream.h>
strstream();
strstream(char *buf, int size, int mode);

istrstream(const char *buf);
istrstream(const char *buf, int size);

ostrstream();
ostrstream(char *buf, int size, int mode=ios::out);

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

Для функции ostrstream() параметр buf представляет собой указатель на массив, собирающий символы, которые записаны в поток. Размер массива передается с помощью параметра size. По умолчанию поток открывается для нормального вывода, но, используя параметр mode, можно задать и другой режим. Допустимые значения параметра mode те же, что используются для одноименного параметра в функции open(). В большинстве случаев параметр mode можно оставлять равным значению, действующему по умолчанию. Если используется версия функции ostrstream() без параметров, происходит автоматическое выделение динамического массива.

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

Если для ввода нужна только часть строки, используйте форму конструктора istrstream() с двумя параметрами. В этом случае будут задействованы только первые size элементов массива, адресуемого параметром buf. Эта строка не обязана содержать завершающий нулевой символ, поскольку ее размер определяется значением параметра size.

Чтобы создать поток, ориентированный на работу с массивами и готовый ко вводу и выводу, используйте конструктор strstream(). В его параметризированной версии параметр buf указывает на строку, которая будет использована для операций ввода-вывода. Значение параметра size задает размер массива, а значение параметра mode определяет, как работает поток. Для нормальных операций ввода-вывода значение параметра mode будет равно ios::in | ios::out. Для операций ввода массив должен иметь завершающий нулевой символ.

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


str()

#include <strstream.h>
char *str();

Описание

Фиксирует динамический массив и возвращает на него указатель

Функция является членом класса strstream.

Функция str() "замораживает", т.е. фиксирует динамически выделенный массив ввода и возвращает на него указатель. Но после фиксации динамический массив нельзя использовать повторно для вывода. Следовательно, не стоит замораживать массив до тех пор, пока в него не будут выведены символы.

ПРИМЕЧАНИЕ. Эта функция предназначена для выполнения операций ввода-вывода, ориентированных на использование массивов.


Классы fstream, ifstream и ofstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок: <fstream.h>
Иерархия:

  • ios -> istream -> ifstream
  • ios -> ostream -> ofstream
  • ios -> iostream -> fstream

Методы

close — Закрывает файл связаный с потоком
open — Связывает файл с потоком
setmode — Устанавливает режим работы соответствующего потока: двоичный или текстовый

Конструкторы

Копировать
fstream();
#include
fstream();
fstream(const char *filename, int mode
    int access=filebuf::openprot);
fstream(int fd);
fstream(int fd, char *buf, int size);

ifstream();
ifstream(const char * filename,
    int mode=ios::in, int access=filebuf::openprot);
ifstream(int fd);
ifstreamfint fd, char *buf, int size);

ofstream();
ofstream(const char * filename, int mode=ios::out,
    int access=filebuf::openprot);
ofstream(int fd);
ofstream(int fd, char *buf, int size);

Функции fstream(), ifstream() и ofstream() представляют собой конструкторы классов fstream, ifstream и ofstream соответственно.

Версии функций fstream(), ifstream() и ofstream(), которые не принимают параметров, создают поток, не связанный ни с одним файлом. Этот поток можно позже связать с нужным файлом с помощью функции open().

Версии функций fstream() , ifstream() и ofstream(), которые принимают имя файла в качестве первого параметра, используются в прикладных программах наиболее часто, хотя вполне корректно можно открыть файл с помощью функции open(), в большинстве случаев обходятся без нее, поскольку эти функции конструкторов fstream, ifstream и ofstream автоматически открывают файл при создании потока. Функции конструкторов имеют те же параметры и значения, действующие по умолчанию, что и функция open().(Подробности — в разделе "open".) Например, самый распространенный способ открытия файла показан в следующем примере.

Копировать
ifstream mystream("myfile");

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

Версии функций fstream(), ifstream() и ofstream(), которые принимают только один параметр(уже действительный дескриптор), создают поток, а затем связывают его с дескриптором файла, заданным параметром fd.

Версии функций fstream(), ifstream() и ofstream(), которые принимают дескриптор файла, указатель на буфер и размер, создают поток и связывают его с дескриптором файла, заданным параметром fd. Параметр buf должен быть указателем на область памяти, которая будет служить в качестве буфера, а параметр size определяет длину буфера в байтах.(Если параметр buf оказывается нулевым указателем и/или если значение параметра size равно нулю, никакой буферизации не происходит.)

Смотрите также

close — Закрывает файл связаный с потоком
open — Связывает файл с потоком


close()

#include <fstream.h>
close()

Описание

Закрывает файл связаный с потоком

Закрывает файл связаный с потоком


open()

#include <fstream.h>
void open(const char *filename, int mode,
    int access=filebuf::openprot);

Описание

Связывает файл с потоком

Функция является членом классов fstream, ifstream и ofstream.

С помощью функции open() файл связывается с потоком. Параметр filename содержит имя файла и может включать спецификатор пути. Значение параметра mode определяет, в каком режиме открывается файл. Ниже перечислены возможные значения этого параметра.

Флаг открытия | Определение
ios::арр | Добавление всех выводимых данных в конец заданного файла
ios::ate | Ввода-вывод может выполняться в любом месте файла. Указатель устанавливаеться в конец файла
ios::binary | Открытие файла для двоичных операций ввода-вывода
ios::in | Открытие файла для вывода
ios::nocreate | Неудача если заданного файла еще не существует
ios::noreplace | Запрет выполнения если заданный файл уже существует
ios::out | Открытие файла для ввода
ios::trunc | Разрушение содержимого уже существующего файла

Используя оператор ИЛИ(OR), можно объединять в одном выражении два или больше значений(из перечисленных выше).

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

Значение ios::binary обеспечивает возможность открывать файл для выполнения двоичных операций ввода-вывода. По умолчанию файлы открываются в текстовом режиме.

Значение ios::in указывает на способность файла к выполнению операций ввода, а значение ios::out — операций вывода. Однако создание потока ifstream само по себе предполагает ввод, создание потока ofstream — вывод, а открытие файла с использованием потока fstream — как ввод, так и вывод.

Использование значения ios::trunc приводит к разрушению содержимого уже существующего файла с таким же именем, а сам файл усекается до нулевой длины.

Включение значения ios::nocreate обрекает функцию open() на неудачу, если заданного файла еще не существует. Значение ios::norepiace запрещает выполнение функции open(), если заданный файл уже существует, а значения ios::ate и ios::арр при этом не заданы.

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

Открывая файл, для параметров mode и access можно использовать значения, действующие по умолчанию. Открывая файл ввода, параметр mode можно по умолчанию установить равным значению ios::in. Открывая файл вывода, параметр mode по умолчанию можно установить равным значению ios::out. В любом случае для параметра access по умолчанию используется вариант обычного файла(normal file). Например, при выполнении следующего фрагмента программы открывается файл с именем TEST для операций вывода.

Копировать
out.open("test");	//по умолчанию работа с обычным
            //файлом для вывода

Чтобы открыть поток для ввода и вывода, необходимо задать для параметра mode значения ios::in и ios::out, как показано ниже.

Копировать
mystream.open("test", ios::in | ios:out);

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

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


setmode()

#include <fstream.h>
int setmode(int mode = filebuf::text);

Описание

Устанавливает режим работы соответствующего потока: двоичный или текстовый

Функция является членом классов ifstream и ofstream.

Функция setmode() устанавливает режим работы соответствующего потока: двоичный или текстовый.(Текстовый устанавливается по умолчанию.) Допустимыми для параметра mode являются значения filebuf::text и filebuf::binary.

Функция возвращает предыдущую установку режима работы потока или значение -1 при обнаружении ошибки.


Классы ввода вывода библиотеки стандарта C++

В языке C++ существует две версии библиотеки iostream: библиотека старого стиля, определенная ранними версиями C++, и библиотека определенная стандартом ANSI/ISO для языка C++(Standard C++), в которой реализован новый подход к программированию. Библиотека старого стиля была описана в предыдущей главе, а эта глава посвящена описанию библиотеки iostream, соответствующей стандарту ANSI/ISO для языка C++

Система ввода-вывода, соответствующая стандарту C++, построена на основе довольно сложной системы шаблонных классов. Ниже приведен список этих классов.

Класс | Назначение
basic_ios | Обеспечивает операции ввода-вывода общего назначения
basic_streambuf | Поддерживает нижний уровень операций ввода-вывода
basic_istream | Поддерживает операции ввода
basic_ostream | Поддерживает операции вывода
basic_iostream | Поддерживает операции ввода-вывода
basic_filebuf | Поддерживает нижний уровень файловых операций ввода-вывода
basic_ifstream | Поддерживает файловые операции ввода
basic_ofstream | Поддерживает файловые операции вывода
basic_fstream | Поддерживает файловые операции ввода-вывода
basic_stringbuf | Поддерживает нижний уровень строковых операций ввода-вывода
basic_istringstream | Поддерживает строковые операции ввода
basic_ostringstrearm | Поддерживает строковые операции вывода
basic_stringstream | Поддерживает строковые операции ввода-вывода

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

Вся система ввода-вывода C++ построена на двух связанных, но различных иерархиях шаблонных классов. Первая выведена из класса ввода-вывода нижнего уровня basic_streambuf. Этот класс поддерживает базовые операции ввода и вывода нижнего уровня и обеспечивает основополагающую поддержку для всей системы ввода-вывода C++. Классы basic_filebuf и bаsc_stringbuf выведены из класса basic_streambuf. Если вы не занимаетесь разработкой новых методов программирования ввода-вывода, вам вряд ли придется напрямую использовать класс basic_streambuf или его подклассы.

В основном, вам придется работать с иерархией классов, которая выведена из класса basic_ios. Это класс ввода-вывода высокого уровня, который обеспечивает форматирование и обработку ошибок, а также предоставляет информацию о состоянии соответствующего потока ввода-вывода. Класс basic_ios используется в качестве базового для нескольких производных классов, включая такие классы, как basic_istream, basic_ostream и basic_iostream. Эти классы используются для создания потоков, способных выполнять операции ввода, вывода и ввода-вывода соответственно. Из класса basic_istream выведены классы basic_ifstream и basic_istringstream, из класса bаsic_ostream выведены классы basic_ofstream и basic_ostringstream, из класса basic_iostream выведены классы basic_fstream и basic_stringstream. Базовым для класса basic_ios является класс ios_base. Следовательно, любой класс, выведенный из класса basic_ios, имеет доступ к членам класса ios_base.

Классы ввода-вывода параметризированы для типа символов, с которыми они работают, и для характеристик этих символов. Например, вот как выглядит спецификация шаблона для класса basic_ios.

Копировать
template<class CharType, class Attr = char_traits<CharType> >
class basic_ios: public ios_base

Здесь элемент CharType задает тип символа(например, char или wchar_t), а элемент Attr определяет тип, который описывает его атрибуты. Обобщенный тип char_traits — это класс, который определяет атрибуты, относящиеся к некоторому символу.

Библиотека ввода-вывода создает две специализации описанных выше иерархий шаблонных классов: одна - для 8-разрядных, а другая — для двубайтовых символов. Ниже приводится полный список соответствия имен шаблонных классов их символьным версиям и версиям двубайтовых символов.

Шаблонный класс | Класс ориентированный на символы | Класс ориентированный на двухбайтовые символы
basic_ios | ios | wios
basic_istream | istream | wistream
basic_ostream | fstream | wostream
basic_iostream | ostream | wiostream
basic_ifstream | iostream | wifstream
basic_ofstream | ifstream | wofstream
basic_fstream | ofstream | wfstream
basic_istringstream | istringstream | wistringstream
basic_ostringstream | ostringstream | wostringstrearn
basic_stringstream | stringstream | wstringstrearn
basic_streambuf | streambuf | wstreambuf
basic_filebuf | filebuf | wfilebuf
basic_stringbuf | stringbuf | wstringbuf

Поскольку подавляющее большинство программистов будут использовать операции ввода-вывода, ориентированные на обработку символов, в данной главе используются именно эти имена (т.е. при ссылке на классы ввода-вывода мы будем просто использовать их "символьные" имена, а не внутренние имена шаблонов). Например, в этой главе вместо имени basic_ios будет употребляться имя ios, вместо basic_istream — имя istream и вместо basic_fstream — имя fstream. Помните, что для потоков, работающих с двубайтовыми символами, существуют параллельные функции, которые действуют аналогично описанным выше.

Иерархия классов

streambuf -> filebuf
stringbuf

ios | -> | istream | -> | ifstream istringstream
 | -> | ostream | -> | ofstream ostringstream
 | -> | iostream | -> | iofstream iostringstream

Смотрите также

Библиотека iostream стандарта C++
Встроенные потоки C++
Заголовки ввода-вывода
Флаги форматирования
Манипуляторы ввода-вывода
Типы данных
Перегруженные операторы « и »
Создание манипуляторов
Пример использования потоков

Класс ios

Назначение: обеспечивает операции ввода-вывода общего назначения
Заголовок:
Иерархия: базовый класс классов ввода-вывода

Методы

bad — Проверка потока на ошибку
clear — Очищает флаги состояния, связанные с потоком
eof — Проверка конца файла
exceptions — Работа с флагами которые вызывают исключения
fail — Проверка на присутствие ошибки ввода-вывода
fill — Проверка на присутствие ошибки ввода-вывода
flags — Работа с флагами
good — Проверка на отутствие ошибок вводв-вывода
precision — Возвращает или устанавливаеттекущее значение точности
rdstate — Возвращает состояние соответствующего потока
setf — Устанавливает флаги форматирования
setstate — Устанавливает состояние соответствующего потока
sync_with_stdio — Позваляет использовать стандартную С-подобную систему ввода-вывода
unsetf — Очистка одного или нескольких флагов форматирования
width — Работа с шириной поля

Класс ostream

Назначение: поддерживает операции вывода
Заголовок:
Иерархия: ios -> ostream

Методы

flush — Запись содержимого буфера
put — Записывает символ ch в соответствующий поток вывода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
write — Записывает из буфера байты в соответствующий поток вывода

Класс istream

Назначение: поддерживает операции ввода
Заголовок:
Иерархия: ios -> istream

Методы

gcount — Возврат количества символов, прочитанных во время последней операции ввода
getline — Читает строку из потока
get — Читает символы из потока
ignore — Чтение и отбрасывание символов из потока ввода
peek — Возвращает следующий символ в потоке или значение EOF
putback — Возвращает символ в соответствующий поток ввода
read — Читает байты из соответствующего потока ввода
readsome — Читает байты из соответствующего потока ввода
seekg — Перемещает указатель ввода
tellg — Определение текужего указателя ввода

Классы fstream, ifstream и ofstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок:
Иерархия:

  • ios -> istream -> ifstream
  • ios -> ostream -> ofstream
  • ios -> iostream -> fstream

Методы

close — Закрывает файл связаный с потоком
open — Связывает файл с потоком

Классы stringstream, istringstream и ostringstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок:
Иерархия:

  • ios -> istream -> istringstream
  • ios -> ostream -> ostringstream
  • ios -> iostream -> stringstream

Методы

str — Возвращает или освобождает строку заполненую текущим содержимым потока и вставляет, если необходимо другую


Библиотека iostream стандарта C++

Существует два фундаментальных различия между библиотеками iostream старого стиля и соответствующей стандарту ANSI/ISO для языка C++. Во-первых, библиотека старого стиля была определена в глобальном пространстве имен, а библиотека iostream стандарта ANSI/ISO для языка C++ содержится в пространстве имен std. Во-вторых, библиотека старого стиля использует С-подобные заголовочные файлы с расширением . h, а библиотека стандарта C++ — заголовки в стиле C++(без расширения . h).

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

Копировать
using namespace std;

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

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

Копировать
std::cout << "Это тест";

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


Встроенные потоки C++

Библиотека iostream стандарта C++ автоматически открывает следующие потоки.

Поток | Значение
сin | Стандартный ввод
cout | Стандартный вывод
сerr | Стандартный вывод ошибок
clog | Буферизированная версия потока сerr
wcin | Версия потока сin для двубайтовых символов
wcout | Версия потока cout для двубайтовых символов
wcerr | Версия потока сerr для двубайтовых символов
wclog | Версия потока clog для двубайтовых символов

По умолчанию стандартные потоки используются для связи с консолью. Однако в средах, которые поддерживают возможность перенаправления ввода-вывода(например, в DOS, UNIX и Windows), стандартные потоки могут быть перенаправлены на другие устройства или в файлы.


Заголовки ввода-вывода

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

Заголовок | Назначение
<fstream> | Файлы ввода-вывода
<iomanip> | Параметризированные манипуляторы ввода-вывода
<ios> | Базовая поддержка ввода-вывода
<iosfwd> | Предварительные(forward) объявления, используемые системой ввода-вывода
<iostream> | Общие операции ввода-вывода
<istream> | Базовая поддержка ввода
<ostream> | Базовая поддержка вывода
<sstream> | Потоки, ориентированные на работу со строками
<streambuf> | Поддержка операций ввода-вывода нижнего уровня

Некоторые из этих заголовков используются для внутренних нужд системой ввода-вывода. А в общем случае ваша программа будет включать лишь заголовки <iostream>, <fstream>, <sstream> и <iomanip>.


Флаги форматирования

В системе ввода-вывода C++ каждый поток связан с набором флагов форматирования, которые управляют процессом форматирования информации. В классе ios_base объявляется перечисление fmtflags, в котором определены следующие значения.

adjustfield
basefield
boolalpha
dec
fixed 		floatfield
hex
internal
left
oct 		right
scientific
showbase
showpoint
showpos 		skipws
unitbuf
uppercase

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

Флаги Назначение
Пробельных символов

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

Выравнивание

Когда установлен флаг left, результат выравнивается по левому краю. А когда установлен флаг right, результат выравнивается по правому краю. Когда установлен флаг internal, числовое значение дополняется пробелами, чтобы заполнить поле между каким-либо знаком или основным символом. Если ни один из этих флагов не установлен, результат выравнивается по правому краю по умолчанию.

Системы счисления

По умолчанию числовые значения выводятся в десятичной системе счисления. Однако основание системы счисления можно изменить. Установка флага oct приведет к выводу результата в восьмеричном представлении, а установка флага hex — в шестнадцатеричном. Чтобы при отображении результата вернуться к десятичной системе счисления, достаточно установить флаг dec.

Основание системы счисления

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

Отображение чисел

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

Установка флага showpos вызывает отображение ведущего знака "плюс" перед положительными значениями.

Установка флага showpoint приводит к отображению десятичной точки и хвостовых нулей для всех чисел с плавающей точкой — нужны они или нет.

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

Разное

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

Если установлен флаг stdi(), потоки stdout и stderr сбрасываются после каждой операции вывода.

Установка флага boolalpha позволяет вводить и выводить булевы значения с помощью ключевых слов true и false.

Поскольку часто приходится обращаться к полям oct, dec и hex, на них допускается коллективная ссылка ios::basefied. Аналогично поля left, right и internal можно собирательно назвать ios::adjustfield. Наконец, поля scientific и fixed можно назвать ios::floatfield.


Манипуляторы ввода-вывода

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

Манипулятор | Назначение | Функция
boolalpha | Устанавливает флаг boolalpha | Ввод-вывод
dec | Устанавливает флаг dec | Ввод-вывод
endl | Выводит символ новой строки и сбрасывает поток | Вывод
ends | Вставляет в поток нулевой символ ('\0') | Вывод
flush | Сбрасывает поток | Вывод
hex | Устанавливает флаг hex | Ввод-вывод
internal | Устанавливает флаг internal | Вывод
left | Устанавливает флаг lеft | Вывод
noboolalpha | Сбрасывает флаг boolalpha | Ввод-вывод
noshowbase | Сбрасывает флаг showbase | Вывод
noshowpoint | Сбрасывает флаг showpoint | Вывод
noshowpos | Сбрасывает флаг showpos | Вывод
noskipws | Сбрасывает флаг skipws | Ввод
nounitbuf | Сбрасывает флаг unitbuf | Вывод
nouppercase | Сбрасывает флаг uppercase | Вывод
oct | Устанавливает флаг oct | Ввод-вывод
resetiosflags (fmtflags f) | Очищает флаги, заданные в переменной f | Ввод-вывод
right | Устанавливает флаг right | Вывод
scientific | Устанавливает флаг scientific | Вывод
setbase (int base) | Устанавливает основание сиетемы счисления равной значению base | Вывод
setfill (int ch) | Устанавливает символ-заполнитель равным значе нию переменной ch | Вывод
setiosflags (fmtflags f) | Устанавливает флаги, заданные в переменной f | Ввод-вывод
setprecision (int p) | Устанавливает количество цифр точности(после десятичной точки) | Вывод
setw(int w) | Устанавливает ширину поля равной значению переменной w | Вывод
showbase | Устанавливает флаг showbase | Вывод
showpoint | Устанавливает флаг showpoint | Вывод
showpos | Устанавливает флаг showpos | Вывод
skipws | Устанавливает флаг skipws | Ввод
unitbuf | Устанавливает флаг unitbuf | Вывод
uppercase | Устанавливает флаг uppercase | Вывод
ws | Пропускает ведущие пробельные символы | Ввод

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

Совет программисту

Одним из самых интересных флагов форматирования, добавленных в новую библиотеку iostream, является флаг boolalpha. Его можно установить либо напрямую, либо путем использования манипуляторов boolalpha() и noboolalpha(). Дело в том, что установка флага boolalpha позволяет вводить и выводить булевы значения с помощью ключевых слов true и false. Обычно нужно было вводить число 1 для значения истины и число 0 для значения лжи. Рассмотрим, например, следующую программу.

Копировать
// Демонстрация использования флага форматирования boolalpha.
#include
using namespace std;
int main()
{
    bool b;

    cout << "Перед установкой флага boolalpha: ";
    b = true;
    cout << b << " ";
    b = false;
    cout << b << endl;

    cout << "После установки флага boolalpha: ";
    b = true;
    cout << boolalpha << b << " ";
    b = false;
    cout << b << endl;

    cout << "Введите булево значение:
    cin >> boolalpha >> b;
    cout << "Вы ввели " << b;

    return 0;
}

Вот пример работы этой программы.

Копировать
Перед установкой флага boolalpha: 1 О
После установки флага boolalpha: true false
Введите булево значение: true
Вы ввели true

Очевидно, что после установки флага boolalpha логические(булевы) значения вводятся и выводятся с помощью слов true и false. Как видно из текста этой программы, флаг boolalpha необходимо установить для потоков cin и cout отдельно, Как и установка всех флагов форматирования, установка флага boolalpha для одного потока не означает, что он установлен и для другого.


Типы данных

Типы streamsize и streamoff

Объект типа streamsize в состоянии хранить самое большое число байтов, которое будет передано во время любой одной операции ввода-вывода. Это разновидность целого типа данных. Объект типа streamoff способен содержать значение, которое указывает позицию смещения внутри потока. Это также разновидность целого типа данных. Данные типы определены в заголовке <ios>, который автоматически включается системой ввода-вывода.

Типы streampos и wstreampos

Объект типа streampos способен содержать значение, которое представляет позицию внутри потока символов типа char. Объект типа wstreampos способен содержать значение, которое представляет позицию внутри потока символов типа wchar_t. Эти типы определены в заголовке <ios_fwd>, который автоматически включается системой ввода-вывода.

Типы pos_type и off _type

Типы pos_type и off_type создают объекты(обычно целочисленные), которые способны содержать значения, представляющие позицию и смещение соответственно внутри потока. Эти типы определены в классе ios(и других классах) и по сути аналогичны типам streamoff и streampos(или их эквивалентам, работающим с символами широкого формата).

Тип open_mode

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

арр | Добавление в конец файла
ate | Переход в конец файла при открытии
binary | Открытие файла для двоичных операций
in | Открытие файла для ввода
out | Открытие файла для вывода
trunc | Очистка файла при условии его существования

Используя оператор ИЛИ(OR), можно объединять в одном выражении два или больше значений(из перечисленных выше).

Тип iostate

Текущее состояние потока ввода-вывода описывается объектом типа iostate, который представляет собой перечисление, определенное в классе ios_base и включающее следующие члены.

goodbit | He обнаружено никаких ошибок
eofbit | Обнаружен конец файла
failbit | Обнаружена нефатальная ошибка ввода-вывода
badbit | Обнаружена фатальная ошибка ввода-вывода

Тип seekdir

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

bed | Начало файла
cur | Текущая позиция
end | Конец файла

Класс failure

В классе ios_base определен тип исключения failure. Он служит в качестве базового класса для типа исключений, которые могут быть сгенерированы системой ввода-вывода. Этот класс наследует класс exception(стандартный класс исключений). Класс failure имеет следующий конструктор.

Копировать
explicit failure(const string &str);

Здесь str — сообщение, которое описывает ошибку. Это сообщение может быть получено из объекта failure путем вызова его функции what().

Копировать
virtual const char *what() const throw();


Перегруженные операторы « и »

Следующие классы перегружают операторы << и >>, связанные со всеми встроенными типами данных.

basic_istream
basic_ostream
basic_iostream

Операторы << и >> наследуют любые классы, производные от перечисленных выше классов.


Создание манипуляторов

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

Все не имеющие параметров манипуляторы вывода имеют следующую структуру.

Копировать
ostream &manip-name(ostream &stream)
{
    // Текст программы,
    return stream;
}

Здесь manip-name — имя манипулятора. Обратите внимание, что манипулятор возвращает ссылку на поток типа ostream. Это необходимо в случае, если манипулятор должен использоваться как часть большого выражения ввода-вывода. Важно понимать, что, хотя манипулятор использует в качестве своего единственного параметра ссылку на поток, с которым он работает, при вставке манипулятора в операцию вывода аргументы у него отсутствуют.

Все не имеющие параметров манипуляторы ввода имеют следующую структуру.

Копировать
istream &manip-name(istream &stream)
{
    // Текст программы.
    return stream;
}

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

Вот пример простого манипулятора вывода с именем setup(). Он устанавливает выравнивание по левому краю, делает ширину поля равной значению 10 и задает в качестве символа заполнителя знак доллара.

Копировать
#include <iostream>
#include <iomanip>
using namespace std;

ostream &setup(ostream &stream)
{
    stream.setf(ios::left) ;
    stream << setw(10) << setfill('$');
    return stream;
}

int main ()
{
    cout << 10 << " " << setup << 10;
    return 0;
}

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


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

Основные используемые функции

Копировать
unsigned short chunk_id;	//Идентификатор блока
unsigned int chunk_len;		//Смещение

//Переменная типа файловый поток чтения, где ifs просто имя переменной
ifstream ifs;

//Открыть файл с именем fname, как бинарный для чтения и поставить файловый указатель в начало
ifs.open(fname.c_str(), ios_base::in | ios_base::binary | ios_base::beg);

ifs.fail();	//Файл открыт?

//Считать в переменную  chunk_id 2 байта;
//причем часть кода "(char*)&" является обязательной и преобразует адрес переменной в указатель на символ
ifs.read((char*)&chunk_id,2);

//Пропустить chunk_len-6 байт; перейти на  chunk_len-6 байт вперед
ifs.ignore(chunk_len-6);

//Поставить файловый указатель на позицию ifs.tellg()-6
ifs.seekg(ifs.tellg()-6);

//Получить текущую позицию файлового указателя
ifs.tellg();

//Конец файла?
ifs.eof();

Примечание. Вместо методов read и write можно использовать перегруженные операторы ">>" и "<<" соответственно

Пример кода

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

Копировать
#include <cstdlib>
#include <iostream>
#include <fstream>
using namespace std;

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

    char buffer[1];
    int i;
    long currentpos;	/*переменная хранящая позицию внутри потока
                (также можно использовать тип streampos
                (или pos_type в комиляторах которые поддерживают ANSI C++))*/
    bool match = false;

    if (argc != 5) {
        cout << "Usage: filter [search string] [replace string] [infile] [outfile]" << endl;
        return 1;
    }

    string searchstring = argv[1];
    string replacestring = argv[2];
    string infilename = argv[3];
    string outfilename = argv[4];

    //создаём поток для ввода(чтения из файла)
    ifstream input(infilename.c_str(), ios::in);
    if (input.fail()) {
        cout << "Unable to open input file!" << endl;
        return 1;
    }

    //создаём поток для вывода(записи в файл)
    ofstream output(outfilename.c_str(), ios::out | ios::trunc);
    if (output.fail()) {
        cout << "Unable to open output file!" << endl;
        return 1;
    }

    while (!input.eof()) {
        currentpos = input.tellg();		//сохранение указателя на позицию в файле
        input.read(buffer, sizeof(buffer));	//можно использовать операцию ">>"
        if (buffer[0] == searchstring[0]) {
            match = true;
            i = 1;
            while (i < searchstring.length() && match) {
                input.read(buffer, sizeof(buffer));
                if (buffer[0] != searchstring[i]) {
                    input.seekg(currentpos);	//установка указателя
                                    //на позицию в файле
                    input.read(buffer, sizeof(buffer));
                    match = false;
                }
                    else
                    i++;
            }
        }
        if (match) {
            output.write(replacestring.c_str(), replacestring.length());
            match = false;
        }
        else
            output.write(buffer, sizeof(buffer));	//можно использовать операцию "<<"
    }
    input.close();
    output.close();
    ifstream display(outfilename.c_str(), ios::in);

    //вывод результатов
    while (!display.eof()) {
        display.read(buffer, sizeof(buffer));
        if (display.good())
            cout << buffer[0];
    }
    display.close();
    return 0;
}

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


Класс ios

Назначение: обеспечивает операции ввода-вывода общего назначения
Заголовок: <iostream>
Иерархия: базовый класс классов ввода-вывода

Методы

bad — Проверка потока на ошибку
clear — Очищает флаги состояния, связанные с потоком
eof — Проверка конца файла
exceptions — Работа с флагами которые вызывают исключения
fail — Проверка на присутствие ошибки ввода-вывода
fill — Проверка на присутствие ошибки ввода-вывода
flags — Работа с флагами
good — Проверка на отутствие ошибок вводв-вывода
precision — Возвращает или устанавливаеттекущее значение точности
rdstate — Возвращает состояние соответствующего потока
setf — Устанавливает флаги форматирования
setstate — Устанавливает состояние соответствующего потока
sync_with_stdio — Позваляет использовать стандартную С-подобную систему ввода-вывода
unsetf — Очистка одного или нескольких флагов форматирования
width — Работа с шириной поля


bad()

#include <iostream>
bool bad() const;

Описание

Проверка потока на ошибку

Функция является членом класса ios

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


clear()

#include <iostream>
void clear(iostate flags = goodbit);

Описание

Очищает флаги состояния, связанные с потоком

Функция является членом класса ios

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


eof()

#include <iostream>
bool eof() const;

Описание

Проверка конца файла

Функция является членом класса ios

Функция eof() возвращает значение true при обнаружении конца соответствующего файла ввода; в противном случае возвращается значение false.


exceptions()

#include <iostream>
iostate exceptions() const;
void exceptions(iostate flags);

Описание

Работа с флагами которые вызывают исключения

Функция является членом класса ios

Первая форма функции exceptions() возвращает объект типа iostate, который показывает, какие флаги вызывают исключение. Вторая форма функции устанавливает эти значения.


fail()

#include <iostream>
bool fail() const;

Описание

Проверка на присутствие ошибки ввода-вывода

Функция является членом класса ios

Функция fail() возвращает значение true при обнаружении в соответствующем потоке ошибки ввода-вывода; в противном случае возвращается значение false.


fill()

#include <iostream>
char fill() const;
char fill(char ch);

Описание

Указывает символ заполнения поля

Функция является членом класса ios

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

Первая форма функции fill() возвращает текущий символ заполнения.


flags()

#include <iostream>
fmtflags flags() const;
fmtflags flags(fmtflags f);

Описание

Работа с флагами

Функция является членом класса ios

Первая форма функции flags() просто возвращает текущие установки флагов форматирования соответствующего потока.

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


good()

#include <iostream>
bool good() const;

Описание

Проверка на отутствие ошибок ввода-вывода

Функция является членом класса ios

Функция good() возвращает значение true, если в соответствующем потоке не обнаружено ни одной ошибки ввода-вывода; в противном случае возвращается значение false.


precision()

#include <iostream>
streamsize precision() const;
streamsize precision(streamsize p);

Описание

Возвращает или устанавливает текущее значение точности

Функция является членом класса ios

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

Первая версия функции precision() возвращает текущее значение точности.

Совет программисту

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

Все не имеющие параметров манипуляторы вывода имеют следующую структуру.

Копировать
ostream &manip-name(ostream &stream)
{
    // Текст программы,
    return stream;
}

Здесь manip-name — имя манипулятора. Обратите внимание, что манипулятор возвращает ссылку на поток типа ostream. Это необходимо в случае, если манипулятор должен использоваться как часть большого выражения ввода-вывода. Важно понимать, что, хотя манипулятор использует в качестве своего единственного параметра ссылку на поток, с которым он работает, при вставке манипулятора в операцию вывода аргументы у него отсутствуют.

Все не имеющие параметров манипуляторы ввода имеют следующую структуру.

Копировать
istream &manip-name(istream &stream)
{
    // Текст программы.
    return stream;
}

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

Вот пример простого манипулятора вывода с именем setup(). Он устанавливает выравнивание по левому краю, делает ширину поля равной значению 10 и задает в качестве символа заполнителя знак доллара.

Копировать
#include <iostream>
#include <iomanip>
using namespace std;

ostream &setup(ostream &stream)
{
    stream.setf(ios::left) ;
    stream << setw(10) << setfill('$');
    return stream;
}

int main ()
{
    cout << 10 << " " << setup << 10;
    return 0;
}

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


rdstate()

#include <iostream>
iostate rdstate() const;

Описание

Возвращает состояние соответствующего потока

Функция является членом класса ios

Функция rdstate() возвращает состояние соответствующего потока. Система ввода-вывода C++ поддерживает информацию о состоянии, касающуюся результата выполнения каждой операции ввода-вывода, связанной с активным потоком. Текущее состояние системы ввода-вывода хранится в виде объекта типа iostate, в котором определены следующие флаги.

Имя флага | Значение
goodbit | He обнаружено никаких ошибок
еоfbit | Обнаружен конец файла
failbit | При выполнении операций ввода-вывода обнаружен нефатальный сбой
badbit | При выполнении операций ввода-вывода обнаружена фатальная ошибка

Эти флаги перечислены в классе ios(посредством класса ios_base).

Функция rdstate() возвращает значение goodbit, когда не обнаружено никакой ошибки; в противном случае устанавливается бит ошибки.


setf()

#include <iostream>
fmtflags setf(fmtflags flags);
fmtflags setf(fmtflags flags1, fmtflags flags2);

Описание

Устанавливает флаги форматирования

Функция является членом класса ios

Функция setf() устанавливает флаги форматирования, связанные с потоком.

Первая версия функции setf() устанавливает флаги форматирования, заданные параметром flags.(На все остальные флаги функция не действует.) Например, чтобы установить флаг showpos для потока cout, можно использовать следующий оператор. cout.setf(ios::showpos);

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

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

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

Обе версии функции setf() возвращают предыдущие установки флагов форматирования, связанные с потоком.


setstate()

#include <iostream>
void setstate(iostate flags) const;

Описание

Устанавливает состояние соответствующего потока

Функция является членом класса ios

Функция setstate() устанавливает состояние соответствующего потока в соответствии с содержимым параметра flags. Подробности приводятся в описании функции rdstate().


sync_with_stdio()

#include <iostream>
bool sync_with_stdio(bool sync = true);

Описание

Позваляет использовать стандартную С-подобную систему ввода-вывода

Функция является членом класса ios

Вызвав функцию sync_with_stdio(), можно безопасно использовать стандартную С-подобную систему ввода-вывода в согласии с опирающейся на классы системой ввода-вывода C++. Чтобы отключить синхронизацию, передайте функции sync_with_stdio() значение false. Функция возвращает предыдущую установку: значение true означает синхронизацию, а значение false — ее отсутствие. По умолчанию стандартные потоки синхронизированы. Эта функция достоверна только в случае, если она вызывается до выполнения любых других операций ввода-вывода.


unsetf()

#include <iostream>
void unsetf(fmtflags flags);

Описание

Очистка одного или нескольких флагов форматирования

Функция является членом класса ios

Функция unsetf() используется для очистки одного или нескольких флагов форматирования.

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


width()

#include <iostream>
streamsize width() const;
streamsize width(streamsize w);

Описание

Работа с шириной поля

Функция является членом класса ios

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

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


Класс istream

Назначение: поддерживает операции ввода
Заголовок: <iostream>
Иерархия: ios -> istream

Методы

gcount — Возврат количества символов, прочитанных во время последней операции ввода
get — Читает символы из потока
getline — Читает строку из потока
ignore — Чтение и отбрасывание символов из потока ввода
peek — Возвращает следующий символ в потоке или значение EOF
putback — Возвращает символ в соответствующий поток ввода
read — Читает байты из соответствующего потока ввода
readsome — Читает байты из соответствующего потока ввода
seekg — Перемещает указатель ввода
tellg — Определение текужего указателя ввода


gcount()

#include <iostream>
streamsize gcount() const;

Описание

Возврат количества символов, прочитанных во время последней операции ввода

Функция является членом класса istream

Функция gcount() возвращает количество символов, прочитанных во время последней операции ввода.


get()

#include <iostream>
int get();
istream &get(char &ch);
istream &get(char *buf, streamsize num);
istream &get(char *buf, streamsize num, char delim);
istream &get(streambuf &buf);
istream &get(streambuf &buf, char delim);

Описание

Читает символы из потока

Функция является членом класса istream

Вообще, функция get() предназначена для чтения символов из потока ввода.

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

Функция get(char &ch) читает символ из соответствующего потока и помещает прочитанное значение в переменную ch. Функция возвращает ссылку на поток.

Функция get(char *buf, streamsize num) читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num-1 символов, либо не встретится символ новой строки, либо не обнаружится конец файла. После выполнения функции get() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Обнаруженный символ новой строки из потока ввода не извлекается. Он остается в потоке до следующей операции ввода. Эта функция возвращает ссылку на поток.

Функция get(char *buf, streamsize num, char delim) читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num-1 символов, либо не встретится символ ограничителя, заданный параметром delim, либо не обнаружится конец файла. После выполнения функции get() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Обнаруженный символ ограничителя из потока ввода не извлекается. Функция возвращает ссылку на поток.

Функция get(streambuf &buf) читает символы из потока ввода в объект streambuf. Символы читаются до тех пор, пока либо не встретится символ новой строки, либо не обнаружится конец файла. Обнаруженный символ новой строки из потока ввода не извлекается. Функция возвращает ссылку на поток.

Функция get(streambuf &buf, char delim) читает символы из потока ввода в объект streambuf. Символы читаются до тех пор, пока либо не встретится символ ограничителя, заданный параметром delim, либо не обнаружится конец файла. Обнаруженный символ ограничителя из потока ввода не извлекается. Функция возвращает ссылку на поток.


getline()

#include <iostream>
istream &getline(char *buf, streamsize num);
istream &getline(char *buf, streamsize num, char delim);

Описание

Читает символы из потока до ограничителя

Функция является членом класса istream

Функция getline(char *buf, streamsize num) читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num-1 символов, либо не ветретится символ новой строки, либо не обнаружится конец файла. После выполнения функции getline() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Обнаруженный символ новой строки из потока ввода извлекается, но в массив buf не помещается. Функция возвращает ссылку на поток.

Функция getline(char *buf, streamsize пит, char delim) читает символы в массив, адресуемый параметром buf, до тех пор, пока либо не будет прочитано num-1 символов, либо не встретится символ ограничителя, заданный параметром delim, либо не обнаружится конец файла. После выполнения функции getline() массив, адресуемый параметром buf, будет иметь завершающий нуль-символ. Обнаруженный символ ограничителя из потока ввода извлекается, но не помещается в массив buf. Функция возвращает ссылку на поток.


ignore()

#include <iostream>
istream &ignore(streamsize num = 1, int delim = EOF);

Описание

Чтение и отбрасывание символов из потока ввода

Функция является членом класса istream

Функцию-член ignore() можно использовать для чтения и отбрасывания символов из потока ввода. Функция читает и отбрасывает символы до тех пор, пока либо не будет проигнорировано num символов(1 по умолчанию), либо не встретится символ ограничителя, заданный параметром delim (EOF по умолчанию). Обнаруженный символ ограничителя удаляется из потока ввода.

Функция ignore() возвращает ссылку на поток.


peek()

#include <iostream>
int peek();

Описание

Возвращает следующий символ в потоке или значение EOF

Функция является членом класса istream

Функция peek() возвращает следующий символ в потоке или значение EOF, если обнаружен конец файла. Ни при каких обстоятельствах функция не удаляет символ из потока.


putback()

#include <iostream>
istream &putback(char ch);

Описание

Возвращает символ в соответствующий поток ввода

Функция является членом класса istream

Функция putback() возвращает символ ch в соответствующий поток ввода.


read()

#include <iostream>
istream &read(char *buf, streamsize num);

Описание

Читает байты из соответствующего потока ввода

Функция является членом класса istream

Функция read() читает num байт из соответствующего потока ввода и помещает их в буфер, адресуемый параметром buf. При достижении конца файла до прочтения num символов функция read() просто прекращает работу и устанавливает флаг failbit, а в буфере содержится столько символов, сколько было прочитано в действительности.(См. раздел "gcount"). Функция read() возвращает ссылку на поток.


readsome()

#include <iostream>
streamsize readsome(char *buf, streamsize num);

Описание

Читает байты из соответствующего потока ввода

Функция является членом класса istream

Функция readsome() читает num байт из соответствующего потока ввода и помещает их в буфер, адресуемый параметром buf. Если поток содержит меньше чем num символов, считывается именно это число символов. Функция readsome() возвращает число прочитанных символов. Разница между функциями read() и readsome() состоит в том, что функция readsome() не устанавливает флаг failbit, если число доступных символов меньше значения параметра num.


seekg()

#include <iostream>
istream &seekg(off_type offset, ios::seek_dir origin);
istream &seekg(pos_type position);

Описание

Перемещает указатель ввода

Функция является членом класса istream

В системе ввода-вывода C++ с помощью функций seekg() и seekp() выполняется произвольный доступ, т.е. система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода(get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Однако, используя функции seekg() и seekp(), можно получить доступ к файлу непоследовательным образом.

Версия функции seekg() с двумя параметрами перемещает указатель ввода на offset байт от позиции, заданной параметром origin. Параметр offset имеет тип off_type. Объект типа off_type способен содержать самое большое допустимое значение, которое может иметь параметр offset.

Параметр origin имеет тип seek_dir и представляет собой перечисление, которое имеет следующие значения.

ios::beg | Смещение от начала
ios::cur | Смещение от текущей позиции
ios::end | Смещение от конца

Версия функции seekg() с одним параметром перемещают указатели файлов в позиции, заданные параметром position. Это значение должно быть предварительно получено путем обращения либо к функции tellg(), либо к функции tellp() соответственно. Тип pos_type позволяет содержать самое большое допустимое значение, которое может иметь параметр position. Эта функция возвращают ссылку на соответствующий поток.

Смотрите также

seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
tellg — Определение текужего указателя ввода


tellg()

#include <iostream>
pos_type tellg();

Описание

Определение текужего указателя ввода

Функция является членом класса istream

Система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода (get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Именно с помощью функций tellg() и tellp() соответственно можно определить текущую позицию указателей ввода и вывода.

Тип pos_type позволяет содержать самое большое значение, которое может возвратить данная функция.

Значения, возвращаемые функциями tellg() и tellp(), можно использовать в качестве параметров функций seekg() и seekp() соответственно.

Смотрите также

seekg — Перемещает указатель ввода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода


Класс ostream

Назначение: поддерживает операции вывода
Заголовок: <iostream>
Иерархия: ios -> ostream

Методы

flush — Запись содержимого буфера
put — Записывает символ ch в соответствующий поток вывода
seekp — Перемещает указатель вывода
tellp — Определение текужего указателя вывода
write — Записывает из буфера байты в соответствующий поток вывода


flush()

#include <iostream>
ostream &flush();

Описание

Запись содержимого буфера

Функция является членом класса ostream

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


put()

#include <iostream>
ostream &put(char ch);

Описание

Записывает символ в соответствующий поток вывода

Функция является членом класса ostream

Функция put() записывает символ ch в соответствующий
поток вывода. Она возвращает ссылку на этот поток.


seekp()

#include <iostream>
ostream &seekp(off_type offset, ios::seek_dir origin);
ostream &seekp(pos_type position);

Описание

Перемещает указатель вывода

Функция является членом класса ostream

В системе ввода-вывода C++ с помощью функций seekg() и seekp() выполняется произвольный доступ, т.е. система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода(get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Однако, используя функции seekg() и seekp(), можно получить доступ к файлу непоследовательным образом.

Версия функции seekp() с двумя параметрами перемещает указатель вывода на offset байт от позиции, заданной параметром origin. Параметр offset имеет тип off_type. Объект типа off_type способен содержать самое большое допустимое значение, которое может иметь параметр offset.

Параметр origin имеет тип seek_dir и представляет собой перечисление, которое имеет следующие значения.

ios::beg | Смещение от начала
ios::cur | Смещение от текущей позиции
ios::end | Смещение от конца

Версия функции seekp() с одним параметром перемещают указатели файлов в позиции, заданные параметром position. Это значение должно быть предварительно получено путем обращения либо к функции tellg(), либо к функции tellp() соответственно. Тип pos_type позволяет содержать самое большое допустимое значение, которое может иметь параметр position. Эта функция возвращают ссылку на соответствующий поток.

Смотрите также

seekg — Перемещает указатель ввода
tellp — Определение текужего указателя вывода
tellg — Определение текужего указателя ввода


tellp()

#include <iostream>
pos_type tellp();

Описание

Определение текужего указателя вывода

Функция является членом класса ostream

Система ввода-вывода C++ управляет двумя указателями, связанными с файлом. Один из них — это указатель ввода (get pointer), который указывает, в каком месте файла будет выполняться следующая операция ввода. А другой — указатель вывода(put pointer), который указывает, в каком месте файла будет выполняться следующая операция вывода. При каждом выполнении операции ввода или вывода соответствующий указатель автоматически перемещается, последовательно изменяя свою позицию. Именно с помощью функций tellg() и tellp() соответственно можно определить текущую позицию указателей ввода и вывода.

Тип pos_type позволяет содержать самое большое значение, которое может возвратить данная функция.

Значения, возвращаемые функциями tellg() и tellp(), можно использовать в качестве параметров функций seekg() и seekp() соответственно.

Смотрите также

seekg — Перемещает указатель ввода
seekp — Перемещает указатель вывода
tellg — Определение текужего указателя ввода


write()

#include <iostream>
ostream &write(const char *buf, streamsize num);

Описание

Записывает из буфера байты в соответствующий поток вывода

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


Классы stringstream, istringstream и ostringstream

Назначение: поддерживают строковые операции ввода-ввода
Заголовок: <sstream>
Иерархия:

  • ios -> istream -> istringstream
  • ios -> ostream -> ostringstream
  • ios -> iostream -> stringstream

Методы

str — Возвращает или освобождает строку заполненую текущим содержимым потока и вставляет, если необходимо другую

Конструкторы

Копировать
#include
explicit stringstream(ios::openmode mode = ios::in | ios::out);
explicit stringstream(const string &str,
        ios::openmode mode = ios::in | ios::out);

explicit istringstream(ios::openmode mode = ios::in);
explicit istringstream(const string str,
        ios::openmode mode = ios::in);

explicit ostringstream(ios::openmode mode = ios::out);
explicit ostringstream(const string str,
        ios::openmode mode = ios::out);

Те версии функций stringstream() , istringstream() и ostringstream(), которые задают только параметр типа openmode, создают пустые потоки. А версии, которые принимают параметр типа string, инициализируют строковый поток.


str()

#include <sstream>
string str() const;
void str(string &s);

Описание

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

Функция является членом классов stringstream, istringstreamn и ostringstream.

Первая форма функции str() возвращает объект класса string, заполненный текущим содержимым потока, который ориентирован на работу со строками.

Вторая форма функции str() освобождает строку, содержащуюся в данный момент в строковом потоке, и заменяет строку, на которую ссылается параметр s.


Классы fstream, ifstream и ofstream

Назначение: поддерживает операции файлового ввода-ввода
Заголовок: <fstream>
Иерархия:

  • ios -> istream -> ifstream
  • ios -> ostream -> ofstream
  • ios -> iostream -> fstream

Методы

close — Закрывает файл связаный с потоком
open — Связывает файл с потоком

Конструкторы

Копировать
fstream();
explicit fstream(const char *filename,
         ios::openmode mode = ios::in | ios::out);

ifstream();
explicit ifstream(const char *filename,
          ios::openmode mode = ios::in);

ofstream();
explicit ofstream(const char *filename,
          ios::openmode mode=ios::out | ios::trunc);

Функции fstream(), ifstream() и ofstream() представляют собой конструкторы классов fstream, ifstream и ofstream соответственно.

Версии функций fstream(), ifstream() и ofstream(), которые не принимают параметров, создают поток, не связанный ни с одним файлом. Этот поток можно позже связать с нужным файлом с помощью функции open().

Версии функций fstream() , ifstream() и ofstream(), которые принимают имя файла в качестве первого параметра, используются в прикладных программах наиболее часто, хотя вполне корректно можно открыть файл с помощью функции open(), в большинстве случаев обходятся без нее, поскольку эти функции конструкторов fstream, ifstream и ofstream автоматически открывают файл при создании потока. Функции конструкторов имеют те же параметры и значения, действующие по умолчанию, что и функция open().(Подробности — в разделе "open".) Например, самый распространенный способ открытия файла показан в следующем примере.

Копировать
ifstream mystream("myfile");

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

Совет программисту

В библиотеке iostream старого стиля конструктор fstream не содержит задаваемого по умолчанию значения для параметра mode. Это значит, что он не открывает автоматически поток для операций ввода и вывода. Поэтому при использовании библиотеки iostream старого стиля для открытия потока на ввод и вывод оба значения ios::in и ios::out должны задаваться явным образом. Имейте это в виду, если обратная совместимость с библиотекой iostream старого стиля является для вас важным фактором.


close()

#include <fstream>
close();

Описание

Закрывает файл связаный с потоком

Закрывает файл связаный с потоком


open()

#include <fstream>
void fstream::open(const char *filename,
        ios::openmode mode = ios::in | ios::out);
void ifstream::open(const char *filename,
        ios::openmode mode = ios::in);
void ofstream::open(const char *filename,
        ios::openmode mode = ios::out | ios::trunc);

Описание

Связывает файл с потоком

Функция является членом классов fstream, ifstream и ofstream.

С помощью функции open() файл связывается с потоком. Параметр filename содержит имя файла и может включать спецификатор пути. Значение параметра mode определяет, в каком режиме открывается файл. Ниже перечислены возможные значения этого параметра.

Флаг открытия | Определение
ios::арр | Добавление всех выводимых данных в конец заданного файла
ios::ate | Ввода-вывод может выполняться в любом месте файла. Указатель устанавливаеться в конец файла
ios::binary | Открытие файла для двоичных операций ввода-вывода
ios::in | Открытие файла для вывода
ios::out | Открытие файла для ввода
ios::trunc | Разрушение содержимого уже существующего файла

Используя оператор ИЛИ(OR), можно объединять в одном выражении два или больше значений(из перечисленных выше).

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

Значение ios::binary обеспечивает возможность открывать файл для выполнения двоичных операций ввода-вывода. По умолчанию файлы открываются в текстовом режиме.

Значение ios::in указывает на способность файла к выполнению операций ввода, а значение ios::out — операций вывода. Однако создание потока ifstream само по себе предполагает ввод, создание потока ofstream — вывод, а открытие файла с использованием потока fstream — как ввод, так и вывод.

Использование значения ios::trunc приводит к разрушению содержимого уже существующего файла с таким же именем, а сам файл усекается до нулевой длины.

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


Математические функции языка С

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

Для использования всех математических функций в программу необходимо включить заголовок <math.h>. Помимо объявления математических функций, этот заголовок определяет один или несколько макросов. В версии С89 заголовком <math.h> определяется только макрос HUGE_VAL, который представляет собой значение типа double, сигнализирующее о возникшем переполнении.

В версии С99 определены следующие макросы.

HUGE_VALF | float-версия макроса HUGE_VAL
HUGE_VALL | long double-версия макроса HUGE_VAL
INFINITY | Значение, представляющее бесконечность
math_errhandling | Содержит макросы MATH_ERRNO и/или MATH_ERREXCEPT
MATH_ERRNO | Встроенная глобальная переменная errno, используемая для вывода со общений об ошибках
MATH_ERREXCEPT | Исключение вещественного типа, возбуждаемое для вывода сообщения об ошибках
NAN | Не число

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

int fpclassify(fpval) | Возвращает FP_INFINITY, FP_NAN, FP_NORMAL, FP_SUBNORMAL или FP_ZERO в зависимости от значения аргумента fpval. Эти макросы опре деляются заголовком <math.h>
int isfinite(fpval) | Возвращает ненулевое значение, если fpval имеет предел
int isinf(fpval) | Возвращает ненулевое значение, если fpval не имеет предела
int isnan(fpval) | Возвращает ненулевое значение, если fpval - не число
int isnormal(fpval) | Возвращает ненулевое значение, если fpval является нормальным значением
int signbit(fpval) | Возвращает ненулевое значение, если fpval отрицательно(т.е. установлен его знаковый разряд)

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

int isgreater(а, Ь) | Возвращает ненулевое значение, если а больше Ь
int isgreaterequal(а, Ь) | Возвращает ненулевое значение, если а больше или равно b
int isless(a, Ь) | Возвращает ненулевое значение, если а меньше Ь
int islessequal(а, Ь) | Возвращает ненулевое значение, если а меньше или равно b
int islessgreater(а, Ь) | Возвращает ненулевое значение, если а больше или меньше b
int isunordered(a, Ь) | Возвращает 1, если а и b неупорядочены одно относительно другого. Возвращает 0, если а и Ь упорядочены

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

Макросы EDOM и ERANGE также используются математическими функциями. Эти макросы определены в заголовке <errno.h>.

Ошибки в версиях С89 и С99 обрабатываются по-разному. Так, в версии С89, если аргумент математической функции не попадает в домен, для которого он определен, возвращается некоторое значение, зависящее от конкретной реализации, а встроенная глобальная целая переменная errno устанавливается равной значению EDOM. В версии С99 ошибка нарушения границ домена также приводит к возврату значения, зависящего от конкретной реализации. Однако по значению math_errhandling можно судить о выполнении других действий. Если math_errhandling содержит значение MATH_ERRNO, встроенная глобальная целая переменная errno устанавливается равной значению EDOM. Если же math_errhandling содержит значение MATH_ERREXCEPT, возбуждается исключение вещественного типа.

В версии С89, если функция генерирует результат, который слишком велик для возможностей представления, происходит переполнение. В этом случае функция возвращает значение HUGE_VAL, а переменная errno устанавливается равной значению ERANGE, сигнализирующему об ошибке диапазона. При обнаружении потери значимости функция возвращает нуль и устанавливает переменную errno равной значению ERANGE. В версии С99 ошибка переполнения также приводит к тому, что функция возвращает значение. HUGE_VAL, а при потере значимости - нуль. Если math_errhandling содержит значение MATH_ERRNO, глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке диапазона. Если же math_errhandling содержит значение MATH_ERREXCEPT, возбуждается исключение вещественного типа.

В версии С89 аргументами математических функций должны быть значения типа double и значения, возвращаемые функциями, имеют тип double. В версии С99 добавлены float- и long double-варианты этих функций, которые используют суффиксы f и l соответственно. Например, в версии С89 функция sin() определена следующим образом.

Копировать
double sin(double arg);

В версии С99 поддерживается приведенное выше определение функции sin() и добавляются еще две ее модификации - sinf() и sinl().

Копировать
float sinf(float arg);
long double sinl(long double arg);

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

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

acos | asin | atan | atan2 | ceil
cos | cosh | exp | fabs | floor
fmod | frexp | ldexp | log | log10
modf | pow | sin | sinh | sqrt
tan | tanh |  |  |

И еще одно: все углы задаются в радианах.

Смотрите также

acos - Возвращает значение арккосинуса
acosh - Возвращает значение гиперболического арккосинуса
asin - Возвращает значение арксинуса
asinh - Возвращает значение гиперболического арксинуса
atan - Возвращает значение арктангенса
atan2 - Возвращает значение арктангенса от а/Ь
atanh - Возвращает значение гиперболического арктангенса
cbrt - Возвращает значение кубического корня
ceil - Возвращает наименьшее целое, которое больше значения заданого аргумента
copysign - Наделяет заданый аргумент знаком, который имеет указаный аргумент
cos - Возвращает значение косинуса
cosh - Возвращает значение гиперболического косинуса
erf - Возвращает значение функции ошибок
erfc - Возвращает дополнительное значение функции ошибок
exp - Возвращает значение экспоненты
exp2 - Возвращает число 2, возведенное в заданую степень
expm1 - Возвращает уменьшенное на единицу значение натурального логарифма е
fabs - Возвращает абсолютное значение
fdim - Возвращает нуль или разность в двух заданных аргументов
floor - Возвращает наибольшее целое которое меньше или равно значению заданного аргумента
fma - Возвращает значение а*Ь+с заданных аргументов
fmax - Возвращает большее из двух значений
fmin - Возвращает меньшее из двух значений
fmod - Возвращает остаток от деления
frexp - Разбивает заданое число на мантиссу и экспоненту
hypot - Возвращает длину гипотенузы при заданных длинах двух катетов
ilogb - Выделяет экспоненциальное значение
ldexp - Возвращает значение выражения num*2^ехр.
lgamma - Вычисляет абсолютное значение гамма-функции и возвращает ее натуральный логарифм
llrint - Возвращает значение округленноге до ближайшего целого
llround - Возвращает значение округленное до ближайшего целого
log - Возвращает значение натурального логарифма
log10 - Возвращает значение логарифма по основанию 10
log1p - Возвращает значение натурального логарифма для аргумента num+1
log2 - Возвращает логарифм по основанию 2
logb - Выделяет экспоненциальное значение
lrint - Возвращает значение округленное до ближайшего целого
lround - Возвращает значение округленное до ближайшего целого
modf - Разбивает аргумент num на целую и дробную части
nan - Возвращает значение, которое не является числом и которое содержит строку
nearbyint - Возвращает значение аргумента округленное до ближайшего целого
nextafter - Функция возвращает следующее после заданного аргумента значение, ближайшее к значению указаного аргумента
nexttoward - Функция возвращает следующее после заданного аргумента значение, ближайшее к значению указаного аргумента
pow - Возвращает число возведённое в степень
remainder - Возвращает остаток от деления значений двух аргументов
remquo - Возвращает остаток от деления значений двух аргументов
rint - Возвращает значение округленное до ближайшего целого
round - Возвращает значение аргумента arg, округленное до ближайшего целого
scalbln - Возвращает произведение параметра val и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр
scalbn - Возвращает произведение заданного параметра и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр
sin - Возвращает значение синуса
sinh - Возвращает значение гиперболического синуса
sqrt - Возвращает значение квадратного корня
tan - Возвращает значение тангенса
tanh - Возвращает значение гиперболического тангенса
tgamma - Возвращает значение гамма-функции
trunc - Возвращает усеченное значение аргумента


acos()

#include <math.h>
float acosf(float arg);
double acos(double arg);
long double acosl(long double arg);

Описание

Возвращает значение арккосинуса

Функции acosf() и acosl() добавлены в версии С99.

Каждая функция семейства acos() возвращает значение арккосинуса от аргумента arg. Значение аргумента должно находиться в диапазоне от -1 до 1; в противном случае возникает ошибка нарушения границ домена.


acosh()

#include <math.h>
float acoshf(float arg);
double acosh(double arg);
long double acoshl(long double arg);

Описание

Возвращает значение гиперболического арккосинуса

Функции acosh(), acoshf() и acoshl() добавлены в версии С99.

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


asin()

#include <math.h>
float asinf(float arg);
double asin (double arg);
long double asinl(long double arg);

Описание

Возвращает значение арксинуса

Функции asinf() и asinl() добавлены в версии С99.

Каждая функция семейства asin() возвращает значение арксинуса от аргумента arg. Значение аргумента должно находиться в диапазоне от -1 до 1; в противном случае возникает ошибка нарушения границ домена.


asinh()

#include <math.h>
float asinhf(float arg);
double asinh(double arg);
long double asinhl(flong double arg);

Описание

Возвращает значение гиперболического арксинуса

Функции asinh(), asinhf() и asinh() добавлены в версии С99.

Каждая функция семейства asinh() возвращает значение гиперболического арксинуса от аргумента аrg.


atan()

#include <math.h>
float atanf(float arg);
double atan(double arg);
long double atanl(long double arg);

Описание

Возвращает значение арктангенса

Функции atanf() и atanl() добавлены в версии С99.

Каждая функция семейства atan() возвращает значение арктангенса от аргумента arg.


atan2()

#include <math.h>
float atan2f(float a, float b);
double atan2(double a, double b);
long double atan2l(long double a, long double b);

Описание

Возвращает значение арктангенса от а/Ь

Функции atan2f() и atan2l() добавлены в версии С99.

Каждая функция семейства atan2() возвращает значение арктангенса от а/Ь. Для вычисления квадранта возвращаемого значения используются знаки аргументов функции.


atanh()

#include <math.h>
float atanhf(float arg);
double atanh(double arg);
long double atanhl(long double arg);

Описание

Возвращает значение гиперболического арктангенса

Функции atanh(), atanhf() и atanhl() добавлены в версии С99.

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


cos()

#include <math.h>
float cosf( float arg);
double cos(double arg);
long double cosl(long double arg);

Описание

Возвращает значение косинуса

Функции cosf() и cosl() добавлены в версии С99.

Каждая функция семейства cos() возвращает значение косинуса аргумента arg. Значение аргумента должно быть выражено в радианах.


cosh()

#include <math.h>
float coshf(float arg);
double cosh(double arg);
long double coshl(long double arg);

Описание

Возвращает значение гиперболического косинуса

Функции coshf() и coshl() добавлены в версии С99.

Каждая функция семейства cosh() возвращает значение гиперболического косинуса аргумента arg.


sin()

#include <math.h>
float sinf(float arg);
double sin(double arg);
long double sinl(long double arg);

Описание

Возвращает значение синуса

Функции sinf() и sinl() добавлены в версии С99.

Каждая функция семейства sin() возвращает значение синуса от аргумента arg. Значение аргумента должно быть задано в радианах.


sinh()

#include <math.h>
float sinhf(float arg);
double sinh(double arg);
long double sinhl(long double arg);

Описание

Возвращает значение гиперболического синуса

Функции sinhf() и sinhl() добавлены в версии С99.

Каждая функция семейства sinh() возвращает значение гиперболического синуса от аргумента arg.


tan()

#include <math.h>
float tanf(float arg);
double tan(double arg);
long double tanl(long double arg);

Описание

Возвращает значение тангенса

Функции tanf() и tanl() добавлены в версии С99.

Каждая функция семейства tan() возвращает значение тангенса от аргумента arg. Значение аргумента должно быть задано в радианах.


tanh()

#include <math.h>
float tanhf(float arg);
double tanh(double arg);
long double tanhl(long double arg);

Описание

Возвращает значение гиперболического тангенса

Функции tanhf() и tanhl() добавлены в версии С99.

Каждая функция семейства tanh() возвращает значение гиперболического тангенса от аргумента arg.


cbrt()

#include <math.h>
float cbrtf(float num);
double cbrt(double num);
long double cbrtl(long double num);

Описание

Возвращает значение кубического корня

Функции cbrt(), cbrtf() и cbrtl() добавлены в версии C99.

Каждая функция семейства cbrt() возвращает значение кубического корня от аргумента num.


exp()

#include <math.h>
float expf(float arg);
double exp(double arg);
long double expl(long double arg);

Описание

Возвращает значение экспоненты

Функции expf() и expl() добавлены в версии С99.

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


exp2()

#include <math.h>
float exp2f(float arg);
double exp2(double arg);
long double exp2l(long double arg);

Описание

Возвращает число 2, возведенное в заданую степень

Функции exp2(), exp2f() и exp21() добавлены в версии C99.

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


expm1()

#include <math.h>
float expm1f(float arg);
double expm1(double arg);
long double expm1l(long double arg);

Описание

Возвращает уменьшенное на единицу значение натурального логарифма е

Функции expml(), expml f() и expm1l() добавлены в версии С99.

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


frexp()

#include <math.h>
float frexpf(float num, int *exp);
double frexp(double num, int *exp);
long double frexpl(long double num, int *exp);

Описание

Разбивает заданое число на мантиссу и экспоненту

Функции frexpf() и frexpl() добавлены в версии С99.

Каждая функция семейства frexp() разбивает число, задаваемое параметром num, на мантиссу mantissa и экспоненту ехр таким образом, что значение mantissa больше или равно 0,5 и меньше 1, а целочисленное значение экспоненты присваивается переменной, адрес которой задается параметром ехр: num=mantissa*2^exp. Значение мантиссы возвращается функцией, а экспонента сохраняется в переменной, адресуемой параметром ехр.


ilogb()

#include <math.h>
int ilogbf(float num);
int ilogb(double num);
int ilogbl(long double num);

Описание

Выделяет экспоненциальное значение

Функции ilogb(), ilogbf() и ilogb() добавлены в версии С99.

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


ldexp()

#include <math.h>
float ldexpf(float num, int exp);
double ldexp(double num, int exp);
long double ldexpl(long double num, int exp);

Описание

Возвращает значение выражения num*2^ехр.

Функции ldexpf() и ldexp1() добавлены в версии С99.

Каждая функция семейства Idexp() возвращает значение выражения num*2ехр.


log()

#include <math.h>
float logf(float num);
double log(double num);
long double logl(long double num);

Описание

Возвращает значение натурального логарифма

Функции logf() и logl() добавлены в версии С99.

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


log10()

#include <math.h>
float log10f(float num)
double log10(double num);
long double log10l(long double num);

Описание

Возвращает значение логарифма по основанию 10

Функции log10f() и log10l() добавлены в версии С99.

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


log1p()

#include <math.h>
float log1pf(float num);
double log1p(double num);
long double log1pl(long double num);

Описание

Возвращает значение натурального логарифма для аргумента num+1

Функции log1p(), log1pf() и log1pl() добавлены в версии С99.

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


log2()

#include <math.h>
float log2f(float num);
double log2(double num);
long double log2l(long double num);

Описание

Возвращает логарифм по основанию 2

Функции log2(), log2f() и log2l() добавлены в версии С99.

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


logb()

#include <math.h>
float logbf(float num);
double logb(double num);
long double logbl(long double num);

Описание

Выделяет экспоненциальное значение

Функции logb(), logbf() и logbl() добавлены в версии С99.

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


pow()

#include <math.h>
float powf(float base, float exp);
double pow(double base, double exp);
long double powl(long double base, long double exp);

Описание

Возвращает число возведённое в степень

Функции powf() и powl() добавлены в версии С99.

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


scalbln()

#include <math.h>
float scalblnf(float val, long int exp);
double scalbln(double val, long int exp);
long double scalblnl(long double val, long int exp);

Описание

Возвращает произведение параметра val и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр

Функции scalbln(), scalblnf() и scalblnl() добавлены в версии С99.

Каждая функция семейства scalbln() возвращает произведение параметра val и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр, т.е. val*^FLT_RADIXexp.

Макрос FLT_RADIX определен в заголовке <float.h>, и его значение - это основание представления экспоненты.


scalbn()

#include <math.h>
float scalbnf(float val, int exp);
double scalbn(double val, int exp);
long double scalbnl(long double val, int exp);

Описание

Возвращает произведение заданного параметра и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр

Функции scalbn(), scalbnf() и scalbnl() добавлены в версии С99.

Каждая функция семейства scalbn() возвращает произведение параметра val и значения FLT_RADIX, возведенного в степень, которая равна значению параметра ехр, т.е. val*FLT_RADIX^exp.

Макрос FLT_RADIX определен в заголовке <float.h>, и его значение - это основание экспоненциального представления.


sqrt()

#include <math.h>
float sqrtf(float num);
double sqrt(double num);
long double sqrtl(long double num);

Описание

Возвращает значение квадратного корня

Функции sqrtf() и sqrtl() добавлены в версии С99.

Каждая функция семейства sqrt() возвращает значение квадратного корня от аргумента num. Если значение аргумента num отрицательно, возникает ошибка нарушения границ домена.


ceil()

#include <math.h>
float ceilf(float num);
double ceil(double num);
long double ceill(long double num);

Описание

Возвращает наименьшее целое, которое больше значения заданого аргумента

Функции ceilf() и ceill() добавлены в версии С99.

Каждая функция семейства ceil() возвращает наименьшее целое(представленное в виде значения с плавающей точкой), которое больше значения аргумента num или равно ему. Например, при num, равном 1,02, функция ceil() вернет значение 2,0, а при num, равном -1,02, - значение -1.


copysign()

#include <math.h>
float copysignf(float val, float signval);
double copysign(double val, double signval);
long double copysignl(long double val , long double signval);

Описание

Наделяет заданый аргумент знаком, который имеет указаный аргумент

Функции copysign(), copysignf() и copysignl() добавлены в версии С99.

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


fabs()

#include <math.h>
float fabsf(float num);
double fabs(double num);
long double fabsl(long double num);

Описание

Возвращает абсолютное значение

Функции fabsf() и fabsl() добавлены в версии С99.

Каждая функция семейства fabs() возвращает абсолютное значение аргумента num.


fdim()

#include <math.h>
float fdimf(float a, float b);
double fdim(double a, double b);
long double fdiml(long double a, long double b);

Описание

Возвращает нуль или разность в двух заданных аргументов

Функции fdim(), fdimf() и fdiml() добавлены в версии С99.

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


floor()

#include <math.h>
float floorf(float num);
double floor(double num);
long double floor(ldong double num);

Описание

Возвращает наибольшее целое которое меньше или равно значению заданного аргумента

Функции floorf() и floorl() добавлены в версии С99.

Каждая функция семейства floor() возвращает наибольшее целое(представленное в виде значения с плавающей точкой), которое меньше значения аргумента num или равно ему. Например, при num, равном 1,02, функция floor() вернет значение 1,0, а при num, равном -1,02, - значение -2,0.


fma()

#include <math.h>
float fmaf(float a, float b, float c);
double fma(double a, double b, double c);
long double fmal(long double a, long double b, long double c);

Описание

Возвращает значение а*Ь+с заданных аргументов

Функции fma(), fma() и fma() определены в версии С99.

Каждая функция семейства fma() возвращает значение а * Ь + с. Округление выполняется только однажды, после завершения всей операции.


fmax()

#include <math.h>
float fmaxf(float a, float b);
double fmax(double a, double b);
long double fmaxl(long double a, long double b);

Описание

Возвращает большее из двух значений

Функции fmax(), fmaxf() и fmaxl() определены в версии С99.

Каждая функция семейства fmax() возвращает большее из значений двух аргументов а и Ь.


fmin()

#include <math.h>
float fminf(float a, float b);
double fmin(double a, double b);
long double fminl(long double a, long double b);

Описание

Возвращает меньшее из двух значений

Функции fmin(), fminf() и fminl() определены в версии С99.

Каждая функция семейства fmin() возвращает меньшее из значений двух аргументов а и Ь.


fmod()

#include <math.h>
float fmodf(float a, float b);
double fmod(double a, double b);
long double fmodl(long double a, long double b);

Описание

Возвращает остаток от деления

Функции fmodf() и fmodl() определены в версии С99.

Каждая функция семейства fmod() возвращает остаток от деления значений аргументов a/b.


hypot()

#include <math.h>
float hypotf(float side1, float side2);
double hypot(double sidel, double side2);
long double hypotl(long double sidel, long double side2);

Описание

Возвращает длину гипотенузы при заданных длинах двух катетов

Функции hypot(), hypotf() и hypotl() определены в версии С99.

Каждая функция семейства hypot() возвращает длину гипотенузы при заданных длинах двух катетов(т.е. функция возвращает значение квадратного корня из суммы квадратов значений аргументов sidel и side2).


lgamma()

#include <math.h>
float lgammaf(float arg);
double lgamma(double arg);
long double lgammal(long double arg);

Описание

Вычисляет абсолютное значение гамма-функции и возвращает ее натуральный логарифм

Функции lgamma(), 1gammaf() и lgammal() добавлены в версии С99.

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


llrint()

#include <math.h>
long long int llrintf(float arg);
long long int llrint(double arg);
long long int llrintl(long double arg);

Описание

Возвращает значение округленноге до ближайшего целого

Функции llrint(), llrintf() и llrintl() добавлены в версии С99.

Каждая функция семейства llrint() возвращает значение аргумента arg, округленного до ближайшего целого, которое имеет тип long long int.


llround()

#include <math.h>
long long int llroundf(float arg);
long long int llround(double arg);
long long int llroundl(long double arg);

Описание

Возвращает значение округленное до ближайшего целого

Функции llround(), llroundf() и llroundl() добавлены в версии С99.

Каждая функция семейства llround() возвращает значение аргумента arg, округленное до ближайшего целого, которое имеет тип long long int. Значения, отстоящие от боль шего и меньшего целых на одинаковую величину(например, число 3,5), округляются в сторону большего целого.


lrint()

#include <math.h>
long int lrintf(float arg);
long int lrint(double arg);
long int lrintl(long double arg);

Описание

Возвращает значение округленное до ближайшего целого

Функции lrint(), lrintf() и lrintl() добавлены в версии С99.

Каждая функция семейства lrint() возвращает значение аргумента arg, округленное до ближайшего целого, которое имеет тип long int.


lround()

#include <math.h>
long int lroundf(float arg);
long int lround(double arg);
long int lroundl(long double arg);

Описание

Возвращает значение округленное до ближайшего целого

Функции lround(), lroundf() и lroundl() добавлены в версии С99.

Каждая функция семейства lround() возвращает значение аргумента arg, округленное до ближайшего целого, которое имеет тип long int. Значения, отстоящие от большего и меньшего целых на одинаковую величину(например, число 3,5), округляются в сторону большего целого.


modf()

#include <math.h>
float modff(float num, float *i);
double modf(double num, double *i);
long double modfl(long double num, long double *i);

Описание

Разбивает аргумент num на целую и дробную части

Функции modff() и modfl() добавлены в версии С99.

Каждая функция семейства modf() разбивает аргумент num на целую и дробную части. Функция возвращает дробную часть и размещает целую часть в переменной, адресуемой параметром i.


nearbyint()

#include <math.h>
float nearbyintf(float arg};
double nearbyint(double arg);
long double nearbyintl(long double arg);

Описание

Возвращает значение аргумента округленное до ближайшего целого

Функции nearbyint(), nearbyintfО и nearbyintl() добавлены в версии С99.

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


nextafter()

#include <math.h>
float nextafterf(float from, float towards);
double nextafter(double from, double towards);
long double nextafterl(long double from, long double towards);

Описание

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

Функции nextafter(), nextafterf() и nextafterl() добавлены в версии С99.

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


nexttoward()

#include <math.h>
float nexttowardf(float from, long double towards);
double nexttoward(double from, long double towards);
long double nexttowardl(long double from, long double towards);

Описание

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

Функции nexttoward(), nexttowardf() и nexttowardl() добавлены в версии С99.

Каждая функция семейства nexttoward() возвращает следующее после аргумента from значение, ближайшее к значению аргумента towards. Действие этих функций аналогично действию функций семейства nextafter() за исключением того, что параметр towards имеет тип long double для всех трех функций.


remainder()

#include <math.h>
float remainderf(float a, float b);
double remainder(double a, double b);
long double remainderl(long double a, long double b);

Описание

Возвращает остаток от деления значений двух аргументов

Функции remainder(), remainderf() и remainderl() определены в версии С99.

Каждая функция семейства remainder() возвращает остаток от деления значений аргументов а/Ь.


remquo()

#include <math.h>
float remquof(float a, float b, int *gue);
double remquo(double a, double b, int *que)
long double remquol(long double a, long double b, int *gue);

Описание

Возвращает остаток от деления значений двух аргументов

Функции remquo(), remquof() и remquol() определены в версии С99.

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


rint()

#include <math.h>
float rintf(float arg);
double rint(double arg);
long double rintl(long double arg);

Описание

Возвращает значение округленное до ближайшего целого

Функции rint(), rintf() rintl() добавлены в версии С99.

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


round()

#include <math.h>
float roundf(float arg);
double round(double arg);
long double roundl(long double arg);

Описание

Возвращает значение аргумента arg, округленное до ближайшего целого

Функции round(), roundf() и roundl() добавлены в версии С99.

Каждая функция семейства round() возвращает значение аргумента arg, округленное до ближайшего целого. Однако возвращаемое число является значением с плавающей точкой. Значения, отстоящие от большего и меньшего целого на одинаковую величину(например, число 3,5), округляются в сторону большего целого.


tgamma()

#include <math.h>
float tgammaf(float arg);
double tgamma(double arg);
long double tgammal(long double arg);

Описание

Возвращает значение гамма-функции

Функции tgamma(), tgammaf() и tgamma1() добавлены в версии С99.

Каждая функция семейства tgamma() возвращает значение гамма-функции от аргумента arg.


trunc()

#include <math.h>
float truncf(float arg);
double trunc(double arg);
long double truncl(long double arg);

Описание

Возвращает усеченное значение аргумента

Функции trunc(), truncf() и trunc() добавлены в версии С99.

Каждая функция семейства trunc() возвращает усеченное значение аргумента arg.


erf()

#include <math.h>
float erff(float arg);
double erf(double arg);
long double erf1(long double arg);

Описание

Возвращает значение функции ошибок

Функции erf(),erff() и erfl() добавлены в версии С99.

Каждая функция семейства erf() возвращает значение функции ошибок от аргумента arg.


erfc()

#include <math.h>
float erfcf(float arg);
double erfc(double arg);
long double erfcl(long double arg);

Описание

Возвращает дополнительное значение функции ошибок

Функции erfc(), erfcf() и erfcl() добавлены в версии С99.

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


nan()

#include <math.h>
float nanf(const char *content);
double nan(const char * content);
long double nanl(const char *content);

Описание

Возвращает значение, которое не является числом и которое содержит строку

Функции nan(), nanf() и nanl() добавлены в версии С99.

Каждая функция семейства nan() возвращает значение, которое не является числом и которое содержит строку, адресуемую параметром content.


Математические функции языка C++

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

Для использования математических функций в языке C++ необходимо включение в программу заголовка <cmath.h>. Этот заголовок не только объявляет математические функции, но и определяет макрос HUGE_VAL. Макросы EDOM и ERANGE также используются математическими функциями. Эти макросы определены в заголовке <cerrno.h>. Если аргумент математической функции не попадает в домен, для которого он определен, функцией возвращается некоторое значение, зависящее от конкретной реализации, а встроенная глобальная целая переменная errno устанавливается равной значению EDOM. Если функция генерирует результат, который слишком велик для возможностей представления, происходит переполнение. В этом случае функция возвращает значение HUGE_VAL, а переменная errno устанавливается равной значению ERANGE, сигнализирующему об ошибке диапазона. При обнаружении потери значимости функция возвращает нуль и устанавливает переменную errno равной значению ERANGE.

В языке C++ поддерживаются оригинальные математические функции, определенные в версии С89. Однако в версии С89 аргументами математических функций должны быть только значения типа double. К этим функциям в языке C++ добавились перегруженные версии, которые явно предназначены для приема значений типа float и long double. Действия, выполняемые функциями, остались теми же.

Все углы задаются в радианах.

Смотрите также

acos - Возвращает значение арккосинуса
asin - Возвращает значение арксинуса
atan - Возвращает значение арктангенса
atan2 - Возвращает значение арктангенса от у/х
ceil - Возвращает наименьшее целое которое больше или равно заданного значения
cos - Возвращает значение косинуса
cosh - Возвращает значение гиперболического косинуса
exp - Возвращает значение экспоненты
fabs - Возвращает абсолютное значение
floor - Возвращает наибольшее целое которое меньше или равно значения заданного аргумента
fmod - Остаток от деления значений аргументов х/у
frexp - Разбивает число на мантиссу и экспоненту
ldexp - Возвращает значение выражения num*2^ехр
log - Возвращает значение натурального логарифма
log10 - Возвращает значение логарифма по основанию 10
modf - Разбивает аргумент на целую и дробную части
pow - Возвращает значение аргумента которое возведено в заданную степень
sin - Возвращает значение синуса
sinh - Возвращает значение гиперболического синуса
sqrt - Возвращает значение квадратного корня
tan - Возвращает значение тангенса
tanh - Возвращает значение гиперболического тангенса


acos()

#include <cmath.h>
float acos(float arg);
double acos(double arg);
long double acos(long double arg);

Описание

Возвращает значение арккосинуса

Функция acos() возвращает значение арккосинуса от аргумента arg. Значение аргумента должно находиться в диапазоне от -1 до 1; в противном случае возникает ошибка нарушения границ домена.


asin()

#include <cmath.h>
float asin(float arg);
double asin(double arg);
long double asin(long double arg);

Описание

Возвращает значение арксинуса

Функция asin() возвращает значение арксинуса от аргумента arg. Значение аргумента должно находиться в диапазоне от -1 до 1; в противном случае возникает ошибка нарушения границ домена.


atan()

#include <cmath.h>
float atan(float arg);
double atan(double arg);
long double atan(long double arg);

Описание

Возвращает значение арктангенса

Функция atan() возвращает значение арктангенса от аргумента arg.


atan2()

#include <cmath.h>
float atan2(float y, float x);
double atan2(double y, double x);
long double atan2(long double y, long double x);

Описание

Возвращает значение арктангенса от у/х

Функция atan2() возвращает значение арктангенса от у/х. Для вычисления квадранта возвращаемого значения используются знаки аргументов функции.


cos()

#include <cmath.h>
float cos(float arg);
double cos(double arg);
long double cos(long double arg);

Описание

Возвращает значение косинуса

Функция cos() возвращает значение косинуса аргумента arg. Значение аргумента должно быть выражено в радианах.


cosh()

#include <cmath.h>
float cosh(float arg);
double cosh(double arg);
long double cosh(long double arg);

Описание

Возвращает значение гиперболического косинуса

Функция cosh() возвращает значение гиперболического косинуса от аргумента arg.


sin()

#include <cmath.h>
float sin(float arg);
double sin(double arg);
long double sin(long double arg);

Описание

Возвращает значение синуса

Функция sin() возвращает значение синуса от аргумента arg. Значение аргумента должно быть задано в радианах.


sinh()

#include <cmath.h>
float sinh(float arg);
double sinh(double arg);
long double sinh(long double arg);

Описание

Возвращает значение гиперболического синуса

Функция sinh() возвращает значение гиперболического синуса от аргумента arg.


tan()

#include <cmath.h>
float tan(float arg);
double tan(double arg);
long double tan(long double arg);

Описание

Возвращает значение тангенса

Функция tan() возвращает значение тангенса от аргумента arg. Значение аргумента должно быть задано в радианах.


tanh()

#include <cmath.h>
float tanh(float arg);
double tanh(double arg);
long double tanh(long double arg);

Описание

Возвращает значение гиперболического тангенса

Функция tanh() возвращает значение гиперболического тангенса от аргумента arg.


exp()

#include <cmath.h>
float exp(float arg);
double exp(double arg);
long double exp(long double arg);

Описание

Возвращает значение экспоненты

Функция exp() возвращает значение экспоненты от аргумента arg(число е, которое возведено в степень, равную значению аргумента arg).


frexp()

#include <cmath.h>
float frexp(float num, int *exp);
double frexp(double num, int *exp);
long double frexp(long double num, int *exp);

Описание

Разбивает число на мантиссу и экспоненту

Функция floor() разбивает число, задаваемое параметром num, на мантиссу mantissa и экспоненту ехр таким образом, что значение mantissa больше или равно 0,5 и меньше 1, а целочисленное значение экспоненты присваивается переменной, адрес которой задается параметром ехр: num=mantissa*2^exp. Значение мантиссы возвращается функцией, а экспонента сохраняется в переменной, адресуемой параметром ехр.


ldexp()

#include <cmath.h>
float ldexp(float num, int exp);
double ldexp(double num, int exp);
long double ldexp(long double num, int exp)

Описание

Возвращает значение выражения num*2^ехр

Функция ldexp() возвращает значение выражения num*2ехр. При переполнении возвращается значение HUGE_VAL.


log()

#include <cmath.h>
float log(float num);
double log(double num);
long double log(long double num);

Описание

Возвращает значение натурального логарифма

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


log10()

#include <cmath.h>
float log10(float num);
double log10(double num);
long double log10(long double num);

Описание

Возвращает значение логарифма по основанию 10

Функция log10() возвращает значение логарифма по основанию 10 для аргумента num. Если значение аргумента num отрицательно, возникает ошибка нарушения границ домена, а если значение num равно нулю - ошибка пределов диапазона.


pow()

#include <cmath.h>
float pow(float base, float exp);
float pow(float base, int exp);
double pow(double base, double exp);
double pow(double base, int exp);
long double pow(long double base, long double exp);
long double pow(long double base, int exp);

Описание

Возвращает значение аргумента которое возведено в заданную степень

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


sqrt()

#include <cmath.h>
float sqrt(float num);
double sqrt(double num);
long double sqrt(long double num);

Описание

Возвращает значение квадратного корня

Функция sqrt() возвращает значение квадратного корня от аргумента num. Если значение аргумента num отрицательно, возникает ошибка нарушения границ домена.


ceil()

#include <cmath.h>
float ceil(float num);
double ceil(double num);
long double ceil(long double num);

Описание

Возвращает наименьшее целое которое больше или равно заданного значения

Функция ceil() возвращает наименьшее целое(представленное в виде значения с плавающей точкой), которое больше значения аргумента num или равно ему. Например, при num, равном 1,02, функция ceil() вернет значение 2,0, а при num, равном -1,02, - значение -1.


fabs()

#include <cmath.h>
float fabs(float num);
double fabs(double num);
long double fabs(long double num);

Описание

Возвращает абсолютное значение

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


floor()

#include <cmath.h>
float floor(float num)
double floor(double num);
long double floor(long double num);

Описание

Возвращает наибольшее целое которое меньше или равно значения заданного аргумента

Функция floor() возвращает наибольшее целое(представленное в виде значения с плавающей точкой), которое меньше значения аргумента num или равно ему. Например, при num, равном 1,02, функция floor() вернет значение 1,0, а при num, равном -1,02, - значение -2,0.


fmod()

#include <cmath.h>
float fmod(float x, float y);
double fmod(double x, double y);
long double fmod(long double x, long double y);

Описание

Остаток от деления значений аргументов х/у

Функция fmod() возвращает остаток от деления значений аргументов х/у.


modf()

#include <cmath.h>
float modf(float num, float *i);
double modf(double num, double *i);
long double modf(long double num, long double *i);

Описание

Разбивает аргумент на целую и дробную части

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


Функции смешаного типа

Стандартная библиотека функций включает ряд полезных функций. Они осуществляют различные преобразования, обрабатывают аргументы переменной длины, выполняют сортировку и поиск, а также генерируют случайные числа. Для использования многих из описанных здесь функций в языке С необходимо включить заголовок <stdlib.h>, а в языке C++ - его эквивалент <cstdlib>. В этой главе для простоты изложения употребляются имена С-заголовков, но ссылки на заголовок <stdlib.h> в соответствующей среде нужно заменить ссылками на заголовок <cstdlib>.

В заголовке <cstdlib> объявлены два типа, div_t и ldiv_t, которые используются в качестве типа значений, возвращаемых функциями div() и ldiv() соответственно, В версии С99 объявляются тип lldiv_t и функция lldiv(). Кроме того, объявляются типы size_t и wchar_t, а также следующие макросы.

Макрос | Значение
MB_CUR_MAX | Максимальная длина(в байтах) многобайтового символа
NULL | Нулевой указатель
RAND_MAX | Максимальное значение, которое может возвратить функция rand()
EXIT_FAILURE | Значение, возвращаемое вызывающему процессу при неудачном завершении программы
EXIT_SUCCESS | Значение, возвращаемое вызывающему процессу при успешном завершении программы

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

Смотрите также

abort - Вызывает немедленное аварийное завершение программы
abs - Возвращает абсолютное значение
assert - Записывает информацию об ошибке в поток stderr
atexit - При нормальном завершении программы приводит к вызову функции, адресуемой заданным параметром
atof - Преобразует строку в значение типа double
atoi - Преобразует строку в значение типа int
atol - Преобразует строку в значение типа long int
atoll - Преобразует строку в значение типа long long int
bsearch - Выполняет двоичный поиск в отсортированном массиве
div - Возвращает частное и остаток от деления
exit - Вызывает немедленное нормальное завершение программы
getenv - Возвращает указатель на данные о среде
labs - Возвращает абсолютное значение
ldiv - Возвращает частное и остаток полученные в результате деления
llabs - Возвращает абсолютное значение
lldiv - Возвращает частное и остаток, полученные в результате деления
longjmp - Возобновляет выполнение программы с места последнего обращения к функции setjmp()
mblen - Возвращает длину(в байтах) многобайтового символа
mbstowcs - Преобразует многобайтовую строку в строку, состоящую из двубайтовых символов
mbtowc - Преобразует многобайтовый символ, который содержится в массиве, в его двубайтовый эквивалент
qsort - Сортирует массив с помощью алгоритма быстрой сортировки Quicksort
rand - Генерирует последовательность псевдослучайных чисел
setjmp - Сохраняет содержимое системного стека в буфере для использования в будущем с помощью функции longjmp()
signal - Регистрирует функцию в качестве обработчика сигнала
srand - Устанавливает стартовую точку для последовательности, генерируемой функцией rand()
strtod - Преобразует строковое представление числа в значение типа double
strtof - Аналогична функции strtod() за исключением того, что возвращает значение типа float
strtol - Преобразует строковое представление числа в значение типа long int
strtold - Аналогична функции strtod() за исключением того, что возвращает значение типа long double
strtoll - Аналогична функции strtol() за исключением того, что возвращает значение типа long long int
strtoul - Преобразует строковое представление числа в значение типа unsigned long
strtoull - Аналогична функции strtoul() за исключением того, что возвращает значение типа unsigned long long int
system - Передает строку в качестве команды для командного процессора операционной системы
va_arg - Макрос берёт аргумент из списка параметров
va_copy -
va_end - Макрос закрывает указатель списка параметров
va_start - Макрос инициализирует указатель списка параметров
wcstombs - Преобразует массив двубайтовых символов в его многобайтовый эквивалент и помещает результат в массив
wctomb - Преобразует двубайтовый символ в его многобайтовый эквивалент и помещает результат в объект
_Exit - Аналогично действию функции exit() за исключением некоторых моментов


atof()

#include <stdlib.h>
double atof(const char *str);

Описание

Преобразует строку в значение типа double

Функция atof() преобразует строку, адресуемую параметром str, в значение типа double. Эта строка должна содержать допустимое число с плавающей точкой. В противном случае возвращаемое значение не определено.

Число может оканчиваться любым символом, который не может быть частью допустимого числа с плавающей точкой. Имеются в виду пробельные символы, знаки препинания(но не точки) и символы, отличные от буквы "Е" или "е". Это значит, что, если функция atof() вызывается с аргументом "100.00HELLO", будет возвращено значение 100,00.


atoi()

#include <stdlib.h>
int atoi(const char *str);

Описание

Преобразует строку в значение типа int

Функция atoi() преобразует строку, адресуемую параметром str, в значение типа int. Эта строка должна содержать допустимое целочисленное число, В противном случае возвращаемое значение не определен(),

Число может оканчиваться любым символом, который не может быть частью целого числа. Имеются в виду пробельные символы, знаки препинания(но не точки) и буквы. Это значит, что, если функция atoi() вызывается с аргументом "123.23", будет возвращено целое значение 123, а порция " . 23 " будет проигнорирована.


atol()

#include <stdlib.h>
long int atol(const char *str);

Описание

Преобразует строку в значение типа long int

Функция atol() преобразует строку, адресуемую параметром str, в значение типа long int. Эта строка должна содержать допустимое целое число, В противном случае возвращаемое значение не определен(),

Число может оканчиваться любым символом, который не может быть частью целого числа. Имеются в виду пробельные символы, знаки препинания(но не точки) и буквы. Это значит, чт(), если функция atoi() вызывается с аргументом "123 . 23", будет возвращено длинное целое значение 123L, а порция ".23" будет проигнорирована.


atoll()

#include <stdlib.h>
long long int atoll(const char *str);

Описание

Преобразует строку в значение типа long long int

Функция atoll() добавлена в версии С99.

Функция atoll() преобразует строку, адресуемую параметром str, в значение типа long long int. В остальном она аналогична функции atoi().


strtod()

#include <stdlib.h>
double strtod(const char * start, char **end);

Описание

Преобразует строковое представление числа в значение типа double

Функция strtod() преобразует строковое представление числа, которое содержится в строке, адресуемой параметром start, в значение типа double и возвращает полученный результат.

В версии С99 к параметрам start и end применен квали-фикатор restrict.

Функция strtod() работает следующим образом. Сначала в строке, адресуемой параметром start, удаляется любой пробельный символ. Затем читается каждый символ, составляющий число. Любой символ, который не может быть частью числа с плавающей точкой, приведет к остановке процесса преобразования. К ним относятся пробельные символы, знаки препинания (но не точки) и символы, отличные от букв "Е" и "е". Наконец, параметр end устанавливается так, чтобы указывать на "непреобразованный" остаток исходной строки, если таковой существует. Это означает, что, если функция strtod() вызывается с аргументом "100.00 Pliers", то она возвратит значение 100.00, а параметр end будет указывать на пробел, предшествующий слову "Pliers".

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


strtof()

#include <stdlib.h>
float strtof(const char * restrict start, char restrict ** restrict end);

Описание

Аналогична функции strtod() за исключением того, что возвращает значение типа float

Функция strtof() добавлена в версии С99.

Функция strtof() аналогична функции strtod() за исключением того, что она возвращает значение типа float. При возникновении переполнения возвращается либо значение HUGE_VAL, либо значение - HUGE_VAL, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на число, никакого преобразования не выполняется и функция возвращает нуль.


strtol()

#include <stdlib.h>
long int strtol(const char *start, char **end, int radix);

Описание

Преобразует строковое представление числа в значение типа long int

Функция strtol() преобразует строковое представление числа, которое содержится в строке, адресуемой параметром start, в значение типа long int и возвращает полученный результат. Основание системы счисления, в которой представлено преобразуемое число, определяется параметром radix. Если значение radix равно нулю, то основание определяется(по первым символам строки) согласно правилам, которые диктуют использование определенных спецификаций. Если значение radix не равно нулю, то оно должно находиться в диапазоне 2-36.

В версии С99 к параметрам start и end применен квалификатор restrict.

Функция strtol() работает следующим образом. Сначала в строке, адресуемой параметром start, удаляется любой пробельный символ. Затем читается каждый символ, составляющий число, Любой символ, который не может быть частью длинного целого числа, приведет к остановке процесса преобразования. К ним относятся пробельные символы, знаки препинания и символы. Наконец, параметр end устанавливается так, чтобы указывать на "непреобразованный" остаток исходной строки, если таковой существует. Это означает, что если функция strtol() вызывается с аргументом "100 Pliers", то она возвратит значение 100L, а параметр end будет указывать на пробел, предшествующий слову "Pliers".

Если результат не может быть представлен как значение типа long int, функция strtol() возвращает либо значение LONG_MAX, либо значение LONG_MIN, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на число, никакого преобразования не выполняется и функция возвращает нуль.


strtold()

#include <stdlib.h>
long double strtold(const char * restrict start, char ** restrict end);

Описание

Аналогична функции strtod() за исключением того, что возвращает значение типа long double

Функция strtold() добавлена в версии С99.

Функция strtold() аналогична функции strtod() за исключением того, что она возвращает значение типа long double. При возникновении переполнения возвращается либо значение HUGE_VALL, либо значение - HUGE_VALL, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на числ(), никакого преобразования не выполняется и функция возвращает нуль.


strtoll()

#include <stdlib.h>
long long int strtoll(const char * restrict start, char ** restrict end, int radix);

Описание

Аналогична функции strtol() за исключением того, что возвращает значение типа long long int

Функция strtoll() добавлена в версии С99.

Функция strtoll() аналогична функции strtol() за исключением того, что она возвращает значение типа long long int. Если результат не может быть представлен как значение типа long long int, возвращается либо значение LLONG_MAX, либо значение LLONG_MIN, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на число, никакого преобразования не выполняется и функция возвращает нуль.


strtoul()

#include <stdlib.h>
unsigned long int strtoul(const char *start, char **end, int radix);

Описание

Преобразует строковое представление числа в значение типа unsigned long

Функция strtoul() преобразует строковое представление числа, которое содержится в строке, адресуемой параметром start, в значение типа unsigned long и возвращает полученный результат. Основание системы счисления, в которой представлено преобразуемое число, определяется параметром radix. Если значение radix равно нулю, то основание определяется(по первым символам строки) согласно правилам, которые диктуют использование определенных спецификаций. Если значение radix задается и не равно нулю, то оно должно находиться в диапазоне 2-36.

В версии С99 к параметрам start и end применен квали-фикатор restrict.

Функция strtoul() работает следующим образом. Сначала в строке, адресуемой параметром start, удаляется любой пробельный символ. Затем читается каждый символ, составляющий число, Любой символ, который не может быть частью длинного целого числа без знака, приведет к остановке процесса преобразования. Имеются в виду пробельные символы, знаки препинания и символы. Наконец, параметр end устанавливается так, чтобы указывать на "непреобразованный" остаток исходной строки, если таковой существует. Это означает, что если функция strtoul() вызывается с аргументом "100 Pliers", то она возвратит значение 100L, а параметр end будет указывать на пробел, предшествующий слову " Pliers".

Если результат не может быть представлен как длинное целое значение без знака, функция strtoul() возвращает значение ULONG_MAX, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на число, никакого преобразования не выполняется и функция возвращает нуль.


strtoull()

#include <stdlib.h>
unsigned long long int strtoull(const char *start, char **end, int radix);

Описание

Аналогична функции strtoul() за исключением того, что возвращает значение типа unsigned long long int

Функция strtoull() добавлена в версии С99.

Функция strtoull() аналогична функции strtoul() за исключением того, что она возвращает значение типа unsigned long long int. Если результат не может быть представлен как значение типа unsigned long long int, возвращается значение ULLONG_MAX, а глобальная переменная errno устанавливается равной значению ERANGE, свидетельствующему об ошибке пределов диапазона. Если параметр start не указывает на числ(), никакого преобразования не выполняется и функция возвращает нуль.


va_arg()

#include <stdarg.h>
type va_arg(va_list argptr, type);

Описание

Макрос берёт аргумент из списка параметров

Макрос берёт аргумент из списка параметров

Смотрите также

Работа с неопределённым числом параметров


va_copy()

#include <stdarg.h>
void va_copy(va_list target, va_list source);

Описание

Макрос копирует список аргументов в объект

Макрос va_copy() добавлен в версии С99.

Смотрите также

Работа с неопределённым числом параметров


va_end()

#include <stdarg.h>
void va_end(va_list argptr);

Описание

Макрос закрывает указатель списка параметров

Макрос закрывает указатель списка параметров

Смотрите также

Работа с неопределённым числом параметров


va_start()

#include <stdarg.h>
void va_start(va_list argptr, last_parm);

Описание

Макрос инициализирует указатель списка параметров

Макрос инициализирует указатель списка параметров

Смотрите также

Работа с неопределённым числом параметров


abs()

#include <stdlib.h>
int abs(int num);

Описание

Возвращает абсолютное значение

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


div()

#include <stdlib.h>
div_t div(int numerator, int denominator);

Описание

Возвращает частное и остаток от деления

Функция div() возвращает частное и остаток, полученные в результате выполнения операции numerator/denominator, в структуре типа div_t.

Структура типа div_t имеет следующие два поля.

Копировать
int quot; /* частное */
int rem; /* остаток */


labs()

#include <stdlib.h>
long labs(long num);

Описание

Возвращает абсолютное значение

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


ldiv()

#include <stdlib.h>
ldiv_t ldiv(long int numerator, long int denominator);

Описание

Возвращает частное и остаток полученные в результате деления

Функция ldiv() возвращает частное и остаток, полученные в результате выполнения операции numerator/denominator, в структуре типа ldiv_t.

Структура типа ldiv_t имеет следующие два поля.

Копировать
long int quot; /* частное */
long int rem; /* остаток */


llabs()

#include <stdlib.h>
long long int llabs(long long int num);

Описание

Возвращает абсолютное значение

Функция llabs() добавлена в версии С99.

Функция llabs() возвращает абсолютное значение аргумента num. Она аналогична функции labs(), но работает со значениями типа long long int.


lldiv()

#include <stdlib.h>
lldiv_t lldiv(long long int numerator,
        long long int denominator);

Описание

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

Функция lldiv() добавлена в версии С99.

Функция lldiv() возвращает частное и остаток, полученные в результате выполнения операции numerator/denominator, в структуре типа lldiv_t. Функция lldivf) аналогична функции Idiv(), но работает со значениями типа long long int.

Структура типа lldiv_t имеет следующие два поля.

Копировать
long long int quot; /* частное */
long long int rem; /* остаток */


rand()

#include <stdlib.h>
int rand(void);

Описание

Генерирует последовательность псевдослучайных чисел

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


srand()

#include <stdlib.h>
void srand(unsigned seed);

Описание

Устанавливает стартовую точку для последовательности, генерируемой функцией rand()

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

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


mblen()

#include <stdlib.h>
int mblen(const char *str, size_t size);

Описание

Возвращает длину(в байтах) многобайтового символа

Функция mblen() возвращает длину(в байтах) многобайтового символа, адресуемого параметром str. Учету подлежат только первые size символов, количество которых не должно превышать значение MB_CUR_MAX. При ошибке функция возвращает значение -1. Функция mblen() определяет достоверность многобайтового символа в соответствии с категорией LC_CTYPE, устанавливающей текущие геополитические характеристики(имеется в виду страна и государственный язык).

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


mbstowcs()

#include <stdlib.h>
size_t mbstowcs(wchar_t *out, const char *in, size_t size);

Описание

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

Функция mbstowcs() преобразует многобайтовую строку, адресуемую параметром in, в строку, состоящую из двубайтовых символов, и помещает результат в массив, адресуемый параметром out. В массиве out сохраняется только size 6айт.

В версии С99 к параметрам out и in применен квалифи-катор restrict.

Функция mbstowcs() возвращает количество преобразованных многобайтовых символов. При возникновении ошибки функция возвращает значение -1.


mbtowc()

#include <stdlib.h>
int mbtowc(wchar_t *out, const char *in, size_t size);

Описание

Преобразует многобайтовый символ, который содержится в массиве, в его двубайтовый эквивалент

Функция mbtowc() преобразует многобайтовый символ, который содержится в массиве, адресуемом параметром in, в его двубайтовый эквивалент и помещает результат в объект, адресуемый параметром out. Преобразованию подлежат только первые size символов.

В версии С99 к параметрам out и in применен квалифи-катор restrict.

Функция возвращает количество байтов, помещенных в объект out. При возникновении ошибки возвращается значение -1. Если указатель in нулевой, функция mbtowc() возвращает ненулевое значение в случае, когда многобайтовые символы имеют кодировку, зависящую от территориально-языковых особенностей. В противном случае возвращается нуль.


wcstombs()

#include <stdlib.h>
int wcstombs(char *out, const wchar_t *in, size_t size);

Описание

Преобразует массив двубайтовых символов в его многобайтовый эквивалент и помещает результат в массив

Функция wcstombs() преобразует массив двубайтовых символов, адресуемый параметром in, в его многобайтовый эквивалент и помещает результат в массив, адресуемый параметром out. Преобразованию подлежат только первые size символов. Процесс преобразования прекращается раньше в случае обнаружения завершающего нулевого символа.

В версии С99 к параметрам out и in применен квалифи-катор restrict.

При успешном выполнении функция wcstombs() возвращает количество байтов, помещенных в массив out. При возникновении ошибки возвращается значение - 1.


wctomb()

#include <stdlib.h>
int wctomb(char *out, wchar_t in);

Описание

Преобразует двубайтовый символ в его многобайтовый эквивалент и помещает результат в объект

Функция wctomb() преобразует двубайтовый символ, содержащийся в параметре in, в его многобайтовый эквивалент и помещает результат в объект, адресуемый параметром out. Массив, адресуемый параметром out, должен иметь длину не меньше MB_CUR_MAX символов.

При успешном выполнении функция wctomb() возвращает количество байтов, содержащихся в многобайтовом символе. При возникновении ошибки возвращается значение -1.

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


abort()

#include <stdlib.h>
void abort(void);

Описание

Вызывает немедленное аварийное завершение программы

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


assert()

#include <assert.h>
void assert(int exp);

Описание

Записывает информацию об ошибке в поток stderr

Макрос assert(), определенный в заголовках <assert.h> и <cassert>, записывает информацию об ошибке в поток stderr, а затем прекращает выполнение программы, если выражение ехр равно нулю. В противном случае макрос assert() никаких действий не выполняет. Несмотря на то что точный результат выполнения этого макроса определяется конкретной реализацией, многие компиляторы используют сообщение, подобное следующему.

Копировать
Assertion failed: <выражение>, file <имя_файла>, line <номер_строки>

В версии С99 отображаемое сообщение также включает имя функции, содержащей макрос assert().

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

После отладки программы нет необходимости в удалении операторов assert() из исходного кода, поскольку, если определен макрос NDEBUG(как и должно быть в идеале), макрос assert() игнорируется.


atexit()

#include <stdlib.h>
int atexit(void (*func)(void));

Описание

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

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

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


exit()

#include <stdlib.h>
void exit(int exit_code);

Описание

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

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

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


getenv()

#include <stdlib.h>
char *getenv(const char *name);

Описание

Возвращает указатель на данные о среде

Функция getenv() возвращает указатель на данные о среде, которая соответствует строке, адресуемой параметром пате в таблице характеристик среды, определенной конкретной реализацией. Ваша программа не должна изменять содержимое этой таблицы.

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

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

Копировать
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    char *s;
    s = getenv("COMSPEC"); /* получить параметр среды */
    printf("Командный процессор находится: %s\n",s);
    return 0;
}


longjmp()

#include <setjmp.h>
void longjmp(jmp_buf envbuf, int status);

Описание

Возобновляет выполнение программы с места последнего обращения к функции setjmp()

Функция longjmp() возобновляет выполнение программы с места последнего обращения к функции setjmp(). Таким образом, функции longjmp() и setjmp() предоставляют средство передачи управления между функциями. Обратите внимание на необходимость включения заголовка <setjmp.h>(в языке C++ используется заголовок <csetjmp>).

Функция longjmp() восстанавливает состояние стека, сохраненное в буфере envbuf с помощью функции setjmp(). В результате выполнение программы возобновляется с оператора, следующего за вызовом функции setjmp(). Иначе говоря, компьютер вводится в "заблуждение": он считает, будто управление программой не выходило за пределы функции, которая вызвала функцию setjmp().(Выражаясь образн(), функция longjmp() "искривляет" время и пространство(памяти), чтобы вернуться в предыдущую точку программы, не выполняя нормальный процесс возврата из функции.)

Буфер evnbuf имеет тип jmp_buf, который определен в заголовке <setjmp.h>. Этот буфер должен быть установлен посредством обращения к функции setjmp() до вызова функции longjmp().

Значение параметра status становится возвращаемым значением функции setjmp(), и его можно опросить, чтобы определить "происхождение" длинного перехода. Единствен ным недопустимым значением является нуль. Функция setjmp() возвращает нуль в том случае, когда она вызывается непосредственно программой, а не косвенно, путем выполнения функции longjmp().

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


raise()

#include <signal.h>
int raise(int signal);

Описание

Посылает выполняемой программе сигнал

Функция raise() посылает выполняемой программе сигнал, заданный параметром signal. При успешном выполнении возвращается нуль, в противном случае - ненулевое значение. Заметьте: функция использует заголовок <signal.h>(в среде языка C++ - <csignal>).

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

Макрос | Значение
SIGABRT | Ошибка завершения
SIGFPE | Ошибка работы с вещественными числами
SIGILL | Ошибочная инструкция
SIGINT | Пользователь нажал комбинацию клавиш <Ctrl+C>
SIGSEGV | Несанкционированный доступ к памяти
SIGTERM | Прекратить выполнение программы


setjmp()

#include <setjmp.h>
int setjmp(jmp_buf envbuf); .

Описание

Сохраняет содержимое системного стека в буфере для использования в будущем с помощью функции longjmp()

Макрос setjmp() сохраняет содержимое системного стека в буфере envbuf для использования в будущем с помощью функции longjmp(). Функция использует заголовок <setjmp.h>(в среде языка C++ - <csetjmp>).

Макрос-функция setjmp() после сохранения среды стека возвращает нуль. Если макрос setjmpO выполняется в результате вызова функции longjmp(), он возвращает значение аргумента, переданного ему функцией longjmp(). А если значение аргумента функции longjmpO равно нулю, макрос setjmp() возвращает значение 1. Информация об ошибках не возвращается.

Макрос setjmp() сохраняет среду стека, которую можно впоследствии восстановить с помощью функции long jmp(). При совместном использовании функции set jmp() и longjmp() обеспечивают способ выполнения "нелокального оператора goto". Они обычно используются для передачи управления подпрограммам обработки ошибок или восстановления в ранее вызванных процедурах без использования нормального процесса вызова и возврата из процедур.


signal()

#include <signal.h>
void (*signal(int signal, void (*func)(int))) (int);

Описание

Регистрирует функцию в качестве обработчика сигнала

Функция signal() регистрирует функцию, адресуемую параметром func, в качестве обработчика сигнала, который задан параметром signal(т.е. функция, адресуемая параметром func, будет вызвана в случае, когда ваша программа получит сигнал signal). Функция использует заголовок <signal.h>(в среде языка C++ - <csignal>).

Значением параметра func может быть адрес функции обработчика сигнала или один из следующих макросов, определенных в заголовке <signal.h>.

Макрос | Значение
SIG_DFL | Использовать стандартную обработку сигнала
SIG_IGN | Игнорировать сигнал

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

При успешном выполнении функция signal() возвращает адрес заранее определенной функции для заданного сигнала. При ошибке возвращается значение SIG_ERR(определенное в заголовке <signal.h>).


system()

#include <stdlib.h>
int system(const char *str);

Описание

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

Функция system() передает строку, адресуемую параметром str, в качестве команды для командного процессора операционной системы.

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


_Exit()

#include <stdlib.h>
void _Exit(int exit_code);

Описание

Аналогично действию функции exit() за исключением некоторых моментов

Функция _Exit() добавлена в версии С99.

Действие функции _Exit() аналогично действию функции exit() за исключением следующих моментов.
· Не вызываются функции завершения, зарегистрированные функцией atexit().
· Не вызываются обработчики сигналов, зарегистрированные функцией signal().
· Буфера открытых файлов необязательно сбрасываются, а сами файлы необязательно закрываются.


bsearch()

#include <stdlib.h>
void *bsearch(const void *key, const void *buf,
        size_t num, size_t size,
        int (*compare)(const void *, const void *));

Описание

Выполняет двоичный поиск в отсортированном массиве

Функция bsearch() выполняет двоичный поиск в отсортированном массиве, адресуемом параметром buf, и возвращает указатель на первый член, который совпадает с ключом-значением, адресуемым параметром key. Количество элементов в массиве задается параметром num, а размер (в байтах) каждого элемента - параметром size.

Для сравнения каждого элемента массива с ключом-значением используется функция, адресуемая параметром compare. Форма записи функции compare должна иметь следующий вид.

Копировать
int func_name(const void *argl, const void *arg2);

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

Сравнение | Возвращаемое значение
argl меньше arg2 | Меньше нуля
argl равен arg2 | Нуль
argl больше arg2 | Больше нуля

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

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


qsort()

#include <stdlib.h>
void qsort(void *buf, size_t num, size_t size,
        int (*compare) (const void *, const void *));

Описание

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

Функция qsort() сортирует массив, адресуемый параметром buf, с помощью алгоритма быстрой сортировки Quicksort (его разработал Н.Э.P. Xoap(C.A.R. Hoarc)). Quicksort считается лучшим алгоритмом сортировки общего назначения. Количество элементов в массиве задается параметром num, а размер(в байтах) каждого элемента - параметром size.

Для сравнения двух элементов массива используется функция, адресуемая параметром compare. Форма записи функции compare должна иметь следующий вид.

Копировать
int func_name(const void *argl, const void *arg2);

Она должна возвращать значения, описанные ниже.

Сравнение | Возвращаемое значение
arg1 меньше arg2 | Меньше нуля
arg1 равен arg2 | Нуль
argl больше arg2 | Больше нуля

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

Совет программисту

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

Сравнение | Возвращаемое значение
argl меньше arg2 | Больше нуля
argl равен arg2 | Нуль
argl больше arg2 | Меньше нуля

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


Функции обработки двубайтовых символов

В 1995 году к стандарту С89 был добавлен ряд функций, предназначенных для обработки двубайтовых символов (wide-character functions), которые позже вошли в стандарт С99 и язык C++. Эти функции работают с символами типа wchar_t, которые занимают 16 бит. В основном, они аналогичны своим char-эквивалентам. Например, функция iswspace() является двубайтовой версией функции isspace(). В целом, функции обработки двубайтовых символов используют те же имена, что и их char-эквиваленты, но добавляется буква "w" (wide-character, т.е. "широкоформатный" символ).

В языке С функции широкоформатных символов используют заголовки <wchar.h> и <wctype.h>, а в языке C++ - заголовки <cwchar> и <cwctype>. В этой главе будут использованы имена С-заголовков, но ссылки на <wchar.h> и <wctype. h> применимы также к заголовкам <cwchar> и <cwctype> соответственно.

Заголовок <wctype.h> определяет типы wint_t, wctrans_t и wctype_t. Многие функции двубайтовых символов принимают в качестве параметра символ широкого формата. Этот параметр имеет тип wint_t, который позволяет содержать символ такого увеличенного формата. Использование типа wint_t в функциях двубайтовых символов, аналогично использованию типа int в char-ориентированных функциях. Типы wctrans_t и wctype_t - это типы объектов, используемые для преобразования символов и определения категории символа соответственно. Кроме того, в заголовке <wctype.h> определен двубайтовый признак конца файла (EOF) под именем WEOF.

Помимо win_t, в заголовке <wchar.h> определены такие типы, как wchar_t, size_t и mbstate_t. Тип wchar_t создает объект двубайтового символа, a size_t - это тип значения, возвращаемого оператором sizeof. Тип mbstate_t описывает объект, который хранит состояние преобразования многобайтового объекта в символ широкого формата. Заголовок <wchar.h> также определяет макросы NULL, WEOF, WCHAR_MAX и WCHAR_MIN. Последние два макроса определяют максимальное и минимальное значения, которые могут храниться в объекте типа wchar_t.

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

Смотрите также

Функции классификации двубайтовых символов
Функции ввода вывода двубайтовых символов
Строковые функции двубайтовых символов
Преобразование строк двубайтовых символов
Работа с массивами двубайтовых символов
Преобразование объектов в двубайтовые символы


Функции классификации двубайтовых символов

Заголовок <wctype.h> содержит прототипы функций двубайтовых символов, которые поддерживают классификацию символов. Эти функции устанавливают категорию символов или преобразуют регистр буквенного символа, устанавливая строчное или прописное написание. Эти функции (вместе с их char-эквивалентами, описанными в главе 7) перечислены в следующей таблице.

Функция | char-эквивалент
int iswalnum(wint_t ch) | isalnum()
int iswalpha(wint_t ch) | isalpha()
int iswblank(wint_t ch) | isblank() (Добавлена в С99.)
int iswcntrl(wint_t ch) | iscntri()
int iswdigit(wint_t ch) | isdigit()
int iswgraph(wint_t ch) | isgraph()
int iswlower(wint_t ch) | islower()
int iswprint(wint_t ch) | isprint()
int iswpunct(wint_t ch) | ispunct()
int iswspace(wint_t ch) | isspace()
int iswupper(wint_t ch) | isupper()
int iswxdigit(wint_t ch) | isxdigit()
wint_t towlower(wint_t ch) | tolower()
wint_t towupper(wint_t ch) | toupper()

Помимо функций, приведенных выше, в заголовке <wctype.h> определена следующая функция, которая предоставляет открытые средства классификации символов.

Копировать
wctype_t wctype(const char *attr);
int iswctype(wint_t ch, wctype_t attr_ob);

Функция wctype() возвращает значение, которое можно передать функции iswctype() в качестве параметра attr_ob. Строка, адресуемая параметром attr, задает свойство, которое должен иметь символ. Это значение можно затем использовать для определения, является ли ch символом, который обладает этим свойством. Если является, то функция iswctype () возвращает ненулевое значение. В противном случае возвращается нуль. Для всех сред выполнения определены следующие строки свойств.

ainum | alpha | cntrl | digit
graph | lower | print | punct
space | upper | xdigit |

В версии С99 также определена строка blank.

Кроме того, в заголовке <wctype.h> определены функции wctrans() и towctrans().

Копировать
wctrans_t wctrans(const char *mapping);
wint_t towctrans(wint_t ch, wctrans_t mapping_ob);

Функция wctrans() возвращает значение, которое можно передать функции towctrans() в качестве параметра mappmg_ob. Строка, адресуемая параметром mapping, задает соответствие одного символа другому. Это значение затем может быть использовано функцией towctrans() для преобразования символа ch. Функция возвращает преобразованное значение. Во всех средах выполнения поддерживаются следующие строки преобразования.

tolower toupper


Функции ввода вывода двубайтовых символов

Некоторые функции ввода-вывода, описанные в главе 6, имеют реализации, ориентированные на работу с двубайтовыми символами. Эти функции (они перечислены в приведенной ниже таблице) используют заголовок <wchar.h>. Обратите внимание на то, что функции swprintf() и vswprintf() требуют передачи дополнительного параметра, в котором не нуждаются их char-эквиваленты.

Функция | char-эквивалент
wchar_t *fgetws(wchar_t *str, int num, FILE *stream) | fgets() В версии С99 к параметрам str и stream применен квалификатор restrict
wint_t fputwc(wchar_t ch, FILE *stream) | fputc()
int fputws(const wchar_t *str, FILE *stream) | fputs() В версии С99 к параметрам str и stream применен квалификатор restrict
int fwprintf(FILE *stream, const wchar_t *fmt, ...) | fprintf() В версии С99 к параметрам stream и fmt применен квалификатор restrict
int fwscanf(FILE *stream, const wchar_t *fmt, ...) | fscanf() В версии С99 к параметрам stream и fmt применен квалификатор restrict
wint_t getwc(FILE *stream) | getc()
wint_t getwchar(void) | getchar()
wint_t putwc(wchar_t ch, FILE *stream) | putc()
wint_t putwchar(wchar_t ch) | putchar()
int swprintf(wchar_t *str, size_t num, const wchar_t * ftmt, ...) | sprintf() Обратите внимание на то, что добавлен параметр num, который ограничивает количество символов, записываемых в массив str. В версии С99 к параметрам str и fmt применен квалификатор restrict
int swscanf(const wchar_t *str, const wchar_t *fmt, ...) | sscanf() В версии С99 к параметрам str и fmt применен квалификатор restrict
wint_t ungetwc(wint_t ch, FILE *stream) | ungetc()
int vfwprintf(FILE *stream, const wchar_t *fmt, va_list arg) | vfprintf() В версии С99 к параметру fmt применен квалификатор restrict
int vfwscanf(FILE * restrict stream, const wchar_t * restrict fmt, va_list arg) | vfscanf () (Добавлена в версии С99.)vfprintf() В версии С99 к параметру fmt применен квалификатор restrict
int vswprintf(wchar_t *str, size_t num, const wchar_t *fmt va_list arg) | vsprintf() Обратите внимание на то, что добавлен параметр num, который ограничивает количество символов, записываемых в массив str. В версии С99 к параметрам str и fmt применен квалификатор restrict
int vswscanf(const wchar_t * restrict str, const wchar_t * restrict fmt, va_list arg) | vsscanf() (Добавлена в версии С99.)
int vwprintf(const wchar_t *fmt, va_list arg) | vprintf() В версии С99 к параметру fmt применен квалификатор restrict
int vwscanf(const wchar_t * restrict fmt, va_list arg) | vscanf() (Добавлена в версии С99.)
int wprintft(const wchar_t *fmt,...) | printf() В версии С99 к параметру fmt применен квалификатор restrict
int wscanf(const wchar_t *fmt,...) | scanf() В версии С99 к параметру fmt применен квалификатор restrict

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

Копировать
int fwide(FILE *stream, int how);

Если значение параметра how положительно, функция fwide() делает поток stream потоком широкоформатных символов. Если же значение параметра how отрицательно, то функция fwide() превращает поток stream в char-поток. А если значение how равно нулю, на поток stream никакого воздействия не оказывается. Если этот поток уже был ориентирован либо на двубайтовые, либо на обычные символы, он изменяться не будет. Функция возвращает положительное значение, если поток использует символы широкого формата, отрицательное, если он использует символы типа char, и нуль, если поток еще не ориентирован. Ориентация потока также определяется его первым использованием.


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

Существуют также двубайтовые версии функций обработки строк, описанных в главе 7. Эти функции (перечисленные в следующей таблице) используют заголовок <wchar.h>. Заметьте, что функция wcstok() требует передачи дополнительного параметра, который не используется ее char-эквивалентом.

Функция | char-эквивалент
wchar_t *wcscat(wchar_t *strl, constwchar_t *str2) | strcat () В версии С99 к пара метрам strl и str2 применен квалификатор restrict
wchar_t *wcschr(const wchar_t *str, wchar_t ch) | strchr()
int wcscmp(const wchar_t *strl, const wchar_t *str2) | strcmp()
int wcscoll(const wchar_t *strl, const wchar_t *str2) | strcoll()
size_t wcscspn(const wchar_t *strl, const wchar_t *str2) | strcspn()
wchar_t *wcscpy(wchar_t *str1, const wchar_t *str2) | strcpy() В версии С99 к пара метрам str1 и str2 применен квалифи катор restrict
size_t wcslen(const wchar_t *str) | strlen()
wchar_t *wcsncpy(wchar_t *strl, const wchar_t *str2, size_t num) | strncpy() В версии С99 к параметрам strl и str2 применен квалификатор restrict
wchar_t *wcsncat(wchar_t *strl, const wchar_t *str2, size_t num) | strncat() В версии С99 к параметрам strl и str2 применен квалификатор restrict
int wcsncmp(constwchar_t *strl, constwchar_t *str2, size_t num) | strncmp()
wchar_t *wcspbrk(const wchar_t *strl, const wchar_t *str2) | strpbrk()
wchar_t *wcsrchr(const wchar_t *str1, wchar_t ch) | strrchr()
size_t wcsspn(const wchar_t *str1, const wchar_t *str2) | strspn()
wchar_t *wcstok(wchar_t *str1, const wchar_t *str2, wchar_t ** endptr) | strtok() Здесь параметр endptr является указателем, который содержит информацию, необходимую для продолжения процесса разделения строки на лексемы. В версии С99 к параметрам str1 и str2 применен квалификатор restrict
wchar_t *wcsstr(const wchar_t *str1, const wchar_t *str2) | strstr()
size_t wcsxfrm(wchar_t *str1, const wchar_t *str2, size_t num) | strxfrm() В версии С99 к параметрам str1 и str2 применен квалификатор restrict


Преобразование строк двубайтовых символов

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

Функция | char-эквивалент
size_t wcsftime(wchar_t *str, size_t max, const wchar_t *fmt, const struct tm *ptr) | strftime() В версии С99 к параметрам strl, fmt и ptr применен квалификатор restrict
double wcstod(const wchar_t *start, wchar_t **end) | strtod() В версии С99 к параметрам start и end применен квалификатор restrict
float wcstof(const wchar_t * restrict start, wchar_t ** restrict end) | strtof() (Добавлена в версии С99.)
long double wcstold(const wchar_t * restrict start, wchar_t ** restrict end) | strtold() (Добавлена в версии С99.)
long int wcstol(const wchar_t *start, wchar_t **end, int radix) | strtol() В версии С99 к параметрам start и end применен квалификатор restrict
long long int wcstoll(const wchar_t * restrict start, wchar_t ** restrict end, int radix) | strtoll() (Добавлена в версии С99.)
unsigned long int wcstoul(const wchar_t * restrict start, wchar_t ** restrict end, int radix) | strtoul() В версии С99 к параметрам start и end применен квалификатор restrict
unsigned long long int wcstoull(const wchar_t *start, wchar_t **end, int radix) | strtoull() (Добавлена в версии С99.)


Работа с массивами двубайтовых символов

Стандартные функции посимвольной обработки массивов (например, memcpy()) также имеют двубайтовые эквиваленты. Эти функции (перечисленные в следующей таблице) используют заголовок <wchar.h>.

Функция | char-эквивалент
wchar_t *wmemchr(const wchar_t *str, wchar_t ch, size_t num) | memchr()
int wmemcmp(const wchar_t *str1, const wchar_t *str2, size_t num) | memcmp()
wchar_t *wmemcpy(wchar_t *str1, const wchar_t *str2, size_t num) | memcpy() В версии С99 к параметрам strl и str2 применен квалификатор restrict
wchar_t *wmemmove(wchar_t *str1, const wchar_t *str2, size_t num) | memmove()
wchar_t *wmemset(wchar_t *str, wchar_t ch, size_t num) | memset()


Преобразование объектов в двубайтовые символы

Стандартная библиотека поддерживает различные функции, предназначенные для преобразования многобайтовых объектов в символы широкого формата (и обратно). Эти функции (перечисленные в следующей таблице) используют заголовок <wchar.h>. Многие из них представляют собой повторно запускаемые (restartable) версии обычных многобайтовых функций. Повторно запускаемая версия использует информацию о состоянии, передаваемую ей в параметре типа mbstate_t. Если этот параметр нулевой, функция предоставит собственный объект типа mbstate_t.

Функция | Описание
win_t btowc(int ch) | Преобразует параметр ch в его двубайтовый эквивалент и воз вращает результат. При ошибке возвращает значение WEOF или, если ch не однобайтовый, многобайтовый символ
size_t mbrlen(const char *str, size_t num, mbstate_t *state) | Повторно запускаемая версия функции mblen(), в которой информация о состоянии передается параметром state. Возвращает положительное число, означающее длину следующего многобайтового символа. Нуль возвращается в случае, если следующий символ - нулевой. При ошибке возвращается отрицательное значение. В версии С99 к параметрам strnstate применен квалификатор restrict
size_t mbrtowc(wchar_t *out, const char *in, size_t num, mbstate_t *state) | Повторно запускаемая версия функции mbtowc(), в которой информация о состоянии передается параметром state. Возвращает положительное число, означающее длину следующего многобайтового символа. Нуль возвращается в случае, если следующий символ - нулевой. При ошибке возвращается значение -1 и переменной errno присваивается макрос EILSEQ. Если преобразование не завершено, возвращается число -2. В версии С99 к параметрам out, in и state применен квалификатор restrict
int mbsinit(const mbstate_t *state) | Возвращает значение true, если параметр state представляет начальное состояние процесса преобразования
size_t mbsrtowcs(wchar_t *out, const char **in, size_t num, mbstate_t *state) | Повторно запускаемая версия функции mbstowcs(), в которой информация о состоянии передается параметром state. Кроме того, функция mbsrtowcs() отличается от функции mbstowcs() тем, что параметр in является косвенным указателем на исходный массив. При ошибке переменной errno присваивается макрос EILSEQ. В версии С99 к параметрам out, in и state применен квалификатор restrict
size_t wcrtomb(char *out, wchar_t ch, mbstate_t *state) | Повторно запускаемая версия функции wctomb(), в которой информация о состоянии передается параметром state. При ошибке переменной errno присваивается макрос EILSEQ. В версии С99 к параметрам out и state применен квалификатор restrict
size_t wcsrtombs(char *out, const wchar_t **in, size_t num, mbstate_t *state) | Повторно запускаемая версия функции wcstombs (), в которой информация о состоянии передается параметром state. Кроме того, функция wcsrtombs() отличается от функции wcstombs() тем, что параметр in является косвенным указателем на исходный массив. При ошибке переменной errno присваивается макрос EILSEQ. В версии С99 к параметрам out, in и state применен квалификатор restrict
int wctob(wint_t ch) | Преобразует параметр ch в его однобайтовый эквивалент. При сбое функция возвращает значение EOF


Строки в языке C++

В языке C++ поддержка строк осуществляется двумя способами. Первый состоит в использовании символьного массива, завершающегося нулевым символом. Такой массив иногда называется С-строкой. Второй способ подразумевает работу с объектом класса типа basic_string. Существует две специализации типа basic_string: тип string, который поддерживает символьные строки, и тип wstring, который поддерживает строки, образованные двубайтовыми символами. Чаще всего используются строковые объекты типа string. Для использования строковых классов C++ необходимо включить в программу заголовок <string>.

Класс basic_string по сути является контейнером. Это значит, что итераторы и алгоритмы STL могут обеспечить работу со строками. Однако строки обладают дополнительными возможностями.

Тип basic_string использует класс char_traits, который определяет ряд атрибутов символов, составляющих строку. Важно понимать, чт(), поскольку большинство строк состоит из символов либо типа char, либо типа wchar_t, класс basic_string в состоянии обработать любой объект, который может быть использован для представления текстового символа.

Спецификация шаблона для класса basic_string имеет следующий вид.

Копировать
template <class CharType, class Attr =
    char_traits<CharType>,
    class Allocator = allocator<T>> class basic_string

Здесь CharType - тип используемого символа, Attr - класс, в котором описаны атрибуты этого символа, и класс Allocator задает распределитель. Класс basic_string имеет следующие конструкторы.

Копировать
explicit basic_string{const Allocator
        &a = Allocator());

basic_string(size_type len, CharType ch,
        const Allocator &a = Allocator());

basic_string(const CharType *str,
        const Allocator &a = Allocator());

basic_string(const CharType *str, size_type len,
        const Allocator &a = Allocator)));

basic_string(const basic_string &str, size_type indx = 0,
        size_type len=npos, const Allocator &a = Allocator());

template <class InIter> basic_string(InIter start,
        InIter end, const Allocator &a = Allocator());

Первая форма конструктора создает пустую строку. Вторая форма создает строку, которая содержит len символов со значением ch. Третья создает строку, которая содержит такие же элементы, как и строка str. Четвертая формирует строку, которая содержит подстроку str, начинающуюся с нулевого(по счету) символа, и имеет длину, равную len символов. Пятая создает строку из другого класса basic_string, используя подстроку, которая начинается с символа indx и имеет длину, равную len символов. Наконец, шестая форма создает строку, которая содержит элементы в диапазоне, заданном параметрами start и end.

Для класса basic_string определены следующие операторы сравнения:

Копировать
==, <, <=, !=, > и >=.

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

Оператор + можно использовать для конкатенации одного строкового объекта с другим или строкового объекта со строкой, созданной в С-стиле. Другими словами, поддерживаются следующие операции.

Копировать
строка + строка
строка + С-строка
С-строка + строка

Оператор + можно использовать для добавления символа в конец строки.

В классе basic_string определена константа npos, которая обычно равна -1. Она представляет размер строки максимально возможной длины.

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

size_type | Некоторый целый тип, эквивалентный типу size_t
reference | Ссылка на символ const-ссылка на символ
const_reference | Итератор const-итератор
iterator | Итератор
const_iterator | const-итератор
reverse_iterator | Реверсивный итератор
const_reverse_iterator | Реверсивный const-итератор
value_type | Тип символа, сохраненного в строке
allocator_type | Тип распределителя
pointer | Указатель на символ внутри строки
const_pointer | const-указатель на символ внутри строки
traits_type | typedef-имя для char_traits<CharType>
difference_type | Тип, который может хранить разность двух адресов

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

Функция-член | Назначение
Операторы строк
reference operator[](size_type indx) const;
const_reference operator[](size_type indx) const; 		Возвращает ссылку на символ, заданный параметром indx
string &operator=(const string &str);
string &operator=(const CharType *str);
string &operator=(CharType ch); 		Присваивает заданную строку или символ данной строке. Возвращает указатель *this
string &operator+=(const string &str);
string &operator+=(const CharType *str);
string &operator+=(CharType ch); 		Добавляет заданную строку или символ в конец данной строки. Возвращает указатель *this
Итераторы
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в строке
iterator end();
const_iterator end() const; 		Возвращает итератор, указывающий на конец строки
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор, указывающий на конец строки
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор, указывающий на начало строки
Добавление
string &append(const string &str); | Добавляет подстроку str в конец данной строки. Возвращает указатель *this
string &append(const string &str, size_type indx, size_type len); | Добавляет подстроку str в конец данной строки. Добавляемая подстрока начинается с позиции indx и имеет длину 1 ел символов. Возвращает указатель *this
string &append(const CharType *str); | Добавляет подстроку s tr в конец данной строки. Возвращает указатель *this
string &append(const CharType *str, size_type num); | Добавляет первые пит символов из строки str в конец данной строки. Возвращает указатель *this
string &append(size_type len, char CharType ch); | Добавляет len символов, заданных параметром ch, в конец данной строки. Возвращает указатель *this
template<class InIter> string &append(InIter start, InIter end); | Добавляет последовательность, заданную параметрами start и end, в конец данной строки. Возвращает указатель *this
Присваивание
string &assign(const string &str); | Присваивает подстроку str данной строке. Возвращает указатель *this
string &assign(const string &str, size_type indx, size_type len); | Присваивает подстроку str данной строке. Присваиваемая подстрока начинается с позиции indx и имеет длину len символов. Возвращает указатель *this
string &assign(const CharType *str); | Присваивает подстроку str данной строке. Возвращает указатель *this
string &assign(const CharType *str, size_type len); | Присваивает данной строке первые len символов из строки str. Возвращает указатель *this
string &assign(size_type len, CharType ch); | Присваивает данной строке len символов, заданных параметром ch. Возвращает указатель *this
template<class InIter> string &assign{InIter start, InIter end); | Присваивает данной строке последовательность, заданнуюпараметрами start и end. Возвращает указатель *this
Поиск
size_type find(const string &str, size_type indx = 0) const; | Возвращает индекс первого вхождения строки str внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find(const CharType *str, size_type indx = 0) const; | Возвращает индекс первого вхождения строки str внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс первого вхождения первых len символов строки str внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find(CharType ch, size_type indx = 0) const; | Возвращает индекс первого вхождения символа ch внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_first_of(const string &str, size_type indx = 0) const; | Возвращает индекс первого символа внутри данной строки, который совпадает с любым символом в строке str. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_first_of(const CharType *str, size_type indx = 0) const; | Возвращает индекс первого символа внутри данной строки, который совпадает с любым символом в строке str. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_first_of(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс первого символа внутри данной строки, который совпадает с любым символом в первых len символах строки str. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение проs
size_type find_first_of(CharType ch, size_type indx = 0) const; | Возвращает индекс первого вхождения символа ch внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение nроs
size_type find_first_not_of(const string &str, size_type indx = 0) const; | Возвращает индекс первого символа внутри данной строки, который не совпадает ни с каким символом в строке str. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращает значение npos
size_type find_first_not_of(const CharType *str, size_type indx = 0) const; | Возвращает индекс первого символа внутри данной строки, который не совпадает ни с каким символом в строке str. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращает значение npos
size_type find_first_not_of(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс первого символа внутри данной строки, который не совпадает ни с однимсимволом в первых len символах строки str. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращает значение npos
size_type find_first_not_of(CharType ch, size_type indx = 0) const; | Возвращает индекс первого символа внутри данной строки, который не совпадает с символом ch. Поиск начинается с индекса indx. Если несовпадения не обнаружен(), возвращает значение npos
size_type find_last_of(const string &str, size_type indx = npos) const; | Возвращает индекс последнего символа внутри данной строки, который совпадает с любым символом в строке str. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_last_of(const CharType *str, size_type indx = npos) const; | Возвращает индекс последнего символа внутри данной строки, который совпадает с любым символом в строке str. Поиск начинается с индекса indx. Если совпадения не об наружено, возвращает значение npos
size_type find_last_of(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс последнего символа внутри данной строки, который совпадает с любым символом в первых len символах строки str. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_last_of{CharType ch, size_type indx = npos) const; | Возвращает индекс последнего вхождения символа ch внутри данной строки. Поиск начинается с индекса indx. Если совпадения не обнаружено, возвращает значение npos
size_type find_last_not_of(const string &str, size_type indx = , npos) const; | Возвращает индекс последнего символа внутри данной строки, который не совпадает ни с одним символом в строке str. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращает значение npos
size_type find_last_not_of(const CharType *str, size_type indx = npos) const; | Возвращает индекс последнего символа внутри данной строки, который не совпадает ни с одним символом в строке str. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращает значение npos
size_type find_last_not_of(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс последнего символа внутри данной строки, который не совпадает ни с одним из первых len символов строки str. Поиск начинается с индекса indx. Если несовпадения не бнаружено, возвращает значение npos
size_type find_last_not_of(CharType ch, size_type indx = npos) const; | Возвращает индекс последнего символа внутри данной строки, который не совпадает с символом ch. Поиск начинается с индекса indx. Если несовпадения не обнаружено, возвращается значение npos
size_type rfind(const string &str, size_type indx = npos) const; | Возвращает индекс последнего вхождения строки str внутри данной строки. Поиск начинается с позиции, заданной индексом indx. Если совпадения не обнаружено, возвращает значение npos
size_type rfind(const CharType *str, size_type indx = npos) const; | Возвращает индекс последнего вхождения строки str внутри данной строки. Поиск начинается с позиции, заданной индексом indx. Если совпадения не обнаружено, возвращает значение npos
size_type rfind(const CharType *str, size_type indx, size_type len) const; | Возвращает индекс последнего вхождения первых len символов строки str внутри данной строки. Поиск начинается с позиции, заданной индексом indx. Если совпадения не обнаружено, возвращает значение npos
size_type rfind(CharType ch, size_type indx = npos) const; | Возвращает индекс последнего вхождения символа ch внутри данной строки. Поиск начинается с позиции, заданной индексом indx. Если совпадения не обнаружено, возвращает значение npos
Сравнение
int compare(const string &str) const; | Сравнивает строку str с данной строкой. Возвращает одно из следующих значений: меньше нуля, если *this < str; нуль, если *this == str; больше нуля, если *this > str
int compare(size_type indx, size_type len, const string &str) const; | Сравнивает строку str с подстрокой внутри данной строки. Эта подстрока начинается с позиции indx и содержит len символов. Возвращает одно из следующих значений: меньше нуля, если *this < str; нуль, если *this == str; больше нуля, если *this > str
int compare(size_type indx, size_type len, const string &str, size_type indx2, size_type len2) const; | Сравнивает подстроку в строке str с подстрокой внутри данной строки. Подстрока в данной строке начинается с позиции indx и содержит len символов. Подстрока в строке str начинается с позиции indx2 и содержит len символов. Функция возвращает одно из следующих значений: меньше нуля, если *this < str; нуль, если *this == str; больше нуля, если *this > str
int compare(const char CharType *str) const; | Сравнивает строку str с данной строкой. Функция возвращает одно из следующих значений: меньше нуля, если *this < str; нуль, если *this == str; больше нуля, если * this > str
int compare(size_type indx, size_type len, const char CharType *str, size_type len2 = npos) const; | Сравнивает подстроку в строке str с подстрокой внутри данной строки. Подстрока в данной строке начинается с позиции indx и содержит len символов. Подстрока в строке str начинается с нулевой позиции и содержит len2 символов. Функция возвращает одно из следующих значений: меньше нуля, если *this < str; нуль, если *this == str; больше нуля, если *this > str
Вставка
iterator insert(iterator i, const CharType &ch); | Вставляет символ ch непосредственно перед символом, заданным итератором i. Возвращает итератор для этого символа
string &insert(size_type indx, const string &str); | Вставляет строку str в данную строку в позиции, заданной индексом indx. Возвращает указатель *this
string &insert(size_type indx1, const string &str, size_type indx2, size_type len); | Вставляет подстроку строки str в данную строку в позиции, заданной индексом indx1. Подстрока начинается с позиции, заданной индексом indx2, и содержит len символов. Возвращает указатель *this
string &insert(size_type indx, const CharType *str); | Вставляет строку str в данную строку в позиции, заданной индексом indx. Возвращает указатель *this
string &insert(size_type indx, const CharType *str, size_type len); | Вставляет первые len символов строки str в данную строку в позиции, заданной индексом indx. Возвращает указатель *this
string &insert(size_type indx, size_type len, CharType ch); | Вставляет len символов со значением ch в данную строку в позиции, заданной индексом indx. Возвращает указатель *this
void insert(iterator i, size_type len, const CharType &ch); | Вставляет len копий символа ch непосредственно перед элементом, заданным итератором i
template <class InIter> void insert(iterator i, InIter start, InIter end); | Вставляет последовательность, заданную параметрами start и end, непосредственно перед элементом, заданным итератором i.
Замена
string &replace(size_type indx, size_type len, const string &str); | Заменяет до len символов в данной строке, начиная с позиции indx, строкой str. Возвращает указатель *this
string &replace(size_type indx1, size_type len1, const string &str, size_type indx2, size_type len2); | Заменяет до len1 символов в данной строке, начиная с позиции indxl, символами(в количестве 1en2) строки str, начиная с позиции indx2. Возвращает указатель *this
string &replace(size_type indx, size_type len, const CharType *str); | Заменяет до len символов в данной строке, начиная с позиции indx, строкой str. Возвращает указатель *this
string &replace(size_type indx1, size_type len1, const CharType *str, size_type len2); | Заменяет до len1 символов в данной строке, начиная с позиции indxl, символами(в количестве len2) строки str, начиная с позиции indx2. Возвращает указатель *this
string &replace(size_type indx, size_type len1, size_type len2, CharType ch); | Заменяет до len1 символов в данной строке, начиная с позиции indx, символами(в количестве 1еп2), заданными параметром ch. Возвращает указатель *this
string &replace(iterator start, iterator end, const string &str); | Заменяет диапазон, заданный параметрами start и end, строкой str. Возвращает указатель *this
string &replace(iterator start, iterator end, const CharType *str); | Заменяет диапазон, заданный параметрами start и end, строкой str. Возвращает указатель *this
string &replace(iterator start, iterator end, const CharType *str, size_type len); | Заменяет диапазон, заданный параметрами start и end, первыми len символами строки str. Возвращает указатель *this
string &replace(iterator start, iterator end, size_type len, CharType ch); | Заменяет диапазон, заданный параметрами start и end, символами(в количестве len), заданными параметром ch. Возвращает указатель *this
template <class InIter> string &replace(iterator startl, iterator endl, InIter start2, InIter end2); | Заменяет диапазон, заданный параметрами start1 и end1, символами из диапазона, заданного параметрами start2 и end2. Возвращает указатель *this
Удаление
iterator erase(iterator i); | Удаляет символ, адресуемый параметром i. Возвращает итератор для символа, расположенного за удаленным символом
iterator erase(iterator start, iterator end); | Удаляет символы в диапазоне, задаваемом параметрами start и end. Возвращает итератор для символа, расположенного за последним удаленным символом
string &erase(size_type indx =0, size_type len = npos); | Начиная с позиции indx, удаляет len символов из данной строки. Возвращает указатель *this
Копирование
size_type copy(CharType *str, size_type len, size_type indx = 0) const; | Начиная с позиции indx, копирует len символов из данной строки в символьный массив, адресуемый параметром str. Возвращает количество скопированных символов
Другие функции
reference at(size_type indx);
const_reference at(size_type indx) const; 		Возвращает ссылку на символ, заданный параметром indx
const CharType *c_str() const; | Возвращает указатель на версию данной строки в С-стиле(т.е. с завершающим нулевым символом)
size_type capacity() const; | Возвращает текущую емкость строки - число символов, которое она может содержать до того, как ей придется запросить дополнительную память
const CharType *data() const; | Возвращает указатель на первый символ в данной строке
bool empty(} const; | Возвращает true, если данная строка пуста, и false в противном случае
allocator_type get_allocator() const; | Возвращает распределитель строки
size_type length() const; | Возвращает количество символов в строке
size_type max_size() const; | Возвращает максимальное количество символов, которое может содержаться в строке
void reserve(size_type num = 0); | Устанавливает емкость строки равной не менее значения num
void resize(size_type num); void resize(size_type num, CharType ch); | Изменяет размер строки, делая его равным значению, заданному параметром. Чтобы строку(при необходимости) удлинить, в ее конец следует добавить элементы со значением, заданным параметром ch
size_type size() const; | Возвращает текущее количество символов в строке
string substr(size_type indx = 0, size_type Jen = npos) const; | Возвращает подстроку(внутри данной строки), состоящую из len символов, начиная с позиции indx
void swap(string &str); | Выполняет обмен символов данной строки и символов строки str

Совет программисту

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

Копировать
// Демонстрация работы со строками.
#include <iostream>
#include <string>
using namespace std;

int main()
{

    string str1 = "abcdefghijklmnopqrstuvwxyz";
    string str2;
    string str3(strl);

    str2 = str1.substr(10, 5);

    cout << "str1: " << str1 << endl;
    cout << "str2: " << str2 << endl;
    cout << "str3: " << str3 << endl;

    str1.replace(5, 10, "");
    cout << "strl.replace(5, 10, \"\"):" << str1 << endl;

    str1 = "one";
    str2 = "two";
    str3 = "three";

    cout << "str1.compare(str2): ";
    cout << str1.compare(str2) << endl;

    if (str1<str2) cout << "str1 меньше str2\n";

    string str4 = str1 + " " + str2 + " " + str3;
    cout << "str4: " << str4 << endl;

    int i = str4.find("wo");
    cout << "str4.substr(i): " << str4.substr(i);

    return 0;
}

Ниже приведен результат работы этой программы.

Копировать
Strl: abcdefghijklmnopqrstuvwxyz
str2: klmno
str3: abcdefghijklmnopqrstuvwxyz
str1.replace(5, 10, ""): abcdepqrstuvwxyz
str1.compare(str2): -1
str1 меньше str2
str4: one two three
str4.substr(i): wo three

Обратите внимание на простоту выполнения обработки строк. Например, оператор + используется для конкатенации, а оператор < - для сравнения двух строк. Чтобы выполнить эти операции со строками с завершающими нулевыми символами в С-стиле, потребуется сделать менее удобные вызовы функций strcat() и strcmp(). Поскольку в языке С++ объекты string можно свободно смешивать со строками с завершающими нулевыми символами в С-стиле, от их применения в программе нет никакого ущерба - наоборот, следует ожидать значительного выигрыша.


Исключения в языке C++

В стандартной библиотеке C++ определены два заголовка, которые имеют отношение к обработке исключительных ситуаций, или исключений: <exception> и <stdexcept>. Исключения используются для сигнализации об ошибочных условиях. Рассмотрим эти заголовки подробнее.

<exception>

Заголовок <exception> определяет классы, типы и функции, которые связаны с обработкой исключений. Вот как выглядят определения классов.

Копировать
class exception {
public:
    exception() throw();
    exception(const bad_exception &ob) throw();
    virtual -exception() throw();
    exception &operator=(const exception &ob) throw();
    virtual const char *what(() const throw();
};

class bad_exception: public exception {
public:
    bad_exception() throw();
    bad_exception(const bad_exception &ob) throw();
    virtual ~bad_exception() throw();
    bad_exception &operator=(const bad_exception &ob) throw();
    virtual const char *what(() const throw();
};

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

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

Из класса exception выведен ряд других важных классов. Класс bad_alloc используется в случае неудачного выполнения оператора new. Класс bad_typeid оказывается полезным при попытке выполнения недопустимого выражения typeid. Наконец, класс bad_cast используется при попытке выполнить неверную операцию динамического приведения типа. Эти классы содержат те же члены, что и класс exception.

Ниже приводятся типы, определенные в заголовке <exception>.

Тип | Значение
terminate_handler | typedef void(*terminate_handler)();
unexpected_handler | typedef void(*unexpected_handler)();

В следующей таблице перечислены функции, определенные в заголовке <exception>.

Функция | Назначение
terminate_handler set_terminate(terminate_handler fn) throw(); | Устанавливает функцию, заданную параметром fn, в качестве обработчика завершения работы. Возвращает указатель на прежний обработчик завершения
unexpected_handler set_unexpected(unexpected_handler fn) throw(); | Устанавливает функцию, заданную параметром fn, в качестве обработчика непредвиденного исключения. Возвращает указатель на прежний обработчик непредвиденного исключения
void terminate(); | Вызывает обработчик завершения, когда не обработано фатальное исключение. По умолчанию вызывает функцию abort()
bool uncaught_exception(); | Возвращает значение true, если исключение не перехвачено
void unexpected(); | Вызывает обработчик непредвиденного исключения, если функция генерирует неразрешенное исключение. По умолчанию вызывает функцию terminate()

<stdexcept>

Заголовок <stdexcept> определяет ряд стандартных исключений, которые могут быть сгенерированы библиотечными функциями C++ и/или системой времени выполнения. Существует два общих типа исключений, определяемых заголовком <stdexcept>: логические ошибки и ошибки времени выполнения(динамические ошибки). Логические ошибки обязаны своим существованием программистам. Динамические ошибки возникают из-за наличия ошибок в библиотечных функциях или системе времени выполнения и не подвластны контролю со стороны программиста.

Определенные в языке C++ стандартные исключения, вызываемые логическими ошибками, выведены из базового класса logic_error. Они приведены в следующей таблице.

Исключение | Причина возникновения
domain_error | Возникла ошибка домена
invalid_argument | В вызове функции использован неверный аргумент
length_error | Была предпринята попытка создания слишком большого объекта
out_of_range | Аргумент функции не попал в требуемый диапазон

Перечисленные ниже динамические исключения выведены из базового класса runtime error.

Исключение | Причина возникновения
overflow_error | Возникло арифметическое переполнение
range_error | Возникла ошибка внутреннего диапазона
underflow error | Возникла потеря значимости


Комплексные числа в языке C++

Заголовок <complex> определяет класс complex, который представляет комплексные числа. Он также определяет ряд функций и операторов, которые работают с объектами типа complex.

Спецификация шаблона для класса complex имеет следующий вид.

Копировать
template <class T> class complex

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

Копировать
class complex<float>
class complex<double>
class complex<long double>

Класс complex имеет следующие конструкторы.

Копировать
complex(const Т &real = T(), const Т = &imaginary = T());
complex(const complex &ob);
template <class T1> complex(const complex<T1> &ob);

Первая форма конструктора создает объект класса complex с вещественной составляющей(real) и мнимой частью(imaginary). По умолчанию эти значения, если они не заданы, устанавливаются равными нулю. Вторая форма создает копию комплексного числа ob. Третья создает комплексный объект из объекта ob.

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

+ | - | * | /
+= | -= | *= | /=
= | == | != |

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

Копировать
complex_ob + скаляр
скаляр + complex_ob
complex_ob + complex_ob

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

В классе complex определены две функции-члена: real() и imag().

Копировать
Т real() const;
Т imag() const;

Функция real() возвращает вещественную составляющую вызывающего объекта, а функция imag() - мнимую. Для объектов класса complex также определены следующие функции.

Функция-член | Назначение
template <class T> Т abs(const complex<T> &ob); | Возвращает абсолютное значение объекта ob
template <class T> Т arg(const complex<T> &ob); | Возвращает аргумент комплексного объекта ob
template <class T> complex<T> conj(const complex<T> &ob); | Возвращает сопряженную величину объекта ob
template <class T> complex<T> cos(const complex<T> &ob); | Возвращает значение косинуса объекта ob
template <class T> complex<T> cosh(const complex<T> &ob); | Возвращает значение гиперболического косинуса объекта ob
template <class T> complex<T> exp(const complex<T> &ob); | Возвращает значение eob
template <class T> Т imag(const complex<T> &ob); | Возвращает мнимую составляющую объекта ob
template <class T> complex<T> log(const complex<T> bob); | Возвращает значение натурального логарифма объекта ob
template <class T> complex<T> logl0(const complex<T> &ob); | Возвращает значение логарифма по основанию 10 объекта ob
template <class T> Т norm(const complex<T> &ob); | Возвращает значение модуля объекта ob
template <class T> complex<T> polar(const Т &v, const Т &theta=0); | Возвращает комплексное число, которое задано модулем v и аргументом theta
template <class T> complex<T> pow(const complex<T> &b, int e); | Возвращает значение be
template <class T> complex<T> pow(const complex<T> &b, const Т &е); | Возвращает значение be
template <class T> complex<T> pow(const complex<T> &b, const complex<T> &e); | Возвращает значение be
template <class T> complex<T> pow(const Т &b, const complex<T> &e); | Возвращает значение be
template <class T> Т real(const complex<T> &ob); | Возвращает вещественную составляющую объекта ob
template <class T> complex<T> sin(const complex<T> &ob); | Возвращает значение синуса объекта ob
template <class T> complex<T> sinh(const complex<T> &ob); | Возвращает значение гиперболического синуса объекта ob квадратного корня из объекта оЬ
template <class T> complex<T> sqrt(const complex<T> &ob); | Возвращает значение квадратного корня из объекта оЬ
template <class T> complex<T> tan(const complex<T> &ob); | Возвращает значение тангенса объекта оЬ
template <class T> complex<T> tanh(const complex<T> &ob); | Возвращает значение гиперболического тангенса объекта оЬ


Библиотечные средства, добавленные в версии С99

В стандарте С99 расширены возможности библиотеки языка С, причем это сделано двояким образом. Во-первых, добавлены новые функции в заголовки, ранее определенные в версии С89. Например, значительно расширена математическая библиотека, поддерживаемая заголовком <math.h>. Эти дополнительные функции описывались в предыдущих главах. Во-вторых, созданы новые категории функций, начиная поддержкой арифметики комплексных чисел и заканчивая макросами обобщенного типа, а также новые заголовки, предназначенные для поддержки таких функций. Эти новые библиотечные элементы и описываются в данной главе. Следует иметь в виду, что ни одно из рассматриваемых здесь средств не поддерживается языком C++.

Смотрите также

Библиотека комплексных чисел
Библиотека вычислений с плавающей точкой
Заголовок stdint.h
Функции преобразования целого формата
Математические макросы обобщенного типа
Заголовок stdbool.h


Библиотека комплексных чисел

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

Библиотека комплексных чисел версии С99 поддерживается заголовком <conplex.h>. В нем определены следующие макросы.

Макрос | Расширение
complex | _Complex
imaginary | _Imaginary
_Complex_I | (const float_Complex) i
_Imaginary_I | (const float imaginary) i
I | _Imaginary_I (или _Complex_I, если не поддерживаются мнимые типы)

Здесь i представляет мнимое значение, которое равно квадратному корню из -1. Поддержка мнимых типов необязательна.

В версии С99 вместо ключевых слов complex и imaginary определены ключевые слова _Complex и _Imaginary, поскольку во многих существующих программах С89 уже определены пользовательские типы комплексных данных с помощью имен complex и imaginary. Использование в версии С99 слов _Complex и _Imaginary позволяет избежать нарушения работоспособности созданного ранее программного кода. Однако в новые программы лучше всего включить заголовок <complex.h>, а затем использовать макросы complex и imaginary.

Ниже приведены математические функции, предназначенные для работы с комплексными числами. Обратите внимание на определение float complex-, double complex- и long double complex-версий для каждой функции. В float complex-версии используется суффикс f, а в long double complex-версии - суффикс 1. Следует также учитывать, что углы измеряются в радианах.

Функция Назначение
float cabsf(float complex arg);
double cabs(double complex arg);
long double cabsl(long double complex arg); 		Возвращает абсолютное значение параметра arg
float complex cacosf(float complex arg);
double complex cacos(double complex arg);
long double complex cacosl(long double complex arg); 		Возвращает комплексное значение арккосинуса от параметра arg
float complex cacoshf(float complex arg);
double complex cacosh(double complex arg);
long double complex cacoshl(long double complex arg); 		Возвращает комплексное значение гиперболического арккосинуса от параметра arg
float cargf(float complex arg);
double carg(double complex arg);
long double cargl(long double complex arg); 		Возвращает значение аргумента комплексного числа arg
float complex casinf(float complex arg);
double complex casin(double complex arg);
long double complex casinl(long double complex arg); 		Возвращает комплексное значение арксинуса от параметра arg
float complex casinhf(float complex arg);
double complex casinh(double complex arg);
long double complex casinhl(long double complex arg); 		Возвращает комплексное значение гиперболического арксинуса от параметра arg
float complex catanf(float complex arg);
double complex catan(double complex arg);
long double complex catanl(long double complex arg); 		Возвращает комплексное значение арктангенса от параметра arg
float complex catanhf(float complex arg);
double complex catanh(double complex arg);
long double complex catanhl(long double complex arg); 		Возвращает комплексное значение гиперболического арктангенса от параметра arg
float complex ccosf(float complex arg);
double complex ccos(double complex arg);
long double complex ccosl(long double complex arg); 		Возвращает комплексное значение косинуса от параметра arg
float complex ccoshf(float complex arg);
double complex ccosh(double complex arg);
long double complex ccoshl(long double complex arg); 		Возвращает комплексное значение гиперболического косинуса от параметра arg
float complex cexpf(float complex arg);
double complex cexp(double complex arg);
long double complex cexpl(long double complex arg); 		Возвращает комплексное значение earg, где е - основание натурального логарифма
float cimagf(float complex arg);
double cimag(double complex arg);
long double cimagl(long double complex arg); 		Возвращает мнимую часть параметра arg
float complex clogf(float complex arg);
double complex clog(double complex arg);
long double complex clogl(long double complex arg); 		Возвращает комплексное значение натурального логарифма от параметра arg
float complex conjf(float complex arg);
double complex conj(double complex arg);
long double complex conjl(long double complex arg); 		Возвращает комплексно-сопряженное значение параметра arg
float complex cpowf(float complex a, long double complex b);
double complex cpow(double complex a, double complex b);
long double complex cpowl(long double complex a, long double complex b); 		Возвращает комплексное значение ab
float complex cprojf(float complex arg);
double complex cproj(double complex arg);
long double complex cproj1(long double complex arg); 		Возвращает проекцию параметра arg на сферу Римана
float crealf(float complex arg);
double creal(double complex arg);
long double creall(long double complex arg); 		Возвращает вещественную часть параметра arg
float complex csinf(float complex arg);
double complex csin(double complex arg);
long double complex csinl(long double complex arg); 		Возвращает комплексное значение синуса от параметра arg
float complex csinhf(float complex arg);
double complex csinh(double complex arg);
long double complex csinhl(long double complex arg); 		Возвращает комплексное значение гиперболического синуса от параметра arg
float complex csqrtf(float complex arg);
double complex csqrt(double complex arg);
long double complex csqrtl(long double complex arg); 		Возвращает комплексное значение квадратного корня из параметра arg
float complex ctanf(float complex arg);
double complex ctan(double complex arg);
long double complex ctanl(long double complex arg); 		Возвращает комплексное значение тангенса от параметра arg
float complex ctanhf(float complex arg);
double complex ctanh(double complex arg);
long double complex ctanhl(long double complex arg); 		Возвращает комплексное значение гиперболического тангенса от параметра arg


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

В заголовке <fenv.h> версии С99 объявляются функции, I которые имеют доступ к среде вычислений с плавающей точкой. Эти функции описаны ниже.

Функция | Назначение
void feclearexcept(int ex); | Очищает исключения, заданные параметром ex
void fegetexceptflag(fexcept_t *fptr, int ex); | Сохраняет в переменной, адресуемой указателем fptr, состояние флагов исключений среды вычислений с плавающей точкой, заданное параметром ех
void feraiseexcept(int ex); | Возбуждает исключения, заданные параметром ех
void fesetexceptflag(fexcept_t *fptr, int ex); | Устанавливает флаги состояния исключений среды вычислений с плавающей точкой, заданные параметром ех, в соответствии с состоянием флагов в объекте, адресуемом параметром fptr
int fetestexcept(int ex); | Выполняет операцию поразрядного ИЛИ для исключений, заданных параметром ех, и текущих флагов состояния исключений среды вычислений с плавающей точкой. Возвращает результат этой операции
int fegetround(void); | Возвращает значение текущего направления округления
int fesetround(int direction); | Устанавливает значение текущего направления округления с помощью параметра direction. При успешном выполнении возвращается нуль
void fegetenv(fenv_t *envptr); | Объект, адресуемый параметром envptr, принимает конфигурацию среды вычислений с плавающей точкой
int feholdexcept(fenv_t *envptr); | Вызывает безостановочную обработку исключения, возникшего при выполнении вычислений с плавающей точкой. Сохраняет конфигурацию среды вычислений с плавающей точкой в переменной, адресуемой параметром envptr, и очищает флаги состояния. При успешном выполнении возвращает нуль
void fesetenv(fenv_t *envptr); | Устанавливает конфигурацию среды вычислений с плавающей точкой равной значению переменной, адресуемой параметром envptr, но не возбуждает исключения с плавающей точкой. Этот объект должен быть получен путем вызова либо функции fegetenv(), либо функции feholdexcept()
void feupdateenv(fenv t *envptr); | Устанавливает конфигурацию среды вычислений с плавающей точкой равной значению переменной, адресуемой параметром envptr. Сначала сохраняет любые текущие исключения и возбуждает эти исключения после установки конфигурации среды в соответствии со значением переменной, адресуемой параметром envptr. Этот объект должен быть получен путем вызова либо функции fegetenv(), либо функции feholdexcept()

Заголовок <fenv.h> также определяет типы fenv_t и fexcept_t, которые представляют конфигурацию среды вычислений с плавающей точкой и флаги состояния исключений среды вычислений с плавающей точкой соответственно, Макрос FE_DFL_ENV задает указатель на действующую по умолчанию конфигурацию среды вычислений с плавающей точкой, определяемую в начале выполнения программы.

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

FE_DIVBYZERO | FE_INEXACT | FE_INVALID
FE_OVERFLOW | FE_UNDERFLOW | FE_ALL_EXCEPT

Все комбинации этих макросов, полученные с помощью оператора ИЛИ, можно сохранять в объекте типа int.

Определены и следующие макросы направления округления.

FE_DOWNWARD FE_TONEAREST FE_TOWARDZERO FE_UPWARD

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

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


Заголовок stdint.h

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

Макросы, имеющие вид intN_t, определяют целое значение длиной N бит. Например, макрос intl6_t задает 16-разрядное целое со знаком. Макросы, имеющие вид uintN_t, определяют целое значение без знака с N бит. Например, макрос uint32_t задает 32-разрядное целое без знака. Макросы, в имени которых N равно 8, 16, 32 или 64, будут доступны во всех средах, работающих с целыми числами перечислен-
ных длин.

Макросы, имеющие вид int_leastN_t, определяют целое значение длиной не менее N бит. Макросы, имеющие вид uint_leastN_t, определяют целое значение без знака с не менее чем N бит. Макросы, в имени которых N равно 8, 16, 32 или 64, будут доступны во всех средах, работающих с целыми числами перечисленных длин. Например, макрос int_least16_t - это допустимый тип значения.

Макросы, имеющие вид int_fastN_t, определяют самый быстродействующий целочисленный тип значения длиной не менее N бит. Макросы, имеющие вид uint_fastN_t, определяют самый быстродействующий целочисленный тип значения без знака с не менее чем N бит. Макросы, в имени которых N равно 8, 16, 32 или 64, будут доступны во всех средах, работающих с целыми числами перечисленных длин. Например, макрос int_fast32_t - это допустимый тип значения для всех известных сред.

Тип intmax_t определяет целое значение максимальной длины со знаком, а тип uintmax_t - целое значение максимальной длины без знака.

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

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

Копировать
INTN_C(значение)
UINTN_C(значение)

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

Также в этом заголовке определены следующие макросы.

Копировать
INTMAX_C(значение)
UINTMAX_C(значение)

Они создают константы максимальной длины заданного значения.


Функции преобразования целого формата

В версии С99 добавлен ряд специализированных функций преобразования целочисленного формата, которые позволяют преобразовывать целые значения максимальной длины. Эти функции поддерживает заголовок <inttypes.h>, который включает заголовок <stdint.h>. Заголовок <inttypes.h> определяет один тип: структуру imaxdiv_t, которая хранит значение, возвращаемое функцией imaxdiv(). Ниже перечислены функции преобразования целых значений.

Функция | Описание
intmax_t imaxabs(intmax_t arg); | Возвращает абсолютное значение параметра arg
imaxdiv_t imaxdiv(intmax_t numerator, intmax_t denominator); | Возвращает структуру imaxdiv_t, которая содержит результат numerator/denominator (числитель/знаменатель). Частное занимает поле quot, а остаток - поле rem. Как поле quot, так и поле rem имеют тип intmax_t
intmax_t strtoimax(const char * restrict start, char ** restrict end, int base); | Версия функции strtol() для целочисленных параметров максимальной длины
uintmax_t strtoumax(const char * restrict start, char ** restrict end, int base); | Версия функции strtoul() для целочисленных параметров максимальной длины
intmax_t wcstoimax(const char * restrict start, char ** restrict end, int base); | Версия функции wcstol() для целочисленных параметров максимальной длины
uintmax_t wcstoumax(const char * restrict start, char ** restrict end, int base); | Версия функции wcstoul() для целочисленных параметров максимальной длины

В заголовке <inttypes.h> также определено множество макросов, которые можно использовать в вызовах функций семейств printf() и scanf() для задания различных целочисленных преобразований. Макросы функции printf() начинаются с префикса PRI, а макросы функции scanf() - с префикса SCN. За этими префиксами стоит такой спецификатор преобразования, как d или и, затем следует имя типа (например, N, MAX, PTR, PASTM или LEASTN, где N задает количество битов). Точный список поддерживаемых макросов преобразования лучше всего узнать, обратившись к соответствующей документации на используемый вами компилятор.


Математические макросы обобщенного типа

В стандарте С99 определены три версии для большинства математических функций: одна - для параметров типа float, другая - для параметров типа double и третья - для параметров типа long double. Например, в стандарте С99 определены следующие функции для операции вычисления синуса.

Копировать
double sin(double arg);
float sinf(float arg);
long double sinl(long double arg);

Все три функции выполняют одну и ту же операцию, разница лишь в типе принимаемых ими данных. Причем для всех функций версия, работающая с типом double, - это оригинальная функция, определенная в стандарте С89, a float- и long double-версии добавлены в стандарте С99. В именах float-версий используется суффикс f, а в именах long double-версий - суффикс l.(Необходимость в применении различных имен вызвана тем, что язык С не поддерживает перегрузки функций.) Предоставляя три различные функции, стандарт С99 позволяет вызвать ту, которая более точно соответствует конкретным условиям. Как упоминалось выше в данной главе, по тем же причинам каждая из функций математики комплексных чисел также представлена тремя версиями.

Несмотря на очевидную полезность наличия трех версий математических функций и функций комплексных чисел, работать с ними не совсем удобно, Во-первых, при передаче данных определенного типа нужно не забыть приписать к имени функции надлежащий суффикс. Это и утомительно, и повышает вероятность возникновения ошибок. Во-вторых, если в процессе разработки проекта изменить тип данных, передаваемых одной из таких функций, нужно не забыть изменить и суффикс в имени функции. А это, опять-таки, очень способствует "размножению" ошибок и действует угнетающе на самого программиста. Чтобы справиться с этими(и другими) проблемами, в стандарте С99 определен набор макросов обобщенного типа, которые можно использовать вместо математических или комплексных функций. Эти макросы автоматически выполняют преобразование в соответствующую функцию в зависимости от типа аргумента. Макросы обобщенного типа определены в заголовке <tgmath.h>, который автоматически включает заголовки <math.h> и <complex.h>.

Для макросов обобщенного типа используются те же имена, что и для double-версий математических или комплексных функций, в которые они преобразуются.(Эти имена также совпадают с именами функций, определенными в стандарте С89 и языке C++.) Следовательно, макрос обобщенного типа для функций sin(), sinf() и sinl() использует имя sin(). Макрос обобщенного типа для функций csin(), csinf() и csinl() также использует имя sin(). Как уже упоминалось, соответствующая функция вызывается в зависимости от типа аргумента. Например, в программе определены следующие переменные.

Копировать
long double Idbl;
float complex fcmplx;

Тогда вызов

Копировать
cos(Idbl)

преобразуется в вызов

Копировать
cosl(Idbl),

а вызов

Копировать
cos(fcmplx)

преобразуется в вызов

Копировать
ccosf(fcmplx).

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

ПРИМЕЧАНИЕ. Если вы программируете на языке C++, в использовании макросов обобщенного типа нет никакой необходимости, поскольку язык C++ предоставляет перегруженные версии математических и комплексных функций.


Заголовок stdbool.h

В стандарт С99 добавлен заголовок <stdbool.h>, который поддерживает тип данных _Вооl. Хотя в нем не определено ни одной функции, он определяет следующие четыре макроса.

Макрос | Расширение
bool | _Bool
true | 1
false | 0
__bool_true_false_are_defined | 1

В версии С99 вместо ключевого слова bool определено ключевое слово _Вооl, поскольку во многих существующих С-программах уже определены собственные пользовательские версии типа bool. Определение в версии С99 булева типа в виде ключевого слова _Вооl позволяет избежать нарушения работоспособности созданного ранее программного кода. То же объяснение касается ключевых слов true и false. Однако при написании новых программ лучше всего включить в них заголовок <stdbool.h>, а затем использовать макросы bool, true и false. В этом случае вы сможете создавать программы, совместимые с языком C++.


Стандартная библиотека шаблонов C++

Значительную часть библиотеки классов C++ составляет стандартная библиотека шаблонов(Standard Template Library — STL). Библиотека STL предоставляет шаблонные классы и функции общего назначения, которые реализуют многие популярные и часто используемые алгоритмы и структуры данных. Например, она включает поддержку векторов, списков, очередей и стеков, а также определяет различные процедуры, обеспечивающие доступ к этим объектам. Поскольку библиотека STL состоит из шаблонных классов, алгоритмы и структуры данных могут быть применены к данным практически любого типа.

STL — это большая библиотека, и поэтому не все ее возможности полностью рассмотрены в настоящей книге. Кроме того, описанная здесь версия библиотеки STL определена стандартом ANSI/ISO C++. Более старые компиляторы могут представлять версию STL, которая несколько отличается от стандартной.

Смотрите также

Обзор STL
Примеры использования STL

Контейнерные классы

bitset - Битовое множество
deque - Дек
list - Линейный список
map - Отображение
multimap - Мультиотображение
multiset - Множество
priority_queue - Приоритетная очередь
queue - Очередь
set - Множество
stack - Стек
vector - Динамический массив

Алгоритмы библиотеки STL

adjacent_find - Выполняет поиск совпадающих смежных элементов внутри последовательности
binary_search - Выполняет двоичный поиск значения внутри упорядоченной последовательности
copy_backward - Аналогично copy(), за исключением того, что копирование происходит в обратном порядке
count - Возвращает количество элементов с определённым значением в последовательности
count_if - Возвращает количество элементов для которых заданный предикат возвращает значение true
equal - Определяет, одинаковы ли два диапазона
equal_range - Возвращает диапазон, в который можно вставить элемент, не нарушая порядок некоторой последовательности
fill - Заполняет диапазон заданным значением
fill_n - Заполняет диапазон заданным значением
find - Выполняет поиск значения в заданом диапазоне
find_end - Выполняет поиск последнего итератора последовательности внутри диапазона
find_first_of - Выполняет поиск первого элемента внутри последовательности
find_if - Выполняет поиск элемента, для которого унарный предикат возвращает значение true
for_each - Применяет функцию к диапазону элементов
generate - Присваивает значения, возвращаемые некоторой генерирующей функцией, элементам из диапазона
generate_n - Присваивает значения, возвращаемые некоторой генерирующей функцией, элементам из диапазона
includes - Устанавливает факт включения всех элементов последовательности
inplace_merge - Объединяет два диапазона
iter_swap - Меняет местами значения
lexicographical_compare - Сравнивает последовательности
lower_bound - Выполняет поиск первого элемента в последовательности
make_heap - Создает кучу из последовательности
max - Возвращает максимальное из двух значений
max_element - Возвращает итератор для максимального элемента внутри диапазона
merge - Оъединяет две упорядоченные последовательности, помещая результат в третью последовательность
min - Возвращает минимальное из двух значений
min_element - Возвращает итератор для минимального элемента внутри диапазона
mismatch - Выполняет поиск первого несовпадения элементов в двух последовательностях
next_permutation - Создает перестановку заданной последовательности
сору - Копирует последовательность и помещает результат в другую последовательность
nth_element - Упорядочивает последовательность так, чтобы слева были элементы меньше заданного, а справа - больше
partial_sort - Сортирует диапазон
partial_sort_copy - Сортирует заданный диапазон, а затем копирует столько элементов, столько может поместиться в результирующую последовательность
partition - Сортирует последовательность таким образом, чтобы сначала шли элементы, для которых предикат возвращает значение true затем false
pop_heap - Меняет местами заданные элементы, а затем перестраивает кучу, используя диапазон, определяемый этими элементами
prev_permutation - Создает предыдущую перестановку последовательности
push_heap - Помещает элемент в конец кучи
random_shuffle - Рандомизирует последовательность
remove - Удаляет из заданного диапазона элементы, которые равны заданному значению
remove_copy - Копирует из заданного диапазона элементы, которые равны заданному значению и помещает результат в другую последовательность
remove_copy_if - Копирует из заданного диапазона элементы, для которых заданный предикат равен значению true, и помещает результат в заданную последовательность
remove_if - Удаляет из заданного диапазона элементы, для которых заданный предикат равен значению true
replace - Внутри заданного диапазона заменяет элементы, которые имеют заданное значение
replace_copy - Внутри заданного диапазона копирует элементы в заданную последовательность
replace_copy_if - Внутри заданного диапазона копирует элементы в последовательность. В процессе копирования происходит замена элементов, для которых заданный предикат равен заданому значению
replace_if - Внутри заданного диапазона заменяет элементы, для которых заданный предикат равен значению true
reverse - Меняет порядок следования элементов в диапазоне
reverse_copy - Копирует в обратном порядке диапазон и сохраняет результат в последовательности
rotate - Выполняет циклический сдвиг влево элементов в диапазоне
rotate_copy - Копирует элементы в диапазоне в последовательность. В процессе копирования выполняется циклический сдвиг влево
search - Выполняет поиск одной последовательности внутри другой
search_n - Внутри некоторой последовательности выполняет поиск другой последовательности
set_difference - Создает последовательность, которая содержит разность между двумя упорядоченными множествами
set_intersection - Создает последовательность, которая содержит пересечение двух упорядоченных множеств
set_symmetric_difference - Создает последовательность, которая содержит симметричную разность между двумя упорядоченными множествами
set_union - Создает последовательность, которая содержит объединение двух упорядоченных
sort - Сортирует диапазон
sort_heap - Сортирует кучу внутри диапазона
stable_partition - Упорядочивает последовательность, таким образом, что все элементы, для которых заданный предикат возвращает значение true, будут размещаться перед элементами, для которых этот предикат возвращает значение false
stable_sort - Выполняет устойчивую сортировку диапазона
swap - Меняет местами значения
swap_ranges - Выполняет обмен элементов в диапазоне
transform - Применяет функцию к диапазону элементов и сохраняет результат в последовательности
unique - Удаляет повторяющиеся элементы из заданного диапазона
unique_copy - Копирует диапазон в новую последовательность, удаляя в процессе копирования повторяющиеся элементы
upper_bound - Находит последний элемент в последовательности, который не больше заданного значения


Обзор STL

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

Контейнеры

Контейнеры - это объекты, содержащие другие объекты. Существует несколько различных типов контейнеров. Например, класс vector, определяет динамический массив, класс queue создает двустороннюю очередь, а класс list обеспечивает работу с линейным списком. Эти контейнеры называются последовательными контейнерами, поскольку в терминологии STL последовательность представляет собой линейный список. Помимо базовых контейнеров, библиотека STL определяет ассоциативные контейнеры, которые позволяют эффективно находить нужные значения на основе заданных ключевых значений(ключей). Например, класс map обеспечивает доступ к значениям с уникальными ключами, т.е. хранит пару "ключ/значение" и предоставляет возможность находить значение по заданному ключу.

Каждый контейнерный класс определяет набор функций, которые можно применять к данному контейнеру. Например, контейнер списка включает функции, предназначенные для выполнения вставки, удаления и объединения элементов. А стек включает функции, которые позволяют помещать значения в стек и извлекать значения из стека.

Алгоритмы

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

Итераторы

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

Итераторы | Разрешаемый доступ
Произвольного доступа (random access) | Сохраняют и считывают значения; позволяют организовать произвольный доступ к элементам
Двунаправленные (bidirectional) | Сохраняют и считывают значения; обеспечивают инкрементно-декрементное перемещение
Однонаправленные (forward) | Сохраняют и считывают значения; обеспечивают только инкрементное перемещение
Входные (input) | Считывают, но не записывают значений; обеспечивают только инкрементное перемещение
Выходные (output) | Записывают, но не считывают значения; обеспечивают только инкрементное перемещение

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

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

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

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

Термин | Представляемый итератор
BiIter | Двунаправленный
ForIter | Однонаправленный
InIter | Входной
OutIter | Выходной
RandIter | Произвольного доступа

Другие элементы библиотеки STL

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

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

Некоторые алгоритмы и контейнеры используют специальный тип функции, называемый предикатом(predicate). Существует два варианта предикатов: унарный и бинарный. Унарный предикат принимает один аргумент, а бинарный - два. Эти функции возвращают результаты "истина/ложь", но точные условия, которые заставят их вернуть значение истины или лжи, определяются программистом. В остальной части этой главы, когда потребуется унарная функция-предикат, на это будет указано с помощью типа UnPred. При необходимости использования бинарного предиката будет применяться тип BinPred. В бинарном предикате аргументы всегда расположены в порядке первый, второй относительно функции, которая вызывает этот предикат. Как для унарного, так и для бинарного предикатов аргументы будут содержать значения, тип которых совпадает с типом объектов, сохраняемых данным контейнером.

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

Помимо заголовков, требуемых различными классами STL, стандартная библиотека C++ включает заголовки <utility> и <functional>, которые обеспечивают поддержку STL. Например, в заголовке <utility> определяется шаблонный класс pair, который может хранить пару значений.

Шаблоны в заголовке <functional> позволяют создавать объекты, которые определяют функцию operator(). Эти объекты называются объектами-функциями, и их во многих случаях можно использовать вместо указателей на функции. Существует несколько встроенных объектов-функций, объявленных в заголовке <functional>.

plus | minus | multiplies | divides | modulus
negateq | equal_to | not_equal_to | greater | greater_equal
less | less_equal | logical_and | logical_or | logical_not

Возможно, самой широко используемой объектом-функцией является less, которая определяет, когда один объект меньше другого, Объекты-функции можно использовать вместо реальных указателей на функции в алгоритмах STL, о которых пойдет речь ниже. Используя объекты-функции вместо указателей на функции, библиотека STL генерирует более эффективный программный код.

"Обитателями" библиотеки STL являются и такие сущности, как связка(binder) и инвертор(negator). Связка связывает аргумент с объектом-функцией, а инвертор возвращает дополнение предиката.

Наконец, следует познакомиться еще с одним термином: адаптер(adaptor). По логике библиотеки STL адаптер преобразует один объект в другой. Например, контейнер queue (который создает стандартную очередь) является адаптером для контейнера deque.


Примеры использования STL

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

Итак, следующая программа иллюстрирует использование класса vector.

Копировать
// Короткая программа демонстрации
// работы класса vector,
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> v; // создаем вектор нулевой длины
    int i;

    // Отображаем исходный размер объекта v.
    cout << "размер = " << v.size() << endl;

    /* Помещаем значения в конец вектора:
    вектор будет расти по мере необходимости.*/
    for(i=0; i<10; i++) v.push_back(i);

    // Отображаем текущий размер объекта v.
    cout << "размер сейчас = " << v.sized << endl;

    // Доступ к содержимому вектора можно получить, используя индексы.
    for(i=0; i<10; i++) cout << v[i] << " ";
    cout << endl;

    // Доступ к первому и последнему элементам вектора.
    cout << "первый = " << v.front() << endl;
    cout << "последний = " << v.back() << endl;

    // Доступ через итератор.
    vector<int>: : iterator p = v.begin();
    while (p != v.end()) {
    cout << *p << " " ;
    p++;

    return 0;
}

Ниже показан результат работы этой программы.

Копировать
размер = 0
размер сейчас =10
0123456789
первый = 0
последний = 9
0123456789

В этой программе вначале создается вектор нулевой длины. Функция-член push_back() помещает значения в конец вектора, увеличивая тем самым его размер по мере необходимости. Функция size() отображает текущий размер вектора. Вектор может быть индексирован подобно обычному массиву. К его содержимому можно также получить доступ с помощью итератора. Функция begin() возвращает итератор в начало вектора, а функция end() - в конец вектора.

И еще одно: обратите внимание на объявление итератора р. Тип iterator определяется несколькими контейнерными классами.

Вот ещё один пример

Копировать
typedef Object *OBJECT;
//Определяем тип данных списка MyList в котором будут хранится указатели
typedef std::list<OBJECT> MyList;
//Определяем тип данных итератора который будет работать с указателеми на объекты типа Object
typedef std::list<OBJECT>::iterator MyListIterator;

MyList List;		//Наш список объектов
Object* cObject;	//Ссылка на конкретный объект

...

MyListIterator iterator = List.begin();  //Берём первый элемент:

//Цикл обхода каждого элемента
while(iterator != List.end()){
    cObject=*iterator;	//используем указатель cObject для ссылки на объект
    cObject->myAction();	//Выполняем метод myAction объекта Object
    iterator++;		//Берём следующий элемент
}


Контейнерные классы

Ниже приведены контейнеры, определенные библиотекой STL.

Контейнер | Описание | Требуемый заголовок
bitset | Битовое множество | <bitset>
deque | Дек(двусторонняя очередь, или очередь с двусторонним доступом) | <deque>
list | Линейный список | <list>
map | Отображение. Хранит пары "ключ/значение", в которых каждый ключ связан только с одним значением | <map>
multimap | Мультиотображение. Хранит пары "ключ/значение", в которых каждый ключ может быть связан с двумя или более значениями | <map>
multiset | Множество, в котором каждый элемент необязательно уникален(мультимножество) | <set>
priority_queue | Приоритетная очередь queue | <queue>
queue | Очередь | <queue>
set | Множество, в котором каждый элемент уникален | <set>
stack | Стек | <stack>
vector | Динамический массив | <vector>

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

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

size_type | Некоторый целочисленный тип, приблизительно эквивалентный типу size_t
reference | Ссылка на элемент
const_reference | const-ссылка на элемент
difference_type | Может представлять разность между двумя адресами
iterator | Итератор
const_iterator | const-итератор
reverse_iterator | Реверсивный итератор
const_reverse_iterator | Константный реверсивныйитератор
value_type | Тип значения, сохраняемого в контейнере(то же самое, что и обобщенный тип т)
allocator_type | Тип распределителя
key_type | Тип ключа
key_compare | Тип функции, которая сравнивает два ключа
mapped_type | Тип значения,сохраняемого в отображении(то же самое, что и обобщенный тип Т)
value_compare | Тип функции, которая сравнивает два значения
value_type | Тип обрабатываемых значений (то же самое, что и обобщенный тип T)
pointer | Тип указателя
const_pointer | Тип константного указателя
container_type | Тип контейнера


bitset

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

Копировать
template <size_t N> class bitset;

Здесь элемент N задает длину(в битах) битового множества. Класс имеет следующие конструкторы.

Копировать
bitset();
bitset(unsigned long bits);
explicit bitset(const string &s, size_t i = 0, size_t num = npos);

Первая форма конструктора создает пустое битовое множеств(), Вторая форма создает битовое множество, биты которого установлены в соответствии с заданными значениями битов параметра bits. Третья форма создает битовое множество с помощью строки s, начиная с позиции i. Строка должна содержать только единицы и нули. Используется только num или s.size()-i значений (выбирается меньшее число). Константа npos - это значение, достаточно большое для описания максимальной длины строки s.

Для класса bitset определены операторы вывода << и >>.

Класс bitset содержит следующие функции-члены.

Функция-член | Назначение
bool any() const; | Возвращает истину, если в исследуемом битовом множестве установлен(т.е. равен 1) хотя бы один бит; в противном случае возвращает ложь
size_type count() const; | Возвращает количество единичных битов
bitset<N> &flip(); | Меняет на противоположное (переключает) состояние всех битов битового множества и возвращает значение *this
bitset<N> &flip(size_ti); | Переключает состояние бита в позиции i используемого битового множества и возвращает значение *this
bool none() const; | Возвращает истину, если в используемом битовом множестве не установлен ни один бит
bool operator !=(const bitset<N> &op2) const; | Возвращает истину, если используемое битовое множество отличается от другого битового множества, заданного в правой части оператора ор2
bool operator == (const bitset<N> &op2) const; | Возвращает истину, если используемое битовое множество совпадает с другим битовым множеством, заданным в правой части оператора ор2
bitset<N> &operator &= (const bitset<N> &op2); | Выполняет логическую операцию И (AND) с каждым битом используемого битового множества и соответствующим битом битового множества в ор2 и оставляет результат в первом; возвращает значение *this
bitset<N> &operator ^= (const bitset<N> &op2); | Выполняет логическую операцию исключающего ИЛИ (XOR) с каждым битом используемого битового множества и соответствующим битом битового множества в ор2 и оставляет результат в первом; возвращает значение * this
bitset<N> &operator |= (const bitset<N> &op2); | Выполняет логическую операцию ИЛИ (OR) с каждым битом используемого битового множества и соответствующим битом битового множества в ор2 и оставляет результат в первом; возвращает значение *this
bitset<N> &operator ~=( ) const; | Меняет на противоположное (переключает) состояние всех битов битового множества и возвращает результат
bitset<N> &operator <<= (size_t num); | Сдвигает влево на num позиций каждый бит используемого битового множества, в котором и оставляет результат; возвращает значение *this
bitset<N> &operator >>= (size_t num); | Сдвигает вправо на num позиций каждый бит используемого битового множества, в котором и оставляет результат; возвращает значение *this
reference operator[](size_type i); | Возвращает ссылку на бит i в используемом битовом множестве
bitset<N> &reset(); | Очищает все биты в используемом битовом множестве и возвращает значение *this
bitset<N> &reset(size_t i); | Очищает бит в позиции i используемого битового множества и возвращает значение * this
bitset<N> &set(); | Устанавливает все биты в используемом битовом множестве и возвращает значение * this
bitset<N> &set(size_t int val = 1); | Устанавливает бит в позиции i используемого битового множества равным значению, заданному параметром val, и возвращает значение *this. Любое ненулевое значение параметра val принимается за 1
size_t size() const; | Возвращает количество битов, которое может содержать данное битовое множество
bool test(size_t i); | Возвращает состояние бита в позиции i
string to_string() const; | Возвращает строку, которая содержит представление двоичного кода в используемом битовом множестве
unsigned long to_ulong() const; | Преобразует данное битовое множество в длинное целое без знака


deque

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

Копировать
template <class Т, class Allocator = allocator<T>> class deque

Здесь Т - тип данных, сохраняемых в деке. Класс deque имеет следующие конструкторы.

Копировать
explicit deque(const Allocator &a = Allocator());
explicit deque(size_type num, const Т &val = Т(), const Allocator &a = Allocator());
deque(const deque<T, Allocator> &ob);
template <class InIter> deque(InIter start, InIter end, const Allocator &a = Allocator());

Первая форма конструктора создает пустой дек. Вторая создает дек, который имеет пит элементов со значением val. Третья создает дек, который содержит те же элементы, что и объект ob. Четвертая создает очередь, которая содержит элементы в диапазоне, заданном параметрами start и end.

Для класса deque определены следующие операторы сравнения: ==, <, < = , !=, > и >=.

Класс deque содержит следующие функции-члены.

Функция-член | Назначение
template <class InIter> void assign(InIter start, InIter end); | Помещает в дек последовательность, определяемую параметрами start и end
void assign(size_type num, const т &val); | Помещает в дек num элементов со значением val
reference at(size_type i);
const_reference at(size_type i) const; 		Возвращает ссылку на элемент, заданный параметром i
reference back();
const_reference back() const; 		Возвращает ссылку на последний элемент в деке
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в деке
void clear(); | Удаляет все элементы из дека
bool empty() const; | Возвращает значение истины, если используемый дек пуст, и значение лжи в противном случае
const_iterator end() const;
iterator end(); 		Возвращает итератор для конца дека
iterator erase(iterator i);
 Удаляет элемент, адресуемый итератором i; возвращает итератор для элемента, расположенного после удаленного элемента
iterator erase(iterator start, iterator end); | Удаляет элементы в диапазоне, задаваемом параметрами start и end; возвращает итератор для элемента, расположенного за последним удаленным элементом
reference front();
const_reference front() const, 		Возвращает ссылку на первый элемент в деке
allocator_type get_allocator() const; | Возвращает распределитель дека
iterator insert(iterator i, const Т &val = Т()); | Вставляет значение val непосредственно перед элементом, заданным параметром i; возвращает итератор для этого элемента
void insert(iterator i, size_type num, const Т &val); | Вставляет num копий значения val сразу перед элементом, заданным параметром i
template <class InIter> void insert(iterator i, InIter start, Inlter end); | Вставляет в дек последовательность, определяемую параметрами start и end, сразу перед элементом, заданным параметром i
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать дек
reference operator[](size_type i) const;
const_reference operator[](size_type i) const; 		Возвращает ссылку на i-й элемент
void pop_back(); | Удаляет последний элемент в деке
void pop_front(); | Удаляет первый элемент в деке
void push_back(const Т &val); | Добавляет элемент со значением, заданным параметром val, в конец дека
void push_front(const т &val); | Добавляет элемент со значением, заданным параметром val, в начало дека
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца дека
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала дека
void resize(size_type num, т val = T()); | Устанавливает размер дека равным значению, заданному пара метром num. Если дек для этого нужно удлинить, то в конец дека добавляются элементы со значением, заданным параметром val
size_type size() const; | Возвращает текущее количество элементов в деке
void swap(deque<T, Allocator> &ob); | Выполняет обмен элементами данного дека и дека ob


list

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

Копировать
template <class Т, class Allocator = allocator<T>> class list

Здесь Т - тип данных, сохраняемых в списке. Класс list имеет следующие конструкторы.

Копировать
explicit list(const Allocator &a = Allocator!) );
explicit list(size_type num, const Т &val = Т(), const Allocator &a = Allocator())
list(const list &ob);
template list(InIter start, InIter end, const Allocator &a = Allocator());

Первая форма конструктора создает пустой список. Вторая создает список, который содержит пит элементов со значением val. Третья создает список, который содержит те же элементы, что и объект ob. Четвертая создает список, который содержит элементы в диапазоне, заданном параметрами start и end.

Для класса list определены следующие операторы сравнения: ==, <, < = , !=,> и >=.

Класс list содержит следующие функции-члены.

Функция-член | Назначение
template <class InIter> void assign(InIter start, InIter end); | Помещает в список последовательность, определяемую параметрами start и end
void assign(size_type num, const Т &val); | Помещает в список num элементов со значением val
reference back();
const_reference back() const; 		Возвращает ссылку на последний элемент в списке
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в списке
void clear(); | Удаляет все элементы из списка
bool empty() const; | Возвращает значение истины, если используемый список пуст, и значение лжи в противном случае
iterator end();
const_iterator end() const; 		Возвращает итератор для конца списка
iterator erase(iterator i); | Удаляет элемент, адресуемый итератором i; возвращает итератор для элемента, расположенного после удаленного элемента
iterator erase(iterator start, iterator end); | Удаляет элементы в диапазоне, задаваемом параметрами start и end; возвращает итератор для элемента, расположенного за последним удаленным элементом
reference front();
const_reference front() const; 		Возвращает ссылку на первый элемент в списке
allocator_type get_allocator() const; | Возвращает распределитель списка
iterator insert(iterator i, const Т &val = Т()); | Вставляет значение val непосредственно перед элементом, заданным параметром i; возвращает итератор для этого элемента
void insert(iterator i, size_type num; const T &val); | Вставляет num копий значения val непосредственно перед элементом, заданным параметром i
template <class InIter> void insert(iterator i, InIter start, InIter end); | Вставляет в список последовательность, определяемую параметрами start и end, непосредственно перед элементом, заданным параметром i
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать список
void merge (list<T, Allocator> &ob);
template <class Comp> void merge(1ist<T, Allocator> &ob, Comp cmpfn); 		Объединяет упорядоченный список, содержащийся в объекте ob, с данным упорядоченным списком. Результат также упорядочивается. После объединения список, содержащийся в ob, остается пустым. Во второй форме может быть задана функция сравнения, которая определяет, когда один элемент меньше другого
void pop_back(); | Удаляет последний элемент в списке
void pop_front(); | Удаляет первый элемент в списке
void push_back(const T &val); | Добавляет элемент со значением, заданным параметром val, в конец списка
void push_front(const T &val); | Добавляет элемент со значением, заданным параметром val, в начало списка
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца списка
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала списка
void remove(const T &val); | Удаляет из списка элементы со значением val
template <class UnPred> void remove_if(UnPred pr); | Удаляет элементы, для которых унарный предикат pr равен значению true
void resize (size_type num, Т val = T()); | Устанавливает размер списка равным значению, заданному параметром num. Если список для этого нужно удлинить, то в конец списка добавляются элементы со значением, заданным параметром val
void reverse(); | Реверсирует список
size_type size() const; | Возвращает текущее количество элементов в списке
void sort();
template <class Comp> void sort(Сomp cmpfn); 		Сортирует список. Вторая форма сортирует список с помощью функции сравнения cmpfn, чтобы определять, когда один элемент меньше другого
void splice(iterator i, list<T, Allocator> &ob); | Вставляет содержимое списка ob в данный список в позиции, указанной итератором i. После выполнения этой операции список ob остается пустым
void splice(iterator i, list<T, Allocator> &ob, iterator el); | Удаляет из списка ob элемент, адресуемый итератором el, и сохраняет его в данном списке в позиции, адресуемой итератором i
void splice(iterator i, list<T, Allocator> &ob, iterator start, iterator end); | Удаляет из списка ob диапазон, определяемый параметрами start и end, и сохраняет его в данном списке, начиная с позиции, адресуемой итератором i
void swap(list<T, Allocator> &ob); | Выполняет обмен элементами данного списка и списка ob
void unique();
template <class BinPred> void unique(BinPred pr); 		Удаляет из списка элементы-дубликаты. Вторая форма для определения уникальности использует предикат pr


map

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

Копировать
template <class Key, class T, class Comp = less<Key>,
    class Allocator = allocator<pair<const Key, T>>> class map

Здесь Key - тип данных ключей, Т - тип сохраняемых (отображаемых) значений, a Comp - функция, которая сравнивает два ключа. Класс map имеет следующие конструкторы.

Копировать
explicit map(const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
map(const map<Key, T, Comp, Allocator> &ob);
template <class InIter> map(InIter start, InIter end,
    const Comp &cmpfn = Comp(), const Allocator &a = Allocator)));

Первая форма конструктора создает пустое отображение. Вторая создает отображение, которое содержит те же элементы, что и отображение ob. Третья создает отображение, которое содержит элементы в диапазоне, заданном параметрами start и end. Функция, заданная параметром cmpfn (и если она задана), определяет упорядочение отображения.

Для класса map определены следующие операторы сравнения: ==,<,<=, !=, > и >=.

Класс map содержит перечисленные ниже функции-члены. В приведенных в следующей таблице описаниях элемент key_type представляет тип ключа, а элемент value_type - пару элементов pair<Key, Т>.

Функция-член | Назначение
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в отображении
void clear(); | Удаляет все элементы из отображения
size_type count(const key_type &k) const; | Возвращает число вхождений ключа k в отображении (1 или 0)
bool empty() const; | Возвращает true, если данное отображение пустое, и false в противном случае
iterator end();
const_iterator end() const; 		Возвращает итератор, указывающий на конец отображения
pair<iterator, iterator> equal_range(const key_type &k);
pair<const_iterator, const_iterator> equal_range(const key_type &k) const; 		Возвращает пару итераторов, которые указывают на первый и последний элементы в отображении, содержащие заданный ключ
void erase(iterator i); | Удаляет элемент, на который указывает итератор i
void erase(iterator start, iterator end); | Удаляет элементы в диапазоне, заданном параметрами start и end
size_type erase(const key_type &k); | Удаляет из отображения элементы, ключи которых имеют значение k
iterator find(const key_type &k);
const_iterator find(const key_type &k) const; 		Возвращает итератор для заданного ключа. Если ключ не обнаружен, возвращает итератор для конца отображения
allocator_type get_allocator() const; | Возвращает распределитель отображения
iterator insert(iterator i, const value_type &val); | Вставляет значение val в позиции или после элемента, заданного итератором i. Возвращает итератор на этот элемент
template <class InIter> void insert(InIter start, InIter end); | Вставляет элементы заданного диапазона
pair<iterator, bool> insert(const value_type &vaJ); | Вставляет значение val в используемое отображение. Возвращает итератор для данного элемента. Элемент вставляет только в том случае, если его еще нет в отображении. Если элемент был вставлен, возвращает пару pair<iterator, true>. В противном случае возвращает пару pair<iterator, false>
key_compare key_comp()const; | Возвращает объект-функцию, которая сравнивает ключи
iterator lower_bound(const key_type &k);
const_iterator lower_bound(const key_type &k)const; 		Возвращает итератор для первого элемента в отображении, ключ которого равен значению k или больше этого значения
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать данное отображение
reference operator[](const key_type &i); | Возвращает ссылку на элемент, заданный параметром i. Если этого элемента не существует, вставляет его в отображение
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца отображения
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала отображения
size_type size() const; | Возвращает текущее число элементов в отображении
void swap(map<Key, T, Comp, Allocator> &ob); | Выполняет обмен элементами данного отображения и отображения оЬ
iterator upper_bound(const key_type &k);
const_iterator upper_bound(const key_type &k) const; 		Возвращает итератор для первого элемента в отображении, ключ которого больше заданного значения k
value_compare value_comp() const; | Возвращает итератор для первого элемента в отображении, ключ которого больше заданного значения k


multimap

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

Копировать
template <class Key, class T, class Comp = less<Key>,
    lass Allocator = allocator<pair<const Key, T>>> class multimap

Здесь Key - тип данных ключей, Т - тип сохраняемых (отображаемых) значений, a Comp - функция, которая сравнивает два ключа. Класс multimap имеет следующие конструкторы.

Копировать
explicit multimap(const Comp &cmpfn = Comp(), const Allocator &a = Allocator(});
multimap(const multimap<Key, T, Comp, Allocator> &ob);
template <class InIter> multimap(InIter start, InIter end, const Comp &cmpfn = Comp(), const Allocator &a = Allocator());

Первая форма конструктора создает пустое мультиотображение. Вторая создает мультиотображение, которое содержит те же элементы, что и мультиотображение оЬ. Третья создает мультиотображение, которое содержит элементы в диапазоне, заданном параметрами start и end. Функция, заданная параметром cmpfn (если она задана), определяет упорядочение мультиотображения.

Для класса multimap определены следующие операторы сравнения: ==,<,<=, !=,> и >=.

Класс multimap содержит перечисленные ниже функции-члены. В приведенных в следующей таблице описаниях элемент key_type представляет тип ключа, а элемент value_type - пару элементов pair<Key, Т>.

Функция-член | Назначение
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в мультиотображении
void clear(); | Удаляет все элементы из мультиотображения
size_type count(const key_type &k) const; | Возвращает число вхождений ключа k в мультиотображении
bool empty() const; | Возвращает true, если данное мультиотображение пустое, и false в противном случае.
iterator end();
const_iterator end() const; 		Возвращает итератор для конца мультиотображения
pair<iterator, iterator> equal_range(const key_type &k);
pair<const_iterator, const_iterator> equal_range(const key_type &k) const; 		Возвращает пару итераторов, которые указывают на первый и последний элементы в мультиотображении, которые содержат заданный ключ
void erase(iterator i); | Удаляет элемент, на который указывает итератор i
void erase(iterator start, iterator end); | Удаляет элементы в диапазоне, заданном параметрами start и end
size_type erase( const key_type &k); | Удаляет из мультиотображения элементы, ключи которых имеют значение k
iterator find(const key_type &?);
const_iterator find(const key_type &fc) const; 		Возвращает итератор для заданного ключа. Если ключ не обнаружен, возвращает итератор для конца мультиотображения
allocator_type get_allocator() const; | Возвращает распределитель мультиотображения
iterator insert(iterator i, const value_type &val); | Вставляет значение val в позиции или после элемента, заданного итератором i. Возвращает итератор для этого элемента
template <class InIter> void insert(InIter start, InIter end); | Вставляет элементы заданного диапазона
iterator insert(const value_type &vai); | Вставляет значение val в используемое мультиотображение
key_compare key_comp() const; | Возвращает объект-функцию, которая сравнивает ключи
iterator lower_bound(const key_type &k);
const_iterator lower_bound(const key_type &k) const; 		Возвращает итератор для первого элемента в мультиотображении, ключ которого равен значению k или больше этого значения
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать данное мультиотображение
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца мультиотображения
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала мультиотображения
size_type size() const; | Возвращает текущее число элементов в мультиотображении
void swap(multimap<Key, T, Comp, Allocator> &ob); | Выполняет обмен элементами данного мультиотображения и мультиотображения ob
iterator upper_bound(const key_type &k);
const_iterator upper_bound(const key_type &k) const; 		Возвращает итератор для первого элемента в мультиотображении, ключ которого больше заданного значения k
value_compare value_comp() const; | Возвращает объект-функцию, которая сравнивает значения


multiset

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

Копировать
template <class Key, class Comp = less<Key>,
    class Allocator = allocator<Key>> class multiset

Здесь Key - тип данных ключей, а Comp - функция, которая сравнивает два ключа. Класс multiset имеет следующие конструкторы.

Копировать
explicit multiset(const Comp &cmpfn - Comp(), const Allocator &a = Allocator());
multiset(const multiset<Key, Comp, Allocator> &ob);
template <class InIter> multiset(InIter start, InIter end,
    const Comp &cmpfn = Comp() , const Allocator &a = Allocator());

Первая форма конструктора создает пустое мультимножество, Вторая создает мультимножество, которое содержит те же элементы, что и мультимножество ob. Третья создает мультимножество, которое содержит элементы в диапазоне, заданном параметрами start и end. Функция, заданная параметром cmpfn(если она задана), определяет упорядочение мультимножества.

Для класса multiset определены следующие операторы сравнения: ==, <, <=, !=, > и >=.

Класс multiset содержит перечисленные ниже функции-члены. В приведенных в следующей таблице описаниях элементы key_type и value_type получены в результате применения оператора typedef для типа данных Key.

Функция-член | Назначение
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в мультимножестве
void clear(); | Удаляет все элементы из мультимножества
size_type count(const key_type &k) const; | Возвращает число вхождений значения k в мультимножестве
bool empty() const; | Возвращает true, если мультимножество пустое, и false в противном случае
iterator end();
const_iterator end() const; 		Возвращает итератор для конца мультимножества
pair<iterator, iterator> equal_range(const key_type &k) const; | Возвращает пару итераторов, которые указывают на первый и последний элементы в мультимножестве, которые содержат заданный ключ
void erase(iterator i); | Удаляет элемент, на который указывает итератор i
void erase(iterator start, iterator end); | Удаляет элементы в диапазоне, заданном параметрами start и end
size_type erase(const key_type &k); | Удаляет из мультимножества элементы, ключи которых имеют значение k
iterator find(const key_type &k); | Возвращает итератор для заданного ключа. Если ключ не обнаружен, возвращает итератор для конца мультимножества
allocator_type get_allocator() const; | Возвращает распределитель мультимножества
iterator insert(iterator i, const value_type &val); | Вставляет значение val в позиции или после элемента, заданного итератором i. Возвращает итератор для этого элемента
template <class InIter> void insert(InIter start, InIter end); | Вставляет элементы заданного диапазона
iterator insert(const value_type &val); | Вставляет значение val в используемое мультимножество. Возвращает итератор для вставленного элемента
key_compare key_comp() const; | Возвращает объект-функцию, которая сравнивает ключи
iterator lower_bound(const key_type &k) const; | Возвращает итератор для первого элемента в мультимножестве, ключ которого равен значению k или больше этого значения
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать данное мультимножество
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца мультимножества
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала мультимножества
size_type size() const; | Возвращает текущее число элементов в мультимножестве
void swap(multiset<Key, T, Comp, Allocator> &ob); | Выполняет обмен элементами данного мультимножества и мультимножества ob
iterator upper_bound(const key_type &k) const; | Возвращает итератор для первого элемента в мультимножестве, ключ которого больше заданного значения k
value_compare value_comp() const; | Возвращает объект-функцию, которая сравнивает значения


queue

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

Копировать
template <class Т, class Container = deque<T>> class queue

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

Копировать
explicit queue(const Container &cnt = Container());

Конструктор queue() создает пустую очередь. По умолчанию в качестве контейнера используется дек(deque), но к очереди можно получить доступ только по принципу "первым вошел - первым вышел". Можно также в качестве контейнера для очереди использовать список(list). Контейнер содержится в защищенном объекте с именем с типа Container.

Для класса queue определены следующие операторы сравнения: ==, <, <=, !=, > и >=.

Класс queue содержит перечисленные ниже функции-члены.

Функция-член | Назначение
value_type &back();
const value_type &back() const; 		Возвращает ссылку на последний элемент в очереди
bool empty() const; | Возвращает true, если данная очередь пустая, и false в противном случае
value_type &front();
const value_type &front() const; 		Возвращает ссылку на первый элемент в очереди
void pop(); | Удаляет первый элемент в очереди
void push(const Т &val); | Добавляет в конец очереди элемент, значение которого задано параметром val
size_type size() const; | Возвращает текущее количество элементов в очереди


priority_queue

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

Копировать
template <class Т, class Container = vector<T>,
    class Comp = less<Container::value_type>> class priority_queue

Здесь Т - тип данных, сохраняемых в приоритетной очереди, Container - тип контейнера, используемого для реализации очереди, а класс Comp задает функцию сравнения, которая определяет, когда один член приоритетной очереди меньше другого по приоритету. Класс priority_queue имеет следующие конструкторы.

Копировать
explicit priority_queue (const Comp &cmpfn = CompO, Container &cnt = Container());
template <class InIter> priority_queue(InIter start, Inlter end,
    const Comp &cmpfn = Comp(), Container &cnt = Container());

Первый конструктор priority_queue() создает пустую приоритетную очередь. Второй создает приоритетную очередь, которая содержит элементы, заданные границами диапазона start и end. По умолчанию в качестве контейнера используется вектор (vector). Можно также в качестве контейнера для приоритетной очереди использовать дек (deque). Этот контейнер хранится в защищенном объекте с именем с типа Container.

Класс priority_queue содержит перечисленные ниже функции-члены.

Функция-член | Назначение
bool empty() const; | Возвращает true, если данная приоритетная очередь пустая, и false в противном случа
void pop(); | Удаляет первый элемент в приоритетной очереди
void push(const Т &val); | Добавляет в приоритетную очередь элемент, значение которого задано параметром val
size_type size() const; | Возвращает текущее количество элементов в приоритетной очереди
const value_type &top() const; | Возвращает ссылку на элемент с наивысшим приоритетом. Этот элемент не удаляется


set

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

Копировать
template <class Key, class Comp = less<Key>,
    class Allocator = allocator<Key>> class set

Здесь Key - тип данных ключей, a Comp - функция, которая сравнивает два ключа. Класс set имеет следующие конструкторы.

Копировать
explicit set(const Comp &cmpfn = Comp(), const Allocator &a = Allocator));
set(const set<Key, Comp, Allocator> &ob);
template <class InIter> setdnlter start, InIter end,
    const Comp &cmpfn = Comp(), const Allocator &a = Allocator());

Первая форма конструктора создает пустое множество, Вторая создает множество, которое содержит те же элементы, что и множество ob. Третья создает множество, которое содержит элементы в диапазоне, заданном параметрами start и end. Функция, заданная параметром cmpfn(если она задана), определяет упорядочение множества.

Для класса set определены следующие операторы сравнения: ==, <, <=, !=, > и >=.

Класс multiset содержит перечисленные ниже функции-члены.

Функция-член | Назначение
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в множестве
void clear(); | Удаляет все элементы из множества
size_type count(const key_type &k) const; | Возвращает число вхождений значения k в множестве
bool empty() const; | Возвращает true, если данное множество пустое, и false в противном случае
iterator end();
const_iterator end() const; 		Возвращает итератор для конца множества
pair<iterator, iterator> equal_range(const key_type &k) const; | Возвращает пару итераторов, которые указывают на первый и последний элементы в множестве, содержащие заданный ключ
void erase(iterator i); | Удаляет элемент, на который указывает итератор i
void erase(iterator start, iterator end); | Удаляет элементы в диапазоне, заданном параметрами start и end
size_type erase(const key_type &k); | Удаляет из множества элементы, ключи которых имеют значение k. Возвращает количество удаленных элементов
iterator find(const key_type &k); | Возвращает итератор для заданного ключа. Если этот ключ не обнаружен, возвращает итератор для конца множества
allocator_type get_allocator() const; | Возвращает распределитель множества
iterator insert(iterator i, const value_type &val); | Вставляет значение val в позиции или после элемента, заданного итератором i. Элементы-дубликаты не вставляет. Возвращает итератор для этого элемента
template <class InIter> void insert(InIter start, Inlter end); | Вставляет элементы заданного диапазона. Элементы-дубликаты не вставляет
pair<iterator, bool> insert(const value_type &val); | Вставляет значение val в используемое множество. Возвращает итератор для вставленного элемента. Элемент вставляет только в том случае, если его еще нет в отображении. Если элемент был вставлен, возвращает пару pair<iterator, true>. В противном случае возвращает пару pair<iterator, false>
key_compare key_comp() const; | Возвращает объектфункцию, которая сравнивает ключи
iterator lower_bound(const key_type &k) const; | Возвращает итератор для первого элемента в множестве, ключ которого равен значению k или больше этого значения
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать данное множество
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
 Возвращает реверсивный итератор для конца множества
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала множества
size_type size() const; | Возвращает текущее число элементов в множестве
void swap(set<Key, T, Comp, Allocator> &ob); | Выполняет обмен элементами данного множества и множества ob
iterator upper_bound(const key_type &k) const; | Возвращает итератор для первого элемента в множестве, ключ которого больше заданного значения k
value_compare value_comp() const; | Возвращает объект-функцию, которая сравнивает значения


stack

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

Копировать
template <class Т, class Container = deque<T>> class stack

Здесь Т - тип данных, сохраняемых в стеке, а Container - тип контейнера, используемого для реализации стека. Класс stack имеет следующий конструктор.

Копировать
explicit stack(const Container &cnt = Container());

Конструктор stack() создает пустой стек. По умолчанию в качестве контейнера используется дек(deque), но к стеку можно получить доступ только по принципу "последним вошел - первым вышел". Можно также в качестве контейнера для стека использовать вектор(vector) или список(list). Контейнер содержится в защищенном объекте с именем с типа Container.

Для класса stack определены следующие операторы сравнения: ==, <, <=, !=, > и >=.

Класс stack содержит перечисленные ниже функции

Функция-член | Назначение
bool empty() const; | Возвращает true, если данный стек пуст, и false в противном случае
void pop(); | Удаляет верхний элемент в стеке, который формально является последним элементом в контейнере
void push(const Т &val); | Помещает элемент, значение которого задано параметром val , в конец стека. Последний элемент в контейнере представляет вершину стека
size_type size() const; | Возвращает текущее количество элементов в стеке
value_type &top();
const value_type &top() const; 		Возвращает ссылку на вершину стека, что эквивалентно последнему элементу в контейнере. Этот элемент не удаляется


vector

Класс vector поддерживает динамический массив. Спецификация его шаблона имеет следующий вид.

Копировать
template <class T, class Allocator = allocator<T>> class vector

Здесь Т - тип сохраняемых данных, a Allocator задает распределитель. Класс vector имеет следующие конструкторы.

Копировать
explicit vector(const Allocator &a = Allocator());
explicit vector(size_type num, const Т &val = T(),
    const Allocator &a = Allocator());
vector(const vector<T, Allocator> &ob);
template <class InIter> vector(InIter start, InIter end,
    const Allocator &a = Allocator());

Первая форма конструктора создает пустой вектор. Вторая создает вектор, который содержит num элементов со значением val. Третья создает вектор, который содержит те же элементы, что и вектор ob. Четвертая создает вектор, который содержит элементы в диапазоне, заданном параметрами start и end.

Для класса vector определены следующие операторы сравнения: ==, <, <=, !=, > и >=.

Класс vector содержит следующие функции-члены.

Функция-член | Назначение
template <class InIter> void assign(InIter start, InIter end); | Помещает в вектор последовательность, определяемую параметрами start и end
void assign(size_type num, const Т &val) | Помещает в вектор num элементов со значением val
reference at(size_type i);
const_reference at(size_type i) const; 		Возвращает ссылку на элемент, заданный параметром i
reference back();
const_reference back() const; 		Возвращает ссылку на последний элемент в векторе
iterator begin();
const_iterator begin() const; 		Возвращает итератор для первого элемента в векторе
size_type capacity() const; | Возвращает текущую емкость вектора, которая представляет собой количество элементов, способное храниться в векторе до того, как возникнет необходимость в выделении дополнительной памяти
void clear(); | Удаляет все элементы из вектора
bool empty() const; | Возвращает значение истины, если используемый вектор пуст, и значение лжи в противном случае
iterator end();
const_iterator end() const; 		Возвращает итератор для конца вектора
iterator erase(iterator i); | Удаляет элемент, адресуемый итератором i; возвращает итератор для элемента, расположенного после удаленного элемента
iterator erase(iterator start, iterator end); | Удаляет элементы в диапазоне, задаваемом параметрами start и end; возвращает итератор для элемента, расположенного за последним удаленным элементом
reference front();
const_reference front() const; 		Возвращает ссылку на первый элемент в векторе
allocator_type get_allocator() const; | Возвращает распределитель вектора
iterator insert(iterator i, const Т &val = T()); | Вставляет значение val непосредственно перед элементом, заданным параметром i; возвращает итератор для этого элемента вектора
void insert(iterator i, size_type num, const Т &val); | Вставляет num копий значения val непосредственно перед элементом, заданным параметром i
template <class InIter> void insert(iterator i, InIter start, InIter end); | Вставляет в вектор последовательность, определяемую параметрами start и end, непосредственно перед элементом, заданным параметром i
size_type max_size() const; | Возвращает максимальное число элементов, которое может содержать вектор
reference operator[](size_type i) const;
const_reference operator[](size_type i) const; 		Возвращает ссылку на элемент, заданный параметром i
void pop_back(); | Удаляет последний элемент в векторе
void push_back(const Т &val); | Добавляет в конец вектора элемент со значением, заданным параметром val
reverse_iterator rbegin();
const_reverse_iterator rbegin() const; 		Возвращает реверсивный итератор для конца вектора
reverse_iterator rend();
const_reverse_iterator rend() const; 		Возвращает реверсивный итератор для начала вектора
void reserve(size_type num); | Устанавливает емкость вектора равной не менее заданного значения num
void resize(size_type num, Т val = T()); | Устанавливает размер вектора равным значению, заданному параметром num. Если вектор для этого нужно удлинить, то в его конец добавляются элементы со значением, заданным параметром val
size_type size() const; | Возвращает текущее количество элементов в векторе
void swap(deque<T, Allocator> &ob); | Выполняет обмен элементами данного вектора и вектора ob

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

void flip(); | Инвертирует значения всех битов в векторе
static void swap(reference i, reference j); | Переставляет местами биты, заданные параметрами i и j


Алгоритмы библиотеки STL

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

Обобщенное имя | Что представляет
BiIter | Двунаправленный(bidirectional) итератор
Forlter | Однонаправленный(forward) итератор
InIter | Входной(input) итератор
OutIter | Выходной(output) итератор
RandIter | Итератор произвольного доступа(random access)
Т | Некоторый тип данных
Size | Некоторый тип целочисленных данных
Func | Некоторый тип функции
Generator | Функция, генерирующая объекты
BinPred | Бинарный предикат
UnPred | Унарный предикат
Comp | Функция сравнения


fill()

template <class ForIter, class T>
    void fill(ForIter start, ForIter end, const Т &val);

Описание

Заполняет диапазон заданным значением

Алгоритм fill() заполняет диапазон значением, заданным параметром val. Диапазон задается параметрами start и end.


fill_n()

template <class ForIter, class Size, class T>
    void fill_n(ForIter start, Size num, const Т &val);

Описание

Заполняет диапазон заданным значением

Алгоритм fill_n() заполняет диапазон значением, заданным параметром val. Начало диапазона задается параметром start, после чего в операции заполнения участвуют num элементов.


generate()

template <cclass ForIter, class Generator>
    void generate(ForIter start, ForIter end, Generator fngen);

Описание

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

Алгоритм generate() присваивает значения, возвращаемые некоторой генерирующей функцией, элементам из диапазона, задаваемого параметрами алгоритма. Диапазон задается граничными параметрами start и end. Функция-генератор передается посредством параметра fngen, причем она не имеет параметров.


generate_n()

template <class ForIter, class Size, class Generator>
    void generate_n(0utIter start, Size num, Generator fngen);

Описание

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

Алгоритм generate_n() присваивает значения, возвращаемые некоторой генерирующей функцией, элементам из диапазона, задаваемого параметрами алгоритма. В алгоритме задается начало диапазона(параметр start) и указывается количество участвующих в операции элементов(параметр num). Функция-генератор передается посредством параметра fngen, причем она не имеет параметров.


random_shuffle()

template <class RandIter>
    void random_shuffie(RandIter start, RandIter end);
template <class RandIter, class Generator>
    void random_shuffie(RandIter start, RandIter end, Generator rand_gen);

Описание

Рандомизирует последовательность

Алгоритм random_shuffle() рандомизирует(т.е. придает случайный характер) последовательность, заданную параметрами start и end.

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

Копировать
rand_gen(num);

Она должна возвращать случайное число в диапазоне между нулем и значением пит.


nth_element()

template <class RandIter>
    void nth_element(RandIter start, RandIter element, RandIter end);
template <class RandIter, class Comp>
    void nth_element(RandIter start, RandIter element, RandIter end,
            Comp cmpfn);

Описание

Упорядочивает последовательность так, чтобы слева были элементы меньше заданного, а справа - больше

Алгоритм nth_element() упорядочивает последовательность, заданную параметрами start и end, таким образом, чтобы все элементы, значения которых меньше значения element, размещались перед этим элементом, а все элементы, значения которых больше значения element, размещались после него,

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


partial_sort()

template <class RandIter>
    void partial_sort(RandIter start, RandIter mid, RandIter end);
template <class RandIter, class Comp>
    void partial_sort(RandIter start, RandIter mid, RandIter end, Comp cmpfn);

Описание

Сортирует диапазон

Алгоритм partial_sort() сортирует диапазон, заданный параметрами start и end. Однако после выполнения алгоритма отсортированными будут только элементы из диапазона, определяемого параметрами start и mid.

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


partial_sort_copy()

template <class InIter, class RandIter>
    RandIter partial_sort_copy(InIter start, InIter end,
                RandIter res_start, RandIter res_end);
template <class InIter, class RandIter, class Comp>
    RandIter partial_sort_copy(InIter start, InIter end,
                RandIter res_start, RandIter res_end, Comp cmpfn);

Описание

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

Алгоритм partial_sort_copy() сортирует диапазон, заданный параметрами start и end, а затем копирует столько элементов, столько может поместиться в результирующую последовательность, которая задана параметрами res_start и res_end. Алгоритм возвращает итератор для последнего элемента, скопированного в результирующую последовательность.

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


partition()

template <class BiIter, class UnPred>
    BiIter partition(BiIter start, BiIter end, UnPred pfn);

Описание

Сортирует последовательность таким образом, чтобы сначала шли элементы, для которых предикат возвращает значение true затем false

Алгоритм partition() сортирует последовательность, заданную параметрами start и end, таким образом, чтобы все элементы, для которых заданный параметром pfn предикат возвращает значение true, размещались перед теми элементами, для которых этот предикат возвращает значение false. Алгоритм возвращает итератор, указывающий на начало диапазона элементов, для которых предикат равен значению false.


sort()

template <class RandIter>
    void sort(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void sort(RandIter start, RandIter end, Comp cmpfn);

Описание

Сортирует диапазон

Алгоритм sort() сортирует диапазон, заданный параметрами start и end.

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


sort_heap()

template <class RandIter>
    void sort_heap(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void sort_heap(RandIter start, RandIter end, Comp cmpfn);

Описание

Сортирует кучу внутри диапазона

Алгоритм sort_heap() сортирует кучу внутри диапазона, задаваемого параметрами start и end.

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


stable_partition()

template <class BiIter, class BinPred>
    BiIter stable_partition(BiIter start, BiIter end, BinPred pfn);

Описание

Упорядочивает последовательность, таким образом, что все элементы, для которых заданный предикат возвращает значение true, будут размещаться перед элементами, для которых этот предикат возвращает значение false

Алгоритм stable_partition() упорядочивает последовательность, заданную параметрами start и end, таким образом, что все элементы, для которых заданный параметром pfn предикат возвращает значение true, будут размещаться перед элементами, для которых этот предикат возвращает значение false. Такое разбиение является стабильным. Это означает охранение относительного упорядочения последовательности. Алгоритм возвращает итератор, указывающий на начало элементов, для которых задаваемый предикат равен значению false.


stable_sort()

template <class RandIter>
    void stable_sort(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void stable_sort(RandIter start, RandIter end, Comp cmpfn);

Описание

Выполняет устойчивую сортировку диапазона

Алгоритм stable_sort() выполняет устойчивую сортировку диапазона, заданного параметрами start и end. Это значит, что равные элементы не переставляются.

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


adjacent_find()

template <class ForIter> ForIter adjacent_find(ForIter start, ForIter end);
template <class ForIter, class BinPred> ForIter
    adjacent_find(ForIter start, ForIter end, BinPred pfn);

Описание

Выполняет поиск совпадающих смежных элементов внутри последовательности

Алгоритм adjacent_find() выполняет поиск совпадающих смежных элементов внутри последовательности, заданной параметрами start и end, и возвращает итератор для первого элемента. Если ни одной такой смежной пары не обнаружено, возвращается значение end. Первая версия предназначена для поиска эквивалентных элементов. Вторая же позволяет задать собственный метод определения совпадающих элементов.


binary_search()

template <class ForIter, class T>
    bool binary_search(ForIter start, ForIter end, const Т &val);
template <class ForIter, class T, class Comp>
    bool binary_search(ForIter start, ForIter end, const Т &val, Comp cmpfn);

Описание

Выполняет двоичный поиск значения внутри упорядоченной последовательности

Алгоритм binary_search() выполняет двоичный поиск значения, заданного параметром val, внутри упорядоченной последовательности, границы которой заданы параметрами start и end. Алгоритм возвращает значение true, если значение val было найдено, и false в противном случае. Первая версия предназначена для поиска в заданной последовательности элементов, которые равны заданному значению. Вторая версия позволяет задать собственную функцию сравнения.


equal_range()

template <class ForIter, class T> pair<ForIter, ForIter>
    equal_range(ForIter start, ForIter end, const Т &val);
template <class ForIter, class T, class Comp> pair<ForIter, ForIter>
    equal_range(ForIter start, ForIter end, const Т &val, Comp cmpfn);

Описание

Возвращает диапазон, в который можно вставить элемент, не нарушая порядок некоторой последовательности

Алгоритм equal_range() возвращает диапазон, в который можно вставить элемент, не нарушая порядок некоторой последовательности. Область, в которой ведется поиск такого диапазона, определяется параметрами start и end. Значение вставляемого элемента передается посредством параметра val. Для задания собственного критерия задайте функцию сравнения с помощью параметра cmpfn.

Шаблонный класс pair - это класс, который может хранить пару объектов в своих членах first и second.


find()

template <class InIter, class T>
    InIter find(InIter start, InIter end, const Т &val);

Описание

Выполняет поиск значения в заданом диапазоне

Алгоритм find() в диапазоне, заданном параметрами start и end, выполняет поиск значения, заданного параметром val. Алгоритм возвращает итератор для первого вхождения элемента или для конца диапазона(end), если искомое значение не обнаружено в заданной последовательности.


find_end()

template <class ForIter1, class ForIter2>
    FwdIter1 find_end(ForIter1 start1, ForIter1 end1, ForIter2 start2, ForIter2 end2);
template <class ForIter1, class ForIter2, class BinPred>
    FwdIter1 find_end(ForIter1 start1, ForIter1 end1, ForIter2 start2, ForIter2 end2, BinPred pfn);

Описание

Выполняет поиск последнего итератора последовательности внутри диапазона

Алгоритм find_end() выполняет поиск последнего итератора последовательности, заданной параметрами start2 и end2 внутри диапазона, заданного параметрами start1 и end1. Если последовательность найдена, возвращается итератор для последнего элемента в этой последовательности. В противном случае возвращается итератор end1.

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


find_first_of()

template <class ForIter1, class ForIter2>
    FwdIter1 find_first_of(ForIter1 start1, ForIter1 end1,
                ForIter2 start2, ForIter2 end2);
template <class ForIter1, class ForIter2, class BinPred>
    FwdIter1 find_first_of(ForIter1 start1, ForIter1 end1,
                ForIter2 start2, ForIter2 end2, BinPred pfn);

Описание

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

Алгоритм find_first_of() выполняет поиск первого элемента внутри последовательности, определенной параметрами start1 и end1, который совпадает с любым элементом внутри диапазона, заданного параметрами start2 и end2. Если совпадения элементов не обнаружено, возвращается итератор end1.

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


find_if()

template <class InIter, class UnPred>
    InIter find_if(InIter start, InIter end, UnPred pfn);

Описание

Выполняет поиск элемента, для которого унарный предикат возвращает значение true

Алгоритм find() в диапазоне, заданном параметрами start и end, выполняет поиск элемента, для которого унарный предикат pfn возвращает значение true. Алгоритм возвращает итератор для первого вхождения элемента или значение end, если искомого значения нет в данной последовательности.


lower_bound()

template <class ForIter1, class T>
    ForIter lower_bound(ForIter start, ForIter end, const Т &val);
template <class ForIter1, class T, class Comp>
    ForIter lower_bound(ForIter start, ForIter end, const Т &val, Comp cmpfn);

Описание

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

Алгоритм lower_bound() выполняет поиск первого элемента в последовательности, заданной параметрами start и end, значение которого не меньше заданного значения val. Алгоритм возвращает итератор для этого элемента.

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


max_element()

template <class ForIter>
    ForIter max_element(ForIter start, ForIter last);
template <class ForIter, class Comp>
    ForIter max_element(ForIter start, ForIter last, Comp cmpfn);

Описание

Возвращает итератор для максимального элемента внутри диапазона

Алгоритм max_element() возвращает итератор для максимального элемента внутри диапазона, заданного параметрами start и last.

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


min_element()

template <class ForIter>
    ForIter min_element(ForIter start, ForIter last);
template <class ForIter, class Comp>
    ForIter min_element(ForIter start, ForIter last, Comp cmpfn);

Описание

Возвращает итератор для минимального элемента внутри диапазона

Алгоритм min_element() возвращает итератор для минимального элемента внутри диапазона, заданного параметрами start и last.

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


mismatch()

template <class InIter1, class InIter2> pair<InIter1, InIter2>
    mismatch(InIter1 start1, InIter1 end!, InIter2 start2);
template <class InIter1, class InIter2, class BinPred> pair<InIter1, InIter2>
    mismatch(InIter1 start1, InIter1 end1, InIter2 start2, BinPred pfn);

Описание

Выполняет поиск первого несовпадения элементов в двух последовательностях

Алгоритм mismatch() выполняет поиск первого несовпадения элементов в двух последовательностях. Возвращаются итераторы для этих двух элементов. Если несовпадения не обнаружено, возвращаются итераторы last1 и start2 + (last1 - start1).

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

Шаблонный класс pair содержит два данных-члена с именами first и second, которые предназначены для хранения пары значений.


search()

template <class ForIter1, class ForIter2>
    ForIter1 search(ForIter1 start1, ForIter1 end1,
            ForIter2 start2, ForIter2 end2);
template <class ForIter1, class ForIter2, class BinPred>
    ForIter1 search(ForIter1 start1, ForIter1 end1,
            ForIter2 start2, ForIter2 end2, BinPred pfn);

Описание

Выполняет поиск одной последовательности внутри другой

Алгоритм search() выполняет поиск одной последовательности внутри другой. Последовательность, внутри которой производится поиск, задается параметрами start1 и end1, а искомая последовательность - параметрами start2 и end2. Если искомая последовательность найдена, возвращается итератор, указывающий на ее начало, В противном случае возвращается итератор end1.

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


search_n()

template <class ForIter, class Size, class T>
    ForIter search_n(ForIter start, ForIter end,
                Size num, Const Т &val);
template <class ForIter, class Size, class T, class BinPred>
    ForIter search_n(ForIter start, ForIter end,
                Size num, Const Т &val, BinPred pfn);

Описание

Внутри некоторой последовательности выполняет поиск другой последовательности

Алгоритм search_n() внутри некоторой последовательности выполняет поиск другой последовательности, которая состоит из num элементов, равных значению val. Последовательность, внутри которой производится поиск, задается параметрами start и end. Если искомая последовательность найдена, возвращается итератор, указывающий на ее начало, В противном случае возвращается итератор end1.

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


upper_bound()

template <class ForIter, class T>
    ForIter upper_bound(ForIter start, ForIter end, const Т &val);
template <class ForIter, class T, class Comp>
    ForIter upper_bound(ForIter start, ForIter end, const Т &val, Comp cmpfn);

Описание

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

Алгоритм upper_bound() находит последний элемент в последовательности, заданной параметрами start и end, который не больше заданного значения val. Алгоритм возвращает итератор для этого элемента.

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


copy_backward()

template <class BiIter1, class BiIter2>
    BiIter2 copy_backward(BiIter1 start, BiIter1 end, BiIter2 result);

Описание

Аналогично copy(), за исключением того, что копирование происходит в обратном порядке

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


reverse_copy()

template <class BiIter, class OutIter>
    OutIter reverse_copy(BiIter first, BiIter last, OutIter result);

Описание

Копирует в обратном порядке диапазон и сохраняет результат в последовательности

Алгоритм reverse_copy() копирует в обратном порядке диапазон, заданный параметрами start и end, и сохраняет результат в последовательности, заданной параметром result. Алгоритм возвращает итератор, указывающий на конец resul't-последовательности.


rotate_copy()

template <class ForIter, class OutIter>
    OutIter rotate_copy(ForIter start, ForIter mid, ForIter end, OutIter result);

Описание

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

Алгоритм rotate_copy() копирует элементы в диапазоне, заданном параметрами start и end, в последовательность, адресуемую параметром result. В процессе копирования выполняется циклический сдвиг влево элементов таким образом, чтобы элемент, заданный параметром mid, стал новым первым элементом. Алгоритм возвращает итератор, указывающий на конец result последовательности.


unique_copy()

template <class ForIter, class OutIter>
    OutIter unique_copy(ForIter start, ForIter end, OutIter result);
template <class ForIter, class OutIter, class BinPred>
    OutIter unique_copy(ForIter start, ForIter end, OutIter result, BinPred pfn);

Описание

Копирует диапазон в новую последовательность, удаляя в процессе копирования повторяющиеся элементы

Алгоритм unique_copy() копирует диапазон, заданный параметрами start1 и end1, удаляя в процессе копирования повторяющиеся элементы. Результат помещается в последовательность, заданную параметром result. Вторая форма позволяет задать бинарный предикат, который определяет, когда один элемент равен другому. Алгоритм unique_copy() возвращает итератор, указывающий на конец диапазона.


replace()

template <class ForIter, class T>
    void replace(ForIter start, ForIter end, const Т bold, Const Т &new);

Описание

Внутри заданного диапазона заменяет элементы, которые имеют заданное значение

Внутри заданного диапазона алгоритм replace() заменяет элементы, которые имеют значение old, элементами, имеющими значение new.


replace_copy()

template <class ForIter, class OutIter, class T>
    OutIter replace_copy(InIter start, InIter end,
                OutIter result, const Т &old, Const Т &new);

Описание

Внутри заданного диапазона копирует элементы в заданную последовательность

Внутри заданного диапазона алгоритм replace_copy() копирует элементы в последовательность, адресуемую параметром result. В процессе копирования происходит замена элементов, которые имеют значение old, элементами, имеющими значение new. Исходный диапазон не изменяется. Алгоритм возвращает итератор, указывающий на конец последовательности, адресуемой параметром result.


replace_copy_if()

template <class ForIter, class OutIter, class UnPred, class T>
    OutIter replace_copy_if(InIter start, InIter end,
                OutIter result, UnPred pfn, Const Т &new);

Описание

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

Внутри заданного диапазона алгоритм replace_copy_if() копирует элементы в последовательность, адресуемую параметром result. В процессе копирования происходит замена элементов, для которых предикат pfn равен значению true, элементами, имеющими значение new. Исходный диапазон не изменяется. Алгоритм возвращает итератор, который указывает на конец последовательности, адресуемой параметром result.


replace_if()

template <class ForIter, class UnPred, class T>
    void replace_if(ForIter start, ForIter end,
            UnPred pfn, Const Т &new);

Описание

Внутри заданного диапазона заменяет элементы, для которых заданный предикат равен значению true

Внутри заданного диапазона алгоритм replace_if() заменяет элементы, для которых предикат pfn равен значению true, элементами, имеющими значение new.


remove()

template <class ForIter, class T>
    ForIter remove(ForIter start, ForIter end, const Т &val);

Описание

Удаляет из заданного диапазона элементы, которые равны заданному значению

Алгоритм remove() удаляет из заданного диапазона элементы, которые равны значению val. Он возвращает итератор, указывающий на конец оставшихся элементов.


remove_copy()

template <class ForIter, class OutIter, class T>
    OutIter remove_copy(InIter start, InIter end, OutIter result, const Т &val);

Описание

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

Алгоритм remove_copy() копирует из заданного диапазона элементы, которые равны значению val, и помещает результат в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.


remove_copy_if()

template <class ForIter, class OutIter, class UnPred>
    OutIter remove_copy_if(InIter start, InIter end,
                OutIter result, UnPred pfn);

Описание

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

Алгоритм remove_copy_if() копирует из заданного диапазона элементы, для которых предикат pfn равен значению true, и помещает результат в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.


remove_if()

template <class ForIter, class UnPred>
    ForIter remove_if(ForIter start, ForIter end, UnPred pfn);

Описание

Удаляет из заданного диапазона элементы, для которых заданный предикат равен значению true

Алгоритм remove_if() удаляет из заданного диапазона элементы, для которых предикат pfn равен значению true. Алгоритм возвращает итератор, указывающий на конец оставшихся элементов.


unique()

template <class ForIter>
    ForIter unique(ForIter start, ForIter end);
template <class ForIter, class BinPred>
    ForIter unique(ForIter start, ForIter end, BinPred pfn);

Описание

Удаляет повторяющиеся элементы из заданного диапазона

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


includes()

template <class InIter1, class InIter2>
    bool includes(InIter1 start1, InIter1 end1,
            InIter2 start2, InIter2 end2);
template <class InIter1, class InIter2, class Comp>
    bool includes(InIter1 start1, InIter1 end1,
            InIter2 start2, InIter2 end2, Comp cmpfn);

Описание

Устанавливает факт включения всех элементов последовательности

Алгоритм includes() устанавливает факт включения всех элементов последовательности, заданной параметрами start2 и end2, последовательностью, заданной параметрами start1 и end1. Алгоритм возвращает значение true, если все элементы одной заданной последовательности обнаружены в другой, и значение false в противном случае.

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


set_difference()

template <class InIter1, class InIter2, class OutIter>
    OutIter set_difference(InIter1 start1, InIter1 end1,
            InIter2 starts, InIter2 end2, OutIter result);
template <class InIter1, class InIter2, class OutIter, class Comp>
    OutIter set_difference(InIter1 start1, InIter1 end1,
            InIter2 start2, InIter2 end2, OutIter result, Comp cmpfn);

Описание

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

Алгоритм set_difference() создает последовательность, которая содержит разность между двумя упорядоченными множествами, определяемыми параметрами start1, end1 и start2, end2, т.е. множество, задаваемое параметрами starts, endS, вычитается из множества, задаваемого параметрами start1, end1. Результат упорядочивается и помещается в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.

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


set_intersection()

template <class InIter1, class InIter2, class OutIter>
    OutIter set_intersection(InIter start1, InIter1 end1,
        InIter2 starts, InIter2 end2, OutIter result);
template <class InIter1, class InIter2, class OutIter, class Comp>
    OutIter set_intersection(InIter start1, InIter1 end1,
        InIter2 starts, InIter2 end2, OutIter result, Comp cmpfn);

Описание

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

Алгоритм set_intersection() создает последовательность, которая содержит пересечение двух упорядоченных множеств, определяемых параметрами start1, end1 и starts, ends, т.е. создаваемая последовательность будет включать только те элементы, которые принадлежат обоим множествам. Результат упорядочивается и помещается в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.

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


set_symmetric_difference()

template <class InIter1, class InIter2, class OutIter>
    OutIter set_symmetric_difference(InIter1 start1, InIter1 end1,
        InIter2 start2, InIter2 end2, OutIter result);
template <class InIter1, class InIter2, class OutIter, class Comp>
    OutIter set_syimmetric_difference(InIter1 start1, InIter1 end1,
        InIter2 start2, InIter2 end2, OutIter result, Comp cmpfn);

Описание

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

Алгоритм set_symmetric_difference() создает последовательность, которая содержит симметричную разность между двумя упорядоченными множествами, определяемыми параметрами start1, end1 и start2, end2, т.е. создаваемая последовательность будет включать только те элементы, которые не являются общими для обоих множеств. Результат упорядочивается и помещается в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.

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


set_union()

template <class InIter1, class InIter2, class OutIter>
    OutIter set_union(InIter1 start1, InIter1 end1,
        InIter2 start2, InIter2 end2, OutIter result);
template <class InIter1, class InIter2, class OutIter, class Comp>
    OutIter set_union(InIter1 start1, InIter1 end1,
        InIter2 start2, InIter2 end2, OutIter result, Comp cmpfn);

Описание

Создает последовательность, которая содержит объединение двух упорядоченных множеств

Алгоритм set_union() создает последовательность, которая содержит объединение двух упорядоченных множеств, определяемых параметрами start1, end1 и start2, end2, т.е. создаваемая последовательность будет включать элементы обоих множеств. Результат упорядочивается и помещается в последовательность, адресуемую параметром result. Алгоритм возвращает итератор, указывающий на конец результата.

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


equal()

template <class InIter1, class InIter2>
    bool equal(InIter1 start1, InIter1 end1, InIter2 start2);
template <class InIter1, class InIter2, class BinPred>
    bool equal(InIter1 start1, InIter1 end1, InIter2 start2, BinPred pfn);

Описание

Определяет, одинаковы ли два диапазона

Алгоритм equal() определяет, одинаковы ли два диапазона. Диапазон, заданный параметрами start1 и end1, сравнивается с последовательностью, адресуемой параметром start2. Если диапазоны одинаковы, возвращается значение true, в противном случае - значение false.

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


iter_swap()

template <class ForIter1, class ForIter2>
    void iter_swap(ForIter1 i, ForIter2 j);

Описание

Меняет местами значения

Алгоритм iter_swap() меняет местами значения, адресуемые итераторами, которые передаются в качестве параметров.


lexicographical_compare()

template <class InIter1, class InIter2>
    bool lexicographical_compare(InIter1 start1, InIter1 end1,
                    InIter2 start2, InIter2 end2);
template <class InIter1, class InIter2, class Comp>
    bool lexicographical_compare(InIter1 start1, InIter1 end1,
                    InIter2 start2, InIter2 end2, Comp cmpfn);

Описание

Сравнивает последовательности

Алгоритм lexicographical_compare() сравнивает последовательность, заданную параметрами start1 и end1, с последовательностью, заданной параметрами start2 и end2. Алгоритм возвращает значение true, если первая последовательность лексически меньше второй(т.е. если первая последовательность опережает вторую с учетом алфавитного порядка).

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


max()

template <class T>
    const Т &max(const Т &i, const T &j);
template <class T, class Comp>
    const T &max(const T &i, const T &j, Comp cmpfn);

Описание

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

Алгоритм max() возвращает максимальное из двух значений.

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


min()

template <class T>
    const Т &min(const Т &i, const Т &j);
template <class T, class Comp>
    const Т &min(const Т &i, const Т &j, Comp cmpfn);

Описание

Возвращает минимальное из двух значений

Алгоритм min() возвращает минимальное из двух значений.

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


next_permutation()

template <class BiIter>
    bool next_permutation(BiIter start, BiIter end);
template <class BiIter, class Comp>
    bool next_permutation(BiIter start, BiIter end, Comp cmpfn);

Описание

Создает перестановку заданной последовательности

Алгоритм next_permutation() создает следующую перестановку заданной последовательности. Перестановка генерируется в предположении, что последовательность, отсортированная от меньшего к большему, представляет собой первую перестановку. Если следующей перестановки не существует, алгоритм next_permutation() сортирует последовательность в виде ее первой перестановки и возвращает значение false. В противном случае возвращается значение true.

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


prev_permutation()

template <class BiIter>
    bool prev_permutation(BiIter start, BiIter end);
template <class BiIter, class Comp>
    bool prev_permutation(BiIter start, BiIter end, Comp cmpfn);

Описание

Создает предыдущую перестановку последовательности

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

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


reverse()

template <class BiIter>
    void reverse(BiIter start, BiIter end);

Описание

Меняет порядок следования элементов в диапазоне

Алгоритм reverse() меняет порядок следования элементов в диапазоне, заданном параметрами start и end, на противоположный.


rotate()

template <class ForIter>
    void rotate(ForIter start, ForIter mid, ForIter end);

Описание

Выполняет циклический сдвиг влево элементов в диапазоне

Алгоритм rotate() выполняет циклический сдвиг влево элементов в диапазоне, заданном параметрами start и end, таким образом, чтобы элемент, заданный параметром mid, стал новым первым элементом.


swap()

template <class T> void swap(Т &i, Т &j);

Описание

Меняет местами значения

Алгоритм swap() меняет местами значения, заданные ссылками i и j.


swap_ranges()

template <class ForIter1, class ForIter2>
    ForIter2 swap_ranges(ForIter1 start1, ForIter1 end1, ForIter2 start2);

Описание

Выполняет обмен элементов в диапазоне

Алгоритм swap_ranges() выполняет обмен элементов в диапазоне, заданном параметрами start1 и end1, и элементов из последовательности, начало которой задается параметром start2. Алгоритм возвращает указатель на конец последовательности, заданной параметром start2.


count()

template <class InIter, class T>
    size_t count(InIter start, InIter end, const Т &val);

Описание

Возвращает количество элементов с определённым значением в последовательности

Алгоритм count() возвращает количество элементов со значением val в последовательности, границы которой заданы параметрами start и end.


count_if()

template <class InIter, class UnPred>
    size_t count(InIter start, InIter end, UnPred pfn);

Описание

Возвращает количество элементов для которых заданный предикат возвращает значение true

Алгоритм count_if(), действуя в последовательности, границы которой заданы параметрами start и end, возвращает количество элементов, для которых унарный предикат pfn возвращает значение true.


for_each()

template <class InIter, class Func>
    Func for_each(InIter start, InIter end, Func fn);

Описание

Применяет функцию к диапазону элементов

Алгоритм for_each() применяет функцию fn к диапазону элементов, заданному параметрами start и end. Алгоритм возвращает функцию fn.


inplace_merge()

template <class BiIter>
    void inplace_merge(BiIter start, BiIter mid, BiIter end);
template <class BiIter, class Comp>
    void inplace_merge(BiIter start, BiIter mid, BiIter end, Comp cmpfn);

Описание

Объединяет два диапазона

Внутри одной последовательности алгоритм inplace_merge() объединяет диапазон, заданный параметрами start и mid, с диапазоном, заданным параметрами mid и end. Оба диапазона должны быть отсортированы в порядке возрастания. После выполнения алгоритма полученная последовательность сортируется в порядке возрастания.

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


make_heap()

template <class RandIter>
    void make_heap(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void make_heap(RandIter start, RandIter end, Comp cmpfn);

Описание

Создает кучу из последовательности

Алгоритм make_heap() создает кучу из последовательности, заданной параметрами start и end.

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


merge()

template <class InIter1, class InIter2, class OutIter>
    OutIter merge(InIter1 start1, InIter1 end1,
            InIter2 start2, InIter2 end2, OutIter result);
template <class InIter1, class InIter2, class OutIter, class Comp>
    OutIter merge(InIter1 start1, InIter1 end1,
            InIter2 start2, InIter2 end2, OutIter result, Comp cmpfn);

Описание

Оъединяет две упорядоченные последовательности, помещая результат в третью последовательность

Алгоритм merge() объединяет две упорядоченные последовательности, помещая результат в третью последовательность. Объединяемые последовательности задаются параметрами start1, endl и start2, end2. Результат помещается в последовательность, адресуемую параметром result. Возвращается итератор, указывающий на конец результирующей последовательности.

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


pop_heap()

template <class RandIter>
    void pop_heap(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void pop_heap(RandIter start, RandIter end, Comp cmpfn);

Описание

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

Алгоритм pop_heap() меняет местами элементы start и end - 1, а затем перестраивает кучу, используя диапазон, определяемый параметрами start и end - 1. Таким образом, первый элемент исходной кучи удаляется и создается новая куча, состоящая из оставшихся элементов. Хотя элемент из кучи удален, он по-прежнему присутствует в контейнере.

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


push_heap()

template <class RandIter>
    void push_heap(RandIter start, RandIter end);
template <class RandIter, class Comp>
    void push_heap(RandIter start, RandIter end, Comp cmpfn);

Описание

Помещает элемент в конец кучи

Алгоритм push_heap() помещает элемент в конец кучи. Предполагается, что диапазон, заданный параметрами start и end, представляет действительную кучу.

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


transform()

template <class InIter, class OutIter, class Funс>
    OutIter transform(InIter start, InIter end,
                OutIter result, Func unaryfunc);
template <class InIter1, class InIter2, class OutIter, class Func>
    OutIter transform(InIter1 start1, InIter1 end1, InIter2 start2,
                OutIter result, Func binaryfunc);

Описание

Применяет функцию к диапазону элементов и сохраняет результат в последовательности

Алгоритм transform() применяет функцию к диапазону элементов и сохраняет результат в последовательности, заданной параметром result. В первой форме диапазон задается параметрами start и end. Применяемая функция задается параметром unaryfunc. Она принимает значение элемента в качестве параметра и должна возвратить преобразованное значение.

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

Обе версии возвращают итератор, указывающий на конец результирующей последовательности.

Совет программисту

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

Копировать
// Пример использования алгоритма преобразования transform().
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

// Простая функция преобразования,
int xform(int i) {
    return i*i; // квадрат исходного значения
}

int main()
{
    list<int> xl;

    int i;

    //Помещаем значения в список.
    for(i=0; i<10; i++) xl.push_back(i);

    cout << "Исходное содержимое списка xl: ";
    list<int>::iterator p = xl.begin();
    while(p != xl.end()){
        cout << *p << " ";
        p++;
    }

    cout << endl;

    // Преобразуем список xl.
    p = transform(xl.begin() , xl.end(), xl.begin(), xform);

    cout << "Преобразованное содержимое списка xl:";

    p = xl.begin();
    while(p!= xl.end()) {
        cout << *p << " ";
        p++;
    }

    return 0;
}

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

Копировать
Исходной содержимое списка xl: 		0 1 2 3 4 5 6 7 8 9
Преобразованное содержимое списка xl: 	0 1 4 9 16 25 36 49 64 81

Как видите, каждый элемент в списке xl возведен в квадрат.


Untitled

Справочник C/C++

Последняя версия справочника находится по адресу: http://devenv.narod.ru/

Содержание в данном рукаводстве принадлежит его авторам

Copyright © 2006 Morden


сору()

template <class InIter, class OutIter>
    OutIter copy(InIter start, InIter end, OutIter result);

Описание

Копирует последовательность и помещает результат в другую последовательность

Алгоритм copy() копирует последовательность, границы которой заданы параметрами start и end, и помещает результат в последовательность, адресуемую параметром result. Алгоритм возвращает указатель на конец результирующей последовательности. Диапазон копируемой последовательности не должен перекрывать диапазон последовательности, заданной параметром result.