Javascript required
Skip to content Skip to sidebar Skip to footer
Home / Data in a Struct Variable Must Be Read One Member at a Time

Data in a Struct Variable Must Be Read One Member at a Time

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 retentivity locations or variables. Data types besides make up one's mind the types of operations or methods of processing of data elements.

The C language provides basic arithmetic types, such every bit integer and real number types, and syntax to build array and compound types. Headers for the C standard library, to exist used via include directives, contain definitions of support types, that take boosted backdrop, such every bit providing storage with an exact size, independent of the linguistic communication implementation on specific hardware platforms.[1] [2]

Basic types [edit]

Main types [edit]

The C language provides the 4 bones arithmetic type specifiers char, int, bladder and double, and the modifiers signed, unsigned, brusque, and long. The following tabular array lists the permissible combinations in specifying a big set up of storage size-specific declarations.

Type Explanation Minimum size ($.25) Format specifier Range Suffix for decimal constants
char Smallest addressable unit of measurement of the car that tin can comprise basic character set. It is an integer type. Actual type tin can be either signed or unsigned. It contains CHAR_BIT bits.[3] viii %c CHAR_MIN / CHAR_MAX due north/a
signed char Of the aforementioned size every bit char, but guaranteed to be signed. Capable of containing at to the lowest degree the [−127, +127] range.[3] [a] 8 %c (or %hhi for numerical output) SCHAR_MIN / SCHAR_MAX [5] n/a
unsigned char Of the same size as char, but guaranteed to exist unsigned. Contains at to the lowest degree the [0, 255] range.[half-dozen] viii %c (or %hhu for numerical output) 0 / UCHAR_MAX n/a
short
short int
signed short
signed short int 		Short signed integer type. Capable of containing at least the [−32,767, +32,767] range.[iii] [a] 16 %hi or %hard disk drive SHRT_MIN / SHRT_MAX n/a
unsigned short
unsigned brusque int 		Short unsigned integer blazon. Contains at least the [0, 65,535] range.[iii] 16 %hu 0 / USHRT_MAX n/a
int
signed
signed int 		Basic signed integer type. Capable of containing at to the lowest degree the [−32,767, +32,767] range.[3] [a] 16 %i or %d INT_MIN / INT_MAX none
unsigned
unsigned int 		Bones unsigned integer type. Contains at least the [0, 65,535] range.[iii] 16 %u 0 / UINT_MAX u or U
long
long int
signed long
signed long int 		Long signed integer type. Capable of containing at to the lowest degree the [−ii,147,483,647, +2,147,483,647] range.[3] [a] 32 %li or %ld LONG_MIN / LONG_MAX fifty or L [7]
unsigned long
unsigned long int 		Long unsigned integer blazon. Capable of containing at least the [0, iv,294,967,295] range.[3] 32 %lu 0 / ULONG_MAX both u or U and l or L
long long
long long int
signed long long
signed long long int 		Long long signed integer type. Capable of containing at least the [−9,223,372,036,854,775,807, +9,223,372,036,854,775,807] range.[3] [a] Specified since the C99 version of the standard. 64 %lli or %lld LLONG_MIN / LLONG_MAX ll or LL
unsigned long long
unsigned long long int 		Long long unsigned integer blazon. Contains at to the lowest degree the [0, +18,446,744,073,709,551,615] range.[3] Specified since the C99 version of the standard. 64 %llu 0 / ULLONG_MAX both u or U and ll or LL
float Existent floating-signal type, usually referred to equally a single-precision floating-indicate type. Bodily properties unspecified (except minimum limits); however, on well-nigh systems, this is the IEEE 754 single-precision binary floating-indicate format (32 bits). This format is required past the optional Annex F "IEC 60559 floating-betoken arithmetic". Converting from text:[b]
  • %f %F
  • %thou %Thousand
  • %due east %E
  • %a %A
double Real floating-point type, unremarkably referred to as a double-precision floating-point blazon. Actual properties unspecified (except minimum limits); however, on most systems, this is the IEEE 754 double-precision binary floating-bespeak format (64 bits). This format is required by the optional Addendum F "IEC 60559 floating-point arithmetic".
  • %lf %lF
  • %lg %lG
  • %le %lE
  • %la %lA [c]
long double Real floating-point type, usually mapped to an extended precision floating-indicate number format. Bodily properties unspecified. Information technology tin can be either x86 extended-precision floating-point format (80 bits, but typically 96 bits or 128 bits in memory with padding bytes), the not-IEEE "double-double" (128 bits), IEEE 754 quadruple-precision floating-point format (128 bits), or the same as double. Run into the article on long double for details. %Lf %LF
%Lg %LG
%Le %LE
%La %LA [c]
  1. ^ a b c d east The minimal ranges −(2n−one−1) to twon−1−1 (east.thousand. [−127,127]) come from the various integer representations allowed by the standard (ones' complement, sign-magnitude, ii's complement).[4] Even so, most platforms use two'due south complement, implying a range of the form −2m−1 to iim−1−1 with k ≥ n for these implementations, eastward.g. [−128,127] (SCHAR_MIN = −128 and SCHAR_MAX = 127) for an viii-bit signed char.
  2. ^ These format strings too be for formatting to text, but operate on a double.
  3. ^ a b Capital differs from lowercase in the output. Uppercase specifiers produce values in the uppercase, and lowercase in lower (%A, %Eastward, %F, %K produce such values every bit INF, NAN and Due east (exponent) in uppercase)

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

