C\C++ эксперт - Вклад участника [ru]

C89 (C version)

2010-06-22T12:48:36Z

Admin: Новая страница: «In 1983, the American National Standards Institute formed a committee, X3J11, to establish a standard specification of C. After a long and arduous process, the stand…»

In 1983, the American National Standards Institute formed a committee, X3J11, to establish a standard specification of C. After a long and arduous process, the standard was completed in 1989 and ratified as ANSI X3.159-1989 "Programming Language C." This version of the language is often referred to as "ANSI C", or sometimes "C89" (to distinguish it from C99).

C99

2010-06-22T12:47:55Z

Admin: Новая страница: «== History == After the ANSI standardization process, the C language specification remained relatively static for some time, whereas C++ continued to evolve, largely…»

== History ==
After the ANSI standardization process, the C language specification remained relatively static for some time, whereas C++ continued to evolve, largely during its own standardization effort. Normative Amendment 1 created a new standard for the C language in 1995, but only to correct some details of the C89 standard and to add more extensive support for international character sets. However, the standard underwent further revision in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999. This standard is commonly referred to as "C99." It was adopted as an ANSI standard in May 2000. The international C standard is maintained by the working group ISO/IEC JTC1/SC22/WG14.

== Design ==
C99 is, for the most part, backward compatible with C89 but is stricter in some ways.

In particular, a declaration that lacks a type specifier no longer has int implicitly assumed. The C standards committee decided that it was of more value for compilers to diagnose inadvertent omission of the type specifier than to silently process legacy code that relied on implicit int. In practice, compilers are likely to display a warning while compiling, assume int and continue translating the program.

C99 introduced several new features, many of which had already been implemented as extensions in several compilers:
* inline functions
* intermingled declarations and code, variable declaration no longer restricted to file scope or the start of a compound statement (block)
* several new data types, including long long int, optional extended integer types, an explicit boolean data type, and a complex type to represent complex numbers
* variable-length arrays
* support for one-line comments beginning with //, as in BCPL or C++
* new library functions, such as snprintf
* new header files, such as stdbool.h, complex.h and inttypes.h
* type-generic math functions (tgmath.h)
* improved support for IEEE floating point
* designated initializers
* compound literals
* support for variadic macros (macros of variable arity)
* restrict qualification to allow more aggressive code optimization
* universal character names, which allows user variables to contain other characters than the standard character set

Parts of the C99 standard are included in the proposed extensions to the C++ language known as TR1 and C++0x, including integer types, header files and library functions. Variable-length arrays are not among them.

== Implementations ==
Most C compilers now have support for at least some of the features of C99. However, there has been less support from vendors such as Microsoft and Borland that have mainly focused on C++.

GCC, despite its extensive C99 support, is still not a completely compliant implementation (44 features done); as of May 2010, 6 of the features are missing or do not work correctly.

The Open Watcom C compiler implements the most-used parts of the standard. However, they are enabled only through an undocumented command-line switch.

According to Sun Microsystems, Sun Studio (which is downloadable without charge) now supports the full C99 standard.

The C interpreter Ch supports major C99 features and it is available without charge in Windows, Linux, Mac OS X, Solaris, QNX and FreeBSD.

The compiler within Pelles C supports most C99 features.

Intel C++ compiler supports some of the most important C99 features.

The free AMD x86 Open64 Compiler Suite has C99 support equal to that of GCC.

The Tiny C Compiler supports most of C99 except complex numbers and variable length arrays.

The Portable C compiler is also working to become C99 compliant.

Clang is C99 compliant, except for the C99 floating-point pragmas.

== Version detection ==
A standard macro __STDC_VERSION__ is defined with value 199901L to indicate that C99 support is available. As with the __STDC__ macro for C90, __STDC_VERSION__ can be used to write code that will compile differently for C90 and C99 compilers, as in this example that ensures that inline is available in either case (by replacing it with static in C90 to avoid linker errors.)

<source lang="C">
#if __STDC_VERSION__ >= 199901L
/* "inline" is a keyword */
#else
# define inline static
#endif
</source>

== Future work ==
Since ratification of the 1999 C standard, the standards working group has prepared technical reports specifying improved support for embedded processing, additional character data types (Unicode support), and library functions with improved bounds checking. Work continues on technical reports addressing decimal floating point, additional mathematical special functions, and additional dynamic memory allocation functions. The C and C++ standards committees have been collaborating on specifications for threaded programming.

As of 2007, work has begun in anticipation of another revision of the C standard, informally called "C1X". The C standards committee has adopted guidelines that should limit the adoption of new features that have not been tested by existing implementations.

It is likely that the standard gets function, which was officially deprecated in response to a defect report concerning its unsafe interface design, will not be specified in the next revision of the C standard.

C/stdarg.h

2010-06-22T12:44:06Z

Admin: Новая страница: «{{C Standard library}} '''stdarg.h''' is a header in the C standard library of the C programming language that allows functions to accept an indefinite number of ar…»

{{C Standard library}}

'''stdarg.h''' is a header in the C standard library of the C programming language that allows functions to accept an indefinite number of arguments.[1] C++ provides this functionality in the header cstdarg; the C header, though permitted, is deprecated in C++.

The contents of stdarg.h are typically used in variadic functions, though they may be used in other functions (for example, vprintf) called by variadic functions.

==<code>stdarg.h</code> типы==

{|class="wikitable"
|-
! Имя !! Описание !! Совместимость
|-
|<code>va_list</code> || тип для итерационных аргументов || [[C89 (C version)|C89]]
|}

==<code>stdarg.h</code> макросы==

{|class="wikitable"
|-
! Имя !! Описание !! Совместимость
|-
|<code>va_start</code> || Start iterating arguments with a <code>va_list</code> || C89
|-
|<code>va_arg</code> || Возвращает аргумент || C89
|-
|<code>va_end</code> || Освобождает <code>va_list</code> || C89
|-
|<code>va_copy</code> || Копирует контент из одного <code>va_list</code> в другой || [[C99]]
|}

== Accessing the arguments ==

To access the unnamed arguments, one must declare a variable of type va_list in the variadic function. The macro va_start is then called with two arguments: the first is the one declared of the type va_list, the second is the name of the last named parameter of the function. After this, each invocation of the va_arg macro yields the next argument. The first argument to va_arg is the va_list and the second is the type of the next argument passed to the function. Finally, the va_end macro must be called on the va_list before the function returns. (It is not required to read in all the arguments.)

C99 provides an additional macro, va_copy, which can duplicate the state of a va_list. The macro invocation va_copy(va2, va1) copies va1 into va2.

There is no mechanism defined for determining the number or types of the unnamed arguments passed to the function. The function is simply required to know or determine this somehow, the means of which vary. Common conventions include:

* Use of a printf or scanf-like format string with embedded specifiers that indicate argument types.
* A sentinel value at the end of the variadic arguments.
* A count argument indicating the number of variadic arguments.

== Type safety ==
Some C implementations provide C extensions that allow the compiler to check for the proper use of format strings and sentinels. Barring these extensions, the compiler usually cannot check whether the unnamed arguments passed are of the type the function expects, or convert them to the required type. Therefore, care should be taken to ensure correctness in this regard, since undefined behavior results if the types do not match. For example, if passing a null pointer, one should not write simply NULL (which may be defined as 0) but cast to the appropriate pointer type. Another consideration is the default argument promotions applied to the unnamed arguments. A float will automatically be promoted to a double. Likewise, arguments of types narrower than an int will be promoted to int or unsigned int. The function receiving the unnamed arguments must expect the promoted type.

GCC has an extension that checks the passed arguments:

; format(archetype, string-index, first-to-check) : The format attribute specifies that a function takes printf, scanf, strftime or strfmon style arguments which should be type-checked against a format string. For example, the declaration:

<source lang="c">
extern int
my_printf (void *my_object, const char *my_format, ...)
__attribute__ ((format (printf, 2, 3)));
</source>
causes the compiler to check the arguments in calls to my_printf for consistency with the printf style format string argument my_format.

C/signal.h

2010-06-22T12:36:50Z

Admin:

{{C Standard library}}

'''signal.h''' — заголовочный файл, определенный в стандартной библиотеке языка Си, для указания того, как программа обрабатывает сигналы во время ее выполнения. Сигнал может оповещать о некотором отклонении от ожидаемого поведения программы (как например, деление на нуль) или о некоторых асинхронных событиях, произошедших вне программы (например, если кто-то нажал кнопку прерывания программы на клавиатуре).

Сигнал может генерироваться при вызове raise (посылает сигнал текущему процессу) или kill (посылает сигнал любому процессу). Каждая реализация определяет какой сигнал что генерирует и определяет их генерацию. реализация может определять сигналы, отличающиеся от перечисленных здесь. Стандартный заголовочный файл <signal.h> может определять дополнительные макросы с именами, начинающимися с SIG, для указания значения этих дополнительных сигналов. Все подобные значения являются целыми константными выражениями >= 0.

Можно указывать обработчик сигнала для всех сигналов кроме двух (SIGKILL и SIGSTOP не могут быть перехвачены, блокированы или проигнорированы). Обработчик сигнала — функция, направляющая вызовы окружению, когда принимает соответствующий сигнал. Целевое окружение приостанавливает выполнение программы пока обработчик сигнала не возвратит значение или вызовет переход (longjmp). Для максимальной переносимости, асинхронный обработчик сигнала должен:

совершать (успешный) вызов сигнала функции
присваивать значения объектам с типом несвязанная переменная sig_atomic_t
возвращать управление обратно вызвавшему его
Если сигнал оповещает об ошибке внутри программы (а сигнал не асинхронный), то обработчик сигнала может завершить ее выполнение, вызвав abort, exit или longjmp.

== Методы ==
* [[C/signal.h/raise | raise]]. Искусственно вызывает сигнал.

* [[C/signal.h/psignal | psignal]], выводит в stderr строку, содержащую номер сигнала. Применяется в 4.3BSD, Solaris и Linux, но не указан в POSIX и SUS. На тех же системах [[C/string.h | string.h]] содержит нестандартный strsignal, который работает аналогично strerror.

* [[C/signal.h/signal | signal]] - назначает действие, предпринимаемое при получении программой сигнала sig. Если значение func равно SIG_DFL, то происходит обработка по умолчанию для указанного сигнала. Если значение func равно SIG_IGN, то сигнал игнорируется. В остальных случаях func указывает на вызываемую функцию ''обработчик сигнала'' при получении сигнала.

Функция func может завершиться выполнением операции возврата или вызовом функций самозавершения, выхода или перехода.

== Члены-типы ==
typedef i-type sig_atomic_t

== Члены-макросы ==
* SIG_DFL — Используется для указания способа обработки сигнала по умолчанию.
* SIG_IGN — Используется для игнорирования сигнала.
* SIG_ERR — Код ошибки.

== Члены-константы ==
{|
|-
!Константа !!Значение !! Стандарты
|-
|[[C/signal.h/SIGHUP | SIGHUP]] ||Отбой ||POSIX||
|-
|[[C/signal.h/SIGINT | SIGINT]] ||Прерывание ||ANSI
|-
|[[C/signal.h/SIGQUIT | SIGQUIT]] ||Выход ||POSIX
|-
|[[C/signal.h/SIGILL | SIGILL]] ||Недопустимая инструкция ||ANSI
|-
|[[C/signal.h/SIGABRT | SIGABRT]] ||Самоостановка ||ANSI
|-
|[[C/signal.h/SIGTRAP | SIGTRAP]] ||Перехват события ||POSIX
|-
|[[C/signal.h/SIGABRT | SIGIOT]] ||Перехват ввода-вывода ||4.2 BSD
|-
|[[C/signal.h/SIGEMT | SIGEMT]] ||Перехват эмуляции ||4.2 BSD
|-
|[[C/signal.h/SIGFPE | SIGFPE]] ||Исключение с плавающей запятой ||ANSI
|-
|[[C/signal.h/SIGKILL | SIGKILL]] ||Неперехватываемый сигнал завершения ||POSIX
|-
|[[C/signal.h/SIGBUS | SIGBUS]] ||Ошибка шины ||4.2 BSD
|-
|[[C/signal.h/SIGSEGV | SIGSEGV]] ||Нарушение сегментации ||ANSI
|-
|[[C/signal.h/SIGSYS | SIGSYS]] ||Неправильный аргумент в системный вызов ||4.2 BSD
|-
|[[C/signal.h/SIGPIPE | SIGPIPE]] ||Нарушение канала ||POSIX
|-
|[[C/signal.h/SIGALRM | SIGALRM]] ||Истечение времени ||POSIX
|-
|[[C/signal.h/SIGTERM | SIGTERM]] ||Завершение ||ANSI
|-
|[[C/signal.h/SIGUSR1 | SIGUSR1]] ||Пользовательский сигнал 1 ||POSIX
|-
|[[C/signal.h/SIGUSR2 | SIGUSR2]] ||Пользовательский сигнал 2 ||POSIX
|-
|[[C/signal.h/SIGCHLD | SIGCHLD]] ||Изменение статуса дочернего процесса ||POSIX
|-
|[[C/signal.h/SIGCHLD | SIGCLD]] ||Аналогично SIGCHLD ||System V
|-
|[[C/signal.h/SIGPWR | SIGPWR]] ||Перезапуск после проблемы с питанием ||System V
|-
|[[C/signal.h/SIGXCPU | SIGXCPU]] ||Ограничение процессорного времени ||POSIX
|}

C/setjmp.h

2010-06-22T12:36:07Z

Admin:

{{C Standard library}}

'''setjmp.h''' is a header defined in the C standard library to provide "non-local jumps," or control flow besides the usual subroutine call and return sequence. The paired functions '''<code>setjmp</code>''' and '''<code>longjmp</code>''' provide this functionality. First <code>setjmp</code> saves the environment of the calling function into a data structure, and then <code>longjmp</code> can use this structure to "jump" back to the point it was created, at the <code>setjmp</code> call.

The typical use for <code>setjmp</code>/<code>longjmp</code> is for exception handling — by calling <code>longjmp</code>, the program can jump out of many levels of nested function calls without having to go to the trouble of setting flag variables which need to be checked in each function. A problem with the use of <code>setjmp</code>/<code>longjmp</code> is that cleanup (such as closing file descriptors, flushing buffers, freeing heap-allocated memory, etc.) is not conducted automatically.

Another not-so-common use of <code>setjmp</code> is to create syntax similar to coroutines.

On systems that support signal handling, POSIX.1 does not specify whether <code>setjmp</code> and <code>longjmp</code> save or restore the current set of blocked signals — if a program employs signal handling it should use POSIX's <code>sigsetjmp</code>/<code>siglongjmp</code>.

Compared to mechanisms in higher-level programming languages such as Python, Java, C++, C#, and particularly in older high-level languages such as Algol 60 and Common Lisp, the <code>setjmp</code>/<code>longjmp</code> technique is archaic. These languages provide more powerful exception handling techniques, while languages such as Scheme, Smalltalk, and Haskell provide even more general continuation-handling constructs.

==Member functions==

