С data types word and

In the C programming language, data types constitute the semantics and characteristics of storage of data elements. They are expressed in the language syntax in form of declarations for memory locations or variables. Data types also determine the types of operations or methods of processing of data elements.

The C language provides basic arithmetic types, such as integer and real number types, and syntax to build array and compound types. Headers for the C standard library, to be used via include directives, contain definitions of support types, that have additional properties, such as providing storage with an exact size, independent of the language implementation on specific hardware platforms.^[1][2]

Basic types[edit]

Main types[edit]

The C language provides the four basic arithmetic type specifiers char, int, float and double, and the modifiers signed, unsigned, short, and long. The following table lists the permissible combinations in specifying a large set of storage size-specific declarations.

The actual size of the integer types varies by implementation. The standard requires only size relations between the data types and minimum sizes for each data type:

The relation requirements are that the long long is not smaller than long, which is not smaller than int, which is not smaller than short. As char‘s size is always the minimum supported data type, no other data types (except bit-fields) can be smaller.

The minimum size for char is 8 bits, the minimum size for short and int is 16 bits, for long it is 32 bits and long long must contain at least 64 bits.

The type int should be the integer type that the target processor is most efficiently working with. This allows great flexibility: for example, all types can be 64-bit. However, several different integer width schemes (data models) are popular. Because the data model defines how different programs communicate, a uniform data model is used within a given operating system application interface.^[8]

In practice, char is usually 8 bits in size and short is usually 16 bits in size (as are their unsigned counterparts). This holds true for platforms as diverse as 1990s SunOS 4 Unix, Microsoft MS-DOS, modern Linux, and Microchip MCC18 for embedded 8-bit PIC microcontrollers. POSIX requires char to be exactly 8 bits in size.^[9][10]

Various rules in the C standard make unsigned char the basic type used for arrays suitable to store arbitrary non-bit-field objects: its lack of padding bits and trap representations, the definition of object representation,^[6] and the possibility of aliasing.^[11]

The actual size and behavior of floating-point types also vary by implementation. The only requirement is that long double is not smaller than double, which is not smaller than float. Usually, the 32-bit and 64-bit IEEE 754 binary floating-point formats are used for float and double respectively.

The C99 standard includes new real floating-point types float_t and double_t, defined in <math.h>. They correspond to the types used for the intermediate results of floating-point expressions when FLT_EVAL_METHOD is 0, 1, or 2. These types may be wider than long double.

C99 also added complex types: float _Complex, double _Complex, long double _Complex.

Boolean type[edit]

C99 added a boolean (true/false) type _Bool. Additionally, the <stdbool.h> header defines bool as a convenient alias for this type, and also provides macros for true and false. _Bool functions similarly to a normal integer type, with one exception: any assignments to a _Bool that are not 0 (false) are stored as 1 (true). This behavior exists to avoid integer overflows in implicit narrowing conversions. For example, in the following code:

unsigned char b = 256;

if (b) {
	/* do something */
}

Variable b evaluates to false if unsigned char has a size of 8 bits. This is because the value 256 does not fit in the data type, which results in the lower 8 bits of it being used, resulting in a zero value. However, changing the type causes the previous code to behave normally:

_Bool b = 256;

if (b) {
	/* do something */
}

The type _Bool also ensures true values always compare equal to each other:

_Bool a = 1, b = 2;

if (a == b) {
	/* this code will run */
}

Size and pointer difference types[edit]

The C language specification includes the typedefs size_t and ptrdiff_t to represent memory-related quantities. Their size is defined according to the target processor’s arithmetic capabilities, not the memory capabilities, such as available address space. Both of these types are defined in the <stddef.h> header (cstddef in C++).

size_t is an unsigned integer type used to represent the size of any object (including arrays) in the particular implementation. The operator sizeof yields a value of the type size_t. The maximum size of size_t is provided via SIZE_MAX, a macro constant which is defined in the <stdint.h> header (cstdint header in C++). size_t is guaranteed to be at least 16 bits wide. Additionally, POSIX includes ssize_t, which is a signed integer type of the same width as size_t.

