VistaIOConst(3) generate constants of the appropriate type


VistaIOFloat VistaIOFloatConst (f)

VistaIODouble VistaIODoubleConst (f)

VistaIOBit VistaIOBitConst (i)

VistaIOUByte VistaIOUByteConst (i)

VistaIOSByte VistaIOSByteConst (i)

VistaIOShort VistaIOShortConst (i)

VistaIOLong VistaIOLongConst (i)


Specifies a floating-point constant.
Specifies an integer constant.


In expressions that get executed within inner loops, you may wish to avoid unnecessary coercions between the C types float and double, or between int and long. By allowing you to specify constants of the appropriate type in a portable, platform-independent manner, these macros allow you to avoid unintended coercions.

In ANSI C, one can specify that a floating point constant is of type float be appending an f character to it. This can be used to avoid coercions in expressions involving other float values. For example, this fragment of code uses a float constant within its loop:

int i;
float f = 0.0;
for (i = 0; i < 10000000; i++)
    f += 1.0f;

It runs about three times faster than this one, which uses a double constant:

int i;
float f = 0.0;
for (i = 0; i < 10000000; i++)
    f += 1.0;

The VistaIOFloatConst and VistaIODoubleConst macros allow you to avoid unnecessary coercions in expressions involving values of type VistaIOFloat and VistaIODouble. Whether or not VistaIOFloat and VistaIODouble are equivalent to float and double may depend on what platform your code is being compiled for. Regardless, you can generate constants of the appropriate type by using the VistaIOFloatConst and VistaIODoubleConst macros. On a platform where VistaIOFloat is defined as float, VistaIOFloatConst(1.0) expands to 1.0f; where VistaIOFloat is defined as double, it expands to 1.0. Similarly, VistaIODoubleConst may or may not append an f character to the constant, depending on how VistaIODouble is defined.

Similarly, the VistaIOBitConst, VistaIOUByteConst, VistaIOSByteConst, VistaIOShortConst, and VistaIOLongConst take an integer constant; each one, depending on the platform, may or may not append an l character to the constant to specify that it is of type long. On platforms where int and long have different representations, using these macros may prevent unintended coercions between the two representations.

So if your want your inner loops to run blindingly fast on any platform, you should write them like this to avoid unnecessary coercions:

int i;
VistaIOFloat f = 0.0;
for (i = 0; i < 10000000; i++)
    f += VistaIOFloatConst (1.0);


The macros can be used with a C compiler that doesn't meet the ANSI standard, but in that case they may not eliminate all type coercions between float and double.

If you're more concerned about your code being easy to read, you may be better off not using these macros.


Art Pope <[email protected]>

Adaption to vistaio: Gert Wollny <[email protected]>