{| class = wikitable
|-
|<code>int setjmp(jmp_buf env)</code> || Sets up the local <code>jmp_buf</code> buffer and initializes it for the jump. This routine<ref name="macro">ISO C states that <code>setjmp</code> must be implemented as a macro, but POSIX explicitly states that it is undefined whether <code>setjmp</code> is a macro or a function.</ref> saves the program's calling environment in the environment buffer specified by the <code>env</code> argument for later use by <code>longjmp</code>. If the return is from a direct invocation, <code>setjmp</code> returns 0. If the return is from a call to <code>longjmp</code>, <code>setjmp</code> returns a nonzero value.
|-
|<code>void longjmp(jmp_buf env, int value)</code> || Restores the context of the environment buffer <code>env</code> that was saved by invocation of the <code>setjmp</code> routine<ref name="macro"/> in the same invocation of the program. Invoking longjmp from a nested signal handler is undefined. The value specified by <code>value</code> is passed from <code>longjmp</code> to <code>setjmp</code>. After <code>longjmp</code> is completed, program execution continues as if the corresponding invocation of <code>setjmp</code> had just returned. If the <code>value</code> passed to <code>longjmp</code> is 0, <code>setjmp</code> will behave as if it had returned 1; otherwise, it will behave as if it had returned <code>value</code>.
|-
|}

<code>setjmp</code> saves the current execution state into a structure of type <code>jmp_buf</code>; later, a <code>longjmp</code> call can transfer control to the point immediately after the call to <code>setjmp</code>. The (apparent) return value from <code>setjmp</code> indicates whether control reached that point normally or from a call to <code>longjmp</code>. This leads to a common idiom: <code>if( setjmp(x) ){/* handle longjmp(x) */}</code>.

==Member types==

{| class = wikitable
|-
|<code>jmp_buf</code> || An array type, such as <code>struct __jmp_buf_tag</code><ref>This is the type used by the GNU C Library, version 2.7</ref>, suitable for holding the information needed to restore a calling environment.
|}

The C99 Rationale describes <code>jmp_buf</code> as being an array type for backwards compatibility; existing code refers to <code>jmp_buf</code> storage locations by name (without the <code>&</code> address-of operator), which is only possible for array types.

==Caveats==
If the function in which setjmp/sigsetjmp was called returns, it is no longer possible to safely use longjmp/siglongjmp with the corresponding jmp_buf/sigjmp_buf object. This is because the stack frame is invalidated when the function returns. Calling longjmp/siglongjmp restores the stack pointer, which—because the function returned—would point to a non-existent and potentially overwritten/corrupted stack frame.

Similarly, C99 does not require that longjmp/siglongjmp preserve the current stack frame. This means that jumping into a function which was exited via a call to longjmp/siglongjmp is undefined. However, most implementations of longjmp/siglongjmp leave the stack frame intact, allowing setjmp/sigsetjmp and longjmp/siglongjmp to be used to jump back-and-forth between two or more functions—a feature exploited for multitasking.

== Simple example ==
This example shows the basic idea of setjmp. Main calls first, which in turn calls second. The "second" function jumps back into main, skipping "first"'s print statement.

<source lang="c">
#include <stdio.h>
#include <setjmp.h>

static jmp_buf buf;

void second(void) {
printf("second\n"); // prints
longjmp(buf,1); // jumps back to where setjmp was called - making setjmp now return 1
}

void first(void) {
second();
printf("first\n"); // does not print
}

int main() {
if ( ! setjmp(buf) ) {
first(); // when executed, setjmp returns 0
} else { // when longjmp jumps back, setjmp returns 1
printf("main"); // prints
}

return 0;
}
</source>
When executed, the above program will output:
second
main
Notice that although the <code>first()</code> subroutine gets called, "<code>first</code>" never is printed. "<code>main</code>" gets printed as the conditional statement <code>if ( ! setjmp(buf) )</code> is executed a second time.

== Exception handling ==
In this example, <code>setjmp</code> is used to bracket exception handling, like <code>try</code> in some other languages. The call to <code>longjmp</code> is analogous to a <code>throw</code> statement, allowing an exception to return an error status directly to the <code>setjmp</code>. The following code adheres to the 1999 ISO C standard and SUS by invoking <code>setjmp</code> in a limited range of contexts:<ref name="SUS">{{man|sh|setjmp|SUS|set jump point for a non-local goto}}</ref>
*As the condition to an <code>if</code>, <code>switch</code> or iteration statement
*As above in conjunction with a single <code>!</code> or comparison with an integer constant
*As a statement (with the return value unused)
Following these rules can make it easier for the implementation to create the environment buffer, which can be a sensitive operation.<ref>[http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf C99 Rationale, version 5.10, April 2003], section 7.13.1</ref> More general use of <code>setjmp</code> can cause undefined behaviour, such as corruption of local variables; conforming compilers and environments are not required to protect or even warn against such usage. However, slightly more sophisticated idioms such as <code>switch ((exception_type = setjmp(env))) { }</code> are common in literature and practice, and remain relatively portable. A simple conforming methodology is presented below, where an additional variable is maintained along with the state buffer. This variable could be elaborated into a structure incorporating the buffer itself.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>

void first(void);
void second(void);

/* This program's output is:

calling first
calling second
entering second
second failed with type 3 exception; remapping to type 1.
first failed, exception type 1

*/

/* Use a file scoped static variable for the exception stack so we can access
* it anywhere within this translation unit. */
static jmp_buf exception_env;
static int exception_type;

int main(int argc, char **argv) {
volatile void *mem_buffer;

mem_buffer = NULL;
if (setjmp(exception_env)) {
/* if we get here there was an exception */
printf("first failed, exception type %d\n", exception_type);
} else {
/* Run code that may signal failure via longjmp. */
printf("calling first\n");
first();
mem_buffer = malloc(300); /* allocate a resource */
printf(strcpy((char*) mem_buffer, "first succeeded!")); /* ... this will not happen */
}
if (mem_buffer)
free((void*) mem_buffer); /* carefully deallocate resource */
return 0;
}

void first(void) {
jmp_buf my_env;

printf("calling second\n");
memcpy(my_env, exception_env, sizeof(jmp_buf));
switch (setjmp(exception_env)) {
case 3:
/* if we get here there was an exception. */
printf("second failed with type 3 exception; remapping to type 1.\n");
exception_type = 1;

default: /* fall through */
memcpy(exception_env, my_env, sizeof(jmp_buf)); /* restore exception stack */
longjmp(exception_env, exception_type); /* continue handling the exception */

case 0:
/* normal, desired operation */
second();
printf("second succeeded\n"); /* not reached */
}
memcpy(exception_env, my_env, sizeof(jmp_buf)); /* restore exception stack */
}

void second(void) {
printf("entering second\n" ); /* reached */
exception_type = 3;
longjmp(exception_env, exception_type); /* declare that the program has failed */
printf("leaving second\n"); /* not reached */
}
</source>

==Cooperative multitasking==
[[C99]] provides that <code>longjmp</code> is guaranteed to work only when the destination is a calling function, i.e., that the destination scope is guaranteed to be intact. Jumping to a function that has already terminated by <code>return</code> or <code>longjmp</code> is undefined.<ref name="ISO/IEC 9899:1999"/> However, most implementations of <code>longjmp</code> do not specifically destroy local variables when performing the jump. Since the context survives until its local variables are erased, it could actually be restored by <code>setjmp</code>. In many environments (such as Really Simple Threads and TinyTimbers), idioms such as <code>if(!setjmp(child_env)) longjmp(caller_env);</code> can allow a called function to effectively pause-and-resume at a <code>setjmp</code>.

This is exploited by thread libraries to provide cooperative multitasking facilities without using <code>setcontext</code> or other fiber facilities. Whereas <code>setcontext</code> is a library service which can create an execution context in heap-allocated memory and can support other services such as buffer overflow protection, abuse of <code>setjmp</code> is implemented by the programmer, who may reserve memory on the stack and fail to notify the library or operating system of the new operating context. On the other hand, a library's implementation of <code>setcontext</code> may internally use <code>setjmp</code> in a fashion similar to this example to save and restore a context, after it has been initialised somehow.

Considering that <code>setjmp</code> to a child function will generally work unless sabotaged, and <code>setcontext</code>, as part of POSIX, is not required to be provided by C implementations, this mechanism may be portable where the <code>setcontext</code> alternative fails.

Since no exception will be generated upon overflow of one of the multiple stacks in such a mechanism, it is essential to overestimate the space required for each context, including the one containing <code>main()</code> and including space for any signal handlers that might interrupt regular execution. Exceeding the allocated space will corrupt the other contexts, usually with the outermost functions first. Unfortunately, systems requiring this kind of programming strategy are often also small ones with limited resources.

<source lang="c">
#include <setjmp.h>
#include <stdio.h>

jmp_buf mainTask, childTask;

void call_with_cushion(void);
void child(void);

int main(void) {
if (!setjmp(mainTask)) {
call_with_cushion(); /* child never returns */ /* yield */
} /* execution resumes after this "}" after first time that child yields */
for (;;) {
printf("Parent\n");
if (!setjmp(mainTask)) {
longjmp(childTask, 1); /* yield - note that this is undefined under C99 */
}
}
}

void call_with_cushion (void) {
char space[1000]; /* Reserve enough space for main to run */
space[999] = 1; /* Do not optimize array out of existence */
child();
}

void child (void) {
for (;;) {
printf("Child loop begin\n");
if (!setjmp(childTask)) longjmp(mainTask, 1); /* yield - invalidates childTask in C99 */

printf("Child loop end\n");
if (!setjmp(childTask)) longjmp(mainTask, 1); /* yield - invalidates childTask in C99 */
}
/* Don't return. Instead we should set a flag to indicate that main()
should stop yielding to us and then longjmp(mainTask, 1) */
}
</source>

C/math.h

2010-06-22T12:29:07Z

Admin:

{{C Standard library}}

'''math.h''' — заголовочный файл стандартной библиотеки языка программирования С, разработанный для выполнения простых математических операций. Большинство функций привлекают использование чисел с плавающей точкой. C++ также реализует данные функции для обеспечения совместимости, все они содержатся в заголовочном файле cmath.

Все эти функции принимают double, если не определено иначе. Для работы с типами float и long double используются функции с постфиксами f и l соответственно. Все функции, принимающие или возвращающие угол, работают с радианами.

== Функции ==
* [[C/math.h/acos | acos]] - арккосинус
* [[C/math.h/acosh | acosh]] - гиперболический арккосинус
* [[C/math.h/asin | asin]] - арксинус
* [[C/math.h/asinh | asinh]] - гиперболический арксинус
* [[C/math.h/atan | atan]] - арктангенс
* [[C/math.h/atan2 | atan2]] - арктангенс с двумя параметрами
* [[C/math.h/atanh | atanh]] - гиперболический арктангенс
* [[C/math.h/cbrt | cbrt]] - кубический корень
* [[C/math.h/ceil | ceil]] - округление до ближайшего большего целого числа
* [[C/math.h/copysign | copysign]] - возвращает величину, абсолютное значение которой равно x, но знак которой соответствует знаку y
* [[C/math.h/cos | cos]] - косинус
* [[C/math.h/cosh | cosh]] - гиперболический косинус
* [[C/math.h/erf | erf]] - функция ошибок
* [[C/math.h/erfc | erfc]] - Дополнительная функция ошибок
* [[C/math.h/exp | exp]] - вычисление экспоненты
* [[C/math.h/exp2 | exp2]] - значение числа 2, возведённого в степень x, 2x
* [[C/math.h/expm1 | expm1]] - значение функции ex − 1
* [[C/math.h/fabs | fabs]] - абсолютная величина (числа с плавающей точкой)
* [[C/math.h/fdim | fdim]] - вычисление положительной разницы между x и y, fmax(x−y, 0)
* [[C/math.h/floor | floor]] - округление до ближайшего меньшего целого числа
* [[C/math.h/fma | fma]] - значение функции (x * y) + z (см. FMA)
* [[C/math.h/fmax | fmax]] - наибольшее значение среди x и y
* [[C/math.h/fmin | fmin]] - наименьшее значение среди x и y
* [[C/math.h/fmod | fmod]] - вычисление остатка от деления нацело для чисел с плавающей точкой
* [[C/math.h/fpclassify | fpclassify]] -
* [[C/math.h/frexp | frexp]] - разбивает число с плавающей точкой на мантиссу и показатель степени.
* [[C/math.h/hypot | hypot]] - гипотенуза, sqrt(x² + y²)
* [[C/math.h/ilogb | ilogb]] - экспонента числа с плавающей точкой, конвертированная в int
* [[C/math.h/isfinite | isfinite]] -
* [[C/math.h/isgreater | isgreater]] -
* [[C/math.h/isgreaterequal | isgreaterequal]] -
* [[C/math.h/isinf | isinf]] -
* [[C/math.h/isless | isless]] -
* [[C/math.h/islessequal | islessequal]] -
* [[C/math.h/islessgreater | islessgreater]] -
* [[C/math.h/isnan | isnan]] -
* [[C/math.h/isnormal | isnormal]] -
* [[C/math.h/isunordered | isunordered]] -
* [[C/math.h/ldexp | ldexp]] - умножение числа с плавающей точкой на целую степень двух
* [[C/math.h/lgamma | lgamma]] - натуральный логарифм абсолютного значения гамма-функции
* [[C/math.h/llrint | llrint]] - округление до ближайшего целого (возвращает long long)
* [[C/math.h/llround | llround]] - округление до ближайшего целого в направлении от нуля (возвращает long long)
* [[C/math.h/log | log]] - натуральный логарифм
* [[C/math.h/log10 | log10]] - логарифм по основанию 10
* [[C/math.h/log1p | log1p]] - натуральный логарифм 1 + x
* [[C/math.h/log2 | log2]] - логарифм по основанию 2
* [[C/math.h/logb | logb]] - целочисленная часть логарифма x по основанию 2
* [[C/math.h/lrint | lrint]] - округление до ближайшего целого (возвращает long)
* [[C/math.h/lround | lround]] - округление до ближайшего целого в направлении от нуля (возвращает long)
* [[C/math.h/modf | modf]] - извлекает целую и дробную части (с учетом знака) из числа с плавающей точкой
* [[C/math.h/nan | nan]] - возвращает нечисловое значение 'Not a Number'
* [[C/math.h/nearbyint | nearbyint]] - округление аргумента до целого значения в формате числа с плавающей точкой
* [[C/math.h/nextafter | nextafter]] - следующий ближайшее представимое для x (по направлению к y)
* [[C/math.h/nexttoward | nexttoward]] - то же, что и nextafter, но y имеет тип long double
* [[C/math.h/pow | pow]] - результат возведения x в степень y
* [[C/math.h/remainder | remainder]] - вычисляет остаток от деления согласно стандарту IEC 60559
* [[C/math.h/remquo | remquo]] - то же, что и remainder, но сохраняет коэффициент по указателю p (как int)
* [[C/math.h/rint | rint]] - округление до целого (возвращает int) с вызовом ошибку inexact, если результат отличается от аргумента
* [[C/math.h/round | round]] - округление до целого (возвращает int)
* [[C/math.h/scalbln | scalbln]] - x * FLT_RADIXn (n is long)
* [[C/math.h/scalbn | scalbn]] - x * FLT_RADIXn (n is int)
* [[C/math.h/signbit | signbit]] -
* [[C/math.h/sin | sin]] - синус
* [[C/math.h/sinh | sinh]] - гиперболический синус
* [[C/math.h/sqrt | sqrt]] - квадратный корень
* [[C/math.h/strftime | strftime]] -
* [[C/math.h/tan | tan]] - тангенс
* [[C/math.h/tanh | tanh]] - гиперболический тангенс
* [[C/math.h/tgamma | tgamma]] - гамма-функция
* [[C/math.h/time | time]] -
* [[C/math.h/trunc | trunc]] - округление до ближайшего целого числа в направлении к нулю

