C Programming: Pointers and Memory Management

• C is a procedural programming language.

Pointers

• Pointers hold the memory address of a variable.
• Pointer arithmetic allows incrementing or decrementing a pointer to access adjacent memory locations.
• void pointers can point to any data type but require explicit casting before dereferencing.
• Double pointers (pointers to pointers) are used to manage arrays of pointers or modify pointers passed to functions.
• Dangling pointers point to memory that has been freed, leading to undefined behavior if dereferenced.
• Memory leaks occur when dynamically allocated memory is not freed, leading to resource exhaustion.

Memory Management

• malloc() allocates a block of memory on the heap and returns a void pointer to the beginning of the allocated block.
• calloc() allocates a block of memory and initializes all bits to zero.
• realloc() changes the size of a previously allocated block of memory.
• free() releases dynamically allocated memory back to the system.

Structures and Unions

• Structures are user-defined data types that group together variables of different data types.
• Structure members are accessed using the dot operator (.).
• Pointers to structures use the arrow operator (->) to access members.
• Unions are user-defined data types that allow multiple variables to share the same memory location.
• The size of a union is determined by the size of its largest member.
• Bit fields allow defining structure members that occupy a specific number of bits.
• Structure padding is the insertion of empty space within a structure to satisfy alignment requirements.
• Structure packing removes padding to reduce the size of the structure, potentially affecting performance.

File I/O

• fopen() opens a file for reading, writing, or appending.
• fclose() closes a file.
• fprintf() writes formatted output to a file.
• fscanf() reads formatted input from a file.
• fread() reads a block of data from a file
• fwrite() writes a block of data to a file.
• fseek() changes the file position.
• ftell() returns the current file position.
• rewind() resets the file position to the beginning of the file.
• fflush() forces the writing of buffered output to a file.

Preprocessor Directives

• #include includes the contents of a header file.
• #define defines a macro.
• #ifdef, #ifndef, #else, #endif are used for conditional compilation.
• #pragma is used to issue special commands to the compiler.

Variable Scope and Storage Classes

• auto is the default storage class for local variables.
• static variables retain their value between function calls and have internal linkage if declared outside a function.
• extern variables are declared outside a function and have external linkage, making them accessible from other files.
• register suggests to the compiler to store the variable in a register for faster access.
• Scope determines the region of the program where a variable is accessible.

Functions

• Function prototypes declare the function's return type, name, and parameters.
• Function pointers hold the address of a function, allowing functions to be passed as arguments to other functions.
• inline functions are expanded at the point of call, potentially improving performance.
• Recursion is a technique where a function calls itself.

Command Line Arguments

• argc is the number of command-line arguments.
• argv is an array of strings containing the command-line arguments.
• argv[0] is the name of the program.

Bitwise Operators

• & is the bitwise AND operator.
• | is the bitwise OR operator.
• ^ is the bitwise XOR operator.
• ~ is the bitwise NOT operator.
• << is the left shift operator.
• >> is the right shift operator.

Dynamic Linking and Shared Libraries

• Dynamic linking resolves external references at runtime.
• Shared libraries are loaded into memory only once and can be used by multiple programs.
• DLLs (Dynamic Link Libraries) are the equivalent of shared libraries in Windows.
• The dlopen(), dlsym(), and dlclose() functions are used to load, access, and unload shared libraries.

Volatile Keyword

• The volatile keyword indicates that a variable's value may be changed by external factors, such as hardware or another thread.
• Prevents the compiler from performing optimizations that could lead to incorrect results.

Const Keyword

• The const keyword indicates that a variable's value cannot be changed after initialization.
• const pointers can point to constant data or be constant themselves.

Type Qualifiers

• const prevents modification of a variable.
• volatile forces re-reading the value from memory on each access.
• restrict indicates that a pointer is the only means of accessing an object.

Error Handling

• Error handling is typically done through return codes.
• The errno variable stores the last error code.
• perror() prints an error message based on the value of errno.

Advanced Data Structures

• Linked lists, stacks, queues, trees, and graphs.
• Hash tables provide efficient key-value lookups.

Multi-threading

• Threads allow concurrent execution of code within a single process.
• pthread_create() creates a new thread.
• pthread_join() waits for a thread to terminate.
• Mutexes provide mutual exclusion to prevent race conditions.
• Semaphores control access to shared resources.
• Condition variables allow threads to wait for a specific condition to be met.

Signal Handling

• Signals are asynchronous notifications sent to a process.
• signal() registers a signal handler.
• Common signals include SIGINT (interrupt), SIGTERM (terminate), and SIGSEGV (segmentation fault).

Inter-Process Communication (IPC)

• Pipes allow unidirectional communication between related processes.
• Named pipes (FIFOs) allow communication between unrelated processes.
• Message queues allow processes to exchange messages.
• Shared memory allows processes to share a region of memory.
• Sockets allow communication between processes on the same or different machines.

Optimization Techniques

• Profiling identifies performance bottlenecks.
• Loop unrolling reduces loop overhead.
• Function inlining reduces function call overhead.
• Cache optimization improves memory access performance.

Code Style and Best Practices

• Use meaningful variable names.
• Comment code effectively.
• Follow consistent indentation and formatting.
• Avoid global variables.
• Handle errors gracefully.
• Write modular and reusable code.