Computer Systems and Programming Languages

A computer system integrates hardware and software to perform complex calculations and logical operations. Hardware components include the Central Processing Unit (CPU), memory, and input/output devices, often based on the Von Neumann architecture where instructions and data share the same memory space. Software encompasses system software like operating systems and application software designed for specific user tasks.

Programming languages facilitate communication between humans and computers. They evolve from low-level machine languages (binary code) to assembly languages (mnemonics), and finally to high-level languages like C. High-level languages are platform-independent and require a compiler to translate source code into machine-executable instructions.

Structure of a C Program

C is a general-purpose, structured programming language developed by Dennis Ritchie. It is known for its efficiency, portability, and low-level memory access capabilities. A standard C program consists of preprocessor directives, functions, variables, and statements.

The execution of a C program begins at the main() function. The following example demonstrates a basic program structure:

#include <stdio.h> // Preprocessor directive for standard I/O

int main() { // Main function entry point
    // Statement to print text to the console
    printf("Initialization successful.\n");
    return 0; // Return status code indicating successful execution
}

In this structure, #include <stdio.h> includes the standard input/output library necessary for functions like printf. The main function returns an integer (int), where 0 typically signifies success. Comments are used to annotate code and are ignored by the compiler. C supports single-line comments (//) and multi-line comments (/* ... */).

Keywords and Identifiers

Keywords are reserved words in C that have predefined meanings and cannot be used for other purposes. These include control flow keywords (if, else, for, while), data type keywords (int, char, float), and storage class keywords (static, extern).

Identifiers are names assigned to variables, functions, and other user-defined elements. Naming rules require identifiers to start with a letter (A-Z, a-z) or an underscore (_), followed by letters, digits, or underscores. C is case-sensitive, meaning Value and value are distinct identifiers. Good naming conventions include CamelCase (e.g., totalAmount) or snake_case (e.g., total_amount).

Data Representation and Storage

Computers store data in binary format (0s and 1s). Understanding number systems—binary, octal, decimal, and hexadecimal—is crucial. For instance, a hexadecimal number is often prefixed with 0x in C.

Integers are stored using binary representation. Negative numbers are typically handled using two's complement arithmetic. In this system, positive numbers remain unchanged, while negative numbers are represented by inverting the bits of the absolute value and adding one. This method simplifies arithmetic logic circuits in hardware.

Data Types

C supports several data types categorized into basic types, enumerated types, void types, and derived types (pointers, arrays).

Type conversion occurs when values of different types interact. Implicit conversion (coercion) happens automatically, typically when assigning a smaller type to a larger type (e.g., int to double). Explicit conversion (casting) forces a type change using the cast operator, which can lead to data loss if converting from a larger to a smaller type.

int units = 100;
double preciseUnits = units; // Implicit conversion
int truncated = (int)99.99;   // Explicit cast, truncated becomes 99

Variables and Constants

A variable is a named storage location in memory whose value can change during program execution. Variables must be declared with a specific type before use. Local variables are defined inside functions and have local scope, while global variables are defined outside functions and are accessible throughout the file.

Constants are fixed values that do not change. They can be defined using the const keyword or the #define preprocessor directive.

• const int MAX_LIMIT = 100;: Defines a read-only integer variable. It respects scope rules and has a specific type.
• #define PI 3.14159: Defines a macro substitution. It is handled by the preprocessor and has no type checking.

Pointers

Every variable resides in memory at a specific address. A pointer is a variable that stores this memory address. Pointers allow for direct memory manipulation and efficient handling of arrays and data structures. The address-of operator (&) retrieves the address of a variable, while the dereference operator (*) accesses the value stored at that address.

int score = 95;
int *score_ptr = &score; // score_ptr holds the address of score

printf("Value: %d\n", *score_ptr); // Dereferences pointer to print 95
printf("Address: %p\n", score_ptr); // Prints the memory address

Pointers are essential for dynamic memory allocation and passing arguments by reference to functions.