C/math.h

2010-06-22T12:28:37Z

Admin:

{{C Standard library}}

'''math.h''' — заголовочный файл стандартной библиотеки языка программирования С, разработанный для выполнения простых математических операций. Большинство функций привлекают использование чисел с плавающей точкой. C++ также реализует данные функции для обеспечения совместимости, все они содержатся в заголовочном файле cmath.

Все эти функции принимают double, если не определено иначе. Для работы с типами float и long double используются функции с постфиксами f и l соответственно. Все функции, принимающие или возвращающие угол, работают с радианами.

* [[C/math.h/acos | acos]] - арккосинус
* [[C/math.h/acosh | acosh]] - гиперболический арккосинус
* [[C/math.h/asin | asin]] - арксинус
* [[C/math.h/asinh | asinh]] - гиперболический арксинус
* [[C/math.h/atan | atan]] - арктангенс
* [[C/math.h/atan2 | atan2]] - арктангенс с двумя параметрами
* [[C/math.h/atanh | atanh]] - гиперболический арктангенс
* [[C/math.h/cbrt | cbrt]] - кубический корень
* [[C/math.h/ceil | ceil]] - округление до ближайшего большего целого числа
* [[C/math.h/copysign | copysign]] - возвращает величину, абсолютное значение которой равно x, но знак которой соответствует знаку y
* [[C/math.h/cos | cos]] - косинус
* [[C/math.h/cosh | cosh]] - гиперболический косинус
* [[C/math.h/erf | erf]] - функция ошибок
* [[C/math.h/erfc | erfc]] - Дополнительная функция ошибок
* [[C/math.h/exp | exp]] - вычисление экспоненты
* [[C/math.h/exp2 | exp2]] - значение числа 2, возведённого в степень x, 2x
* [[C/math.h/expm1 | expm1]] - значение функции ex − 1
* [[C/math.h/fabs | fabs]] - абсолютная величина (числа с плавающей точкой)
* [[C/math.h/fdim | fdim]] - вычисление положительной разницы между x и y, fmax(x−y, 0)
* [[C/math.h/floor | floor]] - округление до ближайшего меньшего целого числа
* [[C/math.h/fma | fma]] - значение функции (x * y) + z (см. FMA)
* [[C/math.h/fmax | fmax]] - наибольшее значение среди x и y
* [[C/math.h/fmin | fmin]] - наименьшее значение среди x и y
* [[C/math.h/fmod | fmod]] - вычисление остатка от деления нацело для чисел с плавающей точкой
* [[C/math.h/fpclassify | fpclassify]] -
* [[C/math.h/frexp | frexp]] - разбивает число с плавающей точкой на мантиссу и показатель степени.
* [[C/math.h/hypot | hypot]] - гипотенуза, sqrt(x² + y²)
* [[C/math.h/ilogb | ilogb]] - экспонента числа с плавающей точкой, конвертированная в int
* [[C/math.h/isfinite | isfinite]] -
* [[C/math.h/isgreater | isgreater]] -
* [[C/math.h/isgreaterequal | isgreaterequal]] -
* [[C/math.h/isinf | isinf]] -
* [[C/math.h/isless | isless]] -
* [[C/math.h/islessequal | islessequal]] -
* [[C/math.h/islessgreater | islessgreater]] -
* [[C/math.h/isnan | isnan]] -
* [[C/math.h/isnormal | isnormal]] -
* [[C/math.h/isunordered | isunordered]] -
* [[C/math.h/ldexp | ldexp]] - умножение числа с плавающей точкой на целую степень двух
* [[C/math.h/lgamma | lgamma]] - натуральный логарифм абсолютного значения гамма-функции
* [[C/math.h/llrint | llrint]] - округление до ближайшего целого (возвращает long long)
* [[C/math.h/llround | llround]] - округление до ближайшего целого в направлении от нуля (возвращает long long)
* [[C/math.h/log | log]] - натуральный логарифм
* [[C/math.h/log10 | log10]] - логарифм по основанию 10
* [[C/math.h/log1p | log1p]] - натуральный логарифм 1 + x
* [[C/math.h/log2 | log2]] - логарифм по основанию 2
* [[C/math.h/logb | logb]] - целочисленная часть логарифма x по основанию 2
* [[C/math.h/lrint | lrint]] - округление до ближайшего целого (возвращает long)
* [[C/math.h/lround | lround]] - округление до ближайшего целого в направлении от нуля (возвращает long)
* [[C/math.h/modf | modf]] - извлекает целую и дробную части (с учетом знака) из числа с плавающей точкой
* [[C/math.h/nan | nan]] - возвращает нечисловое значение 'Not a Number'
* [[C/math.h/nearbyint | nearbyint]] - округление аргумента до целого значения в формате числа с плавающей точкой
* [[C/math.h/nextafter | nextafter]] - следующий ближайшее представимое для x (по направлению к y)
* [[C/math.h/nexttoward | nexttoward]] - то же, что и nextafter, но y имеет тип long double
* [[C/math.h/pow | pow]] - результат возведения x в степень y
* [[C/math.h/remainder | remainder]] - вычисляет остаток от деления согласно стандарту IEC 60559
* [[C/math.h/remquo | remquo]] - то же, что и remainder, но сохраняет коэффициент по указателю p (как int)
* [[C/math.h/rint | rint]] - округление до целого (возвращает int) с вызовом ошибку inexact, если результат отличается от аргумента
* [[C/math.h/round | round]] - округление до целого (возвращает int)
* [[C/math.h/scalbln | scalbln]] - x * FLT_RADIXn (n is long)
* [[C/math.h/scalbn | scalbn]] - x * FLT_RADIXn (n is int)
* [[C/math.h/signbit | signbit]] -
* [[C/math.h/sin | sin]] - синус
* [[C/math.h/sinh | sinh]] - гиперболический синус
* [[C/math.h/sqrt | sqrt]] - квадратный корень
* [[C/math.h/strftime | strftime]] -
* [[C/math.h/tan | tan]] - тангенс
* [[C/math.h/tanh | tanh]] - гиперболический тангенс
* [[C/math.h/tgamma | tgamma]] - гамма-функция
* [[C/math.h/time | time]] -
* [[C/math.h/trunc | trunc]] - округление до ближайшего целого числа в направлении к нулю

C/locale.h

2010-06-22T12:28:16Z

Admin: Новая страница: «{{C Standard library}} '''locale.h''' — заголовочный файл стандартной библиотеки языка программирования …»

{{C Standard library}}

'''locale.h''' — заголовочный файл стандартной библиотеки языка программирования С, который используется для задач связанных из локализацией. Данный заголовочный файл предоставляет две ключевых функции: localeconv и setlocale. Первая обеспечивает доступ к текущей локали, в то время, как вторая позволяет изменять её. Заголовочный файл также содержит структуру struct lconv, которая содержит информацию о текущей локали locale.

Шаблон:C Standard library

2010-06-22T12:27:07Z

Admin:

{{Sidebar
|name = Cтандартная библиотека С
|title = [[C]]
|headingstyle =
|contentstyle = text-align:left;

|heading1 =
|content1 = <div>
* <code>[[C/assert.h|<assert.h>]]</code>
* <code>[[C/complex.h|<complex.h>]]</code>
* <code>[[C/ctype.h|<ctype.h>]]</code>
* <code>[[C/errno.h|<errno.h>]]</code>
* <code>[[C/fenv.h|<fenv.h>]]</code>
* <code>[[C/float.h|<float.h>]]</code>
* <code>[[C/inttypes.h|<inttypes.h>]]</code>
* <code>[[C/iso646.h|<iso646.h>]]</code>
* <code>[[C/limits.h|<limits.h>]]</code>
* <code>[[C/locale.h|<locale.h>]]</code>
* <code>[[C/math.h|<math.h>]]</code>
* <code>[[C/setjmp.h|<setjmp.h>]]</code>
* <code>[[C/signal.h|<signal.h>]]</code>
* <code>[[C/stdarg.h|<stdarg.h>]]</code>
* <code>[[C/stdbool.h|<stdbool.h>]]</code>
* <code>[[C/stddef.h|<stddef.h>]]</code>
* <code>[[C/stdint.h|<stdint.h>]]</code>
* <code>[[C/stdio.h|<stdio.h>]]</code>
* <code>[[C/stdlib.h|<stdlib.h>]]</code>
* <code>[[C/string.h|<string.h>]]</code>
* <code>[[C/tgmath.h|<tgmath.h>]]</code>
* <code>[[C/time.h|<time.h>]]</code>
* <code>[[C/wchar.h|<wchar.h>]]</code>
* <code>[[C/wctype.h|<wctype.h>]]</code></div>
}}

C/limits.h

2010-06-22T12:24:04Z

Admin: Новая страница: «{{C Standard library}} '''limits.h''' — заголовочный файл стандартной библиотеки общего назначения языка…»

{{C Standard library}}

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

== Константы-члены ==
Колонка «минимальное значение диапазона» содержит минимумы из возможного диапазона для константы данного типа, как это указано в стандарте. Иногда, значения _MIN представляют минимумы диапазона, представимые в виде редко используемого обратного кода и знакового диапазона. Большинство реализаций будут иметь больший диапазон по крайней мере для некоторых из этих чисел. например:

* Реализации дополнительного кода имеют SCHAR_MIN равным −128 (аналогично для всех остальных значений _MIN).
* 32-битные реализации устанавливают INT_MAX равным +2,147,483,647 (а также для INT_MIN и UINT_MAX)
* Реализации с поддержкой Юникода устанавливают MB_LEN_MAX 4 или более.
* Многие ЦСП имеют CHAR_BIT равным 16 или более.

{| class="wikitable"
! Имя !! Описание !! Типичное значение 32-битной<br />выполняемой/компилируемой<br />программы(с 1995 и сейчас) !! Типичное значение 64-битной<br />выполняемой/компилируемой<br />(с 2008(?)) !! Стандартный минимум-<br />или максимум диапазона значений по ANSI
|-
|<code>CHAR_BIT</code> || Число бит в [[байт]]е || align="right" | 8 || align="right" | 8 || align="right" | ≥ 8
|-
|<code>SCHAR_MIN</code> || Минимальное значение для знакового char || align="right" | −128 || align="right" | −128 || align="right" | ≤ -127
|-
|<code>SCHAR_MAX</code> || Максимальное значение для знакового char || align="right" | +127 || align="right" | +127 || align="right" | ≥ +127
|-
|<code>UCHAR_MAX</code> || Максимальное значение для беззнакового char || align="right" | +255 || align="right" | +255 || align="right" | ≥ +255
|-
|<code>CHAR_MIN</code> || Минимальное значение для char || align="right" | −128 || align="right" | −128 || align="right" | ≤ -127<br />(если <code>char</code> представлено как a<br /><code>знаковый char</code>; иначе 0)
|-
|<code>CHAR_MAX</code> || Максимальное значение для char || align="right" | +127 || align="right" | +127 || align="right" | ≥ +127<br />(если <code>char</code> представлено как<br /><code>знаковый char</code>; иначе +255)
|-
|<code>MB_LEN_MAX</code> || Максимальная многобайтовая длина символа по всем локалям || align="right" | различается, обычно от 4 || align="right" | различается, обычно от 4 || align="right" | ≥ 1
|-
|<code>SHRT_MIN</code> || Минимальное значение для short int || align="right" | −32,768 || align="right" | −32,768 || align="right" | ≤ -32,767
|-
|<code>SHRT_MAX</code> || Максимальное значение для short int || align="right" | +32,767 || align="right" | +32,767 || align="right" | ≥ +32,767
|-
|<code>USHRT_MAX</code> || Максимальное значение для беззнакового short int || align="right" | +65,535 || align="right" | +65,535 || align="right" | ≥ +65,535
|-
|<code>INT_MIN</code> || Минимальное значение для int || align="right" | −2,147,483,648 || align="right" | −2,147,483,648 || align="right" | ≤ -32,767
|-
|<code>INT_MAX</code> || Максимальное значение для int || align="right" | +2,147,483,647 || align="right" | +2,147,483,647 || align="right" | ≥ +32,767
|-
|<code>UINT_MAX</code> || Максимальное значение для беззнакового int || align="right" | +4,294,967,295 || align="right" | +4,294,967,295 || align="right" | ≥ +65,535
|-
|<code>LONG_MIN</code> || Минимальное значение для long int || align="right" | −2,147,483,648 || align="right" | −9,223,372,036,854,775,808 || align="right" | ≤ -2,147,483,647
|-
|<code>LONG_MAX</code> || Максимальное значение для long int || align="right" | +2,147,483,647 || align="right" | +9,223,372,036,854,775,807 || align="right" | ≥ +2,147,483,647
|-
|<code>ULONG_MAX</code> || максимальное значение для беззнакового long int || align="right" | +4,294,967,295 || align="right" | +18,446,744,073,709,551,615 || align="right" | ≥ +4,294,967,295
|-
|<code>LLONG_MIN</code> || Минимальное значение для long long int || align="right" | −9,223,372,036,854,775,808 || align="right" | −9,223,372,036,854,775,808 || align="right" | ≤ -9,223,372,036,854,775,807
|-
|<code>LLONG_MAX</code> || Максимальное значение для long long int || align="right" | +9,223,372,036,854,775,807 || align="right" | +9,223,372,036,854,775,807 || align="right" | ≥ +9,223,372,036,854,775,807
|-
|<code>ULLONG_MAX</code> || максимальное значение для беззнакового long long int || align="right" | +18,446,744,073,709,551,615 || align="right" | +18,446,744,073,709,551,615 || align="right" | ≥ +18,446,744,073,709,551,615
|}

C/assert.h

2010-06-22T12:18:59Z

Admin:

{{C Standard library}}

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

Макрос assert() добавляет к программе процедуру диагностики. После выполнения, если выражение ложно (то есть, результат сравнения 0), assert() пишет информацию о вызове в поток stderr и вызывает функцию abort(). Информация, которая пишется в stderr включает в себя:

* текст выражения, значение которого равно нулю 0
* имя файла с исходным кодом (предопределённый макрос __FILE__)
* строка у файла с исходным кодом (предопределённый макрос __LINE__)

== Объявления функций ==
[[C/assert.h/assert | assert]]

C/complex.h

2010-06-22T12:18:23Z

Admin:

{{C Standard library}}

'''complex.h''' — заголовочный файл стандартной библиотеки языка программирования С, в котором объявляются функции для комплексной арифметики. Эти функции используют встроенный тип complex, который появился в стандарте C99.

