上記の広告は１ヶ月以上更新のないブログに表示されています。
新しい記事を書く事で広告が消せます。

9.5. Limits

Two header files <float.h> and <limits.h> define several implementation specific limits.

9.5.1. Limits.h

Table 9.1 gives the names declared, the allowable values, and a comment on what they mean. For example, the description of SHRT_MIN shows that in a given implementation the value must be less than or equal to −32767: this means that for maximum portability a program cannot rely on short variables being able to hold values more negative than −32767. Implementations may choose to support values which are more negative but must provide support for at least −32767.

9.5.2. Float.h

For floating point numbers, the file <float.h> contains a similar set of minimum values. (It is assumed that where no minimum value is specified, there is either no minimum, or the value depends on another value.)

[Quote]:http://publications.gbdirect.co.uk/c_book/chapter9/limits.html

Mathematical functions

If you are writing mathematical programs, involving floating point calculations and so on, then you will undoubtedly require access to the mathematics library. This set of functions all take double arguments, and return a double result. The functions and associated macros are defined in the include file .

The macro HUGE_VAL is defined, which expands to a positive double expression, which is not necessarily representable as a float.

For all the functions, a domain error occurs if an input argument is outside the domain over which the function is defined. An example might be attempting to take the square root of a negative number. If this occurs, errno is set to the constant EDOM, and the function returns an implementation defined value.

If the result of the function cannot be represented as a double value then a range error occurs. If the magnitude of the result is too large, the functions return ±HUGE_VAL (the sign will be correct) and errno is set to ERANGE. If the result is too small, 0.0 is returned and the value of errno is implementation defined.

The following list briefly describes each of the functions available:

double acos(double x);
Principal value of the arc cosine of x in the range 0–π radians.
Errors: EDOM if x is not in the range −1–1.
double asin(double x);
Principal value of the arc sine of x in the range -π/2–+π/2 radians.
Errors: EDOM if x is not in the range −1–1.
double atan(double x);
Principal value of the arc tangent of x in the range -π/2–+π/2 radians.
double atan2(double y, double x);
Principal value of the arc tangent of y/x in the range -π–+π radians, using the signs of both arguments to determine the quadrant of the return value.
Errors: EDOM may occur if both x and y are zero.
double cos(double x);
Cosine of x (x measured in radians).
double sin(double x);
Sine of x (x measured in radians).
double tan(double x);
Tangent of x (x measured in radians). When a range error occurs, the sign of the resulting HUGE_VAL is not guaranteed to be correct.
double cosh(double x);
Hyperbolic cosine of x.
Errors: ERANGE occurs if the magnitude of x is too large.
double sinh(double x);
Hyperbolic sine of x.
Errors: ERANGE occurs if the magnitude of x is too large.
double tanh(double x);
Hyperbolic tangent of x.
double exp(double x);
Exponential function of x. Errors: ERANGE occurs if the magnitude of x is too large.
double frexp(double value, int *exp);
Break a floating point number into a normalized fraction and an integral power of two. This integer is stored in the object pointed to by exp.
double ldexp(double x, int exp);
Multiply x by 2 to the power exp
Errors: ERANGE may occur.
double log(double x);
Natural logarithm of x.
Errors: EDOM occurs if x is negative. ERANGE may occur if x is zero.
double log10(double x);
Base-ten logarithm of x.
Errors: EDOM occurs if x is negative. ERANGE may occur if x is zero.
double modf(double value, double *iptr);
Break the argument value into integral and fractional parts, each of which has the same sign as the argument. It stores the integrbal part as a double in the object pointed to by iptr, and returns the fractional part.
double pow(double x, double y);
Compute x to the power y.
Errors: EDOM occurs if x < 0 and y not integral, or if the result cannot be represented if x is 0, and y ≤ 0. ERANGE may also occur.
double sqrt(double x);
Compute the square root of x.
Errors: EDOM occurs if x is negative.
double ceil(double x);
Smallest integer not less than x.
double fabs(double x);
Absolute value of x.
double floor(double x);
Largest integer not greater than x.
double fmod(double x, double y);
Floating point remainder of x/y.
Errors: If y is zero, it is implementation defined whether fmod returns zero or a domain error occurs.

[Quote]:http://64.233.167.104/search?q=cache:Q1DXRLum_skJ:publications.gbdirect.co.uk/c_book/chapter9/maths_functions.html+C+ERANGE&hl=en&ct=clnk&cd=8&gl=us&lr=lang_en|lang_ja&client=firefox-a

