---
name: "VistaIOConst"
section: "3"
platform: "linux"
package: "libvistaio-dev"
version: "1.2.19-3+b2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/VistaIOConst"
---

# VistaIOConst(3)

generate constants of the appropriate type

## NAME

VistaIOConst - generate constants of the appropriate type

## SYNOPSIS

**VistaIOFloat VistaIOFloatConst (*f*)**

**VistaIODouble VistaIODoubleConst (*f*)**

**VistaIOBit VistaIOBitConst (*i*)**

**VistaIOUByte VistaIOUByteConst (*i*)**

**VistaIOSByte VistaIOSByteConst (*i*)**

**VistaIOShort VistaIOShortConst (*i*)**

**VistaIOLong VistaIOLongConst (*i*)**

## ARGUMENTS

- *f*

  Specifies a floating-point constant.

- *i*

  Specifies an integer constant.

## DESCRIPTION

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);
```

## SEE ALSO

[**VistaIORepn**(3)](/VistaIORepn/3.md),

## NOTES

**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.**

## AUTHOR

**Art Pope \<pope@cs.ubc.ca\>**

**Adaption to vistaio: Gert Wollny \<gw.fossdev@gmail.com\>**