== Объявления функций ==
Функции в заголовочном файле <code>complex.h</code> представлены для трёх типов — double, float и long double (заметьте, что значения представлены в радианах):
{| class="wikitable" width="60%"
|<code>cabs, cabsf, cabsl</code> || Абсолютное значение комплексного числа
|-
|<code>cacos, cacosf, cacosl</code> || Комплексный арккосинус
|-
|<code>cacosh, cacoshf, cacoshl</code> || Комплексный гиперболический арккосинус
|-
|<code>carg, cargf, cargl</code> || Аргумент комплексного числа
|-
|<code>casin, casinf, casinl</code> || Комплексный арксинус
|-
|<code>casinh, casinhf, casinhl</code> || Комплексный гиперболический арксинус
|-
|<code>catan, catanf, catanl</code> || Комплексный арктангенс
|-
|<code>catanh, catanhf, catanhl</code> || Комплексный гиперболический арктангенс
|-
|<code>ccos, ccosf, ccosl</code> || Комплексный косинус
|-
|<code>ccosh, ccoshf, ccoshl</code> || Комплексный гиперболический косинус
|-
|<code>cexp, cexpf, cexpl</code> || Комплексная экспонента
|-
|<code>cimag, cimagf, cimagl</code> || Мнимая часть комплексного числа
|-
|<code>clog, clogf, clogl</code> || Натуральный логарифм комплексного числа
|-
|<code>conj, conjf, conjl</code> || Комплексное сопряжённое число
|-
|<code>cpow, cpowf, cpowl</code> || Степень комплексного числа
|-
|<code>cproj, cprojf, cprojl</code> || Проекция на римановскую сферу
|-
|<code>creal, crealf, creall</code> || Действительная часть комплексного числа
|-
|<code>csin, csinf, csinl</code> || Комплексный синус
|-
|<code>csinh, csinhf, csinhl</code> || Комплексный гиперболический синус
|-
|<code>csqrt, csqrtf, csqrtl</code> || Комплексный квадратный корень
|-
|<code>ctan, ctanf, ctanl</code> || Комплексный тангенс
|-
|<code>ctanh, ctanhf, ctanhl</code> || Комплексный гиперболический тангенс
|}

C/ctype.h

2010-06-22T12:18:02Z

Admin:

{{C Standard library}}

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

== Функции ==
* [[C/ctype.h/isalnum | isalnum]] - Проверяет, является ли аргумент буквой или цифрой
* [[C/ctype.h/isalpha | isalpha]] - Проверяет, является ли аргумент буквой
* [[C/ctype.h/isblank | isblank]] - Проверяет, является ли аргумент
* [[C/ctype.h/iscntrl | iscntrl]] - Проверяет, является ли аргумент управляющим символом
* [[C/ctype.h/isdigit | isdigit]] - Проверяет, является ли аргумент цифрой
* [[C/ctype.h/isgraph | isgraph]] - Проверяет, является ли аргумент символом, имеющим графическое представление
* [[C/ctype.h/islower | islower]] - Проверяет, является ли аргумент буквой в нижнем регистре
* [[C/ctype.h/isprint | isprint]] - Проверяет, является ли аргумент символом, который может быть напечатан
* [[C/ctype.h/ispunct | ispunct]] - Проверяет, является ли аргумент символом, имеющим графическое представление, но не являющимся при этом буквой или цифрой
* [[C/ctype.h/isspace | isspace]] - Проверяет, является ли аргумент разделительным символом
* [[C/ctype.h/isupper | isupper]] - Проверяет, является ли аргумент буквой в верхнем регистре
* [[C/ctype.h/isxdigit | isxdigit]] - Проверяет, является ли аргумент цифрой шестнадцатеричной системы счисления
* [[C/ctype.h/tolower | tolower]] - Преобразует аргумент в его строчный аналог (нижний регистр), если это возможно; иначе возвращается неизмененный аргумент.
* [[C/ctype.h/toupper | toupper]] - Преобразует аргумент в его прописной аналог (верхний регистр), если это возможно; иначе возвращается неизмененный аргумент.

C/ctype.h

2010-06-22T12:17:40Z

Admin:

{{C Standard library}}

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

* [[C/ctype.h/isalnum | isalnum]] - Проверяет, является ли аргумент буквой или цифрой
* [[C/ctype.h/isalpha | isalpha]] - Проверяет, является ли аргумент буквой
* [[C/ctype.h/isblank | isblank]] - Проверяет, является ли аргумент
* [[C/ctype.h/iscntrl | iscntrl]] - Проверяет, является ли аргумент управляющим символом
* [[C/ctype.h/isdigit | isdigit]] - Проверяет, является ли аргумент цифрой
* [[C/ctype.h/isgraph | isgraph]] - Проверяет, является ли аргумент символом, имеющим графическое представление
* [[C/ctype.h/islower | islower]] - Проверяет, является ли аргумент буквой в нижнем регистре
* [[C/ctype.h/isprint | isprint]] - Проверяет, является ли аргумент символом, который может быть напечатан
* [[C/ctype.h/ispunct | ispunct]] - Проверяет, является ли аргумент символом, имеющим графическое представление, но не являющимся при этом буквой или цифрой
* [[C/ctype.h/isspace | isspace]] - Проверяет, является ли аргумент разделительным символом
* [[C/ctype.h/isupper | isupper]] - Проверяет, является ли аргумент буквой в верхнем регистре
* [[C/ctype.h/isxdigit | isxdigit]] - Проверяет, является ли аргумент цифрой шестнадцатеричной системы счисления
* [[C/ctype.h/tolower | tolower]] - Преобразует аргумент в его строчный аналог (нижний регистр), если это возможно; иначе возвращается неизмененный аргумент.
* [[C/ctype.h/toupper | toupper]] - Преобразует аргумент в его прописной аналог (верхний регистр), если это возможно; иначе возвращается неизмененный аргумент.

C/errno.h

2010-06-22T12:17:29Z

Admin:

{{C Standard library}}

'''errno.h''' — заголовочный файл стандартной библиотеки языка программирования С, содержащий объявление макроса для идентификации ошибок через их код. POSIX-совместимые операционные системы, наподобие Unix и Linux, могут включать другие макросы для определения ошибок через собственные коды errno. Значение errno имеет смысл только тогда, когда системный вызов или функция возвращает признак ошибки.

Сообщение о ошибке может быть получено с помощью функции strerror или напечатано с помощью perror.

Стандарт POSIX определяет следующие символьные имена ошибок:
{|
|E2BIG || Список аргументов слишком длинный
|-
|EACCES || Отказ в доступе
|-
|EAGAIN || Ресурс временно недоступен
|-
|EBADF || Неправильный дескриптор файла
|-
|EBADMSG || Неправильное сообщение
|-
|EBUSY || Ресурс занят
|-
|ECANCELED || Операция отменена
|-
|ECHILD || Нет дочернего процесса
|-
|EDEADLK || Обход тупика ресурсов
|-
|EDOM || Ошибка области определения
|-
|EEXIST || Файл существует
|-
|EFAULT || Неправильный адрес
|-
|EFBIG || Файл слишком велик
|-
|EINPROGRESS || Операция в процессе выполнения
|-
|EINTR || Прерванный вызов функции
|-
|EINVAL || Неправильный аргумент
|-
|EIO || Ошибка ввода-вывода
|-
|EISDIR || Это каталог
|-
|EMFILE || Слишком много открытых файлов
|-
|EMLINK || Слишком много связей
|-
|EMSGSIZE || Неопределённая длина буфера сообщения
|-
|ENAMETOOLONG || Имя файла слишком длинное
|-
|ENFILE || Слишком много открытых файлов в системе
|-
|ENODEV || Нет такого устройства
|-
|ENOENT || Нет такого файла в каталоге
|-
|ENOEXEC || Ошибка формата исполняемого файла
|-
|ENOLCK || Блокировка недоступна
|-
|ENOMEM || Недостаточно памяти
|-
|ENOSPC || Памяти на устройстве не осталось
|-
|ENOSYS || Функция не реализована
|-
|ENOTDIR || Это не каталог
|-
|ENOTEMPTY || Каталог непустой
|-
|ENOTSUP || Не поддерживается
|-
|ENOTTY || Неопределённая операция управления вводом-выводом
|-
|ENXIO || Нет такого устройства или адреса
|-
|EPERM || Операция не разрешена
|-
|EPIPE || Разрушенный канал
|-
|ERANGE || Результат слишком велик
|-
|EROFS || Файловая система только на чтение
|-
|ESPIPE || Неправильное позиционирование
|-
|ESRCH || Нет такого процесса
|-
|ETIMEDOUT || Операция задержана
|-
|EXDEV || Неопределённая связь
|}

C/fenv.h

2010-06-22T12:17:11Z

Admin:

{{C Standard library}}

'''fenv.h''' - заголовочный файл, определенный в стандартной библиотеке языка Си, он содержит различные функции и макросы для манипуляций с floating-point environment.

В этом заголовочном файле объявлено два типа, fenv_t (represents the whole floating-point environment) и fexcept_t (represents the floating-point status flags). В нем так же объявлены несколько макросов, они начинаются с '''FE_'''.

== Функции ==
Other than fegetround and fetestexcept, these functions return zero/non-zero on success/failure.

{|class="wikitable"
|-
! Объявление !! Описание
|-
|<code>int [[C/fenv.h/feclearexcept | feclearexcept]](int ''excepts'');</code> || clear exceptions specified by ''excepts''
|-
|<code>int [[C/fenv.h/fegetenv | fegetenv]](fenv_t *''penv'');</code> || store current floating-point environment in ''penv''
|-
|<code>int [[C/fenv.h/fegetexceptflag | fegetexceptflag]](fexcept_t *''pflag'', int ''excepts'');</code> || store current status flags in ''pflags''
|-
|<code>int [[C/fenv.h/fegetround | fegetround]](void);</code> || retrieve current rounding direction
|-
|<code>int [[C/fenv.h/feholdexcept | feholdexcept]](fenv_t *''penv'');</code> || save current floating-point environment to ''penv'' and clear all exceptions
|-
|<code>int [[C/fenv.h/feraiseexcept | feraiseexcept]](int ''excepts'');</code> || raise floating-point exceptions
|-
|<code>int [[C/fenv.h/fesetenv | fesetenv]](const fenv_t *''penv'');</code> || set current floating-point environment to ''penv''
|-
|<code>int [[C/fenv.h/fesetexceptflag | fesetexceptflag]](const fexcept_t *''pflags'', int ''excepts'');</code> || set current status flags to those stored in ''pflags''
|-
|<code>int [[C/fenv.h/fesetround | fesetround]](int ''round'');</code> || set current rounding direction to ''round''
|-
|<code>int [[C/fenv.h/fetestexcept | fetestexcept]](int ''excepts'');</code> || test whether certain exceptions have been raised
|-
|<code>int [[C/fenv.h/feupdateenv | feupdateenv]](const fenv_t *''penv'');</code> || restore floating-point environment ''penv'', but keep current exceptions
|}

C/float.h

2010-06-22T12:16:56Z

Admin:

{{C Standard library}}

The header '''float.h''' in the C Standard Library for the C programming language contains macros that expand to various limits and parameters of the standard floating-point types.

The macros, as defined on ISO 9899:1999 section 5.2.4.2.2, are:

* '''FLT_ROUNDS''' - indicates the rounding mode for floating-point addition, meaning:
:* '''-1''' indeterminable;
:* '''0''' toward zero;
:* '''1''' to nearest;
:* '''2''' toward positive infinity;
:* '''3''' toward negative infinity;
:* other value means implementation-defined rounding behavior.

* '''FLT_EVAL_METHOD''' - determines the evaluation formats of expressions involving all floating types:
:* '''-1''' indeterminable;
:* '''0''' evaluate all operations and constants just to the precision of the type;
:* '''1''' evaluate operations and constants of type '''float''' and '''double''' to the range and precision of the '''double''' type;
:* '''2''' evaluate all operations and constants to the range and precision of the '''long double''' type;
:* other value means implementation-defined behavior.

* '''FLT_RADIX''' - radix of exponent representation (at least '''2''').

* '''FLT_MANT_DIG''', '''DBL_MANT_DIG''', '''LDBL_MANT_DIG''' - number of digits in the floating-point significand.

* '''DECIMAL_DIG''' - (at least '''10''')

* '''FLT_DIG''', '''DBL_DIG''', '''LDBL_DIG''' - (at least '''6''', '''10''', '''10''')

* '''FLT_MIN_EXP''', '''DBL_MIN_EXP''', '''LDBL_MIN_EXP'''

* '''FLT_MIN_10_EXP''', '''DBL_MIN_10_EXP''', '''LDBL_MIN_10_EXP''', (at least '''-37''')

* '''FLT_MAX_EXP''', '''DBL_MAX_EXP''', '''LDBL_MAX_EXP'''

* '''FLT_MAX_10_EXP''', '''DBL_MAX_10_EXP''', '''LDBL_MAX_10_EXP''' (at least '''+37''')

* '''FLT_MAX''', '''DBL_MAX''', '''LDBL_MAX''' - (at least '''1E+37''')

* '''FLT_EPSILON''', '''DBL_EPSILON''', '''LDBL_EPSILON''' - (at least '''1E-5''', '''1E-9''', '''1E-9''')

* '''FLT_MIN''', '''DBL_MIN''', '''LDBL_MIN''' - (at least '''1E-37''')

C/inttypes.h

2010-06-22T12:16:40Z

Admin:

{{C Standard library}}

The inttypes.h file is a C header file that is part of the C standard library and API. It was added with the 1999 version of the ISO C standard (known as C99). It includes the stdint.h header. It defines a number of macros for use with the printf and scanf family of functions, as well as functions for working with the intmax_t type.

Шаблон:C Standard library

2010-06-22T12:16:10Z

