Base Ejemplo Formateador Comentario

10 (decimal) 123 Ninguno.

2 (binario) B1111011 Antecede "B" Sólo funciona con valores de 8 bits (0 to 255).

                                               			Caracteres 0-1 válidos.

8 (octal) 0173 Antecede "0" Caracteres 0-7 válidos.

16 (hexadecimal) 0x7B Antecede "0x" Caracteres 0-9, A-F, a-f válidos.

Integer Constants son números utilizados directamente en un sketch, como 123. Por defecto, éstos números son tratados como int, pero puedes cambiarlo con las letras U y L (ver abajo).

Normalmente, las constantes integer son tratadas como enteros base 10 (decimales), pero se puede utilizar notación especial (formateadores) para ingresar números en otras bases.

Base Ejemplo Formateador Comentario

10 (decimal) 123 ninguno.

2 (binario) B1111011 Antecede "B" sólo funciona con valores de 8 bits (0 to 255).

                                               caracteres 0-1 válidos

8 (octal) 0173 Antecede "0" caracteres 0-7 válidos

16 (hexadecimal) 0x7B Antecede "0x" caracteres 0-9, A-F, a-f válidos.

Decimal es base 10. Esta es la matemática de sentido común con que se conocen. Para constantes sin otros prefijos, se asume el formato decimal.

Ejemplo:[@ 101 // igual a 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Binary es base dos. Sólo caracteres 0 y 1 son válidos.

Ejemplo:[@ B101 // igual a 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)

El formateador binario sólo funciona en bytes (8 bits) entre 0 (B0) y 255 (B11111111). Si resulta conveniente ingresar un entero (int, 16 bits) de forma binaria, puedes hacer un procedimiento de dos pasos, como a continuación:

valorInt = (B11001100 * 256) + B10101010; // B11001100 es el byte alto.

Octal es base ocho. Sólo caracteres de 0 hasta 7 son válidos. Los valores Octales son indicados por el prefijo "0"

Ejemplo:

0101 // igual a 65 decimal ((1 * 8^2) + (0 * 8^1) + 1) @]

Hexadecimal (ó hex) es base dieciséis. Los caracteres válidos son del 0 al 9, y las letras desde la A hasta la F; A tiene el valor de 10, B es 11, C es 12, D es 13, E es 14, y la F, como ya habrás adivinado, es 15. Los valores hexadecimales se indican con el prefijo "0x". Nota que los valores de la A a la F, pueden ser escritos en mayúscula o minúscula.

Ejemplo:

0x101 // igual a 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

Formateadors U & L

Por defecto, una constante en enteros es tratada como int con las limitaciones concomitantes en los valores. Para especificar una constante en enteros con otro tipo de datos, continúala con:

• una 'u' ó 'U' para forzar la constante a un formato de datos unsigned. Ejemplo: 33u
• una 'l' ó 'L' para forzar la constante a un formato de datos long. Ejemplo: 100000L
• un 'ul' ó 'UL' para forzar la constante a un formato de datos unsigned long. Ejemplo: 32767ul

Ver También

8 (octal) 0173 leading "0" characters 0-7 valid

16 (hexadecimal) 0x7B leading "0x" characters 0-9, A-F, a-f valid

2 (binary) B1111011 leading 'B' only works with 8 bit values (0 to 255)

8 (octal) 0173 leading "0" characters 0-7 valid

16 (hexadecimal) 0x7B leading "0x" characters 0-9, A-F, a-f valid

101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

0101 // same as 65 decimal ((1 * 8^2) + (0 * 8^1) + 1) @]

0x101 // same as 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

myInt = (B11001100 * 256) + B10101010; // B11001100 is the high byte

It is possible can generate a hard-to-find bug by (unintentionally) including a leading zero before a constant and having the compiler unintentionally interpret your constant as octal

Warning

Example:[@ 101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

@]

Example:

101    // same as 101 decimal  ((1 * 10^2) + (0 * 10^1) + 1)

Example:[@

myInt = (B11001100 * 256) + B10101010; // B11001100 is the high byte

0101    // same as 65 decimal    ((1 * 8^2) + (0 * 8^1) + 1) 

Example:

0x101   // same as 257 decimal  ((1 * 16^2) + (0 * 16^1) + 1)

Example:

B101    // same as 5 decimal   ((1 * 2^2) + (0 * 2^1) + 1)

Example: 101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Example:101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Example: \\

Example:\\ 101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Example: 0101 // same as 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

• a 'u' or 'U' to force the constant into an unsigned data format. Example: 33u
• a 'l' or 'L' to force the constant into a long data format. Example: 100000L

• a 'ul' or 'UL' to force the constant into an unsigned long constant. Example: 32767ul

Example: 101 // same as 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Example: B101 // same as 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)

The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). If it is convenient to input an int (16 bits) in binary form you can do it a two-step procedure such as:

Example: 0101 // same as 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Example: 0x101 // same as 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

Example: 101 // == 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

Example: B101 // == 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 0101 // == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Decimal is base 10. This is the common-sense math with which you are acquainted. Constants without other prefixes are assumed to be in decimal format.

Hexadecimal (or hex) is base sixteen. Valid characters are 0 through 9 and letters A through F; A has the value 10, B is 11, up to F, which is 15. Hex values are indicated by the prefix "0x". Note that A-F may be syted in upper or lower case (a-f).

2 (binary) B1111011 capital 'B' only works with 8 bit values (0 to 255)

Decimal is base 10, this is the common-sense math with which you are acquainted. Constants without other prefixes are assumed to be decimal format.

Octal is base eight. Only characters 0 through 7 are valid. Octal values are indicated by the prefix "0"

Hexadecimal (or hex) is base sixteen. Valid characters are 0 through 9 and letters A through F; A has the value 10, B is 11, up to F, which is 15. Hex values are indicated by the prefix "0x"

By default, an integer constant is treated as an int with the attendant limitations in values. To specify an integer constant with another data type, follow it with:

Integer constants are numbers used directly in a sketch, like 123. By default, these numbers are treated as int's but you can change this with the U and L modifiers (see below).

Normally, integer constants are treated as base 10 (decimal) integers, but special notation (formatters) may be used to enter numbers in other bases.

By default, an integer constant is treated as an int with the attendant limitations in values. To specify an integer constant with another data type, follow it with::

Integer constants are numbers used directly in a sketch, like 123. Normally, these numbers are treated as base 10 (decimal) integers, but special notation (formatters) may be used to enter numbers in other bases.

An integer constant may be followed by:

16 (hexadecimal) 0x7B leading 0x characters 0-9, A-F, a-f valid

Base Example Formatter Comment

2 (binary) B1111011 capital 'B' only works with 8 bit values

                                               characters 0-1 valid

8 (octal) 0173 leading zero characters 0-7 valid

16 (hexadecimal) 0x7B leading 0x characters 0-9, A-F valid

Base Example Formatter Comment

2 (binary) B1111011 capital 'B' only works with 8 bit values

                                             characters 0-1 valid

8 (octal) 0173 leading zero characters 0-7 valid

16 (hexadecimal) 0x7B leading 0x characters 0-9, A-F valid

                                            characters 0-1 valid

• a 'u' or 'U' to force the constant into an unsigned data format. Example: 33u
• a 'l' or 'L' to force the constant into a long data format. Example: 100000L
• a 'ul' or 'UL' to force the constant into an unsigned long constant. Example: 32767ul

• a 'u' or 'U' to force the constant into an unsigned data format, like 33u

You can generate a hard-to-find bug by (unintentionally) including a leading zero before a constant and having the compiler unintentionally interpret your constant as octal

\\

\\

• #define

• #Define

Example: 101 == 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)

• constants

• a 'l' or 'L' to indicate a long constant, like 100000L

• unsigned int

• unsigned long

• a 'l' or 'L' to indicate a long constant, like 100000l

U & L formatters

In the C language, an integer constant may be followed by:

• a 'u' or 'U' to indicate an unsigned constant, like 33u
• a 'ul' or 'UL' to indicate an unsigned long constant, like 32767ul

Base Example Formatter Comment

2 (binary) B1111011 capital 'B' (only works with 8 bit values)

8 (octal) 0173 leading zero characters 0-7 valid

16 (hexadecimal) 0x7B leading 0x characters 0-9, A-F valid

Base Example Formatter Comment

10 (decimal) 123 none

2 (binary) B1111011 capital 'B' (only works with 8 bit values)

8 (octal) 0173 leading zero

16 (hexadecimal) 0x7B leading 0x

You can generate a hard-to-find bug by unintentionally including a leading zero before a constant and having the compiler unintentionally interpret your contstant as octal

Warning

You can generate a hard-to-find bug by unintentionally including a leading zero before a constant and having the compiler interpreting your constant unintentionally interpreted as octal

10 (decimal) 123

2 (binary) B1111011 (only works with 1 to 8 bit values)

8 (octal) 0173

16 (hexadecimal) 0x7B

Numbers are sometimes entered in hexidecimal to save characters in entering larger numbers. This is something that comes with practice to programmers but is often confusing to beginners.

[@

Integer constants are the numbers you type directly into your sketch, like 123. Normally, these numbers are treated as base 10 (decimal) integers, but you can use special notation (formatters) to enter numbers in other bases.

So why would one want to enter numbers in another base? Often it is convenient to enter numbers in binary form if they are being used to set port variables. This often corresponds to setting one pin HIGH and another LOW, for example.

Numbers are sometimes entered in hexidecimal to save characters in entering larger numbers. This is something that comes with practice to programmers but is often confusing to beginning programmers.

Example: B101 == 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: B101 == 5 decimal. a

Example: 0101 == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Example: 101 == 101 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 101 == 101 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 101 == 101 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 0101 == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Example: 101 == 101 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 0101 == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Example: 0x101 == 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

Example: 101 == 101 decimal ((1 * 2^2) + (0 * 2^1) + 1)

Example: 0101 == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)

Example: 0x101 == 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

• Constants

One can generate a hard-to-find bug by unintentionally including a leading zero before a constant and having the compiler interpreting your constant (unwantedly) as octal \\\

The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). If it's convenient to input an int (16 bits) in binary form you can do it a two-step procedure such as this:

