\documentclass[10pt,twocolumn,a4paper,twoside]{report} \usepackage[koi8-u]{inputenc} \usepackage[russian]{babel} % \usepackage[T1]{fontenc} \usepackage{fancyhdr} \usepackage[includehead,includefoot]{geometry} \geometry{a4paper,top=7mm,bottom=7mm,footskip=1cm,left=15mm,right=7mm,twoside} % preamble \pagestyle{fancy} \title{``C/C++'' --- кратко обо всём} \date{\today} \author{Роман Савоченко \\rom\_as@diyaorg.dp.ua} \newcommand{\mycom}[3]{\rule{1ex}{1ex}\enskip\bf{#1}\it{#2}\rm{#3[5pt]}} \newcommand{\slh}{\backslash} %\newcommand{\mycom}[3]{\vspace[5pt] \rule{1ex}{1ex} \bf{#1}\it{#2}\rm{#3[5pt]}} %\let\underscore=\_ \catcode`_=13 %\def_{\underscore\penalty75\relax} \begin{document} \footnotesize {\setlength{\parskip}{0pt}\maketitle\tableofcontents} \chapter{Язык ``C/C++''} \section{Ключевые слова С/С++} \begin{tabular}{|l|l|l|l|} \hline \multicolumn{4}{|l|}{Ключевые слова для С/С++}\\ \hline auto & break & case & char \\ 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 \\ \hline \multicolumn{4}{|l|}{Ключевые слова только для С++}\\ \hline asm & bool & catch & class \\ const_cast & delete & dynamic_cast & explicit \\ false & friend & inline & mutable \\ namespace & new & operator & private \\ protected & public & reintepret_cast & static_cast \\ template & this & throw & true \\ try & typeid & typename & using \\ virtual & wchar_t & & \\ \hline \end{tabular} \section{Постоянные} \begin{tabular}{|l|l|} \hline \multicolumn{2}{|c|}{\textbf{Целые константы}} \\ \hline Десятичные & цифры 0-9;(12, 111, 956) \\ Восьмеричные & цифры 0-7;(012=10, 011=73, 076=62) \\ Шестнадцатеричные & цифры 0-9,буквы A-F или a-f \\ & (0x12=18, 0x2f=47, 0XA3=163) \\ \hline \multicolumn{2}{|c|}{\textbf{Длинные целые константы}}\\ \hline Десятичная & 12l=12, 956L=956; \\ Восьмеричные & 012l=10, 076L=62; \\ Шестнадцатеричные & 0x12l=18, 0XA3L=163.\\ \hline \multicolumn{2}{|c|}{\textbf{Беззнаковые целые константы}}\\ \hline Десятичная & 12u=12, 956U=956; \\ Восьмеричные & 012u=10, 076U=62; \\ Шестнадцатеричные & 0x12u=18, 0XA3U=163.\\ \hline \multicolumn{2}{|c|}{\textbf{Константы с плавающей точкой}}\\ \hline \multicolumn{2}{|l|}{Всегда представляются типами float, double и long double:}\\ \multicolumn{2}{|l|}{345. = 345; 2.1e5 = 210000; .123E3fL = 123; 4037e-5l = .04037}\\ \hline \multicolumn{2}{|c|}{\textbf{Символьные константы}}\\ \hline \multicolumn{2}{|l|}{Состоит из одного символа кода ASCII, заключеного в}\\ \multicolumn{2}{|l|}{апострофы: 'A'; 'a'; '7'; '\$'.}\\ \multicolumn{2}{|l|}{Многобайтовые символы: L'ab'.}\\ \multicolumn{2}{|l|}{Специальные символы:}\\ \verb+\a+ & звонок \\ \verb+\b+ & возврат на один символ назад\\ \verb+\f+ & перевод страницы\\ \verb+\n+ & новая строка\\ \verb+\r+ & перевод каретки\\ \verb+\t+ & горизонтальная табуляция\\ \verb+\v+ & вертикальная табуляция\\ \verb+\'+ & апостроф\\ \verb+\"+ & двойные кавычки\\ \verb+\\+ & обратная дробная черта\\ \verb+\?+ & вопросительный знак\\ \verb+\23+ & символ задан десятичным числом\\ \verb+\0x23+ & символ задан шестнадцатеричным числом\\ \verb+\023+ & символ задан восьмеричным числом\\ \hline \multicolumn{2}{|c|}{\textbf{Строковые константы (литералы)}}\\ \hline \multicolumn{2}{|l|}{Представляет последовательность символов кода ASCII,}\\ \multicolumn{2}{|l|}{заключённой в кавычки: "строка".}\\ \hline \end{tabular} \section{Переменные} \subsection{Основные типы переменных} \begin{tabular}{|l|l|l|} \hline Тип (байт_сист) & Диапазон значений \\ \hline bool (1) & false=0; true=1 \\ char (1) & -128\dots127 \\ int (2_16) & -32.768\dots32.767 \\ int (4_32) & $-2^{31}$ \dots $2^{31}$ \\ short & -32.768\dots32.767 \\ long (4_32) & $-2^{31}$ \dots $2^{31}$ \\ long (8_64) & $-2^{63}$ \dots $2^{63}$ \\ long long (8) & $-2^{63}$ \dots $2^{63}$ \\ unsigned char (1) & 0 \dots 255 \\ unsigned (2_16) & 0 \dots 65535 \\ unsigned (4_32) & 0 \dots $2^{32}$ \\ unsigned short (2) & 0 \dots 65535 \\ unsigned long (4_32) & 0 \dots $2^{32}$ \\ unsigned long (8_64) & 0 \dots $2^{64}$ \\ unsigned long long (8) & 0 \dots $2^{64}$ \\ enum (2_16) & 32.768\dots32.767 \\ enum (4_32) & $-2^{31}$ \dots $2^{31}$ \\ float (4) & $3.4*10^{38}$ (7 знаков) \\ double (8) & $3.4*10^{308}$ (15 знаков) \\ long double (12) & $3.4*10^{4932}$ (19 знаков) \\ \hline \end{tabular} \subsection{Перечислимый тип (enum)} Определяет тип enum и-или enum переменную. Если фигурные скобки заданы то ключевое слово enum объявляет тип enum, состоящий из набора именованных целочисленных констант. Переменная типа enum хранит одно из значений, определенных типом enum. Таким образом, enum переменная всегда имеет тип int. Enum может использоваться, для объявления констант, которые могут использовать имена без объявления переменных для них, как показано в следующем примере: \begin{verbatim} enum DAYS { saturday, sunday = 10, monday, tuesday, wednesday, thursday, friday } today; enum DAYS yesterday = monday; DAYS yesterday = monday; // C++ int tomorrow = wednesday; \end{verbatim} \subsection{Структура (struct)} Объявляет тип структуры и-или переменную структуры. Если заданы фигурные скобки то определяется структурный тип. Безымянные разрядные поля могут использоваться для выравнивания. \par Если фигурные скобки не заданы то ключевое слово \emph{struct} используется для определения переменной структуры. В языке C++ добавлена возможность использования в структуре ключевых слов public, private, protect: \begin{verbatim} struct my_str; //my_str - как прототип, определена позже struct POINT { int x; int y; } here = { 20, 40 }; struct POINT there, *ther1; ther1->x = 2; struct CELL { //Выбор количества битов для элементов unsigned character : 8; // 00000000 ???????? unsigned foreground : 3; // 00000??? 00000000 unsigned intensity : 1; // 0000?000 00000000 unsigned blink : 1; // ?0000000 00000000 unsigned :1 // заполнитель } screen[25][80]; POINT example(POINT there) { there.x = 3; there.y = 5; }; \end{verbatim} \subsection{Тип объединение (union)} Объявляет тип - объединение, и-или переменную объединения. Если фигурные скобки заданы то, union объявляет тип объединения, состоящий из последовательности переменных, значения (известных как элементы объединения) которых могут иметь различные типы. Переменная типа union может содержать один элемент любого типа, определенного объединением. Размером объединения является размер самого большого типа в объединении. Переменная может быть определена, указанием ее имени после заключительной фигурной скобки. Если фигурные скобки не даны, то ключевое слово union используется, для определения переменной объединения. Например: \begin{verbatim} union UNKNOWN { char ch; int i; long l; float f; double d; } var1; // Variable of type UNKNOWN union UNKNOWN var2; // Variable of type UNKNOWN var1.i = 6; // Use variable as integer var2.d = 5.327; // Use variable as double \end{verbatim} C++ Поддерживает анонимные объединения: \begin{verbatim} union { int my_data; float this_data; }; my_data=3 \end{verbatim} \subsection{Пустой тип (void)} Если этот тип используется как тип возврата из функции то функция не возвращает значений. Если используется как список параметров функции, то входные параметры у функции отсутствуют. Если используется указатель на тип void то его при использовании необходимо приводить к конкретному типу. \subsection{Сокращенный тип (typedef)} Описание typedef используется для замены сложных типов данных или создания своих специфических типов данных: \begin{verbatim} typedef unsigned long int ULINT; ULINT my_const; \end{verbatim} \subsection{Тип класс (class)} \subsubsection{Общие понятия} В С++ добавлен класс - расширение понятия структуры. Память при определении класса не выделяется. Класс имеет имя (тег) и состоит из полей, представляющих его члены. В С++ допускается использование вложенных классов. Ключевое слово public определяет те члены класса, к которым имеется прямой доступ. Ключевое слово private используется для сокрытия определенных деталей класса, которые доступны только функциям членам класса и дружественным функциям. Все члены класса по умолчанию считаются приватными. Ключевое слово protected используется для открытия доступа только членам этого класса и членам производных от него классов. Функции класса могут определятся как внутри(увеличивается объем программы и скорость выполнения) так и вне(уменьшается объем программы и скорость выполнения) его тела. При создании в программе объекта экземпляра, его членам присваиваются некоторые начальные значения эту операцию выполняет специальная функция - конструктор имя которой совпадает с именем класса. Для освобождения памяти и других операций при закрытии класса используется деструктор имя которого совпадает с именем класса и с добавлением впереди символа "\verb+~+". \parДля присваивания переменной одного класса переменной другого класса можно в классе использовать оператор: \verb+operator char *()+ в котором описывается процедура преобразования одной переменной в другую что позволит в дальнейшем упростить обмен: title=big_book. \par Одинаковые классы допускают копирования содержимого из одного класса в другой. \par Конструкторы с одним параметром определённого типа могут использоваться для неявного преобразования типов (от типа параметра к типу класса). Для исключения этого нужно использовать директиву \textbf{explicit}. \begin{verbatim} class book { public: char title[256]; char author[64]; book(char *title="A", char *autor="B", char *publisher= "C") { strcpy(book::title, title); strcpy(book::author, author); strcpy(book::publisher, publisher); }; ~book(void); char *get_price(*publisher) {*publisher}; char show_title(void); private: char publisher[256]; }; book diary; book::~book(void) { cout << ?Уничтожение экземпляра << title << '\n'; }; void book::show_title(void) {cout << title << '\n'; }; book tips(?Jamsa's 1001 C/C++?, ?Jamsa?, ?Jamsa Press?); } \end{verbatim} \subsubsection{Дружественные классы и члены} Дружественные классы - friend указывает на класс который может использовать private члены текущего класса. Есть возможность узкого указания на член класса friend имеющего доступ к private членам текущего класса. Кроме того есть возможность создавать взаимные friend - классы. Дружественная функция может не принадлежать ни какому классу т.е быть автономной. \begin{verbatim} class book { public: char title[256]; char author[64]; friend class Reader::show_reader(void); private: char publisher[256]; }; class Reader { public: Reader (char *name) {strcpy(Reader::name, name); }; void show_reader(class book book) {cout<<"Читатель"<base_mess(); base_pointer->show_mess(); base_pointer = new Der; base_pointer->der_mess(); base_pointer->show_mess(); } \end{verbatim} \subsubsection{Инициализаторы} Для инициализации членов данных из конструктора можно использовать инициализаторы. Которые являются единственным способом инициализации константных членов класса: \begin{verbatim} class Time { public: Time(); const int time; }; Time::Time() : time(10) {...}; \end{verbatim} \subsubsection{Композиция} Классы допускают композицию т.е включение одного объекта в другой. Включенные объекты уничтожаются после уничтожения содержащего их объекта. \begin{verbatim} class Time { public: Time(); const int time; }; class Date { public Date(); private const Time time; } Date::Date : time() {...}; \end{verbatim} \subsubsection{Ссылка на себя} В классах есть возможность ссылаться на себя. Эта функция обеспечивается ключевым словом которое содержит адрес текущего объекта. Может использоваться сцепления путём возврата адреса или ссылки объекта его членами функциями. \subsubsection{Proxy классы} Proxy классами называются классы которые призваны скрывать private члены классов закрытой реализации библиотеки. Создаются они путем создания указателя на скрываемый класс в private поле proxy класса:\\ \begin{verbatim} class Sequry { public void setValue(int x); private: int value; }; class Proxy { public setValue(int x) {ptr->setValue(x);}; private Sequry *ptr; } \end{verbatim} \section{Синтаксис} \subsection{Полезные обороты} \begin{itemize} \item Приведение типов:\\ \verb+long с = (long)a;+ - традиционная запись;\\ \verb+long с = long(a);+ - функциональная запись;\\ \item Декларация нескольких переменных одного типа: \begin{verbatim} int x, // x y, // y z; // z \end{verbatim} \item Варианты использования параметров функций: \begin{itemize} \item для меняющихся аргументов необходимо использовать ссылки или указатели (ссылки на массив);\\ \verb+int test(int *ptr, int &alias, int[] &mass );+ \item для неизменяемых аргументов использовать прямую передачу по значению ;\\ \verb+int test(int value);+ \item для больших неизменяемых аргументов использовать константные ссылки или указатели на константные данные;\\ \verb+int test(const int &value, const int *ptr);+ \end{itemize} \item Использование ключевого слова const (запрет модификации): \begin{itemize} \item Неконстантный указатель на неконстантные данные;\\ \verb+void test(char *str);+ \item Неконстантный указатель на константные данные;\\ \verb+void test(const char *str);+ \item Константный указатель на неконстантные данные;\\ \verb+int * const ptr = &x;+ \item Константный указатель на константные данные;\\ \verb+const int * const ptr = &x;+ \item Константный класс. Не позволяет запускать неконстантные функции члены, кроме конструктора и деструктора;\\ \verb+const Time moon(12,0,0);+ \item Константная функция. Недопускется ничего (кроме mutable членов) модифицировать в константных функциях, а также вызывать неконстантные функции;\\ \verb+int getValue() const;+ \end{itemize} \item Предотвращение многократного включения заголовочных файлов: \begin{verbatim} #ifndef TEST_H #define TEST_H #endif \end{verbatim} \item Коментирование/исключение больших кусков кода: \begin{verbatim} #if 0 #endif \end{verbatim} \item Использование значений параметров функций по умолчанию: \begin{verbatim} void show_values(int one=1, int two=2, int three=3); show_value(); show_value(23); \end{verbatim} \item Объявление переменных по месту: \begin{verbatim} for (int count = 0; count < 10;count++) \end{verbatim} \item Функции переменного числа параметров: \begin{verbatim} void text(parm x,char *fmt, ...) { char str[100]; va_start (argptr,fmt); vsprintf(str,fmt,argptr); va_end(argptr); printf(str); } text(54,"hello %s","world"); \end{verbatim} \item Указание способа(языка) для которого должна компилироваться функция: \begin{verbatim} extern "C" func(); // В стиле "C" extern "C++" func(): // В стиле "C++" extern "C++" { int func(void); } \end{verbatim} \end{itemize} \subsection{Указатели} Особенностью языка ``С/С++'' является возможность доступа к переменной не только по имени но и с использованием механизма указателей. Для этого в языке предусмотрены символы: ``\&'' и ``*''. \par Символ ``*'' используется для индикации переменной (*ptr), которая расположена в памяти по адресу на который указывает одноимённая переменная без звёздочки. Символ ``\&'' используется как для определения адреса ячейки памяти переменной, так и для определения адреса указателя на переменную. \begin{itemize} \item Назначение адреса указателя \begin{verbatim} int *ptr = (int *)0x0010;} //при инициализации ptr = (int *)0x0010;} //в программе \end{verbatim} \item Присвоение значения непосредственно переменной на которую указывает указатель:\\ \verb+ *ptr = 300 + \item Родовой указатель в ``С/С++'' основан на использовании указателя типа {\bf (void *)}. Ключевое слово {\bf void} говорит об отсутствии данных о размере объекта в памяти. Во всех случаях использования указателя описанного как {\bf void*}, необходимо выполнять операцию явного приведения типа указателя: \begin{verbatim} unsigned long block = 0xffeeddccL; void *ptr = █ unsigned char = *(unsigned char *)ptr; long int four_bytes = *(long int *)ptr; \end{verbatim} \item Определение адреса указателя: \begin{verbatim} int *ptr; k = &ptr; \end{verbatim} \item Указатель на указатель: \begin{verbatim} int data = 5; int *ptr = &data; // ptr[0]==5; int **ptr1 = &ptr; // ptr1[0][0]==5; int ***ptr2 = &ptr1; // ptr2[0][0][0]==5; \end{verbatim} \item Возврат указателя функцией:\\ \verb+bool *cimpare(int, int);+ \item Указатель на функцию:\\ \verb+bool (* compare)(int, int);+ \item Указатели на члены класса (.* и ->*) \begin{verbatim} class Test { public: void funct() { cout << "Функция\n"; } int value; }; Test t; Test *tPtr = &t; void (Test::*memPtr)() = &Test::funct; int Test::*vPtr = &Test::value; (tPtr->*memPtr)(); //косвенный вызов функции cout << (*tPtr).*vPtr << endl; \end{verbatim} \end{itemize} \subsection{Ссылки} Ссылка являются псевдонимом (алиасом) от переменной на которую она ссылается. При изменении ссылаемой переменной изменяется ссылка. В основном ссылки используются при описании параметров функций и указывают что переменная может меняться. \begin{verbatim} int &test(int &x); int data = 5; int &al_data = data; // al_data == 5; al_data = 10; // data == 10; data = 7; // al_data == 7; \end{verbatim} \subsection{Массивы} Как и в других языках ``С/С++'' поддерживает массивы которые тесно переплетаются с указателями. Элементы массива имеют один и тот же тип и расположены в памяти друг за другом. Имя массива также можно воспринимать как указатель на начало массива.\par В отличие от других языков в ``С/С++'' отсутствует специальный строковый тип. Вместо него строковые литералы представляются как одномерный массив элементов типа char оканчивающегося символом ``0''. \begin{itemize} \item Явное указание числа элементов массива и списка начальных значений: \begin{verbatim} char array[] = {'A','B','C','D',0}; char array[] = "ABCD"; char array[5] = {'A','B','C','D',0}; char *string = "ABCD"; string = "ABCD"; \end{verbatim} \item Обращение к элементам массива с помощью указателя: \begin{verbatim} *(array+i); array[i][j]; *(array[i]+j); *(*(array+i)+j); \end{verbatim} \item Многомерные массивы: \begin{verbatim} matrix[2] == &matrix[2][10]; long (* matrix1)[3][2][4]; matrix1 = new long[3][2][4]; char *messages[20] == char messages[20][80]); char string[][80]= { "Первая строка", "Вторая строка", "Следующая строка" }; int m[][3] = { {00}, {10, 11}, {20, 21, 22,} }; char *Names[]= { "Aleksey", "Vladislav", "Vitaly" }; \end{verbatim} \item Массив указателей на функцию: \begin{verbatim} int (* fcmp[5])(int) = {cmp_name, cmp_title, cmp_year, cmp_price, cmp_totaly}; void (* func[3])(int); //определение (* func[choice])(choice); //вызов \end{verbatim} \end{itemize} \subsection{Перегрузка функций} В языке C++ разрешается иметь множество функций с одним и тем же именем, но отличающиеся типами параметров или их количеством: \begin{verbatim} int sum(int *array, int element) { } float sum(float *array, int element) { } \end{verbatim} \subsection{Перегрузка операций} Перегрузкой операция является процедура расширения функций существующих операция для новых типов x(объектов). Операции допускающие перегрузку указанны в табл.\ref{relop}. При перегрузке операций их старшинство и ассоциативность не изменяется. \begin{itemize} \item Унарная операция (префиксная).\\ \textbf{Операция:} \\ \textit{!S}\\ \textbf{Вызывает:} \\ \textit{S.operator!()} \\ \textit{operator!(S)} \\ \textbf{Объявляется:} \\ \textit{bool operator!() const;} \\ \textit{friend bool operator!(const String \&);} \item Унарная операция (постфиксная).\\ \textbf{Операция:} \\ \textit{d1++}\\ \textbf{Вызывает:} \\ \textit{d1.operator++(0)} \\ \textit{operator++(d1,0)} \\ \textbf{Объявляется:} \\ \textit{Date operator++(int);} \\ \textit{friend Date operator++(Date \&,int);} \item Бинарная операция.\\ \textbf{Операция:} \\ \textit{y+=z}\\ \textbf{Вызывает:} \\ \textit{y.operator+=(z)} \\ \textit{operator+=(y,z)} \\ \textbf{Объявляется:} \\ \textit{const String \&operator+=(const String \&);} \\ \textit{friend const String \&operator+=(String \&, const String \&);} \item Вызов функции.\\ \textbf{Операция:} \\ \textit{string(2,2);}\\ \textbf{Вызывает:} \\ \textit{string.operator()(2,2);} \\ \textbf{Объявляется:} \\ \textit{String operator()(int,int);} \item Приведение типов.\\ \textbf{Операция:} \\ \textit{(char *)S;}\\ \textbf{Вызывает:} \\ \textit{S.operator char*()} \\ \textbf{Объявляется:} \\ \textit{String operator char*();} \\ \textit{String(char *);} - конструктор неявного преобразования. \item операция 'new'.\\ \textbf{Операция:} \\ \textit{Class1 *cls = new Class1;}\\ \textit{Class1 *cls = new ("class") Class1;}\\ \textbf{Вызывает:} \\ \textit{Class1 *cls = Class2.operator new(sizeof(Class1));} \\ \textit{Class1 *cls = Class2.operator new("class", sizeof(Class1));} \\ \textbf{Объявляется:} \\ \textit{void* Class2::operator new(size_t size);} \\ \textit{void* Class2::operator new(string modul, size_t size);} \\ \item операция 'delete'.\\ \textbf{Операция:} \\ \textit{delete cls;}\\ \textbf{Вызывает:} \\ \textit{Class2.operator delete(cls);} \\ \textbf{Объявляется:} \\ \textit{void* Class2::operator delete(void *addr);} \\ \end{itemize} \begin{table}[!hbp] \caption{\bf{Операции допускающие перегрузку}} \label{relop} \begin{tabular}{|c|c|c|c|c|c|c|c|} \hline + & - & * & / & \% & \verb+^+ & \& & | \\ \hline \verb+~+ & ! & = & < & > & += & -= & *= \\ \hline /= & \%= & \verb+^=+ & \&= & |= & < < & > > & > >= \\ \hline < <= & == & != & <= & >= & \&\& & || & ++ \\ \hline - - & ->* & , & -> & [] & () & new & delete \\ \hline new[] & delete[] & & & & & & \\ \hline \end{tabular} \end{table} \subsection{Шаблоны} Шаблоны определяются с помощью ключевого слова \textbf{template} и предназначены для определения функций и классов способных работать с различными типами входных и выходных параметров. Шаблоны и наследование связаны следующим образом: \begin{itemize} \item шаблон класса может быть производным от шаблонного класса; \item шаблон класса может являться производным от нешаблонного класса; \item шаблон класса может быть производным от шаблона класса; \item нешаблонный класс может быть производным от шаблона класса; \end{itemize} Шаблонные классы: \begin{itemize} \item Объявление: \begin{verbatim} template class Tree { public: Tree( const Templ& n ); insertN(const Templ &); } template Tree::Tree(const Templ& n) { }; \end{verbatim} \item Использование: \begin{verbatim} Tree NewTree(23); Tree NewTree(56.8); \end{verbatim} \end{itemize} Шаблонные функции: \begin{itemize} \item Объявление: \begin{verbatim} template // или template ; T max(T val1, T val2, T val3) { T max = val1; if(val2 > max) max=val2; if(val3 > max) max=val3; return max; } \end{verbatim} \item Использование: \begin{verbatim} int rez = max(1,10,3); float rez = max(0.5,9.99,6.78); \end{verbatim} \end{itemize} Шаблоны и друзья: \begin{verbatim} friend void f1(); //друг любого класса friend void f2(x &); //друг конкретного класса friend void A::f4(); //друг любого класса friend void C::f5(x &); //друг конкретного класса friend class Y; //класс Y дружественен любому классу friend class Z; //класс Y дружественен конкретному классу \end{verbatim} \subsection{Обработка исключительных ситуаций} В языке C++, добавлен мощный аппарат обработки исключительных ситуаций. Этот аппарат позволяет отлавливать как все типы исключений, так и конкретно взятый тип исключений. Так если записать \verb+catch(...)+, то будут отлавливаться все типы исключений. Кроме того обработка исключительных ситуаций оказываться вынесенной из "основной линии" выполнения программы. Для генерации повторных исключений в \textbf{catch} опускаться использование \textbf(throw) без параметров. Если происходит глубоковложенное исключение, то выполняется "раскрутка" стека для возвращения до ближайшего \textbf{catch} Обработка исключительных ситуаций описывается следующим образом: \begin{verbatim} try //начало блока испытания { if() throw MyType(); // Принудительная генерация // (точка генерации) } catch(MyType &Mt) {...}; // Отлов и обработка в блоке // перехвата \end{verbatim} Для ограничения круга генерируемых исключений функцией, можно указать спецификацию исключений для функции: \begin{verbatim} int g(double h) throw(a,b,c) //может генер. a,b,c и //unexpected int g(double h) throw() //не может генерировать //(кроме unexpected) int g(double h) //может генерировать все \end{verbatim} Стандартные обработчики исключений: \begin{itemize} \item{bad_alloc (exception)} - Ошибка выделения памяти с помощью new; \item{bad_cast (exception)} - генерируется dynamic_cast; \item{bad_exception (exception)} - Неожиданое исключение генерируется в случае неожиданного исключения при включении std::bad_exception в throw-список функции; \item{bad_typeid (exception)} - генерируется typeid; \item{invalid_argument (exception)} - Функции передан недопустимый аргумент; \item{logic_error (exception)} - исключения в логических операциях; \item{length_error (exception)} - Длина более максимально допустимой; \item{out_of_range (exception)} - Аргумент вне допустимого диапазона; \item{runtime_error (exception)} - Ошибка в программе; \item{overflow_error (runtime_error)} - Математическая ошибка переполнения сверху; \item{underflow_error (runtime_error)} - Математическая ошибка переполнения снизу; \end{itemize} Чтоб избежать утечек памяти, обусловленных забыванием вызова delete после new, можно использовать шаблон auto_ptr, который будет автоматически разрушаться.\\ На базе класса exception, можно генерировать собственные исключения. \section{Операции} \begin{tabular}{|p{14mm}|p{53mm}|p{14mm}|} \hline \it Символ & \it Описание & \it Направл. \\ \hline \multicolumn{3}{|c|}{Самый высокий приоритет}\\ \hline ::(унарн) & Область видимости & справа \\ ::(бинар) & Область видимости & слева \\ \hline () & Вызов функции & слева \\ \verb+[]+ & Выделение элемента массива & слева \\ -> & Выделение элемента структуры адресуемой указателем & слева \\ . & Выделение элемента структуры или объединения & слева \\ ->* & Обращение по адресу объекта к адресу функции объекта & слева \\ .* & Обращение через объект к адресу функции объекта & слева \\ \hline ++ & Пост-приращение & справа \\ -- -- & Пост-декремент & справа \\ + & Унарный плюс & справа \\ - & Унарный минус & справа \\ ! & Логическое отрицание & справа \\ \verb+~+ & Побитовое отрицание & справа \\ (тип) & Приведение типов < (float)i > & справа \\ \verb+*+ & Обращение по адресу переменной & справа \\ \& & Определение адреса переменной & справа \\ sizeof & Определение размера, в байтах & справа \\ \hline * & Умножение & слева \\ / & Деление & слева \\ \% & Остаток от деления & слева \\ \hline + & Сумма & слева \\ - & Разность & слева \\ \hline << & Сдвиг влево & слева \\ >> & Сдвиг вправо & слева \\ \hline < & Меньше & слева \\ <= & Меньше и равно & слева \\ > & Больше & слева \\ >= & Больше и равно & слева \\ \hline == & Равно & слева \\ != & Неравно & слева \\ \hline \& & Поразрядный "И" & слева \\ \hline \verb+^+ & Поразрядный "исключающий ИЛИ" & слева \\ \hline | & Поразрядный "ИЛИ" & слева \\ \hline \&\& & Логический "И" & слева \\ \hline || & Логический "ИЛИ" & слева \\ \hline ?: & Условная операция & справа\\ & \emph{int i=(val>=0)?val:-val;} & \\ \hline = & Присваивание & справа \\ += -= *= /= \%= |= \&= \^= <= >= & Составное присваивание & справа \\ \hline , & Операция последования (последовательность выполнения) & слева \\ \hline \end{tabular} \section{Операторы} \subsection{C} \mycom{break\\} {} {Прекращает выполнение ближайшего внешнего оператора: do, for, switch или while.\\ {\bf for(;;) \{ printf("TEST"); break; \} } \\ } \mycom{case\\} {} { Оценивает <выражение> и выполняет любое утверждение, связанное с <постоянной-выражением>. Если не имеется никакого соответствия с постоянным выражением, утверждение, связанное с заданным по умолчанию ключевым словом выполняется. Если заданное по умолчанию ключевое слово не используется, управление переходит к утверждению после блока переключателя.\\ } \mycom{continue\\} {for(i=0;i<2;i++)\{printf("test"); continue; exit(1);\} \\} {Передает управление в начало оператора цикла do, for, или while вызывая следующую итерацию.\\} \mycom{default\\}{} {Используется в \textbf{switch} для выполнения действий если не выполняется не одно из условий.\\} \mycom{do\\} {do оператор while(выражение);\\} {Выполняет <оператор>, пока <выражение> истинно. Условие проверяется в конце цикла.\\} \mycom{else\\}{} {Выполняет <выражение1>, если <выражение> истинно (отлично от нуля); если else присутствует, и <выражение> - ложно (нуль), выполняется <выражение2>. После выполнения <выражение1> или <выражение2>, управление переходит к следующему утверждению.\\} \mycom{for\\} {for(init-expr; cond-expr; increment) оператор;\\} {Выполняет <оператор>, пока инициализированное число , над которым производится операция , удовлетворяет условному выражению .\\} \mycom{goto\\}{} {Управления безусловно передается на оператор с меткой <имя:>.\\} \mycom{if\\} {if (выражение) выражение1; [else выражение2;]\\} {Выполняет <выражение1>, если <выражение> истинно (отлично от нуля); если else присутствует, и <выражение> - ложно (нуль), выполняется <выражение2>. После выполнения <выражение1> или <выражение2 >, управление переходит к следующему оператору.\\} \mycom{longjmp\\} {void longjmp(jmp_buf env, int value);\\} {Передает управление по адресу с порядковым номером .\\} \mycom{return\\}{} {Прекращает выполнение текущей функции и возвращает управление вызывающей программе, с возможностью передачи значения выражения.\\} \mycom{setjmp\\} {int setjmp(jmp_buf env);\\} {Запоминает в адрес текущего места в программе для дальнейшего возврата к нему посредством longjmp. Функция возвращает порядковый номер сохраненного адреса начиная с "0".\\} \mycom{switch\\} {switch(выражение)\{ \\ case константа1: выражение1; [break;] \\ case константа(n): выражение(n); [break;] \\ {[default: выражение(n+1);]} \\ \} \\} { Сравнивает <выражение> с константами во всех вариантах case и выполняет оператор связанный с <постоянной-выражением>. Если отсутствует соответствия с постоянных с выражениями то выполняется утверждение, связанное с ключевым словом default. Если ключевое слово default не используется то управление переходит к утверждению после блока переключателя.\\} \mycom{while\\} {while(выражение) оператор;\\} {Выполняет <оператор>, пока <выражение> истинно.\\} \subsection{C++} \mycom{explicit\\}{} {Ставится перед конструктором объекта и предотвращает использование конструктора для неявного преобразования типов.\\} \mycom{namespace\\}{} {Назначение области действия имён:\\ \textbf{namespace Example \{ int myvar; \}\\ k = Example::myvar;}\\} \mycom{this\\}{} {Содержит указатель на собственный объект класса (т.е на себя);\\} \mycom{typeid\\}{} {Возвращает ссылку на объект \textbf{type_info}. Объект \textbf{type_info} - это поддерживаемый системой объект, представляющий тип.\\ \textbf{const char *dataType = typeid(T).name();}\\} \mycom{typename\\}{} {Указывает, что следующий за ним идентификатор обозначает тип. Обычно используется внутри шаблонов.\\} \mycom{using\\}{} {Делает глубоковложенную команду, со специальной областью видимости, видимой по умолчанию:\\ {\bf using std::cout; \\ cout << "test"; \\ using namespace math; } \\} \subsubsection{Операторы преобразования типов} \mycom{static_cast\\}{} {Выполняет стандартные преобразования (статическое):\\ \textbf { int x = static_cast(d);\\ string s = static_cast("ch_string");\\ derivedPtr = static_cast(basePtr);} (преобразование потомка к базовому классу)\\} \mycom{dinamic_cast\\}{} {Выполняет динамическое приведение, иными словами, в процессе выполнения с проверкой возможности приведения. Можно использовать для программной проверки типа наследника из базового класса.\\ \textbf{cylinderPtr = dynamic_cast(shapePtr);\\ if(cylinderPtr != NULL) shapePtr->area(); //Цилиндр}\\} \mycom{const_cast\\}{} {Используется для снятия константности или volatile путём приведения:\\ \textbf{const_cast(this)->number--;} (при вызове из константной функции)\\} \mycom{reinterpret_cast\\}{} {Для нестандартных преобразований:\\ \textbf{count << *reintepret_cast(ptr) << endl;} (преобразует (int *) в (char *) и разыменовует)\\} \subsubsection{Ключевые слова-операторы} Стандарт C++ предоставляет ключевые слова-операторы, которые могут использоваться вместо нескольких операторов C++. \begin{tabular}{|p{12mm}|p{12mm}|p{57mm}|} \hline \it Оператор & \it Слово-оператор & \it Описание \\ \hline \multicolumn{3}{|c|}{Логические операторы-ключевые слова}\\ \hline \verb+&&+ & and & логическое И (AND) \\ \verb+||+ & or & логическое ИЛИ (OR) \\ \verb+!+ & not & логическое НЕ (NOT) \\ \hline \multicolumn{3}{|c|}{Оператор "не равно"-ключевое слово}\\ \hline \verb+!=+ & not_eq & не равно \\ \hline \multicolumn{3}{|c|}{Побитовые операторы-ключевые слова}\\ \hline \verb+&+ & bitand & побитовое И (AND) \\ \verb+|+ & bitor & побитовое включающее ИЛИ (OR) \\ \verb+^+ & xor & побитовое исключающее ИЛИ (OR) \\ \verb+~+ & compl & побитовое инвертирование разрядов \\ \hline \multicolumn{3}{|c|}{Побитовые операторы присваивания-ключевые слова}\\ \hline \verb+&=+ & and_eq & побитовое И (AND) и присваивание\\ \verb+|=+ & or_eq & побитовое включающее ИЛИ (OR) и присваивание\\ \verb+^=+ & xor_eq & побитовое исключающее ИЛИ (OR) и присваивание\\ \hline \end{tabular} \section{Спецификаторы класса памяти} \mycom{auto\\}{} {Указывающий, что переменная имеет локальную (автоматическую) протяженность. Разрушается при выходе из функции.\\} \mycom{register\\}{} {Определяет, что переменная должна быть ,если возможно, сохранена в машинном регистре.\\} \mycom{extern\\}{} {Определяет переменную которая должна быть видна в других объектных модулях.\\} \mycom{mutable\\}{} {Определяет в классе переменную которую можно модифицировать даже из константной функции.\\} \mycom{static\\}{} {Объявляет переменную которая будет являться одной для всех экземпляров функции и которая инициализируется при запуске программы. Статические функции объектов определяются в одном экземпляре и становятся видимыми за пределы класса владельца. Кроме того статическая функция член не может являться константной и имеют доступ только к статическим полям. Static в глобальном отношении может использоваться для ограничения области действия переменной пределами одного файла.\\ \textbf{static int getCount();}\\ } \section{Препроцессор} Препроцессор это часть языка С. Препроцессор считывает исходный код и, отвечает на размещенные в нем директивы, производит модифицированную версию этого исходного кода, которая передаётся компилятору. Подстановки препроцессором выполняются рекурсивно, т.е выполняется многопроходная обработка. \begin{enumerate} \item Определение/удаление макроса: \begin{verbatim} #define VAL_T 345 #undef VAL_T #define VAL_T 234 \end{verbatim} Макрос может быть определён без значения и может использоваться в качестве проверяемого флага. \item Для перевода на другую строку используется \verb+;\+ : \begin{verbatim} #define FILLSCREAN(color) _AX = 0x0600;\ _CX = 0x0000;\ _DX = 0x184f;\ _BH = color;\ geninterrupt(0x10); \end{verbatim} \item Использование параметров: \begin{verbatim} #define min(a,b) ((a) < (b) ? (a) : (b)) result = min(44,uplimit); // result = ((44) < (uplimit) ? (44) : (uplimit)); \end{verbatim} \item Для объединения формальных параметров используются символы \verb+##+ : \begin{verbatim} #define var( i , j ) ( i##j ) // var( x , 6 ) = x6 \end{verbatim} \item Для преобразования фактического параметра в строку используется символ \verb+#+ который помещается перед формальным макропараметром: \begin{verbatim} #define TRACE(flag) printf(#flag "=%d\n", flag) \end{verbatim} \item Вариантный макрос (...): \begin{verbatim} #define err(...) fprintf(stderr,__VA_ARGS__) err("%s %d\n","The error code ",48); // fprintf(stderr,"%s %d\n","The error code ",48); #define errout(a,b,...) \ fprintf(stderr,"File %s Line %d\n",a,b); \ fprintf(stderr,__VA_ARGS__) errout(__FILE__,__LINE__,"Unexpected termination\n"); \end{verbatim} \end{enumerate} \subsection{Директивы Препроцессора} \mycom{_Pragma\\} {_Pragma("GCC poison printf")\\} {Оператор для вызова прагмы из тела макроса.\\} \mycom{\#define\\} {\#define ident ident1; \\} {Заменяет все последующие определения на лексему (совокупность лексем).\\} \mycom{\#elif, \#if \\} { \#if expresion\\ \#elif expresion1\\ \#endif\\ } {Проверяет выражение , связанное с директивами \#if, или \#elif , если выражение истинно (отличный от нуля), то выполняются следующие строки до директив условия или конца условий. Директива \#elif является объединением директив \#else и \#if. Если имеется \#else, то нижестоящие строки выполняются когда выражение в \#if или \#elif имеет нулевое значение. Нельзя использовать в качестве условия оператор sizeof, составные типы, float или enum типы.\\} \mycom{defined\\} { \#if defined(VAR)\\ \#elif !defined(NVAR)\\ \#endif\\ } { Оператор проверки определённости, используется в паре с \#if.\\ } \mycom{\#else\\}{} {Нижестоящие строки выполняются если выражение в \#if, \#ifdef, \#ifndef или \#elif имеет нулевое значение.\\} \mycom{\#endif\\}{} {Указывает на конец условия.\\} \mycom{\#error\\} {\#error сообщение\\} {Генерация сообщения ошибки на stderr и завершения процесса компиляции. \\} \mycom{\#ifdef\\} {\#ifdef \\} {Выполняет последующие строки до \#endif, если был ранее определен.\\} \mycom{\#ifndef\\} {\#ifndef \\} {Выполняет последующие строки до \#endif, если не был ранее определён.\\} \mycom{\#include\\} {\#include \\} {Вставляет содержимое файла в текущий файл. Если путь к имени файла включен в двойные кавычки ,то поиск осуществляется внутри текущего каталога.\\} \mycom{\#include_next\\} {\#include_next \\} {????\\} \mycom{\#line\\} {\#line n file\\} {Изменяет внутренний номер строки компилятора на , а также изменяет внутреннее имя файла на . Текущий номер строки и имя файла доступны через константы препроцессора __LINE__ и __FILE__.\\} \mycom{\#pragma\\} {\#pragma directives\\} {Инструктирует компилятор, о выполнение машинно-специфических возможностей, определенных параметром (таблица \ref{pragma}).\\} \mycom{\#undef\\} {\#undef identifier\\} {Удаляет текущее определение , который был предварительно определен директивой \#define.\\} \mycom{\#warning\\} {\#warning сообщение\\} {Генерация сообщения предупреждения на stderr и продолжение компиляции. \\} \begin{table}[!hbp] \caption{Параметры директивы pragma, препроцессора} \label{pragma} \begin{tabular}{|p{20mm}|p{65mm}|} \hline Имя & Назначение \\ \hline pack & Определяет, как компилятор выравнивает данные при сохранении в памяти. Может также использоваться с, вталкиванием и выталкиванием параметров.\newline \#pragma pack(n) \newline \#pragma pack(push, n) \newline \#pragma pack(pop)\\ \hline \end{tabular} \end{table} \begin{table}[!hbp] \caption{Предопределённые символьные константы} \label{prepconst} \begin{tabular}{|p{30mm}|p{50mm}|} \hline Имя & Назначение \\ \hline \verb+__BASE_FILE__+ & Полный путь к каталогу исходного файла;\\ \verb+__CHAR_UNSIGNED__+ & Указывает что символьный тип является безнаковым;\\ \verb+__cplusplus+ & Указывает что исходный код является программой на языке С++;\\ \verb+__DATE__+ & Дата компиляции исходного файла (строка);\\ \verb+__FILE__+ & Имя исходного файла (строка);\\ \verb+__func__+ & Имя текущей функции;\\ \verb+__FUNCTION__+ & ----//----;\\ \verb+__PRETTY_FUNCTION__+ & Полное имя текущей функции. Для C++ включает имена классов;\\ \verb+__INCLUDE_LEVEL__+ & Глубина включения (include) файла;\\ \verb+__LINE__+ & Номер текущей строки исходного текста (целое число);\\ \verb+__NO_INLINE__+ & Указывает на отсутствие inline-функций;\\ \verb+__OBJC__+ & Программа на языке Objective-C;\\ \verb+__OPTIMIZE__+ & Назначен любой уровень оптимизации;\\ \verb+__OPTIMIZE_SIZE__+ & Оптимизация размера программы;\\ \verb+__STDC__+ & Компилятор соответствует правилам стандарта языка C;\\ \verb+__TIME__+ & Время компиляции исходного файла (строка);\\ \verb+__VERSION__+ & Полный номер версии;\\ \hline \end{tabular} \end{table} \section{Стандартные заголовочные файлы} \mycom{assert.h | cassert (ANSI)\\}{} {Содержит макросы и информацию, для дополнительной диагностики, помогающей при отладке программы.\\} \mycom{bios.h\\}{} {BIOS сервисные функции (INT 10).\\} \mycom{conio.h\\}{} {Подпрограммы Ввода - вывода.\\} \mycom{ctipe.h | cctype (ANSI)\\}{} {Символьная классификация.\\} \mycom{direct.h\\}{} {Управление каталогами.\\} \mycom{dos.h\\}{} {MS-DOS функции (INT 21).\\} \mycom{env.h (POSIX)\\}{} {Содержит прототипы для окружений строковых функций.\\} \mycom{errno.h (ANSI)\\}{} {Переменные, и утилиты обработки ошибок.\\} \mycom{fcntl.h (POSIX)\\}{} {Флажки, используемые в функциях open и sopen.\\} \mycom{float.h | cfloat (ANSI)\\}{} {Содержит предельные размеры переменных с плавающей точкой для данной системы.\\} \mycom{graph.h\\}{} {Программы для работы с графикой низкого уровня.\\} \mycom{io.h\\}{} {Низкоуровневый ввод-вывод.\\} \mycom{limits.h | climits (ANSI)\\}{} {Содержит общие ограничения системы.\\} \mycom{locale.h (ANSI)\\}{} {Содержит информацию для выполнения локализации ПО.\\} \mycom{malloc.h\\}{} {Содержит прототипы функций распределения памяти.\\} \mycom{math.h | cmath (ANSI)\\}{} {Содержит прототипы математических библиотечных функций.\\} \mycom{memory.h\\}{} {Подпрограммы манипуляции с буферами.\\} \mycom{serach.h\\}{} {Функции поиска и сортировки.\\} \mycom{setjmp.h (ANSI)\\}{} {Прототипы Функций setjmp и longjmp (безусловного перехода)\\} \mycom{sygnal.h (ANSI)\\}{} {Прототипы функций для работы с сигналами и описание самих сигналов.\\} \mycom{stdarg.h (ANSI)\\}{} {Содержит макрокоманды для работы с функциями имеющими список параметров переменной длины.\\} \mycom{stdio.h | cstdio (ANSI)\\}{} {Содержит прототипы стандартных библиотечных функций ввода-вывода и используемую ими информацию.\\} \mycom{stdlib.h | cstdlib (ANSI)\\}{} {Содержит прототипы функций для преобразования чисел в текст, текста в числа, для выделения памяти, генерации случайных чисел и других полезных операций.\\} \mycom{string.h | cstring (ANSI)\\}{} {Содержит прототипы функций для обработки строк стиля C.\\} \mycom{strstream.h | strstream (ANSI)\\}{} {Для формирования строк через поток.\\} \mycom{time.h | ctime (ANSI)\\}{} {Содержит прототипы функций для работы со временем и датами.\\} \mycom{iostream\\}{} {Содержит прототипы функций стандартного ввода и вывода.\\} \mycom{iomanip\\}{} {Содержит прототипы функций для операций с потоками, дающие возможность форматировать потоки данных.\\} \mycom{fstream\\}{} {Содержит прототипы функций для операций с файловым вводом-выводом.\\} \mycom{utility\\}{} {Содержит классы и функции, используемые многими заголовочными файлами стандартной библиотеки.\\}{} \mycom{vector, list, deque, queue, stack, map, set, bitset\\}{} {Содержат классы которые реализуют контейнеры стандартной библиотеки.\\} \mycom{functional\\}{} {Содержит классы и функции, используемые алгоритмами стандартной библиотеки.\\} \mycom{memory\\}{} {Содержит классы и функции, используемые стандартной библиотекой для выделения памяти контейнерам стандартной библиотеки.\\} \mycom{iterator\\}{} {Содержит классы для доступа к данным в контейнерах стандартной библиотеки.\\} \mycom{algorithm\\}{} {Содержит функции для манипулирования данными в контейнерах стандартной библиотеки.\\} \mycom{exception, stdexcept\\}{} {Содержат классы использующиеся для обработки исключительных ситуаций.\\} \mycom{string\\}{} {Определения класса string из стандартной библиотеки.\\} \mycom{sstream\\}{} {Прототипы функций выполняющих ввод из строк в память и наоборот.\\} \mycom{locale\\}{} {Содержит классы и функции, используемые потоковой обработкой различных языков.\\} \mycom{limits\\}{} {Содержит классы для определения интервалов значений численного типа данных для данной платформы.\\} \mycom{typeinfo\\}{} {Содержит классы для идентификации времени выполнения.\\} \chapter{Основные функции языка ``С/С++''} \section{Математические функции (math.h|cmath)} \mycom{ceil, ceilf, ceill (POSIX)\\} {double ceil(double x);\\ float ceilf(float x);\\ long double ceill(long double x);\\} {Функции округления до наименьшего целого, не меньшего, чем аргумент.\\} \mycom{cos (POSIX)\\} {double cos(double x);\\} {Возвращает значение косинуса x, где x - это значение в радианах.\\} \mycom{exp (POSIX)\\} {double exp(double x);\\} {Возвращает значение числа 'e' возведенного в степень x.\\} \mycom{fabs, fabsf, fabsl (POSIX)\\} {double fabs(double x);\\ float fabsf(float x);\\ long double fabsl(long double x);\\} {Абсолютное значение числа с плавающей точкой.\\} \mycom{floor, floorf, floorl (POSIX)\\} {double floor(double x);\\ float floorf(float x);\\ long double floorl(long double x);\\} {Наибольшее целое значение, но не большее x.\\} \mycom{fmod (POSIX)\\} {double fmod(double x, double y);\\} {Функция получения остатка от деления (с плавающей точкой).\\} \mycom{log (POSIX)\\} {double log(double x);\\} {Возвращает натуральный логарифм x.\\} \mycom{log10 (POSIX)\\} {double log10(double x);\\} {Возвращает десятичный логарифм x.\\} \mycom{matherr (ANSI)\\} {int matherr(struct expection *error_info);\\} {Пользовательская функция обработки ошибок математических операций. Описание ошибки передается в указателе на структуру \\ } \mycom{pow (POSIX)\\} {double pow(double x, double y);\\} {Возвращает значение x в степени y.\\} \mycom{rand, srand \\} {int rand(void);\\ void srand(unsigned int seed);\\} {rand() - возвращает псевдослучайное число в диапазоне от нуля до RAND_MAX.\\ srand() - устанавливает свой аргумент как основу (seed) для новой последовательности псевдослучайных целых чисел, возвращаемых функцией rand().\\} \mycom{sin (POSIX)\\} {double sin(double x);\\} {Возвращает значение синуса аргумента x, где x указан в радианах.\\} \mycom{sqrt (POSIX)\\} {double sqrt(double x);\\} {Функция вычисления квадратного корня.\\} \mycom{tan (POSIX)\\} {double tan(double x);\\} {Возвращает тангенс аргумента x, где x задан в радианах.\\} \section{Функции для работы с дисками, директориями и файлами} \subsection{Функции потокового ввода-вывода} \mycom{fopen, fdopen, freopen (ANSI POSIX) \\} {FILE *fopen(const char *path, const char *mode);\\ FILE *fdopen(int fildes, const char *mode);\\ FILE *freopen(const char *path, const char *mode, FILE *stream);\\} {fopen - открывает файл с именем path и связывает его с потоком.\\ fdopen - связывает поток с существующим описателем файла .\\ freopen - открывает файл с именем path и связывает его с потоком stream. Исходный поток (если такой существовал) закрывается.\\} \mycom{fclose (ANSI) \\} {int fclose( FILE *stream);\\} {Закрывает поток .\\} \mycom{fgetc,getchar (ANSI) \\} {int fgetc(FILE *stream);\\ int getchar(void);\\} {Считывает очередной символ из потока или из stdin.\\} \mycom{fprintf (ANSI) \\} {int fprintf(FILE *stream, const char *format, ...);\\} {Осуществляет форматированный вывод в поток . Табл~\bf{\ref{stream}}\\} \mycom{fflush (ANSI) \\} {int fflush(FILE *stream);\\} {"Сбрасывает" буферы потока .\\} \mycom{perror (ANSI) \\} {void perror(const char *s);\\} {Выводит в стандартный поток ошибки сообщения, описывая ошибку, произошедшую при последнем системном вызове или вызове библиотечной функции.\\} \begin{table}[!hbp] \footnotesize \caption{\bf{Символы управления форматированием}} \label{formsymb} \begin{tabular}{|p{12mm}|p{69mm}|} \hline \it Элемент & \it Эффект \\ & \verb+%[флаги][ширина][.точность][F | N | h | l]<тип>+ \\ \hline \multicolumn{2}{|c|}{\it Флаги}\\ \hline 0 & Для чисел ширина поля будет заполнена слева нулям. \\ - & Производится выравнивание выводимого числа по левому краю в пределах выделенного поля. Правая сторона выделенного поля дополняется пробелами. \\ + & Выводится знак числа символом '-' или '+' \\ * & Обозначает пропуск при вводе поля, определенного данной спецификацией. Введенное значение не присваивается ни какой переменной.\\ Пробел & Выводится пробел перед положительным числом и знак '-' перед отрицательным.\\ \# & Выводится идентификатор системы счисления для целых:\\ & - 0 перед числом в восьмеричной с/c;\\ & - 0х или 0Х в шеснадцатеричной с/c; \\ & - ничего для чисел в десятичной с/c. \\ \hline \multicolumn{2}{|c|}{\it Ширина (воздействует только на вывод)}\\ \hline n & Определяет минимальную ширину поля в символах. Если после преобразозования ширины недостаточно, выводится столько символов,сколько есть, с дополнением пробелами.\\ 0n & Все тоже, но позиции слева для целого числа дополняются нулям.\\ * & Число выводимых символов определяется значением соответствующей переменной.\\ \hline \multicolumn{2}{|c|}{\it Точность (воздействует только на вывод)}\\ \hline ничего & Точность по умолчанию.\\ .0 & Для d, i, o, u, x - точность по умолчанию. Для e, E, f - десятичная точка отсутствует.\\ .n & Для e, E, f не более знаков после точки.\\ * & Следующий аргумент из списка аргументов - точность.\\ \hline \multicolumn{2}{|c|}{\it Модификатор (воздействует там, где применимо)}\\ \hline h & Перед d, i, o, u, x, X аргумент является - short int.\\ l & Перед d, i, o, u, x, X аргумент является - long int.\\ & Перед e, E, f, g, G аргумент является - double (только для scanf).\\ L & Длиное двойной точности.\\ F & Указатель (FAR).\\ N & Указатель (NEAR).\\ \hline % \multicolumn{2}{|c|}{\textit{Поле образец -} \verb+j+ }\\ \multicolumn{2}{|c|}{\it Поле образец - \%[*][ширина] [образец] }\\ \hline \multicolumn{2}{|p{81mm}|}{Определяет множество символов, из которых может состоять вводимая строка. Если в образце стоит символ '\^\ ', то вводится будут все символы кроме перечисленных: [a-z],[A-F0-9]; [\^\ 0-9] }\\ \hline \multicolumn{2}{|c|}{\it Тип переменной: \bf char }\\ \hline c & При вводе, читается и передается переменной один байт. При выводе - байт переменной преобразуется к типу char и записуется в выходной поток.\\ \hline \multicolumn{2}{|c|}{\it Тип переменной: \bf int }\\ \hline d & Десятичное int со знаком.\\ i & Десятичное int со знаком.\\ o & Восьмеричное int без знака.\\ u & Десятичное int без знака.\\ x & Шеcтнадцатеричное int без знака (0 - f).\\ X & Шестнадцатеричное int без знака (0 - F).\\ n & Указатель NEAR (только смещение).\\ p & Указатель FAR (сегмент[селектор]:смещение).\\ \hline \multicolumn{2}{|c|}{\it Тип переменной: \bf float }\\ \hline f & Значение со знаком в форме [-]dddd.dddd .\\ e & Значение со знаком в форме [-]d.dddde[+ | -]ddd .\\ E & Значение со знаком в форме [-]d.ddddE[+ | -]ddd .\\ g & Значение со знаком в формате 'e' или 'f' в зависимости от значения и специфицированной точности.\\ G & Значение со знаком в формате 'E' или 'F' в зависимости от значения и специфицированной точности.\\ \hline \multicolumn{2}{|c|}{\it Тип переменной: \bf char * }\\ \hline s & При вводе принимает символы без преобразования до тех пор, пока не встретится \verb+'\n'+ или пока не достигнута специфицированная точночть. При выводе выдаёт в поток все символы до тех пор пока не встретится \verb+'\0'+ или не достигнута специфицированная точность.\\ \hline \end{tabular} \end{table} \subsection{Работа с директориями} \mycom{chdir, fchdir (POSIX) \\} {int chdir(const char *path);\\ int fchdir(int fd);\\} {Установка текущей директории , .\\} \mycom{ftw, nftw \\} {int ftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag), int depth);\\ int nftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag, struct FTW *s), int depth, int flags);\\} {Перемещается по дереву каталогов, начиная с указанного каталога . Для каждого найденного элемента дерева вызываются: с указанием полного имени этого элемента, указатель на структуру элемента и целое число. Функция nftw() выполняет то же самое, что и ftw(), только имеет еще один параметр, flags, то есть вызывает свои функции еще с одним параметром. \\} \mycom{getcwd (POSIX) \\} {char *getcwd(char *buf, size_t size);\\} {Копирует абсолютный путь к текущему рабочему каталогу в массив , имеющий длину .\\} \mycom{mkdir (POSIX) \\} {int mkdir(const char *pathname, mode_t mode);\\} {Создаёт каталог с режимом .\\} \mycom{opendir, closedir (POSIX) \\} {DIR *opendir(const char *name);\\ int closedir(DIR *dir);\\} {Открывает/закрывает поток каталога, соответствующий каталогу .\\} \mycom{readdir (POSIX) \\} {struct dirent *readdir(DIR *dir);\\} {Возвращает указатель на следующую запись каталога.\\} \mycom{rmdir (POSIX) \\} {int rmdir(const char *pathname);\\} {Удаляет каталог .\\} \subsection{Доступ к файлам} \mycom{access (POSIX) \\} {int access(const char *pathname, int mode);\\} {Проверка, имеет ли процесс права на чтение(R_OK), запись(W_OK), выполнение(X_OK) или существование файла(F_OK).\\} \mycom{close (POSIX) \\} {int close(int fd);\\} {Закрывает открытый описатель файла .\\} \mycom{create (POSIX) \\} {int creat(const char *pathname, mode_t mode);\\} {Создаёт файл и возвращает его описатель.\\} \mycom{dup, dup2 (POSIX) \\} {int dup(int oldfd);\\ int dup2(int oldfd, int newfd);\\} {dup - предоставляет новому описателю наименьший свободный номер.\\ dup2 - делает копией (если это необходимо), закрывая newfd.\\} \mycom{fcntl (POSIX) \\} {int fcntl(int fd, int cmd);\\ int fcntl(int fd, int cmd, long arg);\\ int fcntl(int fd, int cmd, struct flock * lock);\\} {Выполняет различные операции над файловым описателем fd.\\} \mycom{flock (BSD) \\} {int flock(int fd, int operation);\\} {Устанавливает или снимает "мягкую" блокировку открытого файла .\\} \mycom{fsync, fdatasync (POSIX) \\} {int fsync(int fd);\\ int fdatasync(int fd);\\} {fsync - копирует все части файла, находящиеся в памяти, на устройство . fdatasync - тоже что и fsync, но без метаданных.\\} \mycom{fileno (ANSI) \\} {int fileno(FILE *stream);\\} {Возвращает описатель .\\} \mycom{lseek (POSIX) \\} {off_t lseek(int fildes, off_t offset, int whence);\\} {Устанавливает позицию чтения/записи информации в файле.\\} \mycom{mknod (BSD) \\} {int mknod(const char *pathname, mode_t mode, dev_t dev);\\} {Создаёт файл (обычный файл, файл устройства или именованный канал) , с правами доступа и дополнительной информацией .\\} \mycom{open (POSIX) <\\} {int open(const char *pathname, int flags);\\ int open(const char *pathname, int flags, mode_t mode);\\} {Открывает файл и возвращает описатель файла.\\} \mycom{read, readv (POSIX) \\} {ssize_t read(int fd, void *buf, size_t count);\\ int readv(int fd, const struct iovec * vector, int count);\\} {Записывает байтов файлового описателя в буфер или вектор .\\} \mycom{readlink (BSD) \\} {int readlink(const char *path, char *buf, size_t bufsiz);\\} {Помещает содержимое символьной ссылки в буфер длиной .\\} \mycom{remove (ANSI,POSIX) \\} {int remove(const char *pathname);\\} {Удаляет имя файла и, возможно, сам файл.\\} \mycom{rename (ANSI) \\} {int rename(const char *oldpath, const char *newpath);\\} {Изменяет имя или расположение файла на .\\} \mycom{select (POSIX) \\} {int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);\\ int pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, sigset_t *sigmask);\\} {Ждут изменения статуса нескольких файловых описателей в течении . n - на единицу больше самого большого номера описателей из всех наборов. Для манипуляции набором существуют 4 макроса:\\ FD_ZERO - очищающий набор;\\ FD_SET - Добавляет заданный описатель к набору;\\ FD_CLR - Удаляет описатель из из набора;\\ FD_ISSET - Проверяет, является ли описатель частью набора;\\} \mycom{sendfile (*) \\} {ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);\\} {Производит чтение данных из по смещению длиной и запись их в .\\} \mycom{write, writev (POSIX) \\} {ssize_t write(int fd, const void *buf, size_t count);\\ int writev(int fd, const struct iovec * vector, int count);\\} {Записывает или вектора в файл .\\} \mycom{unlink (POSIX) \\} {int unlink(const char *pathname);\\} {Удаляет имя файла из файловой системы. Если это имя было последней ссылкой на файл и нет ни одного процесса, которые бы открыли этот файл, то файл удаляется.\\} \begin{table}[!hbp] \caption{\bf{Стандартные потоки ввода-вывода}} \label{stream} \begin{tabular}{|p{15mm}|p{70mm}|} \hline Имя & Назначение \\ \hline stdin(0) & Стандартный вход;\\ stdout(1) & Стандартный выход (буфериз.);\\ stderr(2) & Стандартный выход ошибок (небуфериз.);\\ \hline \end{tabular} \end{table} \subsection{Функции работы с временными файлами} \mycom{mkstemp (BSD) \\} {int mkstemp(char *template);\\} {Создает временный файл с уникальным именем определённым