Admin: Новая страница: «{{Sidebar |name = C Standard library |title = C standard library |headingstyle = |contentstyle = text-align:left; |heading1 = |content1 = <div>…»

{{Sidebar
|name = C Standard library
|title = [[C standard library]]
|headingstyle =
|contentstyle = text-align:left;

|heading1 =
|content1 = <div>
* <code>[[C/assert.h|<assert.h>]]</code>
* <code>[[C/complex.h|<complex.h>]]</code>
* <code>[[C/ctype.h|<ctype.h>]]</code>
* <code>[[C/errno.h|<errno.h>]]</code>
* <code>[[C/fenv.h|<fenv.h>]]</code>
* <code>[[C/float.h|<float.h>]]</code>
* <code>[[C/inttypes.h|<inttypes.h>]]</code>
* <code>[[C/iso646.h|<iso646.h>]]</code>
* <code>[[C/limits.h|<limits.h>]]</code>
* <code>[[C/locale.h|<locale.h>]]</code>
* <code>[[C/math.h|<math.h>]]</code>
* <code>[[C/setjmp.h|<setjmp.h>]]</code>
* <code>[[C/signal.h|<signal.h>]]</code>
* <code>[[C/stdarg.h|<stdarg.h>]]</code>
* <code>[[C/stdbool.h|<stdbool.h>]]</code>
* <code>[[C/stddef.h|<stddef.h>]]</code>
* <code>[[C/stdint.h|<stdint.h>]]</code>
* <code>[[C/stdio.h|<stdio.h>]]</code>
* <code>[[C/stdlib.h|<stdlib.h>]]</code>
* <code>[[C/string.h|<string.h>]]</code>
* <code>[[C/tgmath.h|<tgmath.h>]]</code>
* <code>[[C/time.h|<time.h>]]</code>
* <code>[[C/wchar.h|<wchar.h>]]</code>
* <code>[[C/wctype.h|<wctype.h>]]</code></div>
}}

Шаблон:Sidebar

2010-06-22T12:15:59Z

Admin:

<table class="vertical-navbox {{#if:{{{wraplinks|}}}|{{#ifeq:{{{wraplinks|}}}|true||nowraplinks}}|nowraplinks}} {{{class|}}} {{{bodyclass|}}}" cellspacing="5" style="float:right; clear:right; color:black; background:#f9f9f9; border:1px solid #aaa; <noinclude>width:13.0em;</noinclude> margin:0 0 1.0em 1.0em; padding:0.2em; border-spacing:0.4em 0; text-align:center; line-height:1.4em; font-size:88%; {{{style|}}} {{{bodystyle|}}}" cellpadding="{{{cellpadding|0}}}">{{#if:{{{outertitle<includeonly>|</includeonly>}}}
| <caption class="{{{outertitleclass|}}}" style="padding-bottom:0.2em; font-size:125%; line-height:1.15em; font-weight:bold; {{{outertitlestyle|}}}">{{{outertitle}}}</caption>}}{{#if:{{{topimage<includeonly>|</includeonly>}}}
| <tr><td class="{{{topimageclass|}}}" style="padding:0.4em 0; {{{topimagestyle|}}}">{{{topimage}}}{{#if:{{{topcaption<includeonly>|</includeonly>}}} |<div style="padding-top:0.2em; font-size:85%; line-height:1.2em; {{{topcaptionstyle|}}}">{{{topcaption}}}</div>}}</td></tr>}}{{#if:{{{pretitle<includeonly>|</includeonly>}}}
| <tr><td style="{{#if:{{{topimage<includeonly>|</includeonly>}}} |padding-top:0.2em; |padding-top:0.4em;}} font-size:85%; line-height:1.2em; {{{pretitlestyle|}}}">{{{pretitle}}}</td></tr>}}{{#if:{{{title<includeonly>|</includeonly>}}}
| <tr><th class="{{{titleclass|}}}" style="padding:0.2em 0.4em 0.2em; {{#if:{{{pretitle<includeonly>|</includeonly>}}} |padding-top:0;}} font-size:145%; line-height:1.15em; font-weight:bold; {{{titlestyle|}}}">{{{title}}}</th></tr>}}{{#if:{{{image<includeonly>|</includeonly>}}}
| <tr><td class="{{{imageclass|}}}" style="padding:0.2em 0 0.4em; {{{imagestyle|}}}">{{{image}}}{{#if:{{{caption<includeonly>|</includeonly>}}} |<div style="padding-top:0.2em; font-size:85%; line-height:1.2em; {{{captionstyle|}}}">{{{caption}}}</div>}}</td></tr>}}{{#if:{{{above<includeonly>|</includeonly>}}} |<tr><td style="padding:0.3em 0.4em 0.3em; font-weight:bold; {{{abovestyle|}}}">{{{above}}}}}{{#if:{{{heading1<includeonly>|</includeonly>}}}
|<tr><td style="padding-top:0.2em; {{#if:{{{image<includeonly>|</includeonly>}}} |padding-top:0.4em;}} font-weight:bold; {{{headingstyle|}}} {{{heading1style|}}}">{{{heading1}}}</td></tr>}}{{#if:{{{content1<includeonly>|</includeonly>}}}
|<tr><td style="{{#if:{{{heading1|{{{heading<includeonly>|</includeonly>}}}}}} | |padding-top:0.2em;}} padding-bottom:0.2em; {{{contentstyle|}}} {{{content1style|}}}">{{{content1}}}</td></tr>}}{{#if:{{{heading2<includeonly>|</includeonly>}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading2style|}}}">{{{heading2}}}</td></tr>}}{{#if:{{{content2<includeonly>|</includeonly>}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content2style|}}}">{{{content2}}}</td></tr>}}{{#if:{{{heading3<includeonly>|</includeonly>}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading3style|}}}">{{{heading3}}}</td></tr>}}{{#if:{{{content3<includeonly>|</includeonly>}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content3style|}}}">{{{content3}}}</td></tr>}}{{#if:{{{heading4|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading4style|}}}">{{{heading4}}}</td></tr>}}{{#if:{{{content4<includeonly>|</includeonly>}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content4style|}}}">{{{content4<noinclude>|................</noinclude>}}}</td></tr>}}{{#if:{{{heading5|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading5style|}}}">{{{heading5}}}</td></tr>}}{{#if:{{{content5|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content5style|}}}">{{{content5}}}</td></tr>}}{{#if:{{{heading6|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading6style|}}}">{{{heading6}}}</td></tr>}}{{#if:{{{content6|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content6style|}}}">{{{content6}}}</td></tr>}}{{#if:{{{heading7|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading7style|}}}">{{{heading7}}}</td></tr>}}{{#if:{{{content7|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content7style|}}}">{{{content7}}}</td></tr>}}{{#if:{{{heading8|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading8style|}}}">{{{heading8}}}</td></tr>}}{{#if:{{{content8|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content8style|}}}">{{{content8}}}</td></tr>}}{{#if:{{{heading9|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading9style|}}}">{{{heading9}}}</td></tr>}}{{#if:{{{content9|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content9style|}}}">{{{content9}}}</td></tr>}}{{#if:{{{heading10|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading10style|}}}">{{{heading10}}}</td></tr>}}{{#if:{{{content10|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content10style|}}}">{{{content10}}}</td></tr>}}{{#if:{{{heading11|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading11style|}}}">{{{heading11}}}</td></tr>}}{{#if:{{{content11|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content11style|}}}">{{{content11}}}</td></tr>}}{{#if:{{{heading12|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading12style|}}}">{{{heading12}}}</td></tr>}}{{#if:{{{content12|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content12style|}}}">{{{content12}}}</td></tr>}}{{#if:{{{heading13|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading13style|}}}">{{{heading13}}}</td></tr>}}{{#if:{{{content13|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content13style|}}}">{{{content13}}}</td></tr>}}{{#if:{{{heading14|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading14style|}}}">{{{heading14}}}</td></tr>}}{{#if:{{{content14|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content14style|}}}">{{{content14}}}</td></tr>}}{{#if:{{{heading15|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading15style|}}}">{{{heading15}}}</td></tr>}}{{#if:{{{content15|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content15style|}}}">{{{content15}}}</td></tr>}}{{#if:{{{heading16|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading16style|}}}">{{{heading16}}}</td></tr>}}{{#if:{{{content16|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content16style|}}}">{{{content16}}}</td></tr>}}{{#if:{{{heading17|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading17style|}}}">{{{heading17}}}</td></tr>}}{{#if:{{{content17|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content17style|}}}">{{{content17}}}</td></tr>}}{{#if:{{{heading18|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading18style|}}}">{{{heading18}}}</td></tr>}}{{#if:{{{content18|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content18style|}}}">{{{content18}}}</td></tr>}}{{#if:{{{heading19|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading19style|}}}">{{{heading19}}}</td></tr>}}{{#if:{{{content19|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content19style|}}}">{{{content19}}}</td></tr>}}{{#if:{{{heading20|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading20style|}}}">{{{heading20}}}</td></tr>}}{{#if:{{{content20|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content20style|}}}">{{{content20}}}</td></tr>}}{{#if:{{{heading21|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading21style|}}}">{{{heading21}}}</td></tr>}}{{#if:{{{content21|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content21style|}}}">{{{content21}}}</td></tr>}}{{#if:{{{heading22|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading22style|}}}">{{{heading22}}}</td></tr>}}{{#if:{{{content22|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content22style|}}}">{{{content22}}}</td></tr>}}{{#if:{{{heading23|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading23style|}}}">{{{heading23}}}</td></tr>}}{{#if:{{{content23|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content23style|}}}">{{{content23}}}</td></tr>}}{{#if:{{{heading24|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading24style|}}}">{{{heading24}}}</td></tr>}}{{#if:{{{content24|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content24style|}}}">{{{content24}}}</td></tr>}}{{#if:{{{heading25|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading25style|}}}">{{{heading25}}}</td></tr>}}{{#if:{{{content25|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content25style|}}}"> {{{content25}}}</td></tr>}}{{#if:{{{heading26|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading26style|}}}">{{{heading26}}}</td></tr>}}{{#if:{{{content26|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content26style|}}}">{{{content26}}}</td></tr>}}{{#if:{{{heading27|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading27style|}}}">{{{heading27}}}</td></tr>}}{{#if:{{{content27|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content27style|}}}">{{{content27}}}</td></tr>}}{{#if:{{{heading28|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading28style|}}}">{{{heading28}}}</td></tr>}}{{#if:{{{content28|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content28style|}}}">{{{content28}}}</td></tr>}}{{#if:{{{heading29|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading29style|}}}">{{{heading29}}}</td></tr>}}{{#if:{{{content29|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content29style|}}}">{{{content29}}}</td></tr>}}{{#if:{{{heading30|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading30style|}}}">{{{heading30}}}</td></tr>}}{{#if:{{{content30|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content30style|}}}">{{{content30}}}</td></tr>}}{{#if:{{{heading31|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading31style|}}}">{{{heading31}}}</td></tr>}}{{#if:{{{content31|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content31style|}}}">{{{content31}}}</td></tr>}}{{#if:{{{heading32|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading32style|}}}">{{{heading32}}}</td></tr>}}{{#if:{{{content32|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content32style|}}}">{{{content32}}}</td></tr>}}{{#if:{{{heading33|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading33style|}}}">{{{heading33}}}</td></tr>}}{{#if:{{{content33|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content33style|}}}">{{{content33}}}</td></tr>}}{{#if:{{{heading34|}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading34style|}}}">{{{heading34}}}</td></tr>}}{{#if:{{{content34|}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content34style|}}}">{{{content34}}}</td></tr>}}{{#if:{{{heading35<includeonly>|</includeonly>}}} |<tr><td style="padding-top:0.2em; font-weight:bold; {{{headingstyle|}}} {{{heading35style|}}}">{{{heading35}}}</td></tr>}}{{#if:{{{content35<includeonly>|</includeonly>}}} |<tr><td style="padding-bottom:0.2em; {{{contentstyle|}}} {{{content35style|}}}">{{{content35}}}</td></tr>}}{{#if:{{{below<includeonly>|</includeonly>}}} |<tr><td style="padding:0.3em 0.4em 0.3em; font-weight:bold; {{{belowstyle|}}}">{{{below}}}</td></tr>}}<!--

</table>

Шаблон:Sidebar

2010-06-22T12:14:34Z

Admin:

Шаблон:Sidebar

2010-06-22T12:13:35Z

Admin: Новая страница: «<table class="vertical-navbox {{#if:{{{wraplinks|}}}|{{#ifeq:{{{wraplinks|}}}|true||nowraplinks}}|nowraplinks}} {{{class|}}} {{{bodyclass|}}}" cellspacing="5" <!-- …»

C/iso646.h

2010-06-22T12:12:11Z

Admin:

{{C Standard library}}

The iso646.h header file is part of the C standard library. It was added to this library in a 1995 amendment to the C90 standard. It defines a number of macros which allow programmers to use C language bitwise and logical operators, which, without the header file, cannot be quickly or easily typed on some international and non-QWERTY keyboards.

== Макросы ==
The iso646.h header defines the following 11 macros as stated below:

{| class="wikitable" style="font-family:monospace; text-align:center;"
|- style="font-family:sans-serif;"
! style="width:10em;" | Макрос
! style="width:10em;" | Определен как
|-
| and || &&
|-
| and_eq || &=
|-
| bitand || &
|-
| bitor || <nowiki>|</nowiki>
|-
| compl || ~
|-
| not || <nowiki>!</nowiki>
|-
| not_eq || <nowiki>!=</nowiki>
|-
| or || <nowiki>||</nowiki>
|-
| or_eq || <nowiki>|</nowiki>=
|-
| xor || ^
|-
| xor_eq || ^=
|}

These identifiers are operator keywords in the ISO C++ programming language and do not require the inclusion of a header file. For consistency, the C++98 standard provides the header <ciso646>. However the latter file has no effect, being empty.[1]

C/iso646.h

2010-06-22T12:10:18Z

Admin: Новая страница: «The iso646.h header file is part of the C standard library. It was added to this library in a 1995 amendment to the C90 standard. It defines a number of macros which…»

The iso646.h header file is part of the C standard library. It was added to this library in a 1995 amendment to the C90 standard. It defines a number of macros which allow programmers to use C language bitwise and logical operators, which, without the header file, cannot be quickly or easily typed on some international and non-QWERTY keyboards.

== Макросы ==
The iso646.h header defines the following 11 macros as stated below:

{| class="wikitable" style="font-family:monospace; text-align:center;"
|- style="font-family:sans-serif;"
! style="width:10em;" | Макрос
! style="width:10em;" | Определен как
|-
| and || &&
|-
| and_eq || &=
|-
| bitand || &
|-
| bitor || <nowiki>|</nowiki>
|-
| compl || ~
|-
| not || <nowiki>!</nowiki>
|-
| not_eq || <nowiki>!=</nowiki>
|-
| or || <nowiki>||</nowiki>
|-
| or_eq || <nowiki>|</nowiki>=
|-
| xor || ^
|-
| xor_eq || ^=
|}

These identifiers are operator keywords in the ISO C++ programming language and do not require the inclusion of a header file. For consistency, the C++98 standard provides the header <ciso646>. However the latter file has no effect, being empty.[1]

C/inttypes.h

2010-06-22T12:08:51Z

Admin: Новая страница: «The inttypes.h file is a C header file that is part of the C standard library and API. It was added with the 1999 version of the ISO C standard (known as C99). It in…»

The inttypes.h file is a C header file that is part of the C standard library and API. It was added with the 1999 version of the ISO C standard (known as C99). It includes the stdint.h header. It defines a number of macros for use with the printf and scanf family of functions, as well as functions for working with the intmax_t type.

C/float.h

2010-06-22T12:07:52Z

Admin: Новая страница: «The header '''float.h''' in the C Standard Library for the C programming language contains macros that expand to various limits and parameters of the standard floati…»

The header '''float.h''' in the C Standard Library for the C programming language contains macros that expand to various limits and parameters of the standard floating-point types.

The macros, as defined on ISO 9899:1999 section 5.2.4.2.2, are:

* '''FLT_ROUNDS''' - indicates the rounding mode for floating-point addition, meaning:
:* '''-1''' indeterminable;
:* '''0''' toward zero;
:* '''1''' to nearest;
:* '''2''' toward positive infinity;
:* '''3''' toward negative infinity;
:* other value means implementation-defined rounding behavior.

* '''FLT_EVAL_METHOD''' - determines the evaluation formats of expressions involving all floating types:
:* '''-1''' indeterminable;
:* '''0''' evaluate all operations and constants just to the precision of the type;
:* '''1''' evaluate operations and constants of type '''float''' and '''double''' to the range and precision of the '''double''' type;
:* '''2''' evaluate all operations and constants to the range and precision of the '''long double''' type;
:* other value means implementation-defined behavior.

* '''FLT_RADIX''' - radix of exponent representation (at least '''2''').

* '''FLT_MANT_DIG''', '''DBL_MANT_DIG''', '''LDBL_MANT_DIG''' - number of digits in the floating-point significand.

* '''DECIMAL_DIG''' - (at least '''10''')

* '''FLT_DIG''', '''DBL_DIG''', '''LDBL_DIG''' - (at least '''6''', '''10''', '''10''')

* '''FLT_MIN_EXP''', '''DBL_MIN_EXP''', '''LDBL_MIN_EXP'''

* '''FLT_MIN_10_EXP''', '''DBL_MIN_10_EXP''', '''LDBL_MIN_10_EXP''', (at least '''-37''')

* '''FLT_MAX_EXP''', '''DBL_MAX_EXP''', '''LDBL_MAX_EXP'''

* '''FLT_MAX_10_EXP''', '''DBL_MAX_10_EXP''', '''LDBL_MAX_10_EXP''' (at least '''+37''')

* '''FLT_MAX''', '''DBL_MAX''', '''LDBL_MAX''' - (at least '''1E+37''')

* '''FLT_EPSILON''', '''DBL_EPSILON''', '''LDBL_EPSILON''' - (at least '''1E-5''', '''1E-9''', '''1E-9''')

* '''FLT_MIN''', '''DBL_MIN''', '''LDBL_MIN''' - (at least '''1E-37''')

C/fenv.h

2010-06-22T12:06:26Z

Admin: Новая страница: «'''fenv.h''' - заголовочный файл, определенный в стандартной библиотеке языка Си, он содержит ра…»

'''fenv.h''' - заголовочный файл, определенный в стандартной библиотеке языка Си, он содержит различные функции и макросы для манипуляций с floating-point environment.

В этом заголовочном файле объявлено два типа, fenv_t (represents the whole floating-point environment) и fexcept_t (represents the floating-point status flags). В нем так же объявлены несколько макросов, они начинаются с '''FE_'''.

== Функции ==
Other than fegetround and fetestexcept, these functions return zero/non-zero on success/failure.

{|class="wikitable"
|-
! Объявление !! Описание
|-
|<code>int [[C/fenv.h/feclearexcept | feclearexcept]](int ''excepts'');</code> || clear exceptions specified by ''excepts''
|-
|<code>int [[C/fenv.h/fegetenv | fegetenv]](fenv_t *''penv'');</code> || store current floating-point environment in ''penv''
|-
|<code>int [[C/fenv.h/fegetexceptflag | fegetexceptflag]](fexcept_t *''pflag'', int ''excepts'');</code> || store current status flags in ''pflags''
|-
|<code>int [[C/fenv.h/fegetround | fegetround]](void);</code> || retrieve current rounding direction
|-
|<code>int [[C/fenv.h/feholdexcept | feholdexcept]](fenv_t *''penv'');</code> || save current floating-point environment to ''penv'' and clear all exceptions
|-
|<code>int [[C/fenv.h/feraiseexcept | feraiseexcept]](int ''excepts'');</code> || raise floating-point exceptions
|-
|<code>int [[C/fenv.h/fesetenv | fesetenv]](const fenv_t *''penv'');</code> || set current floating-point environment to ''penv''
|-
|<code>int [[C/fenv.h/fesetexceptflag | fesetexceptflag]](const fexcept_t *''pflags'', int ''excepts'');</code> || set current status flags to those stored in ''pflags''
|-
|<code>int [[C/fenv.h/fesetround | fesetround]](int ''round'');</code> || set current rounding direction to ''round''
|-
|<code>int [[C/fenv.h/fetestexcept | fetestexcept]](int ''excepts'');</code> || test whether certain exceptions have been raised
|-
|<code>int [[C/fenv.h/feupdateenv | feupdateenv]](const fenv_t *''penv'');</code> || restore floating-point environment ''penv'', but keep current exceptions
|}

C примеры

2010-06-21T19:46:52Z

Admin:

C/errno.h

2010-06-21T19:42:21Z

Admin: Новая страница: «'''errno.h''' — заголовочный файл стандартной библиотеки языка программирования С, содержащий …»

'''errno.h''' — заголовочный файл стандартной библиотеки языка программирования С, содержащий объявление макроса для идентификации ошибок через их код. POSIX-совместимые операционные системы, наподобие Unix и Linux, могут включать другие макросы для определения ошибок через собственные коды errno. Значение errno имеет смысл только тогда, когда системный вызов или функция возвращает признак ошибки.

Сообщение о ошибке может быть получено с помощью функции strerror или напечатано с помощью perror.

Стандарт POSIX определяет следующие символьные имена ошибок:
{|
|E2BIG || Список аргументов слишком длинный
|-
|EACCES || Отказ в доступе
|-
|EAGAIN || Ресурс временно недоступен
|-
|EBADF || Неправильный дескриптор файла
|-
|EBADMSG || Неправильное сообщение
|-
|EBUSY || Ресурс занят
|-
|ECANCELED || Операция отменена
|-
|ECHILD || Нет дочернего процесса
|-
|EDEADLK || Обход тупика ресурсов
|-
|EDOM || Ошибка области определения
|-
|EEXIST || Файл существует
|-
|EFAULT || Неправильный адрес
|-
|EFBIG || Файл слишком велик
|-
|EINPROGRESS || Операция в процессе выполнения
|-
|EINTR || Прерванный вызов функции
|-
|EINVAL || Неправильный аргумент
|-
|EIO || Ошибка ввода-вывода
|-
|EISDIR || Это каталог
|-
|EMFILE || Слишком много открытых файлов
|-
|EMLINK || Слишком много связей
|-
|EMSGSIZE || Неопределённая длина буфера сообщения
|-
|ENAMETOOLONG || Имя файла слишком длинное
|-
|ENFILE || Слишком много открытых файлов в системе
|-
|ENODEV || Нет такого устройства
|-
|ENOENT || Нет такого файла в каталоге
|-
|ENOEXEC || Ошибка формата исполняемого файла
|-
|ENOLCK || Блокировка недоступна
|-
|ENOMEM || Недостаточно памяти
|-
|ENOSPC || Памяти на устройстве не осталось
|-
|ENOSYS || Функция не реализована
|-
|ENOTDIR || Это не каталог
|-
|ENOTEMPTY || Каталог непустой
|-
|ENOTSUP || Не поддерживается
|-
|ENOTTY || Неопределённая операция управления вводом-выводом
|-
|ENXIO || Нет такого устройства или адреса
|-
|EPERM || Операция не разрешена
|-
|EPIPE || Разрушенный канал
|-
|ERANGE || Результат слишком велик
|-
|EROFS || Файловая система только на чтение
|-
|ESPIPE || Неправильное позиционирование
|-
|ESRCH || Нет такого процесса
|-
|ETIMEDOUT || Операция задержана
|-
|EXDEV || Неопределённая связь
|}

C примеры

2010-06-21T19:41:16Z

Admin:

C/complex.h

2010-06-21T19:40:30Z

Admin: /* Объявления функций */

'''complex.h''' — заголовочный файл стандартной библиотеки языка программирования С, в котором объявляются функции для комплексной арифметики. Эти функции используют встроенный тип complex, который появился в стандарте C99.

== Объявления функций ==
Функции в заголовочном файле <code>complex.h</code> представлены для трёх типов — double, float и long double (заметьте, что значения представлены в радианах):
{| class="wikitable" width="60%"
|<code>cabs, cabsf, cabsl</code> || Абсолютное значение комплексного числа
|-
|<code>cacos, cacosf, cacosl</code> || Комплексный арккосинус
|-
|<code>cacosh, cacoshf, cacoshl</code> || Комплексный гиперболический арккосинус
|-
|<code>carg, cargf, cargl</code> || Аргумент комплексного числа
|-
|<code>casin, casinf, casinl</code> || Комплексный арксинус
|-
|<code>casinh, casinhf, casinhl</code> || Комплексный гиперболический арксинус
|-
|<code>catan, catanf, catanl</code> || Комплексный арктангенс
|-
|<code>catanh, catanhf, catanhl</code> || Комплексный гиперболический арктангенс
|-
|<code>ccos, ccosf, ccosl</code> || Комплексный косинус
|-
|<code>ccosh, ccoshf, ccoshl</code> || Комплексный гиперболический косинус
|-
|<code>cexp, cexpf, cexpl</code> || Комплексная экспонента
|-
|<code>cimag, cimagf, cimagl</code> || Мнимая часть комплексного числа
|-
|<code>clog, clogf, clogl</code> || Натуральный логарифм комплексного числа
|-
|<code>conj, conjf, conjl</code> || Комплексное сопряжённое число
|-
|<code>cpow, cpowf, cpowl</code> || Степень комплексного числа
|-
|<code>cproj, cprojf, cprojl</code> || Проекция на римановскую сферу
|-
|<code>creal, crealf, creall</code> || Действительная часть комплексного числа
|-
|<code>csin, csinf, csinl</code> || Комплексный синус
|-
|<code>csinh, csinhf, csinhl</code> || Комплексный гиперболический синус
|-
|<code>csqrt, csqrtf, csqrtl</code> || Комплексный квадратный корень
|-
|<code>ctan, ctanf, ctanl</code> || Комплексный тангенс
|-
|<code>ctanh, ctanhf, ctanhl</code> || Комплексный гиперболический тангенс
|}

Заглавная страница

2010-06-21T19:39:46Z

Admin: /* C Примеры */

<div style="text-align: center; width: 90%; padding: 0.5em; margin: auto;">
На данный момент уже '''{{NUMBEROFPAGES}}''' {{plural: {{NUMBEROFPAGES}} |страница|страниц}} и '''{{NUMBEROFFILES}}''' {{plural: {{NUMBEROFFILES}} |файл|файлов}}.
</div>

== [[C | C Примеры]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C/Console | Console]]
* [[C/Data Structure Algorithm | Data Structure Algorithm]]
* [[C/Data Type | Data Type]]
* [[C/Development | Development]]
* [[C/File | File]]
* [[C/Function | Function]]
* [[C/Language Basics | Language Basics]]
| style="width: 25%;"|
* [[C/Macro Preprocessor | Macro Preprocessor]]
* [[C/Math | Math]]
* [[C/Memory | Memory]]
* [[C/Pointer | Pointer]]
* [[C/Small Application | Small Application]]
* [[C/String | String]]
* [[C/Structure | Structure]]
| style="width: 25%;"|
* [[C/assert.h | assert.h]]
* [[C/complex.h | complex.h]]
* [[C/ctype.h | ctype.h]]
* [[C/math.h | math.h]]
* [[C/setjmp.h | setjmp.h]]
* [[C/signal.h | signal.h]]
* [[C/stdio.h | stdio.h]]
| style="width: 25%;"|
* [[C/stdlib.h | stdlib.h]]
* [[C/string.h | string.h]]
* [[C/time.h | time.h]]
* [[C/wctype.h | wctype.h]]
|}

== [[C_Tutorial | C Учебник]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C Tutorial/Array | Array]]
* [[C Tutorial/Data Structure | Data Structure]]
* [[C Tutorial/Data Type | Data Type]]
* [[C Tutorial/File | File]]
* [[C Tutorial/Function | Function]]
* [[C Tutorial/Language | Language]]
* [[C Tutorial/Memory | Memory]]
* [[C Tutorial/Operator | Operator]]
| style="width: 25%;"|
* [[C Tutorial/Pointer | Pointer]]
* [[C Tutorial/Preprocessor | Preprocessor]]
* [[C Tutorial/Search Sort | Search Sort]]
* [[C Tutorial/Statement | Statement]]
* [[C Tutorial/String | String]]
* [[C Tutorial/Structure | Structure]]
* [[C Tutorial/Wide Character String | Wide Character String]]
* [[C Tutorial/assert.h | assert.h]]
| style="width: 25%;"|
* [[C Tutorial/ctype.h | ctype.h]]
* [[C Tutorial/math.h | math.h]]
* [[C Tutorial/printf scanf | printf scanf]]
* [[C Tutorial/setjmp.h | setjmp.h]]
* [[C Tutorial/signal.h | signal.h]]
* [[C Tutorial/stdio.h | stdio.h]]
* [[C Tutorial/stdlib.h | stdlib.h]]
* [[C Tutorial/string.h | string.h]]
| style="width: 25%;"|
* [[C Tutorial/time.h | time.h]]
* [[C Tutorial/wctype.h | wctype.h]]
|}

== [[C++ | C++ Примеры]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C++/Bitset | Bitset]]
* [[C++/Class | Class]]
* [[C++/Console | Console]]
* [[C++/Data Structure | Data Structure]]
* [[C++/Data Type | Data Type]]
* [[C++/Deque | Deque]]
* [[C++/Development | Development]]
* [[C++/File | File]]
| style="width: 25%;"|
* [[C++/Function | Function]]
* [[C++/Generic | Generic]]
* [[C++/Language | Language]]
* [[C++/List | List]]
* [[C++/Map Multimap | Map Multimap]]
* [[C++/Overload | Overload]]
* [[C++/Pointer | Pointer]]
* [[C++/Qt | Qt]]
| style="width: 25%;"|
* [[C++/Queue Stack | Queue Stack]]
* [[C++/STL Algorithms Binary search | STL Algorithms Binary search]]
* [[C++/STL Algorithms Heap | STL Algorithms Heap]]
* [[C++/STL Algorithms Helper | STL Algorithms Helper]]
* [[C++/STL Algorithms Iterator | STL Algorithms Iterator]]
* [[C++/STL Algorithms Merge | STL Algorithms Merge]]
* [[C++/STL Algorithms Min Max | STL Algorithms Min Max]]
* [[C++/STL Algorithms Modifying sequence operations | STL Algorithms Modifying sequence operations]]
| style="width: 25%;"|
* [[C++/STL Algorithms Non modifying sequence operations | STL Algorithms Non modifying sequence operations]]
* [[C++/STL Algorithms Sorting | STL Algorithms Sorting]]
* [[C++/STL Basics | STL Basics]]
* [[C++/Set Multiset | Set Multiset]]
* [[C++/String | String]]
* [[C++/Valarray | Valarray]]
* [[C++/Vector | Vector]]
|}

== [[C++ Tutorial | C++ Учебник]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C++ Tutorial/Array | Array]]
* [[C++ Tutorial/Class | Class]]
* [[C++ Tutorial/Data Types | Data Types]]
* [[C++ Tutorial/Development | Development]]
* [[C++ Tutorial/Exceptions | Exceptions]]
* [[C++ Tutorial/File Stream | File Stream]]
* [[C++ Tutorial/Function | Function]]
* [[C++ Tutorial/Language Basics | Language Basics]]
| style="width: 25%;"|
* [[C++ Tutorial/Operator Overloading | Operator Overloading]]
* [[C++ Tutorial/Operators statements | Operators statements]]
* [[C++ Tutorial/Pointer | Pointer]]
* [[C++ Tutorial/STL Algorithms Binary search | STL Algorithms Binary search]]
* [[C++ Tutorial/STL Algorithms Heap | STL Algorithms Heap]]
* [[C++ Tutorial/STL Algorithms Helper | STL Algorithms Helper]]
* [[C++ Tutorial/STL Algorithms Iterator | STL Algorithms Iterator]]
* [[C++ Tutorial/STL Algorithms Merge | STL Algorithms Merge]]
| style="width: 25%;"|
* [[C++ Tutorial/STL Algorithms Min Max | STL Algorithms Min Max]]
* [[C++ Tutorial/STL Algorithms Modifying sequence operations | STL Algorithms Modifying sequence operations]]
* [[C++ Tutorial/STL Algorithms Non modifying sequence operations | STL Algorithms Non modifying sequence operations]]
* [[C++ Tutorial/STL Algorithms Sorting | STL Algorithms Sorting]]
* [[C++ Tutorial/STL Introduction | STL Introduction]]
* [[C++ Tutorial/Structure | Structure]]
* [[C++ Tutorial/bitset | bitset]]
* [[C++ Tutorial/deque | deque]]
| style="width: 25%;"|
* [[C++ Tutorial/list | list]]
* [[C++ Tutorial/map multimap | map multimap]]
* [[C++ Tutorial/queue stack | queue stack]]
* [[C++ Tutorial/set multiset | set multiset]]
* [[C++ Tutorial/string | string]]
* [[C++ Tutorial/template | template]]
* [[C++ Tutorial/valarray | valarray]]
* [[C++ Tutorial/vector | vector]]
|}