ptrdiff_t is a signed integer type used to represent the difference between pointers. It is guaranteed to be valid only against pointers of the same type; subtraction of pointers consisting of different types is implementation-defined.

Interface to the properties of the basic types[edit]

Information about the actual properties, such as size, of the basic arithmetic types, is provided via macro constants in two headers: <limits.h> header (climits header in C++) defines macros for integer types and <float.h> header (cfloat header in C++) defines macros for floating-point types. The actual values depend on the implementation.

Properties of integer types[edit]

• CHAR_BIT – size of the char type in bits (at least 8 bits)
• SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN(C99) – minimum possible value of signed integer types: signed char, signed short, signed int, signed long, signed long long
• SCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX(C99) – maximum possible value of signed integer types: signed char, signed short, signed int, signed long, signed long long
• UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, ULLONG_MAX(C99) – maximum possible value of unsigned integer types: unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long
• CHAR_MIN – minimum possible value of char
• CHAR_MAX – maximum possible value of char
• MB_LEN_MAX – maximum number of bytes in a multibyte character

Properties of floating-point types[edit]

• FLT_MIN, DBL_MIN, LDBL_MIN – minimum normalized positive value of float, double, long double respectively
• FLT_TRUE_MIN, DBL_TRUE_MIN, LDBL_TRUE_MIN (C11) – minimum positive value of float, double, long double respectively
• FLT_MAX, DBL_MAX, LDBL_MAX – maximum finite value of float, double, long double, respectively
• FLT_ROUNDS – rounding mode for floating-point operations
• FLT_EVAL_METHOD (C99) – evaluation method of expressions involving different floating-point types
• FLT_RADIX – radix of the exponent in the floating-point types
• FLT_DIG, DBL_DIG, LDBL_DIG – number of decimal digits that can be represented without losing precision by float, double, long double, respectively
• FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON – difference between 1.0 and the next representable value of float, double, long double, respectively
• FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG – number of FLT_RADIX-base digits in the floating-point significand for types float, double, long double, respectively
• FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP – minimum negative integer such that FLT_RADIX raised to a power one less than that number is a normalized float, double, long double, respectively
• FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP – minimum negative integer such that 10 raised to that power is a normalized float, double, long double, respectively
• FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP – maximum positive integer such that FLT_RADIX raised to a power one less than that number is a normalized float, double, long double, respectively
• FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP – maximum positive integer such that 10 raised to that power is a normalized float, double, long double, respectively
• DECIMAL_DIG (C99) – minimum number of decimal digits such that any number of the widest supported floating-point type can be represented in decimal with a precision of DECIMAL_DIG digits and read back in the original floating-point type without changing its value. DECIMAL_DIG is at least 10.

Fixed-width integer types[edit]

The C99 standard includes definitions of several new integer types to enhance the portability of programs.^[2] The already available basic integer types were deemed insufficient, because their actual sizes are implementation defined and may vary across different systems. The new types are especially useful in embedded environments where hardware usually supports only several types and that support varies between different environments. All new types are defined in <inttypes.h> header (cinttypes header in C++) and also are available at <stdint.h> header (cstdint header in C++). The types can be grouped into the following categories:

• Exact-width integer types that are guaranteed to have the same number n of bits across all implementations. Included only if it is available in the implementation.
• Least-width integer types that are guaranteed to be the smallest type available in the implementation, that has at least specified number n of bits. Guaranteed to be specified for at least N=8,16,32,64.
• Fastest integer types that are guaranteed to be the fastest integer type available in the implementation, that has at least specified number n of bits. Guaranteed to be specified for at least N=8,16,32,64.
• Pointer integer types that are guaranteed to be able to hold a pointer. Included only if it is available in the implementation.
• Maximum-width integer types that are guaranteed to be the largest integer type in the implementation.

The following table summarizes the types and the interface to acquire the implementation details (n refers to the number of bits):

Printf and scanf format specifiers[edit]

The <inttypes.h> header (cinttypes in C++) provides features that enhance the functionality of the types defined in the <stdint.h> header. It defines macros for printf format string and scanf format string specifiers corresponding to the types defined in <stdint.h> and several functions for working with the intmax_t and uintmax_t types. This header was added in C99.

Printf format string

The macros are in the format PRI{fmt}{type}. Here {fmt} defines the output formatting and is one of d (decimal), x (hexadecimal), o (octal), u (unsigned) and i (integer). {type} defines the type of the argument and is one of n, FASTn, LEASTn, PTR, MAX, where n corresponds to the number of bits in the argument.

Scanf format string

The macros are in the format SCN{fmt}{type}. Here {fmt} defines the output formatting and is one of d (decimal), x (hexadecimal), o (octal), u (unsigned) and i (integer). {type} defines the type of the argument and is one of n, FASTn, LEASTn, PTR, MAX, where n corresponds to the number of bits in the argument.

Functions

This section needs expansion. You can help by adding to it. (October 2011)

Additional floating-point types[edit]

Similarly to the fixed-width integer types, ISO/IEC TS 18661 specifies floating-point types for IEEE 754 interchange and extended formats in binary and decimal:

• _FloatN for binary interchange formats;
• _DecimalN for decimal interchange formats;
• _FloatNx for binary extended formats;
• _DecimalNx for decimal extended formats.

Structures[edit]

Structures aggregate the storage of multiple data items, of potentially differing data types, into one memory block referenced by a single variable. The following example declares the data type struct birthday which contains the name and birthday of a person. The structure definition is followed by a declaration of the variable John that allocates the needed storage.

struct birthday {
	char name[20];
	int day;
	int month;
	int year;
};

struct birthday John;

The memory layout of a structure is a language implementation issue for each platform, with a few restrictions. The memory address of the first member must be the same as the address of structure itself. Structures may be initialized or assigned to using compound literals. A function may directly return a structure, although this is often not efficient at run-time. Since C99, a structure may also end with a flexible array member.

A structure containing a pointer to a structure of its own type is commonly used to build linked data structures:

struct node {
	int val;
	struct node *next;
};

Arrays[edit]

For every type T, except void and function types, there exist the types «array of N elements of type T«. An array is a collection of values, all of the same type, stored contiguously in memory. An array of size N is indexed by integers from 0 up to and including N−1. Here is a brief example:

int cat[10];  // array of 10 elements, each of type int

Arrays can be initialized with a compound initializer, but not assigned. Arrays are passed to functions by passing a pointer to the first element. Multidimensional arrays are defined as «array of array …», and all except the outermost dimension must have compile-time constant size:

int a[10][8];  // array of 10 elements, each of type 'array of 8 int elements'

Pointers[edit]

Every data type T has a corresponding type pointer to T. A pointer is a data type that contains the address of a storage location of a variable of a particular type. They are declared with the asterisk (*) type declarator following the basic storage type and preceding the variable name. Whitespace before or after the asterisk is optional.

char *square;
long *circle;
int *oval;

Pointers may also be declared for pointer data types, thus creating multiple indirect pointers, such as char ** and int ***, including pointers to array types. The latter are less common than an array of pointers, and their syntax may be confusing:

char *pc[10];   // array of 10 elements of 'pointer to char'
char (*pa)[10]; // pointer to a 10-element array of char

The element pc requires ten blocks of memory of the size of pointer to char (usually 40 or 80 bytes on common platforms), but element pa is only one pointer (size 4 or 8 bytes), and the data it refers to is an array of ten bytes (sizeof *pa == 10).

Unions[edit]

A union type is a special construct that permits access to the same memory block by using a choice of differing type descriptions. For example, a union of data types may be declared to permit reading the same data either as an integer, a float, or any other user declared type:

union {
	int i;
	float f;
	struct {
		unsigned int u;
		double d;
	} s;
} u;

The total size of u is the size of u.s – which happens to be the sum of the sizes of u.s.u and u.s.d – since s is larger than both i and f. When assigning something to u.i, some parts of u.f may be preserved if u.i is smaller than u.f.

Reading from a union member is not the same as casting since the value of the member is not converted, but merely read.

Function pointers[edit]

Function pointers allow referencing functions with a particular signature. For example, to store the address of the standard function abs in the variable my_int_f:

int (*my_int_f)(int) = &abs;
// the & operator can be omitted, but makes clear that the "address of" abs is used here

Function pointers are invoked by name just like normal function calls. Function pointers are separate from pointers and void pointers.

Type qualifiers[edit]

The aforementioned types can be characterized further by type qualifiers, yielding a qualified type. As of 2014 and C11, there are four type qualifiers in standard C: const (C89), volatile (C89), restrict (C99) and _Atomic (C11) – the latter has a private name to avoid clashing with user names,^[12] but the more ordinary name atomic can be used if the <stdatomic.h> header is included. Of these, const is by far the best-known and most used, appearing in the standard library and encountered in any significant use of the C language, which must satisfy const-correctness. The other qualifiers are used for low-level programming, and while widely used there, are rarely used by typical programmers.^{[citation needed]}

See also[edit]

• C syntax
• Uninitialized variable
• Integer (computer science)

References[edit]

Word Size and Data Types

A word is the amount of data that a machine can process at one time. This fits into the document analogy that includes characters (usually eight bits) and pages (many words, often 4 or 8KB worth) as other measurements of data. A word is an integer number of bytes for example, one, two, four, or eight. When someone talks about the «n-bits» of a machine, they are generally talking about the machine’s word size. For example, when people say the Pentium is a 32-bit chip, they are referring to its word size, which is 32 bits, or four bytes.

The size of a processor’s general-purpose registers (GPR’s) is equal to its word size. The widths of the components in a given architecture for example, the memory bus are usually at least as wide as the word size. Typically, at least in the architectures that Linux supports, the memory address space is equal to the word size[2]. Consequently, the size of a pointer is equal to the word size. Additionally, the size of the C type long is equal to the word size, whereas the size of the int type is sometimes less than that of the word size. For example, the Alpha has a 64-bit word size. Consequently, registers, pointers, and the long type are 64 bits in length. The int type, however, is 32 bits long. The Alpha can access and manipulate 64 bits, one word at a time.

Further read : http://www.makelinux.com/books/lkd2/ch19lev1sec2

1. 07-02-2010

   
   

   #1

   

   
   Registered User
   

   ---

   what is the WORD datatype?
   

   I had a programming class assignment to make a simple guessing game ( we’re just starting out programming in C) and I read this code that changes the color of the console:

   Code:

   HANDLE mainwin = GetStdHandle ( STD_OUTPUT_HANDLE );
       WORD DefaultColor; 
       CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
       GetConsoleScreenBufferInfo(mainwin, &csbiInfo); 
       DefaultColor = csbiInfo.wAttributes;

   I know what each bit does, but I would like to know what the WORD datatype / structure is? ( sorry if I’m not using the correct terminology, I’m just beginning programming, and it’s really fun )

   Thanks alot for the help

   ---

2. 07-02-2010

   
   

   #2

   

   
   C++まいる！Cをこわせ！
   

   ---

   WORD in a Windows environment is just that — a word. Now the definition of a word is some type of data that is 16 bits (2 bytes) for x86. Typically an alias for short (ONLY guaranteed under Windows!).

   Originally Posted by Adak
   

   io.h certainly IS included in some modern compilers. It is no longer part of the standard for C, but it is nevertheless, included in the very latest Pelles C versions.

   Originally Posted by Salem
   

   You mean it’s included as a crutch to help ancient programmers limp along without them having to relearn too much.

   Outside of your DOS world, your header file is meaningless.

   ---

3. 07-02-2010

   
   

   #3

   

   
   Registered User
   

   ---

   Oh ok, thanks
   So word is sort of like a string that can only hold to characters? (2 bytes?)
   Thanks for the help

   ---

4. 07-03-2010

   
   

   #4

   

   
   Registered User
   

   ---

   No, a WORD is just a 2-Byte (unsigned) data type, you can use it for whatever you like.

   Windows Data Types (Windows)

   ---

5. 07-03-2010

   
   

   #5

   

   
   C++まいる！Cをこわせ！
   

   ---

   When we speak of types such as word, dword, qword, etc, they all refer to a storage unit, or place, where we can store at most n bytes (2, 4, 8 in this case respectively). What exactly you want to store in them is up to you, because to the hardware it’s all bits.
   Now, these types are all (usually) represented by integer types (short, int, long long respectively in this case).

   Originally Posted by Adak
   

   io.h certainly IS included in some modern compilers. It is no longer part of the standard for C, but it is nevertheless, included in the very latest Pelles C versions.

   Originally Posted by Salem
   

   You mean it’s included as a crutch to help ancient programmers limp along without them having to relearn too much.

   Outside of your DOS world, your header file is meaningless.

   ---

6. 07-03-2010

   
   

   #6

   

   
   Registered User
   

   ---

   Oh ok, its starting to make more sense now,
   Thanks alot Elysia and DeadPlanet,
   + the link was really helpful as well

   ---

7. 07-05-2010

   
   

   #7

   

   
   Programming Wraith
   

   

   ---

   Short question: Why are data types bigger that BYTE called *WORD? (WORD, DWORD, QWORD … )

   Devoted my life to programming…

   ---

8. 07-05-2010

   
   

   #8

   

   
   Just a pushpin.
   

   

   ---

   Short question: Why are data types bigger that BYTE called *WORD? (WORD, DWORD, QWORD … )

   A word is the data size that a processor naturally handles. So for a 32-bit processor, it’s theoretically 32 bits (or an int), although x86 processors support 16 and 32 bits equally via the *x and e*x registers.

   Since smaller data sizes have to be padded for operations there’s really no speed gain from using e.g. bytes vs. words. So it’s probably more convenient to define data types that are word size rather than byte size — that way you have a much larger int range at no cost of speed.
   Therefore Windows has DWORD (double word) and QWORD (quad word), which correspond to 2 words and 4 words respectively (or a 16-bit long int and long long int).

   Since the modern Windows API really came about in Windows ’95 and that was a 16-bit system, WORD was defined to be a 16-bit data structure (on 16-bit processors, an int, and a short was 8 bits like a char). Hence the 16-bit Windows word. And it stuck on into win32, probably for compatibility reasons.

   EDIT: Nevermind the ’95 part, 16-bit started out with DOS, but the point is still valid.

   Last edited by bernt; 07-06-2010 at 08:23 AM.

   Consider this post signed

   ---

9. 07-05-2010

   
   

   #9

   

   
   Programming Wraith
   

   

   ---

   Devoted my life to programming…

   ---

A Caution: reserved words, «keywords,» and predefined identifiers…

Here is a list of all
the reserved words in Standard C++,
and a few predefined identifiers
for the sake of comparison.

There is a distinction between reserved
words and predefined identifiers,
which are sometimes collectively referred to
as keywords. Nevertheless, be aware that the terminology is
nonstandard. As an illustration, some authors use keyword in
the same sense that others use reserved word.

C++ Reserved Words

The reserved words of C++ may be conveniently placed into several
groups. In the first group, we put those that were also present in the
C programming language and have been carried over into
C++. There are

32 such reserved words

:

auto   const     double  float  int       short   struct   unsigned
break  continue  else    for    long      signed  switch   void
case   default   enum    goto   register  sizeof  typedef  volatile
char   do        extern  if     return    static  union    while

There are another

30 reserved words that were not in C

, are therefore
new to C++:

asm         dynamic_cast  namespace  reinterpret_cast  try
bool        explicit      new        static_cast       typeid
catch       false         operator   template          typename
class       friend        private    this              using
const_cast  inline        public     throw             virtual
delete      mutable       protected  true              wchar_t

The following 11 C++ reserved words are not essential when the standard
ASCII character set is being used, but they have been added to provide
more readable alternatives for some of the C++ operators, and also to
facilitate programming with character sets that lack characters needed
by C++.

and      bitand   compl   not_eq   or_eq   xor_eq
and_eq   bitor    not     or       xor

Note that your particular compiler may not be completely up-to-date,
which means that some (and possibly many) of the reserved words in
the preceding two groups may not yet be implemented.

Some Predefined Identifiers