myInt = (B11001100 * 256) + B10101010; // B11001100 is the high byte

Example: 0101 == 65 decimal (1 * 8^2) + (0 * 8^1) + 1

Hexadecimal (or hex) is base sixteen. Valid characters are 0 through 9 and letters A through F; A has the value 10, B is 11, up to F, which is 15.

Example: 0x101 == 257 decimal (1 * 16^2) + (0 * 16^1) + 1

To decode a two-digit hex value into decimal multiply the most significant (left-most) digit by 16 and add the right digit.

Decimal is base 10, this is the common-sense math with which you are aquainted.

Example: 101 == 101 decimal

Decimal is base 10, this is the common-sense math with which you are aquainted. Example: 101 == 101 decimal

Binary is base two. Only characters 0 and 1 are valid.

Example: B101 == 5 decimal.

Octal is base eight. Only characters 0 through 7 are valid.

Example: 0101 == 65 decimal

Binary is base two. Only characters 0 and 1 are valid. Example: B101 == 5 decimal.

Base Example Comment

10 (decimal) 123 default format - cannot start with 0 (zero)

2 (binary) B1111011 use capital B only (not C++ 0b), only works on bytes

8 (octal) 0173 start constant with zero (0)

16 (hexadecimal) 0x7B start with zero - x (0x)

Integer constants are the numbers you type directly into your sketch, like 123. Normally, these numbers are treated as base 10 (decimal) integers, but you can use special notation (formatters) to enter numbers in other bases. See the following table for details.

Base Example Comment

10 (decimal) 123 default format - cannot start with 0 (zero)

@]

Notice that in hexadecimal, valid characters are 0 through 9 and A through F; A has the value 10, B is 11, up to F, which is 15. To decode a two-digit hex value into decimal multiply the most significant (left-most) digit by 16 and add the right digit.

myInt = (B11001100 * 256) + B10101010; // B11001100 is the high byte

Notice that in hexadecimal, valid characters are 0 through 9 and A through F; A has the value 10, B is 11, up to F, which is 15.

The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). If it's convenient to input an int (16 bits) in binary form you can do it a two-step procedure such as this:

@@myInt = (B11001100 * 256) + B10101010; // first constant is the high byte

The binary constants only work between 0 (B0) and 255 (B11111111). The others can be negative and bigger.

Base Example 10 (decimal) 123 2 (binary) B1111011 8 (octal) 0173 16 (hexadecimal) 0x7B

Integer Constants

Integer constants are the numbers you type directly into your sketch, like 123. Normally, these numbers are treated as base 10 (decimal) integers, but you can use special notation to enter numbers in other bases. See the following table for details.

 
Name          Base       Prefix       Example      Value
Decimal         10         none           123        123
Binary           2            B      B1111011        123
Octal            8            0          0173        123
Hexadecimal     16           0x          0x7B        123

Notice that in hexadecimal, some digits can be letters; A has the value 10, B is 11, up to F, which is 15.

Example

See also

• byte
• int
• long

Reference Home