Заглавная страница

2010-06-21T19:39:25Z

Admin: /* C Примеры */

<div style="text-align: center; width: 90%; padding: 0.5em; margin: auto;">
На данный момент уже '''{{NUMBEROFPAGES}}''' {{plural: {{NUMBEROFPAGES}} |страница|страниц}} и '''{{NUMBEROFFILES}}''' {{plural: {{NUMBEROFFILES}} |файл|файлов}}.
</div>

== [[C | C Примеры]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C/Console | Console]]
* [[C/Data Structure Algorithm | Data Structure Algorithm]]
* [[C/Data Type | Data Type]]
* [[C/Development | Development]]
* [[C/File | File]]
* [[C/Function | Function]]
* [[C/Language Basics | Language Basics]]
| style="width: 25%;"|
* [[C/Macro Preprocessor | Macro Preprocessor]]
* [[C/Math | Math]]
* [[C/Memory | Memory]]
* [[C/Pointer | Pointer]]
* [[C/Small Application | Small Application]]
* [[C/String | String]]
* [[C/Structure | Structure]]
| style="width: 25%;"|
* [[C/assert.h | assert.h]]
* [[C/complex.h | complex.h]]
* [[C/ctype.h | ctype.h]]
* [[C/math.h | math.h]]
* [[C/setjmp.h | setjmp.h]]
* [[C/signal.h | signal.h]]
* [[C/stdio.h | stdio.h]]
* [[C/stdlib.h | stdlib.h]]
| style="width: 25%;"|
* [[C/string.h | string.h]]
* [[C/time.h | time.h]]
* [[C/wctype.h | wctype.h]]
|}

