|
|
|
|
|
 |
HP C
|
| Previous | Contents | Index |
The <float.h> and <limits.h> header files define several macros that expand to various implementation-specific limits and parameters. This appendix contains the contents of these header files for HP C for OpenVMS Systems.
The <float.h> header file has the following contents:
#ifndef _LOADED
#define _LOADED 1
/****************************************************************************
**
** <float.h> - Characteristics of floating types
**
*****************************************************************************
** Header introduced by the ANSI C Standard
*****************************************************************************
**
** Copyright 2001, 2004 Hewlett-Packard Development Company, L.P.
**
** Confidential computer software. Valid license from HP required for
** possession, use or copying. Consistent with FAR 12.211 and 12.212,
** Commercial Computer Software, Computer Software Documentation, and
** Technical Data for Commercial Items are licensed to the U.S. Government
** under vendor's standard commercial license.
**
******************************************************************************
*/
#include <decc$types.h>
#pragma
#ifdef
{
#endif
/*
** The following literals and routines are available on OpenVMS for
** Alpha, but only after OpenVMS V7.1 or with C++.
*/
#if defined _ANSI_C_SOURCE
# if (defined(|| (_VER >= 70100000))
/*
** Values for the IEEE Rounding Modes (IEEE ANSI Values)
**
** RZ = Round toward zero (chopped)
** RN = Round toward nearest (default, normal)
** RP = Round toward plus infinity
** RM = Round toward minus infinity
*/
# define FP_RND_RZ 0
# define FP_RND_RN 1
# define FP_RND_RP 2
# define FP_RND_RM 3
/*
** IEEE Constants
*/
# ifdef _IEEE_FP
# pragma _model
# pragma _model _refdef
extern double decc$gt_dinfinity;
extern double decc$gt_dqnan;
extern double decc$gt_dsnan;
extern float decc$gs_sinfinity;
extern float decc$gs_sqnan;
extern float decc$gs_ssnan;
# if __X_FLOAT
# if (__CRTL_VER >= 60200000)
extern long double decc$gx_long_dbl_infinity;
# endif
extern long double decc$gx_long_dbl_qnan;
extern long double decc$gx_long_dbl_snan;
# endif
# pragma _model
# define DBL_INFINITY decc$gt_dinfinity
# define LDBL_INFINITY DBL_INFINITY
# define DBL_QNAN decc$gt_dqnan
# define DBL_SNAN decc$gt_dsnan
# define FLT_INFINITY decc$gs_sinfinity
# define FLT_QNAN decc$gs_sqnan
# define FLT_SNAN decc$gs_ssnan
# if __X_FLOAT
# if (__CRTL_VER >= 60200000)
# define LDBL_INFINITY decc$gx_long_dbl_infinity
# else
# define LDBL_INFINITY DBL_INFINITY
# endif
# define LDBL_QNAN decc$gx_long_dbl_qnan
# define LDBL_SNAN decc$gx_long_dbl_snan
# else
# define LDBL_INFINITY DBL_INFINITY
# define LDBL_QNAN DBL_QNAN
# define LDBL_SNAN DBL_SNAN
# endif
# endif
/*
** Macros to get decc$ names
*/
# if (_VER < 70100000)
# define write_rnd($write_rnd(
# define read_rnd decc$read_rnd
# endif
/*
** Functions to read and write floating point rounding mode
*/
unsigned int write_rnd(unsigned int
_rnd(void);
# endif
#endif
/*
** Rounding mode for floating point addition:
*/
#ifdef _FLT_ROUNDS
# define FLT_ROUNDS (_FLT_ROUNDS-1) /* use compiler generated
value, if present */
#else
# define FLT_ROUNDS 1
#endif
/*
** Radix of exponent representation:
*/
#define FLT_RADIX 2
/*
** Number of FLT_RADIX digits in the mantissa including the hidden bit:
*/
#define _FLT_MANT_DIG 24
#define _DBL_MANT_DIG 53
#ifdef
#define _FLT_MANT_DIG 24
#define _FLT_MANT_DIG 53
#define _FLT_MANT_DIG 113
#endif
/*
** Number of decimal digits of precision:
*/
#define _FLT_DIG 6
#define _FLT_DIG 15
#ifdef
#define _FLT_DIG 6
#define _FLT_DIG 15
#define _FLT_DIG 33
#endif
/*
** Minimum negative integer such that FLT_RADIX raised to that power
** minus 1 is a normalized floating-point number:
*/
#define _FLT_MIN_EXP (-127)
#define _FLT_MIN_EXP (-1023)
#ifdef
#define _FLT_MIN_EXP (-125)
#define _FLT_MIN_EXP (-1021)
#define _FLT_MIN_EXP (-16381)
#endif
/*
** Minimum negative integer such that 10 raised to that power is in the
** range of normalized floating-point numbers:
*/
#define _FLT_MIN_10_EXP (-38)
#define _FLT_MIN_10_EXP (-308)
#ifdef
#define _FLT_MIN_10_EXP (-37)
#define _FLT_MIN_10_EXP (-307)
#define _FLT_MIN_10_EXP (-4931)
#endif
/*
** Maximum integer such that FLT_RADIX raised to that power minus 1 is a
** representable finite floating point number:
*/
#define _FLT_MAX_EXP 127
#define _FLT_MAX_EXP 1023
#ifdef
#define _FLT_MAX_EXP 128
#define _FLT_MAX_EXP 1024
#define _FLT_MAX_EXP 16384
#endif
/*
** Maximum integer such that 10 raised to that power is in the range of
** representable finite floating-point numbers:
*/
#define _FLT_MAX_10_EXP 38
#define _FLT_MAX_10_EXP 307
#ifdef
#define _FLT_MAX_10_EXP 38
#define _FLT_MAX_10_EXP 308
#define _FLT_MAX_10_EXP 4932
#endif
/*
** Maximum representable finite floating-point number:
*/
#define _FLT_MAX 1.7014117e+38f
#define _FLT_MAX 8.98846567431157854e+307
#ifdef
#define _FLT_MAX 3.40282347e+38f
#define _FLT_MAX 1.79769313486231570e+308
#define _FLT_MAX 1.189731495357231765085759326628007016196477e4932l
#endif
/*
** The difference between 1.0 and the least value greater than 1.0 that
** is representable in the given floating-point type
** (i.e. 1.0 + epsilon != 1.0):
*/
#define _FLT_EPSILON ((float)(1.0 / (1 << 23)))
#define _FLT_EPSILON (1.0 / (1 << 30) / (1 << 22))
#ifdef
#define _FLT_EPSILON 1.19209290e-07f
#define _FLT_EPSILON 2.2204460492503131e-16
#define _FLT_EPSILON 1.9259299443872358530559779425849273185381e-34l
#endif
/*
** Minimum normalized positive floating-point number:
*/
#define _FLT_MIN ((float) 2.93873587705571877e-39)
#define _FLT_MIN 5.56268464626800346e-309
#ifdef
#define _FLT_MIN 1.17549435e-38f
#define _FLT_MIN 2.2250738585072014e-308
#define _FLT_MIN ((long double)
3.3621031431120935062626778173217526025981e-4932l)
#endif
/*
** Define the FLT values to be either the
*/
#if _FLOAT
# define FLT_MANT_DIG _FLT_MANT_DIG
# define FLT_DIG _FLT_DIG
# define FLT_MIN_EXP _FLT_MIN_EXP
# define FLT_MIN_10_EXP _FLT_MIN_10_EXP
# define FLT_MAX_EXP _FLT_MAX_EXP
# define FLT_MAX_10_EXP _FLT_MAX_10_EXP
# define FLT_MAX _FLT_MAX
# define FLT_EPSILON _FLT_EPSILON
# define FLT_MIN _FLT_MIN
#else
# define FLT_MANT_DIG _FLT_MANT_DIG
# define FLT_DIG _FLT_DIG
# define FLT_MIN_EXP _FLT_MIN_EXP
# define FLT_MIN_10_EXP _FLT_MIN_10_EXP
# define FLT_MAX_EXP _FLT_MAX_EXP
# define FLT_MAX_10_EXP _FLT_MAX_10_EXP
# define FLT_MAX _FLT_MAX
# define FLT_EPSILON _FLT_EPSILON
# define FLT_MIN _FLT_MIN
#endif
/*
** Define the DBL values to be either the
*/
#if _FLOAT
# define DBL_MANT_DIG _FLT_MANT_DIG
# define DBL_DIG _FLT_DIG
# define DBL_MIN_EXP _FLT_MIN_EXP
# define DBL_MIN_10_EXP _FLT_MIN_10_EXP
# define DBL_MAX_EXP _FLT_MAX_EXP
# define DBL_MAX_10_EXP _FLT_MAX_10_EXP
# define DBL_MIN _FLT_MIN
#elif _FLOAT
# define DBL_MANT_DIG _DBL_MANT_DIG
# define DBL_DIG _FLT_DIG
# define DBL_MIN_EXP _FLT_MIN_EXP
# define DBL_MIN_10_EXP _FLT_MIN_10_EXP
# define DBL_MAX_EXP _FLT_MAX_EXP
# define DBL_MAX_10_EXP _FLT_MAX_10_EXP
# define DBL_MIN _FLT_MIN
#else
# define DBL_MANT_DIG 56
# define DBL_DIG 16
# define DBL_MIN_EXP _FLT_MIN_EXP
# define DBL_MIN_10_EXP _FLT_MIN_10_EXP
# define DBL_MAX_EXP _FLT_MAX_EXP
# define DBL_MAX_10_EXP _FLT_MAX_10_EXP
# define DBL_MIN 2.93873587705571877e-39
#endif
#if _FLOAT
# define DBL_MAX _FLT_MAX
#elif _FLOAT
# define DBL_MAX _FLT_MAX
#else
# ifndef
# define DBL_MAX 1.70141183460469229e+38
# else
# define DBL_MAX 1.70141183460469213e+38
# endif
#endif
#if _FLOAT
# define DBL_EPSILON _FLT_EPSILON
#elif _FLOAT || (_FLOAT && defined(
# define DBL_EPSILON (1.0 / (1 << 20) / (1 << 16) / (1 << 16))
#else
# define DBL_EPSILON (1.0 / (1 << 23) / (1 << 16) / (1 << 16))
#endif
/*
** Define the LDBL values based on _FLOAT
*/
#if _FLOAT
# define LDBL_MANT_DIG _FLT_MANT_DIG
# define LDBL_DIG _FLT_DIG
# define LDBL_MIN_EXP _FLT_MIN_EXP
# define LDBL_MIN_10_EXP _FLT_MIN_10_EXP
# define LDBL_MAX_EXP _FLT_MAX_EXP
# define LDBL_MAX_10_EXP _FLT_MAX_10_EXP
# define LDBL_MAX _FLT_MAX
# define LDBL_EPSILON _FLT_EPSILON
# define LDBL_MIN 3.3621031431120935062626778173217526025981e-4932l
#else
# define LDBL_MANT_DIG DBL_MANT_DIG
# define LDBL_DIG DBL_DIG
# define LDBL_MIN_EXP DBL_MIN_EXP
# define LDBL_MIN_10_EXP DBL_MIN_10_EXP
# define LDBL_MAX_EXP DBL_MAX_EXP
# define LDBL_MAX_10_EXP DBL_MAX_10_EXP
# define LDBL_MAX DBL_MAX
# define LDBL_EPSILON DBL_EPSILON
# define LDBL_MIN DBL_MIN
#endif
#ifdef
}
#endif
#pragma
#endif /* _LOADED */
|
The <limits.h> header file has the following contents:
#ifndef _LOADED
#define _LOADED 1
/****************************************************************************
**
** <limits.h> - Sizes of integral types
**
*****************************************************************************
** Header introduced by the ANSI C Standard
*****************************************************************************
**
** Copyright 2001, 2004 Hewlett-Packard Development Company, L.P.
**
** Confidential computer software. Valid license from HP required for
** possession, use or copying. Consistent with FAR 12.211 and 12.212,
** Commercial Computer Software, Computer Software Documentation, and
** Technical Data for Commercial Items are licensed to the U.S. Government
** under vendor's standard commercial license.
**
******************************************************************************
** Note
******************************************************************************
**
** Section 2.2.4.2 of the Rationale states "The limits for the maxima and
** minima of unsigned types are specified as unsigned constants..."
**
** The alert reader will notice there are no minima for the unsigned types,
** but we will follow the Rationale's advice anyway.
**
******************************************************************************
** Implementors Note
******************************************************************************
**
** Some constants in this file such as INT_MIN is defined in terms of an
** expression involving an INT_MAX which is a constant value. Please do
** not be tempted to speed processing up by evaluating those expressions
** into constant values. This will cause things to not work correctly.
******************************************************************************
*/
#include <decc$types.h>
#pragma
*
** Number of bits for the smallest object that is not a bit-field (byte)
*/
#define CHAR_BIT 8
/*
** Minimum and maximum values for "signed/unsigned char"
*/
#define UCHAR_MAX 255u
#define SCHAR_MAX 127
#define SCHAR_MIN (-SCHAR_MAX - 1)
/*
** Minimum and maximum values for "char" affected by /unsigned_char qualifier
*/
#ifdef _CHAR
#define CHAR_MIN 0
#define CHAR_MAX UCHAR_MAX
#else
#define CHAR_MIN SCHAR_MIN
#define CHAR_MAX SCHAR_MAX
#endif
/*
** Minimum and maximum values for "signed/unsigned short int"
*/
#define USHRT_MAX 65535u
#define SHRT_MAX 32767
#define SHRT_MIN (-SHRT_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned int"
*/
#define UINT_MAX 4294967295u
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned long int"
*/
#define ULONG_MAX 4294967295u
#define LONG_MAX 2147483647
#define LONG_MIN (-LONG_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned
*/
#define _MAX 65535u
#define _MAX 32767
#define _MIN (-_MAX - 1)
#define _MAX 4294967295u
#define _MAX 2147483647
#define _MIN (-_MAX - 1)
#ifdef
#define _MAX 18446744073709551615u
#define _MAX 9223372036854775807
#define _MIN (-_MAX - 1)
#endif
#if _VER < 60200000
# define MB_LEN_MAX 1 /* Before OpenVMS V6.2 */
#else
# define MB_LEN_MAX 8 /* After OpenVMS V6.2 */
#endif
/*
** Limits which changed beginning with OpenVMS V6.2
*/
# if defined(_XOPEN_SOURCE) || !defined(_ANSI_C_SOURCE)
# define COLL_WEIGHTS_MAX 5 /* Max collate weights */
# define NL_TEXTMAX 8192
# define NL_SETMAX 65535
# define NL_MSGMAX 65535
# define CHARCLASS_NAME_MAX 14
# define NL_ARGMAX 9
# define NL_LANGMAX 14
# define TZNAME_MAX 15
# define SSIZE_MAX INT_MAX
/*
** Limits needed to support *conf() functions.
*/
# define BC_BASE_MAX -1 /* Max ibase and obase values
** for bc not implemented */
# define BC_DIM_MAX -1 /* Max num elements in array
** for bc not implemented */
# define BC_SCALE_MAX -1 /* Max scale value allowed by
** bc not implemented */
# define BC_STRING_MAX -1 /* Max len of string constant
** by bc not implemented */
# define EXPR_NEST_MAX (-1) /* Max num expression nested
for expr */
# define LINE_MAX (-1) /* Max len of utility input
** line */
# define RE_DUP_MAX (-1) /* Max num repeated reg for
** interval */
# define NGROUPS_MAX 0 /* User can be in no extra groups */
# define PASS_MAX 31 /* Max bytes in a password */
# define ARG_MAX 4096 /* Max len of arg to exec rtns */
/*
** These are used by pathconf() as well as others
*/
# define LINK_MAX 1 /* Only 1 link to a file */
# define MAX_CANON 511 /* Max bytes in terminal canonical
** input */
# define MAX_INPUT 511 /* Max bytes required as input
** before reading */
# define NAME_MAX 255 /* Max bytes in filename */
# define PATH_MAX 255 /* Max bytes in pathname */
# define PIPE_BUF 512 /* Max atomic bytes on write to pipe */
/*
** New limits with DEC C V5.2
*/
# define _POSIX_PIPE_BUF 512
#endif /* XOPEN_SOURCE */
#if defined(_XOPEN_SOURCE_EXTENDED) || !defined(_ANSI_C_SOURCE)
# define ATEXIT_MAX 32767 /* Max number of functions that
** may be registered with atexit().
** essentially unlimited
*/
# define IOV_MAX (-1) /* Maximum number of iovec
** structures that one process
** has available for use with
** readv() or writev() */
#endif
/*
** Macros defined by the POSIX 1003.1c-1995 formally approved at
** the June 1995 meeting of the IEEE Standards Board. The correct
** feature test macro for strictly conforming POSIX 1003.1c-1995
** applications is:
**
** #define _POSIX_C_SOURCE 199506L
*/
#if _POSIX_C_SOURCE >= 199506 || !defined _ANSI_C_SOURCE
# ifndef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
# define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
# endif
# ifndef _POSIX_THREAD_KEYS_MAX
# define _POSIX_THREAD_KEYS_MAX 128
# endif
# ifndef _POSIX_THREAD_THREADS_MAX
# define _POSIX_THREAD_THREADS_MAX 64
# endif
# ifndef PTHREAD_DESTRUCTOR_ITERATIONS
# define PTHREAD_DESTRUCTOR_ITERATIONS
_POSIX_THREAD_DESTRUCTOR_ITERATIONS
# endif
# ifndef PTHREAD_KEYS_MAX
# define PTHREAD_KEYS_MAX 255
# endif
# ifndef PTHREAD_STACK_MIN
# if defined
# define PTHREAD_STACK_MIN 8192
# else
# define PTHREAD_STACK_MIN 1024
# endif
# endif
#endif /* _POSIX_C_SOURCE >= 199506 */
#pragma
#endif /* _LOADED */
|
additive operator: An operator that performs addition
(+) or subtraction (--). These operators perform arithmetic conversion
on each of the operands, if necessary. See also arithmetic
conversion rules.
aggregate: A data structure (array, structure, or
union) composed of segments called members. You declare the members to
be of either a scalar or aggregate data type. Members of an array are
called elements and must be of the same data type. A structure has
named members that can be of different data types. A union is a
structure that is as long as its longest declared member and that
contains the value of only one member at a time.
ampersand (&): As a unary operator, computes the
address of its operand. As a binary operator, performs a bitwise AND on
two operands; both must be of an integral type. As an assignment
operator (&=), performs a bitwise AND on two expressions and
assigns the result to the left object. The double ampersand
(&&), a binary operator, performs a logical AND on two
operands. See also binary operator, bitwise operator, logical
operator, and unary operator.
argument: An expression that appears within the
parentheses of a function call. The expression is evaluated and the
result is copied into the corresponding parameter of the called
function. See also argument passing and parameter.
argument passing: The mechanism by which the value of
the argument in a function call is copied to a parameter in the called
function. In C, all arguments are passed by value; that is, the
parameter receives a copy of the argument's value. Therefore, a
function called in C cannot modify the value of an argument except by
using its address. In general, addresses are passed using the ampersand
operator (see ampersand (&)) in the function call or by
passing a pointer variable. In addition, using an array or function
name (an array with no brackets or function identifier with no
parentheses) as an argument results in the passing of the address of
the array or function.
arithmetic conversion rules: The set of rules that
govern the changing of a value of an operand from one data type to
another in arithmetic expressions. Conversions take place in
assignments by changing the type of the right operand's result to that
of the object referred to by the left operand; the resultant type also
applies to the assignment expression. Conversions are also performed
when arguments are passed to functions.
arithmetic operator: A C operator that performs a
mathematical operation. In an expression, certain operations take
precedence (are performed first) over other operations. The unary minus
operator (--) is at the highest level of precedence. At the next level
are the binary operators for multiplication (*), division (/), and mod
(%). At the next level are addition (+) and subtraction (--). There is
no unary plus operator, and there is no exponentiation operator. If
necessary, all the binary operators perform the arithmetic conversions
on their operands. See also arithmetic conversion rules.
arithmetic type: One of the integral data types,
enumerated types, float, or double.
array: An aggregate data type consisting of
subscripted members, called elements, all of the same type. Elements of
an array can be one of the fundamental types or can be structures,
unions, or other arrays (to form multidimensional arrays).
assignment expression: An expression that has the following form:
E1 asgnop E2 |
Expression E1 must evaluate to an lvalue, the asgnop operator is an
assignment operator, and E2 is an expression. The type of an assignment
expression is that of its left operand. The value of an assignment
expression is that of the left operand after the assignment takes
place. If the operator is of the form op=, then the operation E1 op
(E2) is performed, and the result is assigned to the object referred to
by E1; E1 is evaluated once.
assignment operator: The combination of an arithmetic
or bitwise operator with the assignment symbol (=); also, the
assignment symbol by itself. See also assignment expression.
asterisk (*): As a unary operator, treats its operand
as an address and results in the contents of that address. As a binary
operator, multiplies two operands, performing the arithmetic
conversions, if necessary. As an assignment operator (*=), multiplies
an expression by the value of the object referred to by the left
operand, and assigns the product to that object. See also
binary operator and unary operator.
binary operator: An operator that is placed between
two operands. The binary operators include arithmetic operators, shift
operators, relational operators, equality operators, bitwise operators
(AND, OR, and XOR), logical connectives, and the comma operator, in
that order of precedence. All binary operators group from left to
right. HP C has no exponentiation operator. The exp
library function must be used instead.
bitwise operator: An operator that performs Boolean
algebra on the binary values of two operands, which must be integral.
If necessary, the operators perform the arithmetic conversions. Both
operands are evaluated. All bitwise operators are associative, and
expressions using them may be rearranged. The operators include, in
order of precedence, the single ampersand (&) (bitwise AND), the
circumflex (^) (bitwise exclusive OR), and the single bar (|) (bitwise
inclusive OR).
block: See compound statement.
block activation: The run-time activation of a block
or function, in which local auto and register
variables are allocated storage and, if they are declared with
initializers, given initial values. Variables of storage class
static, extern, globaldef, and
globalvalue are allocated and initialized at link time. The
block activation precedes the execution of any executable statements in
the function or block. Functions are activated when they are called.
Internal blocks (compound statements) are activated when the program
control flows into them. Internal blocks are not activated if they are
entered by a goto statement, unless the goto target
is the label of the block rather than the label of some statement
within the block. If a block is entered by a goto statement,
references to auto and register variables declared in
the block are still valid references, but the variables may not be
properly initialized. Blocks that make up the body of a switch
statement are not activated; auto or register
variables declared in the block are not initialized.
built-in functions: The function definitions that are
part of the HP C compiler for OpenVMS systems. A call to one
of these functions does not call a function in a run-time library or in
your program. Most of the built-in functions access the VAX hardware
instructions to perform operations quickly that are cumbersome, slow,
or impossible in the C language.
cast: An expression preceded by a cast operator of the
form (type_name). The cast operator forces the conversion of the
evaluated expression to the given type. The expression is assigned to a
variable of the specified type, which is then used in place of the
whole construction. The cast operator has the same precedence as the
other unary operators.
CDD/Repository: An optional OpenVMS software product,
available under a separate license, that maintains a set of data
structure definitions that many programs on a system, written in many
languages, can access. The language-independent definitions are
translated into the target language when they are included in the
program stream. You can include the CDD records in HP C
programs using the #dictionary preprocessor directive. This
directive is specific to HP C for OpenVMS Systems, and is not portable.
character:
See also string.
comma operator: A C operator used to separate two expressions as follows:
E1, E2 |
The expressions E1 and E2 are evaluated left to right, and the value of
E1 is discarded. The type and value of the comma expression are those
of E2.
comment: A sequence of characters introduced by the
pair /* and terminated by */. Comments are ignored during compilation.
They may not be nested.
Common Data Dictionary (CDD): See
CDD/Repository.
compilation unit: All the source files compiled to
form a single object module. In other C documentation, the term source
file is synonymous with the OpenVMS compilation unit, which is not
necessarily a single source file. Declarations and definitions within a
compilation unit determine the lexical scope of functions and variables.
compound statement: Valid C statements enclosed in
braces ({ }). Compound statements can also include declarations. The
scope of these variables is local to the compound statement. A compound
statement, when it is not the body of a function, is called a block.
conditional operator: The C operator (?:), which is used in conditional expressions of the following form:
E1 ? E2 : E3 |
E1, E2, and E3 are valid C expressions. E1 is evaluated, and if it is
nonzero, the result is the value of E2; otherwise, the result is the
value of E3. Either E2 or E3 is evaluated, but not both.
constant: A primary expression whose value does not
change. A constant may be literal or symbolic.
constant expression: An expression involving only
constants. Constant expressions are evaluated at compile time so they
may be used wherever a constant is valid.
conversion: The changing of a value from one data type
to another. Conversions take place in assignments by changing the type
of the right operand's result to that of the object referred to by the
left operand; the resultant type also applies to the assignment
expression. Conversions are also performed when arguments are passed to
functions: char and short become int;
unsigned char and unsigned short become unsigned
int if no function prototype is in scope; float becomes
double. Conversions can also be forced by means of a cast.
Conversions are performed on operands in arithmetic expressions by the
arithmetic conversions.
conversion characters: A character used with the
HP C RTL Standard I/O functions that is preceded by a percent
sign (%) and specifies an input or output format. For example, letter d
instructs the function to input/output the value in a decimal format.
| Previous | Next | Contents | Index |
|
|||||||||||