構文

#include <limits.h>

説明

次の記号は、 <limits.h> で定義されています。 これらは、このマニュアルの説明文中で使用されているものです。 HP-UX 値 欄は、すべての HP-UX システムで移植性のあるアプリケーションを 作成するために想定すべき値を示しています。

値の後の記号は、次に示す意味を持っています。

これらの限界値の中には、システム構成によって違うものがあります。 その値は、 sysconf(2) を使って動的にに知ることができます。 また、ファイルシステムや、特殊ファイルに対応するデバイスに よって違うものがあります。 その値は pathconf(2) を使って知ることができます。 さらに、時代遅れのものもあります。 他の限界値に対して冗長であったり、移植可能なアプリケーションを 作成するのに役立ちません。 これらは、他のシステムからのアプリケーションの移植や、『 X/Open Portability Guide, Issue 2 』に従うアプリケーションをサポートしたり、以前の HP-UX の旧製品との互換性を保つために提供されています。 新しいアプリケーションでは _XPG2 フラグを定義しないでください。

コンパイルの際に <limits.h> ファイルをインクルードして、 そのアプリケーションが、ある特定のシステムで動作できるかどうかを 調べるための適当な限界値を検査することができます。 さらに、そのシステムに適合するようにアプリケーションの挙動を変えて、 様々な範囲にわたる限界値の設定やシステムの移植性を向上することもできます。

\".na

定数	説明	HP-UX 値	ARG_MAX
環境データを含む、 exec(2)への引き数の最大長 (バイト単位)	5120 +*
CHAR_BIT	char のビット数	8 =
CHAR_MAX	char の最大整数値	127 =
CHAR_MIN	char の最小整数値	-128 =
CHILD_MAX	ユーザー ID あたりの並行プロセス の最大個数	25 +-*
CLK_TCK	1 秒間あたりのクロックチック数	50 +#
DBL_DIG	double の精度の桁数	15 +
DBL_MAX	double の最大正数値	1.7976931348623157e+308 +
DBL_MIN	double の最小正数値	4.94065645841246544e-324 -
FCHR_MAX	ファイルの最大オフセット (バイト単位)	INT_MAX +-*
FLT_DIG	float の精度の桁数	6 +
FLT_MAX	float の最大正数値	3.40282346638528860e+38 +
FLT_MIN	float の最小正数値	1.40129846432481707e-45 -
INT_MAX	int の最大 10 進値	2147483647 +
INT_MIN	int の最小 10 進値	-2147483648 -
LINE_MAX	1 行あたりの最大文字数	2048 =
LINK_MAX	1 ファイルあたりの最大リンク数	32767 +*
LOCK_MAX	システムロック テーブルの最大エントリー数	32 +-*
LONG_BIT	long のビット数	32 +
LONG_MAX	long の最大 10 進値	2147483647 +
LONG_MIN	long の最小 10 進値	-2147483648 -
MAX_CANON	ターミナル基準入力行に含まれる最大バイト数	512 +*
MAX_CHAR	ターミナル入力キューに含まれる最大バイト数	MAX_INPUT =*
MAX_INPUT	ターミナル入力キューに含まれる最大バイト数	512 +*
NAME_MAX	1 つのパス名構成要素の最大バイト数	14 +*
NL_ARGMAX	NLS printf(3S) 関数および scanf(3S)関数の呼出しの際の最大「桁」数	9 =
NL_MSGMAX	1 つの NLS メッセージカタログに含まれる 最大メッセージ数	32767 +
NL_SETMAX	1 つの NLS メッセージカタログに含まれる 最大セット数	255 +
NL_TEXTMAX	1 つの NLS メッセージ文字列に含まれる 最大バイト数	8192 +
NGROUPS_MAX	プロセスあたりの最大補助グループ数	20 +
OPEN_MAX	1 つのプロセスがオープンできる最大ファイル数	60 +*
PASS_MAX	1 つのパスワードに含まれる最大文字数	8 +
PATH_MAX	null ターミネータを除く、 1 つのパス名に含まれる最大文字数	1023 +*
PID_MAX	1 つのプロセス ID の最大値	30000 +
PIPE_BUF	1 つのパイプへの書込み単位の最大バイト数	8192 +*
PIPE_MAX	1 回の書込みで 1 つのパイプに書き込める最大バイト数	INT_MAX +
PROC_MAX	システムの最大並行プロセス数	84 +-*
SCHAR_MAX	signed char の最大整数値	127 =
SCHAR_MIN	signed char の最小整数値	-128 =
SHRT_MAX	short の最大 10 進値	32767 +
SHRT_MIN	short の最小 10 進値	-32768 -
STD_BLK	物理的 I/O ブロックに含まれるバイト数	512 +
SYSPID_MAX	システムプロセスの最大プロセス ID	4 +-*
SYS_NMLN	uname(2) が返す文字列の長さ	8 +*
SYS_OPEN	システムでオープンされるファイルの最大個数	120 +-*
TMP_MAX	tmpnam(3S) が生成するユニークな名前の 最大個数	17576 +
UCHAR_MAX	unsigned char の最大整数値	255 =
UID_MAX	ユーザー ID やグループ ID として 使用できない値の最小値	2147483647 +
UINT_MAX	unsigned int の最大 10 進値	4294967295 +
ULONG_MAX	unsigned long の最大 10 進値	4294967295 +
USHRT_MAX	unsigned short の最大 10 進値	65535 +
USI_MAX	unsigned int の最大 10 進値	UINT_MAX =*
WORD_BIT	1 つの「ワード」 (int) 中のビット数	32 +

[Quote]:http://64.233.167.104/search?q=cache:CV3oOiXYuGAJ:www.docs.hp.com/ja/B2355-60104-09/limits.5.html+INT_MAX&hl=en&ct=clnk&cd=2&gl=us&lr=lang_en|lang_ja&client=firefox-a

C++ offers new capabilities, some of which supplant those offered by the ANSI C preprocessor. These new capabilities enhance the type safety and predictability of the language:

* In C++, objects declared as const can be used in constant expressions. This allows programs to declare constants that have type and value information, and enumerations that can be viewed symbolically with the debugger. Using the preprocessor #define directive to define constants is not as precise. No storage is allocated for a const object unless an expression that takes its address is found in the program.

* The C++ inline function capability supplants function-type macros. The advantages of using inline functions over macros are:

o Type safety. Inline functions are subject to the same type checking as normal functions. Macros are not type safe.
o Correct handling of arguments that have side effects. Inline functions evaluate the expressions supplied as arguments prior to entering the function body. Therefore, there is no chance that an expression with side effects will be unsafe.

For more information on inline functions, see inline, __inline, __forceinline.

[Quote]:http://msdn2.microsoft.com/en-us/library/ttsbh614.aspx

Preprocessing expands macros in all lines that are not preprocessor directives (lines that do not have a # as the first non-white-space character) and in parts of some directives that are not skipped as part of a conditional compilation. "Conditional compilation" directives allow you to suppress compilation of parts of a source file by testing a constant expression or identifier to determine which text blocks are passed on to the compiler and which text blocks are removed from the source file during preprocessing.

The #define directive is typically used to associate meaningful identifiers with constants, keywords, and commonly used statements or expressions. Identifiers that represent constants are sometimes called "symbolic constants" or "manifest constants." Identifiers that represent statements or expressions are called "macros." In this preprocessor documentation, only the term "macro" is used.

When the name of the macro is recognized in the program source text or in the arguments of certain other preprocessor commands, it is treated as a call to that macro. The macro name is replaced by a copy of the macro body. If the macro accepts arguments, the actual arguments following the macro name are substituted for formal parameters in the macro body. The process of replacing a macro call with the processed copy of the body is called "expansion" of the macro call.

In practical terms, there are two types of macros. "Object-like" macros take no arguments, whereas "function-like" macros can be defined to accept arguments so that they look and act like function calls. Because macros do not generate actual function calls, you can sometimes make programs run faster by replacing function calls with macros. (In C++, inline functions are often a preferred method.) However, macros can create problems if you do not define and use them with care. You may have to use parentheses in macro definitions with arguments to preserve the proper precedence in an expression. Also, macros may not correctly handle expressions with side effects. See the getrandom example in The #define Directive for more information.

Once you have defined a macro, you cannot redefine it to a different value without first removing the original definition. However, you can redefine the macro with exactly the same definition. Thus, the same definition can appear more than once in a program.

[Quote]:http://msdn2.microsoft.com/en-us/library/503x3e3s.aspx