== [[C_Tutorial | C Учебник]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C Tutorial/Array | Array]]
* [[C Tutorial/Data Structure | Data Structure]]
* [[C Tutorial/Data Type | Data Type]]
* [[C Tutorial/File | File]]
* [[C Tutorial/Function | Function]]
* [[C Tutorial/Language | Language]]
* [[C Tutorial/Memory | Memory]]
* [[C Tutorial/Operator | Operator]]
| style="width: 25%;"|
* [[C Tutorial/Pointer | Pointer]]
* [[C Tutorial/Preprocessor | Preprocessor]]
* [[C Tutorial/Search Sort | Search Sort]]
* [[C Tutorial/Statement | Statement]]
* [[C Tutorial/String | String]]
* [[C Tutorial/Structure | Structure]]
* [[C Tutorial/Wide Character String | Wide Character String]]
* [[C Tutorial/assert.h | assert.h]]
| style="width: 25%;"|
* [[C Tutorial/ctype.h | ctype.h]]
* [[C Tutorial/math.h | math.h]]
* [[C Tutorial/printf scanf | printf scanf]]
* [[C Tutorial/setjmp.h | setjmp.h]]
* [[C Tutorial/signal.h | signal.h]]
* [[C Tutorial/stdio.h | stdio.h]]
* [[C Tutorial/stdlib.h | stdlib.h]]
* [[C Tutorial/string.h | string.h]]
| style="width: 25%;"|
* [[C Tutorial/time.h | time.h]]
* [[C Tutorial/wctype.h | wctype.h]]
|}

== [[C++ | C++ Примеры]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C++/Bitset | Bitset]]
* [[C++/Class | Class]]
* [[C++/Console | Console]]
* [[C++/Data Structure | Data Structure]]
* [[C++/Data Type | Data Type]]
* [[C++/Deque | Deque]]
* [[C++/Development | Development]]
* [[C++/File | File]]
| style="width: 25%;"|
* [[C++/Function | Function]]
* [[C++/Generic | Generic]]
* [[C++/Language | Language]]
* [[C++/List | List]]
* [[C++/Map Multimap | Map Multimap]]
* [[C++/Overload | Overload]]
* [[C++/Pointer | Pointer]]
* [[C++/Qt | Qt]]
| style="width: 25%;"|
* [[C++/Queue Stack | Queue Stack]]
* [[C++/STL Algorithms Binary search | STL Algorithms Binary search]]
* [[C++/STL Algorithms Heap | STL Algorithms Heap]]
* [[C++/STL Algorithms Helper | STL Algorithms Helper]]
* [[C++/STL Algorithms Iterator | STL Algorithms Iterator]]
* [[C++/STL Algorithms Merge | STL Algorithms Merge]]
* [[C++/STL Algorithms Min Max | STL Algorithms Min Max]]
* [[C++/STL Algorithms Modifying sequence operations | STL Algorithms Modifying sequence operations]]
| style="width: 25%;"|
* [[C++/STL Algorithms Non modifying sequence operations | STL Algorithms Non modifying sequence operations]]
* [[C++/STL Algorithms Sorting | STL Algorithms Sorting]]
* [[C++/STL Basics | STL Basics]]
* [[C++/Set Multiset | Set Multiset]]
* [[C++/String | String]]
* [[C++/Valarray | Valarray]]
* [[C++/Vector | Vector]]
|}

== [[C++ Tutorial | C++ Учебник]] ==
{| width="100%"
|- valign="top"
| style="width: 25%;"|
* [[C++ Tutorial/Array | Array]]
* [[C++ Tutorial/Class | Class]]
* [[C++ Tutorial/Data Types | Data Types]]
* [[C++ Tutorial/Development | Development]]
* [[C++ Tutorial/Exceptions | Exceptions]]
* [[C++ Tutorial/File Stream | File Stream]]
* [[C++ Tutorial/Function | Function]]
* [[C++ Tutorial/Language Basics | Language Basics]]
| style="width: 25%;"|
* [[C++ Tutorial/Operator Overloading | Operator Overloading]]
* [[C++ Tutorial/Operators statements | Operators statements]]
* [[C++ Tutorial/Pointer | Pointer]]
* [[C++ Tutorial/STL Algorithms Binary search | STL Algorithms Binary search]]
* [[C++ Tutorial/STL Algorithms Heap | STL Algorithms Heap]]
* [[C++ Tutorial/STL Algorithms Helper | STL Algorithms Helper]]
* [[C++ Tutorial/STL Algorithms Iterator | STL Algorithms Iterator]]
* [[C++ Tutorial/STL Algorithms Merge | STL Algorithms Merge]]
| style="width: 25%;"|
* [[C++ Tutorial/STL Algorithms Min Max | STL Algorithms Min Max]]
* [[C++ Tutorial/STL Algorithms Modifying sequence operations | STL Algorithms Modifying sequence operations]]
* [[C++ Tutorial/STL Algorithms Non modifying sequence operations | STL Algorithms Non modifying sequence operations]]
* [[C++ Tutorial/STL Algorithms Sorting | STL Algorithms Sorting]]
* [[C++ Tutorial/STL Introduction | STL Introduction]]
* [[C++ Tutorial/Structure | Structure]]
* [[C++ Tutorial/bitset | bitset]]
* [[C++ Tutorial/deque | deque]]
| style="width: 25%;"|
* [[C++ Tutorial/list | list]]
* [[C++ Tutorial/map multimap | map multimap]]
* [[C++ Tutorial/queue stack | queue stack]]
* [[C++ Tutorial/set multiset | set multiset]]
* [[C++ Tutorial/string | string]]
* [[C++ Tutorial/template | template]]
* [[C++ Tutorial/valarray | valarray]]
* [[C++ Tutorial/vector | vector]]
|}

C/complex.h

2010-06-21T19:38:06Z

Admin: Новая страница: «'''complex.h''' — заголовочный файл стандартной библиотеки языка программирования С, в котором …»

'''complex.h''' — заголовочный файл стандартной библиотеки языка программирования С, в котором объявляются функции для комплексной арифметики. Эти функции используют встроенный тип complex, который появился в стандарте C99.

== Объявления функций ==
Функции в заголовочном файле <code>complex.h</code> представлены для трёх типов — double, float и long double (заметьте, что значения представлены в радианах):
{| class="wikitable" width="60%"
|<code>cabs, cabsf, cabsl</code> || Абсолютное значение комплексного числа
|-
|<code>cacos, cacosf, cacosl</code> || Комплексный арккосинус
|-
|<code>cacosh, cacoshf, cacoshl</code> || Комплексный гиперболический арккосинус
|-
|<code>carg, cargf, cargl || Аргумент комплексного числа
|-
|<code>casin, casinf, casinl || Комплексный арксинус
|-
|<code>casinh, casinhf, casinhl</code> || Комплексный гиперболический арксинус
|-
|<code>catan, catanf, catanl</code> || Комплексный арктангенс
|-
|<code>catanh, catanhf, catanhl</code> || Комплексный гиперболический арктангенс
|-
|<code>ccos, ccosf, ccosl</code> || Комплексный косинус
|-
|<code>ccosh, ccoshf, ccoshl</code> || Комплексный гиперболический косинус
|-
|<code>cexp, cexpf, cexpl</code> || Комплексная экспонента
|-
|<code>cimag, cimagf, cimagl</code> || Мнимая часть комплексного числа
|-
|<code>clog, clogf, clogl</code> || Натуральный логарифм комплексного числа
|-
|<code>conj, conjf, conjl</code> || Комплексное сопряжённое число
|-
|<code>cpow, cpowf, cpowl</code> || Степень комплексного числа
|-
|<code>cproj, cprojf, cprojl</code> || Проекция на римановскую сферу
|-
|<code>creal, crealf, creall</code> || Действительная часть комплексного числа
|-
|<code>csin, csinf, csinl</code> || Комплексный синус
|-
|<code>csinh, csinhf, csinhl</code> || Комплексный гиперболический синус
|-
|<code>csqrt, csqrtf, csqrtl</code> || Комплексный квадратный корень
|-
|<code>ctan, ctanf, ctanl</code> || Комплексный тангенс
|-
|<code>ctanh, ctanhf, ctanhl</code> || Комплексный гиперболический тангенс
|}

C примеры

2010-06-21T19:37:23Z

Admin:

C/assert.h

2010-06-21T19:36:14Z

Admin:

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

Макрос assert() добавляет к программе процедуру диагностики. После выполнения, если выражение ложно (то есть, результат сравнения 0), assert() пишет информацию о вызове в поток stderr и вызывает функцию abort(). Информация, которая пишется в stderr включает в себя:

* текст выражения, значение которого равно нулю 0
* имя файла с исходным кодом (предопределённый макрос __FILE__)
* строка у файла с исходным кодом (предопределённый макрос __LINE__)

[[C/assert.h/assert | assert]]

C/assert.h

2010-06-21T19:36:05Z

Admin:

C/ctype.h

2010-06-21T19:35:08Z

Admin:

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

* [[C/ctype.h/isalnum | isalnum]] - Проверяет, является ли аргумент буквой или цифрой
* [[C/ctype.h/isalpha | isalpha]] - Проверяет, является ли аргумент буквой
* [[C/ctype.h/isblank | isblank]] - Проверяет, является ли аргумент
* [[C/ctype.h/iscntrl | iscntrl]] - Проверяет, является ли аргумент управляющим символом
* [[C/ctype.h/isdigit | isdigit]] - Проверяет, является ли аргумент цифрой
* [[C/ctype.h/isgraph | isgraph]] - Проверяет, является ли аргумент символом, имеющим графическое представление
* [[C/ctype.h/islower | islower]] - Проверяет, является ли аргумент буквой в нижнем регистре
* [[C/ctype.h/isprint | isprint]] - Проверяет, является ли аргумент символом, который может быть напечатан
* [[C/ctype.h/ispunct | ispunct]] - Проверяет, является ли аргумент символом, имеющим графическое представление, но не являющимся при этом буквой или цифрой
* [[C/ctype.h/isspace | isspace]] - Проверяет, является ли аргумент разделительным символом
* [[C/ctype.h/isupper | isupper]] - Проверяет, является ли аргумент буквой в верхнем регистре
* [[C/ctype.h/isxdigit | isxdigit]] - Проверяет, является ли аргумент цифрой шестнадцатеричной системы счисления
* [[C/ctype.h/tolower | tolower]] - Преобразует аргумент в его строчный аналог (нижний регистр), если это возможно; иначе возвращается неизмененный аргумент.
* [[C/ctype.h/toupper | toupper]] - Преобразует аргумент в его прописной аналог (верхний регистр), если это возможно; иначе возвращается неизмененный аргумент.

C/math.h

2010-06-21T19:31:19Z

Admin:

'''math.h''' — заголовочный файл стандартной библиотеки языка программирования С, разработанный для выполнения простых математических операций. Большинство функций привлекают использование чисел с плавающей точкой. C++ также реализует данные функции для обеспечения совместимости, все они содержатся в заголовочном файле cmath.

Все эти функции принимают double, если не определено иначе. Для работы с типами float и long double используются функции с постфиксами f и l соответственно. Все функции, принимающие или возвращающие угол, работают с радианами.

