C Programming: Data Types and Variables

• C is a general-purpose programming language widely used because of its flexibility, efficiency, and control over hardware.
• Data types specify the type of data that a variable can store, influencing memory allocation and the operations that can be performed on it.
• Variables are named storage locations that hold values of a specific data type.

Basic Data Types

• int: Used for storing integer numbers (whole numbers without decimal points).
• float: Used for storing single-precision floating-point numbers (numbers with decimal points).
• double: Used for storing double-precision floating-point numbers, offering higher precision than float.
• char: Used for storing single characters (letters, digits, symbols).

Integer Data Type (int)

• Stores whole numbers, both positive and negative.
• Size of int is compiler and architecture dependent, often 4 bytes (32 bits).
• Range typically from -2,147,483,648 to 2,147,483,647 for a 4-byte integer.
• Modifiers can alter size and range: short, long, long long, unsigned, and signed.
• short int: Smaller integer, usually 2 bytes.
• long int: Larger integer, usually 4 or 8 bytes.
• long long int: Even larger integer, usually 8 bytes.
• unsigned int: Non-negative integers only, effectively doubling the positive range.
• signed int: Can store both positive and negative integers (default).

Floating-Point Data Types (float and double)

• Used for numbers with fractional parts or those requiring more precision.
• float: Single-precision floating-point number, typically 4 bytes.
• double: Double-precision floating-point number, typically 8 bytes.
• double provides more significant digits and a wider range than float.
• long double: Extended-precision floating-point number, offering even higher precision (size is compiler-dependent).
• Floating-point literals are represented with a decimal point or in exponential notation (e.g., 3.14, 2.0e-5).

Character Data Type (char)

• Used to store single characters, represented as small integers corresponding to their ASCII values.
• Size of char is typically 1 byte.
• Can be signed or unsigned, though usually signed by default.
• unsigned char represents values from 0 to 255.
• signed char represents values from -128 to 127.
• Character literals are enclosed in single quotes (e.g., 'A', '7', '$').

Qualifiers

• Qualifiers modify the properties of basic data types, altering their range and behavior.
• signed: Specifies that a variable can hold both positive and negative values (default for integer types).
• unsigned: Specifies that a variable can only hold non-negative values.
• short: Reduces the amount of storage allocated to the variable (usually for int).
• long: Increases the amount of storage allocated to the variable (for int and double).

Variables

• Variables must be declared before they can be used.
• Declaration involves specifying the data type and the name of the variable.
• Syntax: data_type variable_name; (e.g., int age;, float price;).
• Multiple variables of the same type can be declared in a single statement: int x, y, z;.

Variable Initialization

• Assigning an initial value to a variable during declaration.
• Syntax: data_type variable_name = value; (e.g., int count = 0;, float pi = 3.14159;).
• Uninitialized variables contain garbage values.
• Initialization can be done at declaration or later using the assignment operator =.

Variable Naming Rules

• Variable names are case-sensitive.
• Must begin with a letter or underscore (_).
• Can contain letters, digits, and underscores.
• Keywords (reserved words in C) cannot be used as variable names (e.g., int, float, for, while).
• Should be descriptive and meaningful for readability.
• Common conventions: snake_case (e.g., user_age) or camelCase (e.g., userAge).

Scope of Variables

• Scope refers to the region of the program where a variable is accessible.
• Local variables: Declared inside a block or function and are only accessible within that block or function.
• Global variables: Declared outside any function and are accessible throughout the entire program.
• Block scope: Variables declared inside a block (e.g., inside an if statement or a loop) are only accessible within that block.
• Function scope: Variables declared inside a function are only accessible within that function.
• Global variables should be used sparingly to avoid naming conflicts and maintain code modularity.

Constants

• Constants are values that cannot be changed during program execution.
• Defined using the const keyword or the #define preprocessor directive.
• const keyword: Creates a named constant of a specific data type (e.g., const int MAX_SIZE = 100;).
• #define directive: Creates a symbolic constant by replacing a name with a value during preprocessing (e.g., #define PI 3.14159).
• Constants improve code readability and prevent accidental modification of important values.

Type Conversion (Casting)

• Converting a value from one data type to another.
• Implicit conversion: Performed automatically by the compiler when types are compatible (e.g., assigning an int to a float).
• Explicit conversion (casting): Performed using the cast operator (data_type) (e.g., int x = (int)3.14;).
• Casting can lead to loss of precision or data, so it should be used carefully.
• When dividing two integers, casting one of them to a float or double ensures that the result is a floating-point number.

Operators

• Symbols that perform operations on operands (variables and values).
• Arithmetic operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulus).
• Assignment operators: = (assignment), += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), %= (modulus and assign).
• Increment and decrement operators: ++ (increment), -- (decrement).
• Relational operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).
• Logical operators: && (logical AND), || (logical OR), ! (logical NOT).
• Bitwise operators: & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), ~ (bitwise NOT), << (left shift), >> (right shift).
• Each operator has a defined precedence and associativity that determines the order of evaluation in expressions.

Input and Output

• stdio.h header file provides standard input and output functions.
• printf(): Used for formatted output to the console.
  • Syntax: printf("format string", arguments);
  • Format specifiers: %d (integer), %f (float), %lf (double), %c (character), %s (string).
• scanf(): Used for formatted input from the console.
  • Syntax: scanf("format string", &variable1, &variable2, ...);
  • Requires the address operator & to store the input value in the variable.
• getchar(): Reads a single character from the input.
• putchar(): Writes a single character to the output.