The relation requirements are that the long long is non smaller than long, which is not smaller than int, which is not smaller than brusque. As char's size is e'er the minimum supported data blazon, no other data types (except flake-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 $.25 and long long must contain at least 64 bits.

The type int should be the integer blazon that the target processor is most efficiently working with. This allows not bad flexibility: for example, all types can be 64-bit. However, several unlike integer width schemes (information models) are pop. Because the data model defines how different programs communicate, a uniform information model is used within a given operating organisation 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 equally diverse as 1990s SunOS 4 Unix, Microsoft MS-DOS, modern Linux, and Microchip MCC18 for embedded 8-bit PIC microcontrollers. POSIX requires char to exist exactly eight bits in size.

Various rules in the C standard brand unsigned char the basic type used for arrays suitable to store arbitrary non-bit-field objects: its lack of padding $.25 and trap representations, the definition of object representation,[half-dozen] and the possibility of aliasing.[9]

The bodily size and behavior of floating-signal types also vary by implementation. The only guarantee 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.

The C99 standard includes new real floating-signal types float_t and double_t, defined in <math.h>. They stand for 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/faux) type _Bool. Additionally, the <stdbool.h> header defines bool every bit a convenient allonym 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 i (true). This behavior exists to avert integer overflows in implicit narrowing conversions. For example, in the post-obit 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 non fit in the data type, which results in the lower 8 $.25 of information technology being used, resulting in a zero value. However, irresolute the type causes the previous lawmaking to carry normally: 

                        _Bool                                    b                                    =                                    256            ;                        if                                    (            b            )                                    {                                                /* practice something */                        }

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

                        _Bool                                    a                                    =                                    ane            ,                                    b                                    =                                    2            ;                        if                                    (            a                                    ==                                    b            )                                    {                                                /* practice something */                        }

Size and arrow difference types [edit]

The C language specification includes the typedefs size_t and ptrdiff_t to represent memory-related quantities. Their size is divers co-ordinate to the target processor'due south arithmetic capabilities, non the retentivity 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 detail implementation. The operator sizeof yields a value of the blazon 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 broad. Additionally, POSIX includes ssize_t, which is a signed integer blazon of the same width as size_t.

ptrdiff_t is a signed integer blazon used to correspond the difference between pointers. It is guaranteed to be valid only confronting pointers of the same type; subtraction of pointers consisting of dissimilar 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 <bladder.h> header (cfloat header in C++) defines macros for floating-betoken types. The actual values depend on the implementation.

Properties of integer types [edit]

  • CHAR_BIT – size of the char type in bits (at to the lowest degree 8 $.25)
  • 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 bladder, double, long double respectively
  • FLT_TRUE_MIN, DBL_TRUE_MIN, LDBL_TRUE_MIN (C11) – minimum positive value of bladder, 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-indicate 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 tin be represented without losing precision by bladder, double, long double, respectively
  • FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON – difference between 1.0 and the next representable value of bladder, 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 bladder, 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 ability is a normalized bladder, 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-bespeak blazon tin be represented in decimal with a precision of DECIMAL_DIG digits and read dorsum in the original floating-point blazon without changing its value. DECIMAL_DIG is at to the lowest degree x.

Fixed-width integer types [edit]

The C99 standard includes definitions of several new integer types to enhance the portability of programs.[two] The already available basic integer types were deemed insufficient, considering their actual sizes are implementation defined and may vary across different systems. The new types are peculiarly useful in embedded environments where hardware ordinarily supports only several types and that back up varies between different environments. All new types are defined in <inttypes.h> header (cinttypes header in C++) and too 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 take the same number n of $.25 across all implementations. Included only if it is available in the implementation.
  • Least-width integer types that are guaranteed to be the smallest blazon bachelor in the implementation, that has at to the lowest degree specified number n of $.25. Guaranteed to be specified for at to the lowest degree Northward=8,16,32,64.
  • Fastest integer types that are guaranteed to be the fastest integer blazon bachelor in the implementation, that has at least specified number due north of bits. Guaranteed to be specified for at least N=viii,16,32,64.
  • Arrow integer types that are guaranteed to be able to concur a pointer. Included only if it is available in the implementation.
  • Maximum-width integer types that are guaranteed to be the largest integer blazon in the implementation.

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

Type category Signed types Unsigned types
Type Minimum value Maximum value Type Minimum value Maximum value
Exact width intn_t INTnorthward_MIN INTn_MAX uintn_t 0 UINTnorthward_MAX
Least width int_leastn_t INT_LEASTnorthward_MIN INT_LEASTdue north_MAX uint_leastn_t 0 UINT_LEASTn_MAX
Fastest int_fastn_t INT_FASTn_MIN INT_FASTdue north_MAX uint_fastn_t 0 UINT_FASTn_MAX
Arrow intptr_t INTPTR_MIN INTPTR_MAX uintptr_t 0 UINTPTR_MAX
Maximum width intmax_t INTMAX_MIN INTMAX_MAX uintmax_t 0 UINTMAX_MAX

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. Information technology defines macros for printf format cord and scanf format string specifiers respective 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} . Hither {fmt} defines the output formatting and is one of d (decimal), ten (hexadecimal), o (octal), u (unsigned) and i (integer). {type} defines the type of the argument and is one of north , FASTnorthward , To the lowest degreen , PTR, MAX, where n corresponds to the number of bits in the statement.

Scanf format string

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

Functions

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:

  • _FloatNorthward for binary interchange formats;
  • _DecimalN for decimal interchange formats;
  • _FloatNorthwardx for binary extended formats;
  • _DecimalN10 for decimal extended formats.

Structures [edit]

Structures aggregate the storage of multiple data items, of potentially differing data types, into ane retention cake referenced by a unmarried variable. The post-obit instance declares the information type struct birthday which contains the name and birthday of a person. The structure definition is followed past a declaration of the variable John that allocates the needed storage. 

                        struct            birthday                                    {                                                char                                    name            [            20            ];                                                int                                    twenty-four hour period            ;                                                int                                    month            ;                                                int                                    year            ;                        };                        struct            birthday                                    John            ;

The retention layout of a structure is a language implementation outcome for each platform, with a few restrictions. The memory address of the offset member must be the same as the address of structure itself. Structures may be initialized or assigned to using chemical compound literals. A office may straight return a construction, although this is frequently not efficient at run-time. Since C99, a structure may likewise end with a flexible array member.

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

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

Arrays [edit]

For every blazon T, except void and role types, at that place exist the types "assortment of North elements of type T". An assortment is a collection of values, all of the same blazon, stored contiguously in retentiveness. An array of size North 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 tin exist initialized with a compound initializer, but non assigned. Arrays are passed to functions past passing a pointer to the first element. Multidimensional arrays are divers as "array of array …", and all except the outermost dimension must have compile-time constant size: 

                        int                                    a            [            x            ][            8            ];                                    // array of ten elements, each of type 'array of viii int elements'

Pointers [edit]

Every data blazon 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 item blazon. They are alleged with the asterisk (*) type declarator following the basic storage blazon and preceding the variable name. Whitespace before or after the asterisk is optional. 

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

Pointers may besides be declared for arrow information types, thus creating multiple indirect pointers, such every bit char ** and int ***, including pointers to array types. The latter are less common than an array of pointers, and their syntax may be disruptive: 

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

The element pc requires ten blocks of memory of the size of pointer to char (usually 40 or fourscore bytes on common platforms), but chemical element pa is merely one pointer (size 4 or 8 bytes), and the data it refers to is an array of x 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 information types may exist declared to permit reading the same data either as an integer, a float, or any other user declared type: 

                        marriage            {                                                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 usu 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 exist preserved if u.i is smaller than u.f.

Reading from a union fellow member is not the same every bit casting since the value of the fellow member is non 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 part abs in the variable my_int_f: 

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

Part pointers are invoked by proper noun simply like normal part calls. Role pointers are carve up 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[update] 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,[10] but the more ordinary proper noun diminutive 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.[ commendation needed ]

See also [edit]

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

References [edit]

  1. ^ Barr, Michael (2 December 2007). "Portable Stock-still-Width Integers in C". Retrieved 18 January 2016.
  2. ^ a b ISO/IEC 9899:1999 specification, TC3 (PDF). p. 255, § vii.xviii Integer types <stdint.h>.
  3. ^ a b c d e f g h i j ISO/IEC 9899:1999 specification, TC3 (PDF). p. 22, § 5.2.4.2.1 Sizes of integer types <limits.h>.
  4. ^ Rationale for International Standard—Programming Languages—C Revision v.10 (PDF). p. 25, § 5.2.4.ii.1 Sizes of integer types <limits.h>.
  5. ^ https://docs.microsoft.com/en-united states of america/cpp/c-language/cpp-integer-limits?view=msvc-170.
  6. ^ a b ISO/IEC 9899:1999 specification, TC3 (PDF). p. 37, § 6.2.half dozen.1 Representations of types – General.
  7. ^ https://en.cppreference.com/westward/cpp/language/integer_literal.
  8. ^ "64-Fleck Programming Models: Why LP64?". The Open Group. Retrieved ix Nov 2011.
  9. ^ ISO/IEC 9899:1999 specification, TC3 (PDF). p. 67, § six.5 Expressions.
  10. ^ C11:The New C Standard, Thomas Plum

Data in a Struct Variable Must Be Read One Member at a Time

Source: https://en.wikipedia.org/wiki/C_data_types