* [[C/math.h/acos | acos]] - арккосинус
* [[C/math.h/acosh | acosh]] - гиперболический арккосинус
* [[C/math.h/asin | asin]] - арксинус
* [[C/math.h/asinh | asinh]] - гиперболический арксинус
* [[C/math.h/atan | atan]] - арктангенс
* [[C/math.h/atan2 | atan2]] - арктангенс с двумя параметрами
* [[C/math.h/atanh | atanh]] - гиперболический арктангенс
* [[C/math.h/cbrt | cbrt]] - кубический корень
* [[C/math.h/ceil | ceil]] - округление до ближайшего большего целого числа
* [[C/math.h/copysign | copysign]] - возвращает величину, абсолютное значение которой равно x, но знак которой соответствует знаку y
* [[C/math.h/cos | cos]] - косинус
* [[C/math.h/cosh | cosh]] - гиперболический косинус
* [[C/math.h/erf | erf]] - функция ошибок
* [[C/math.h/erfc | erfc]] - Дополнительная функция ошибок
* [[C/math.h/exp | exp]] - вычисление экспоненты
* [[C/math.h/exp2 | exp2]] - значение числа 2, возведённого в степень x, 2x
* [[C/math.h/expm1 | expm1]] - значение функции ex − 1
* [[C/math.h/fabs | fabs]] - абсолютная величина (числа с плавающей точкой)
* [[C/math.h/fdim | fdim]] - вычисление положительной разницы между x и y, fmax(x−y, 0)
* [[C/math.h/floor | floor]] - округление до ближайшего меньшего целого числа
* [[C/math.h/fma | fma]] - значение функции (x * y) + z (см. FMA)
* [[C/math.h/fmax | fmax]] - наибольшее значение среди x и y
* [[C/math.h/fmin | fmin]] - наименьшее значение среди x и y
* [[C/math.h/fmod | fmod]] - вычисление остатка от деления нацело для чисел с плавающей точкой
* [[C/math.h/fpclassify | fpclassify]] -
* [[C/math.h/frexp | frexp]] - разбивает число с плавающей точкой на мантиссу и показатель степени.
* [[C/math.h/hypot | hypot]] - гипотенуза, sqrt(x² + y²)
* [[C/math.h/ilogb | ilogb]] - экспонента числа с плавающей точкой, конвертированная в int
* [[C/math.h/isfinite | isfinite]] -
* [[C/math.h/isgreater | isgreater]] -
* [[C/math.h/isgreaterequal | isgreaterequal]] -
* [[C/math.h/isinf | isinf]] -
* [[C/math.h/isless | isless]] -
* [[C/math.h/islessequal | islessequal]] -
* [[C/math.h/islessgreater | islessgreater]] -
* [[C/math.h/isnan | isnan]] -
* [[C/math.h/isnormal | isnormal]] -
* [[C/math.h/isunordered | isunordered]] -
* [[C/math.h/ldexp | ldexp]] - умножение числа с плавающей точкой на целую степень двух
* [[C/math.h/lgamma | lgamma]] - натуральный логарифм абсолютного значения гамма-функции
* [[C/math.h/llrint | llrint]] - округление до ближайшего целого (возвращает long long)
* [[C/math.h/llround | llround]] - округление до ближайшего целого в направлении от нуля (возвращает long long)
* [[C/math.h/log | log]] - натуральный логарифм
* [[C/math.h/log10 | log10]] - логарифм по основанию 10
* [[C/math.h/log1p | log1p]] - натуральный логарифм 1 + x
* [[C/math.h/log2 | log2]] - логарифм по основанию 2
* [[C/math.h/logb | logb]] - целочисленная часть логарифма x по основанию 2
* [[C/math.h/lrint | lrint]] - округление до ближайшего целого (возвращает long)
* [[C/math.h/lround | lround]] - округление до ближайшего целого в направлении от нуля (возвращает long)
* [[C/math.h/modf | modf]] - извлекает целую и дробную части (с учетом знака) из числа с плавающей точкой
* [[C/math.h/nan | nan]] - возвращает нечисловое значение 'Not a Number'
* [[C/math.h/nearbyint | nearbyint]] - округление аргумента до целого значения в формате числа с плавающей точкой
* [[C/math.h/nextafter | nextafter]] - следующий ближайшее представимое для x (по направлению к y)
* [[C/math.h/nexttoward | nexttoward]] - то же, что и nextafter, но y имеет тип long double
* [[C/math.h/pow | pow]] - результат возведения x в степень y
* [[C/math.h/remainder | remainder]] - вычисляет остаток от деления согласно стандарту IEC 60559
* [[C/math.h/remquo | remquo]] - то же, что и remainder, но сохраняет коэффициент по указателю p (как int)
* [[C/math.h/rint | rint]] - округление до целого (возвращает int) с вызовом ошибку inexact, если результат отличается от аргумента
* [[C/math.h/round | round]] - округление до целого (возвращает int)
* [[C/math.h/scalbln | scalbln]] - x * FLT_RADIXn (n is long)
* [[C/math.h/scalbn | scalbn]] - x * FLT_RADIXn (n is int)
* [[C/math.h/signbit | signbit]] -
* [[C/math.h/sin | sin]] - синус
* [[C/math.h/sinh | sinh]] - гиперболический синус
* [[C/math.h/sqrt | sqrt]] - квадратный корень
* [[C/math.h/strftime | strftime]] -
* [[C/math.h/tan | tan]] - тангенс
* [[C/math.h/tanh | tanh]] - гиперболический тангенс
* [[C/math.h/tgamma | tgamma]] - гамма-функция
* [[C/math.h/time | time]] -
* [[C/math.h/trunc | trunc]] - округление до ближайшего целого числа в направлении к нулю

C/signal.h/SIGXCPU

2010-06-21T19:16:16Z

Admin: Новая страница: «В POSIX-системах, SIGXCPU — сигнал, посылаемый компьютерной программе, превышающей лимит процес…»

В POSIX-системах, SIGXCPU — сигнал, посылаемый компьютерной программе, превышающей лимит процессорного времени.

SIGXCPU — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), X — сокращенное написание англ. exceeded — превышеный, CPU — сокращенное англ. CPU time — время центрального процессора.

== Использование ==
SIGXCPU посылается, когда время, потраченное процессором для выполнения процесса, превышает допустимое значение (определенное системным вызовом fcntl и шеллом).

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

На некоторых операционных системах, Boehm garbage collector использует SIGXCPU и SIGPWR для синхронизации кросс-процессного сбора мусора.

C/signal.h/SIGPWR

2010-06-21T19:15:47Z

Admin: Новая страница: «В некоторых Unix-системах, SIGPWR — сигнал, посылается процессам при аварии сетевого питания. S…»

В некоторых Unix-системах, SIGPWR — сигнал, посылается процессам при аварии сетевого питания.

SIGPWR — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

Сигнал SIGINFO в Linux, является синонимом SIGPWR.

SIG — общий префикс сигналов (от англ. signal), PWR — сокращение англ. power — питание, INFO — сокращение англ. information — информация.

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

На некоторых операционных системах, Boehm garbage collector использует SIGPWR и SIGXCPU для синхронизации кросс-процессного сбора мусора.

C/signal.h/SIGCHLD

2010-06-21T19:14:44Z

Admin: Новая страница: «В POSIX-системах SIGCHLD — сигнал, посылаемый при изменении статуса дочернего процесса (заверше…»

В POSIX-системах SIGCHLD — сигнал, посылаемый при изменении статуса дочернего процесса (завершен, приостановлен или возобновлен).

SIGCHLD — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов, CHLD — сокращенное написание англ. child — ребенок, дочерний объект (английский компьютерный жаргон).

== Использование ==
В Unix процесс может порождать «дочерние» процессы системным вызовом fork() или его вариантами. Родительский процесс, если он существует, уведомляется системой о завершении дочерних процессов (или изменении их состояния) сигналом SIGCHLD. Родительский процесс не должен предпринимать для этого никаких действий. Сигнал может быть игнорирован, если не нуждается в обработке (по умолчанию он игнорируется).

== Процессы-зомби ==
Основная статья: Процесс-зомби
Дочерний процесс по завершении становится «зомби» — пустой записью в таблице процессов, хранящей информацию о завершенном процессе (точнее — код завершения) - до тех пор, пока родительский процесс не получит эту информацию с помощью системного вызова wait() или не завершится сам.

В короткоживущих программах наличие «зомби» вполне нормальное явление — зомби не занимают много ресурсов и исчезают с завершением родительского процесса. Но аккуратные программисты всегда заботятся о обработке «зомби». В общем случае для предотвращения накопления «зомби» программа должна использовать обработчик сигнала SIGCHLD c вызовом wait().

В Perl-е установка
<source lang="perl">$SIG{'CHLD'}="IGNORE"</source>

на самом деле устанавливает обработчик с обработкой процессов-зомби, как описано выше.

Python при
<source lang="python">signal.signal(signal.SIGCHLD, signal.SIG_IGN)</source>

делает то же самое.

C/signal.h/SIGUSR2

2010-06-21T19:12:59Z

Admin: Новая страница: «В POSIX-системах, SIGUSR1 и SIGUSR2 — пользовательские сигналы, которые могут быть использованы для…»

В POSIX-системах, SIGUSR1 и SIGUSR2 — пользовательские сигналы, которые могут быть использованы для межпроцессной синхронизации и управления.

SIGUSR1 и SIGUSR2 — целочисленные константы, определенные в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), USR — сокращенное написание англ. user-defined — определяемый пользователем.

== Использование ==
SIGUSR1 и SIGUSR2 могут быть использованны программой для произвольных нужд, например для межпроцессной (или межпоточной) синхронизации, управления фоновыми процессами (демонами) и т. п. По умолчанию, сигналы SIGUSR1 и SIGUSR2 завершают выполнение процесса.

Ранние разработки системы сигналов не имели пользовательских сигналов, поэтому для управления демонами (для их реинициализации) традиционно используется сигнал SIGHUP.

C/signal.h/SIGUSR1

2010-06-21T19:12:30Z

C/signal.h/SIGTERM

2010-06-21T19:11:57Z

Admin: Новая страница: «В POSIX-системах, SIGTERM — сигнал, для запроса завершения процесса. SIGTERM — целочисленная конст…»

В POSIX-системах, SIGTERM — сигнал, для запроса завершения процесса.

SIGTERM — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), TERM — сокращенное написание англ. terminate — завершить.

== Использование ==
SIGTERM посылается процессу утилитой kill по умолчанию. В отличие от SIGKILL этот сигнал может быть обработан или проигнорирован программой.

C/signal.h/SIGALRM

2010-06-21T19:11:34Z

Admin: Новая страница: «В POSIX-системах, SIGALRM — сигнал, посылаемый процессу по истечении времени предварительно зад…»

В POSIX-системах, SIGALRM — сигнал, посылаемый процессу по истечении времени предварительно заданном функцией alarm().

SIGALRM — целочисленная константа, определённая в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов, АLRM — сокращенное написание англ. alarm — тревога, сигнал будильника.

== Использование ==
Программы, обычно используют SIGALRM при реализации тайм-аута для долговременной опрерации, или выполнения операции через определённые интервалы.

SIGALRM посылается ядром через целое количество секунд после вызова alarm(). Иногда этот механизм используется для реализации функции sleep().

C/signal.h/SIGPIPE

2010-06-21T19:11:02Z

Admin: Новая страница: «В POSIX-системах, SIGPIPE — сигнал, посылаемый процессу при записи в соединение (пайп, сокет) при …»

В POSIX-системах, SIGPIPE — сигнал, посылаемый процессу при записи в соединение (пайп, сокет) при отсутствии или обрыве соединения с другой (читающей) стороной.

SIGPIPE — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), PIPE — англ. pipe — труба, соединение.

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

Наиболее простой вариант пайпа создает шелл Unix, между программами, запускаемыми из командной строки, разделенными символом «|», например, командная строка:

<source lang="bash">dmesg | less</source>
создает пайп от программы dmesg (выводящей отладочные сообщения ядра при загрузке) к программе постраничного просмотра less. Если программа less завершится, прежде чем получит весь вывод dmesg, dmesg будет преждевременно завершена сигналом SIGPIPE.

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

C/signal.h/SIGSYS

2010-06-21T19:10:02Z

Admin: Новая страница: «В POSIX-системах, SIGSYS — сигнал, предназначенный для посылки программе, при попытке передать …»

В POSIX-системах, SIGSYS — сигнал, предназначенный для посылки программе, при попытке передать неправильный аргумент в системный вызов.

SIGSYS — целочисленная константа, определенная в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), SYS — сокращенное написание англ. system call — системный вызов.

== Использование ==
Теоретически, SIGSYS может быть послан, когда процесс передает неправильный аргумент в системный вызов. На практике же, система возвращает ENOSYS, если системного вызова с запрошенным кодом не существует или соответствующую ошибку, если аргумент системного вызова неправилен (например, EBADF, если заданного файлового дескриптора не существует). POSIX.1 говорит о SIGSYS следующим образом:

: ''There is very little that a conforming POSIX.1 application can do by catching, ignoring or masking ... SIGSYS. ...''
: ''One portable use that does exist ... is that a command interpreter can recognize them as the cause of a process's termination.''

: ''Приложение, отвечающее POSIX.1 при перехвате SIGSYS, может сделать довольно мало.''
: ''Например, командный интерпретатор может указать его как причину завершения процесса.''

C/signal.h/SIGSEGV

2010-06-21T19:09:20Z

Admin: /* Использование */

Материал из Википедии — свободной энциклопедииПерейти к: навигация, поиск
SIGSEGV Описание: Исключение при обращении в память
По умолчанию: завершение с дампом памяти
коды SA_SIGINFO
SEGV_MAPERR Обращение к незадействованной странице
SEGV_ACCERR Нарушение прав доступа к странице

В POSIX-системах, SIGSEGV — сигнал, посылаемый процессу при попытке обращения к несуществующей памяти или обращения с нарушением прав доступа.

SIGSEGV — целочисленная константа, определённая в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), SEGV — англ. segmentation violation — нарушение сегментации.

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

== Использование ==
Система отображает память в адресное пространство процесса страницами размером 4—8 КБ (размер страницы зависит от аппаратной платформы, например в i386 это 4 КБ), по мере необходимости — по мере выделения памяти процессом. Также, в адресное пространство могут быть отображены:

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

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

Операционная система может предоставить дополнительные данные о возникшей ошибке, используя стек сигнала (англ. signal stack), который может помочь разработчику в отладке данной ошибки.

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

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

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

C/signal.h/SIGSEGV

2010-06-21T19:09:08Z

Admin: Новая страница: «Материал из Википедии — свободной энциклопедииПерейти к: навигация, поиск SIGSEGV Описание: …»

Материал из Википедии — свободной энциклопедииПерейти к: навигация, поиск
SIGSEGV Описание: Исключение при обращении в память
По умолчанию: завершение с дампом памяти
коды SA_SIGINFO
SEGV_MAPERR Обращение к незадействованной странице
SEGV_ACCERR Нарушение прав доступа к странице

В POSIX-системах, SIGSEGV — сигнал, посылаемый процессу при попытке обращения к несуществующей памяти или обращения с нарушением прав доступа.

SIGSEGV — целочисленная константа, определённая в заголовочном файле signal.h. Символьные имена сигналов используются вместо номеров, так как в разных реализациях номера сигналов могут различаться.

SIG — общий префикс сигналов (от англ. signal), SEGV — англ. segmentation violation — нарушение сегментации.

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

== Использование ==
Система отображает память в адресное пространство процесса страницами размером 4—8 КБ (размер страницы зависит от аппаратной платформы, например в i386 это 4 КБ), по мере необходимости — по мере выделения памяти процессом. Также, в адресное пространство могут быть отображены:

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

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

Операционная система может предоставить дополнительные данные о возникшей ошибке, используя стек сигнала (англ. signal stack), который может помочь разработчику в отладке данной ошибки.

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

SIGSEGV может быть перехвачен или проигнорирован. Однако игнорирование SIGSEGV, в некоторых случаях, может привести к непредсказуемым результатам [1](англ.).

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