Beginning C++ programmers are sometimes
confused by the difference between the
two terms reserved word and
predefined identifier, and
some potential for confusion.

One of the difficulties is that some
keywords that one might «expect»
to be reserved words are not.
The keyword main is a prime
example, and others include things
like the endl manipulator and
other keywords from the vast
collection of C++ libraries.

For example, you could declare a
variable called main inside
your main function, initialize
it, and then print out its value (but
ONLY do that to verify that you can!).
On the other hand, you could not
do this with a variable named else.
The difference is that else is
a reserved word, while
main is «only» a predefined
identifier.

Here is a short list of some predefined identifiers:

cin   endl     INT_MIN   iomanip    main      npos  std
cout  include  INT_MAX   iostream   MAX_RAND  NULL  string

References:
http://www.cppreference.com/keywords/index.html
http://msdn.microsoft.com/en-us/library/2e6a4at9(VS.80).aspx

Four characteristics of variables:

1. Name
2. Type
3. Size
4. Value

Data types in C refers to an extensive system used for declaring variables or functions of different types. The type of a variable determines how much space it occupies in the storage and how the bit pattern stored is interpreted.

The following table provides all the data types that you will use during Arduino programming.

void

The void keyword is used only in function declarations. It indicates that the function is expected to return no information to the function from which it was called.

Example

Void Loop ( ) {
   // rest of the code
}

Boolean

A Boolean holds one of two values, true or false. Each Boolean variable occupies one byte of memory.

Example

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

Char

A data type that takes up one byte of memory that stores a character value. Character literals are written in single quotes like this: ‘A’ and for multiple characters, strings use double quotes: «ABC».

However, characters are stored as numbers. You can see the specific encoding in the ASCII chart. This means that it is possible to do arithmetic operations on characters, in which the ASCII value of the character is used. For example, ‘A’ + 1 has the value 66, since the ASCII value of the capital letter A is 65.

Example

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

unsigned char

Unsigned char is an unsigned data type that occupies one byte of memory. The unsigned char data type encodes numbers from 0 to 255.

Example

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

byte

A byte stores an 8-bit unsigned number, from 0 to 255.

Example

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Integers are the primary data-type for number storage. int stores a 16-bit (2-byte) value. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) — 1).

The int size varies from board to board. On the Arduino Due, for example, an int stores a 32-bit (4-byte) value. This yields a range of -2,147,483,648 to 2,147,483,647 (minimum value of -2^31 and a maximum value of (2^31) — 1).

Example

int counter = 32 ;// declaration of variable with type int and initialize it with 32

Unsigned int

Unsigned ints (unsigned integers) are the same as int in the way that they store a 2 byte value. Instead of storing negative numbers, however, they only store positive values, yielding a useful range of 0 to 65,535 (2^16) — 1). The Due stores a 4 byte (32-bit) value, ranging from 0 to 4,294,967,295 (2^32 — 1).

Example

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

Word

On the Uno and other ATMEGA based boards, a word stores a 16-bit unsigned number. On the Due and Zero, it stores a 32-bit unsigned number.

Example

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Long

Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from -2,147,483,648 to 2,147,483,647.

Example

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

unsigned long

Unsigned long variables are extended size variables for number storage and store 32 bits (4 bytes). Unlike standard longs, unsigned longs will not store negative numbers, making their range from 0 to 4,294,967,295 (2^32 — 1).

Example

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

short

A short is a 16-bit data-type. On all Arduinos (ATMega and ARM based), a short stores a 16-bit (2-byte) value. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) — 1).

Example

short val = 13 ;//declaration of variable with type short and initialize it with 13

float

Data type for floating-point number is a number that has a decimal point. Floating-point numbers are often used to approximate the analog and continuous values because they have greater resolution than integers.

Floating-point numbers can be as large as 3.4028235E+38 and as low as -3.4028235E+38. They are stored as 32 bits (4 bytes) of information.

Example

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

double

On the Uno and other ATMEGA based boards, Double precision floating-point number occupies four bytes. That is, the double implementation is exactly the same as the float, with no gain in precision. On the Arduino Due, doubles have 8-byte (64 bit) precision.

Example

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352