Size of Data Types in C

C is a customisable programming language that is widely used for developing system software, applications, and embedded systems. One of the fundamental aspects of C programming is understanding the size of different data types. 

• The size of a data type determines the amount of memory it occupies and the range of values it can store.
• The type of data it usually carries is defined by using data types with variables and functions. This data may be in the form of a value or character.

Key terms: Primary Data, Char Size, Unsigned and Signed, Floating-Point Data, Derived Data

---

Types of Data Types

[Click Here for Sample Questions]

There are many different data types available in the C language, and each one may include a unique data type with a predefined range.

Read More:

---

Primary Data Types

[Click Here for Sample Questions]

Primary data types serve as the bedrock of C programming, enabling the manipulation of fundamental values. The following are primary data types:

(i) Char Size: The char data type, allocating 1 byte of memory, serves as the basic unit for representing a single character. Despite its modest size, the char type exhibits versatility by accommodating characters and small integers.

• Stores a single character, such as 'a', 'A', or '$'.
• Occupies 1 byte of memory.
• Can be used to represent ASCII values, which range from 0 to 127.

char ch = 'a';

print f ("%c", ch); // Output: a

(ii) Short Integer Size: The short integer data type, denoted by the 'short' keyword, typically occupies 2 bytes of memory. Its restricted size is advantageous in scenarios where memory conservation is critical.

(iii) Long Integer Size: The long integer data type, identified by the 'long' keyword, generally requires 4 bytes of memory. The augmented size of long integers facilitates representing a broader range of values than short integers.

• Stores integer values, such as 10, -20, or 12345.
• Typically occupies 4 bytes of memory, but the size may vary depending on the system architecture.
• Can act for both positive and negative whole numbers.

Example:

int num = 10;

print f ("%d", num); // Output: 10

Differentiating the Range for Unsigned and Signed Types

A simple understanding of the distinctions between unsigned and signed types is important for effective numerical handling.

• The 1's Complement: For signed integers, the 1's complement is a binary representation derived by flipping all the bits. While accommodating positive and negative numbers, this system introduces complexities in arithmetic operations.
• The 2's Complement: The 2's complement is the standard binary representation for signed integers, conferring advantages in arithmetic operations. Positive integers are represented conventionally, while negative numbers are obtained by taking the 1's complement and adding 1.

---

Floating-Point Data Types

[Click Here for Sample Questions]

Floating-point data types are pivotal in representing real numbers with fractional components.

Characteristics of floating-point data types in both normalised and de-normalized forms

(i) The Normalized Form: In the normalised form, the floating-point representation ensures that the most significant bit of the mantissa is consistently set to 1.

• This structure facilitates efficient arithmetic operations and extends the range of representable values.

(ii) The De-Normalized Form: De-normalized numbers relax the requirement for the most significant bit of the mantissa to be 1, allowing the representation of extremely small values.

• While enhancing precision for values close to zero, de-normalized numbers come with performance trade-offs.

Example:

• Stores single-precision floating-point numbers, such as 3.14, 12.5, or -0.001.
• Occupies 4 bytes of memory.
• Can represent decimal values with a limited degree of precision.

float pi = 3.14;

print f ("%f", pi); // Output: 3.140000

---

Derived Data Types

[Click Here for Sample Questions]

Derived data types, constructed from primary data types, encompass arrays, structures, unions, and pointers.

(i) Arrays: Arrays enable the storage of multiple elements of the same data type under a single identifier. Mastery of array sizes is crucial for optimizing memory allocation and efficient data access.

(ii) Structures: Structures permit the grouping of different data types under a singular identifier. Each element within a structure, referred to as a member, contributes to the overall size of the structure.

(iii) Unions: Unions, akin to structures, share memory among all members.The size of a union is dictated by its largest member, offering memory optimization.

(iv) Pointers: Pointers allow for dynamic memory allocation and manipulation by storing the memory address of another variable. 

• Enabling dynamic memory allocation and manipulation.
• A profound understanding of pointer sizes is imperative for averting memory-related pitfalls.

Common data types in C along with examples

---

Things to Remember

• C's 'double' data type, typically 8 bytes, is designed for double-precision floating-point numbers.
• Increased precision comes with higher memory consumption, which is important in memory-critical scenarios.
• The ' size of' operator in C calculates data type sizes, aiding in efficient memory management.
• 2's complement in C simplifies arithmetic operations, eliminating the need for a separate subtraction operation.
• Single-precision ('float') and double-precision ('double') in C have distinct precision and memory characteristics.
• Pointers in C store memory addresses, which are crucial for dynamic memory tasks, requiring an understanding of pointer sizes.

Also Read: