Libraries are the building blocks of software development, enabling code reuse, modular design, and efficient distribution. In C, libraries come in two forms: static libraries (.a) and shared libraries (.so, .dylib, .dll). This comprehensive guide covers everything from basic library creation to advanced techniques like symbol visibility, versioning, and cross-platform development.

Understanding C Libraries

Static Libraries (.a on Unix, .lib on Windows)

Compiled code is copied into the executable at link time
No runtime dependencies on the library
Larger executable size
Each program gets its own copy

Shared Libraries (.so on Linux, .dylib on macOS, .dll on Windows)

Loaded at runtime from a single location
Smaller executable size
Multiple programs share the same library in memory
Runtime dependency on the library being present

Static Library Flow: ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Source │────▶│ Compiler │────▶│ Object │ │ Files │ │ (gcc -c) │ │ Files │ └─────────────┘ └─────────────┘ └─────────────┘ │ ▼ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Executable │◀────│ Linker │◀────│ Archiver │ │ with lib │ │ (gcc) │ │ (ar) │ └─────────────┘ └─────────────┘ └─────────────┘ Shared Library Flow: ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Source │────▶│ Compiler │────▶│ Position- │ │ Files │ │ (gcc -c) │ │ Independent│ └─────────────┘ └─────────────┘ └─────────────┘ │ ▼ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Executable │ │ Runtime │ │ Shared │ │ with stub │────▶│ Loader │◀────│ Library │ └─────────────┘ └─────────────┘ └─────────────┘

Creating a Simple Library

1. Library Source Files

// mathlib.h - Public header #ifndef MATHLIB_H #define MATHLIB_H #ifdef __cplusplus extern "C" { #endif // Library version #define MATHLIB_VERSION_MAJOR 1 #define MATHLIB_VERSION_MINOR 0 #define MATHLIB_VERSION_PATCH 0 // Basic mathematical functions int add(int a, int b); int subtract(int a, int b); int multiply(int a, int b); int divide(int a, int b, int *remainder); // Advanced functions double power(double base, int exponent); long long factorial(int n); int is_prime(int n); int gcd(int a, int b); int lcm(int a, int b); // String utilities char* str_reverse(const char *str); int str_is_palindrome(const char *str); // Error codes typedef enum { MATHLIB_SUCCESS = 0, MATHLIB_ERROR_DIVISION_BY_ZERO, MATHLIB_ERROR_INVALID_ARGUMENT, MATHLIB_ERROR_OUT_OF_MEMORY } MathLibError; // Error handling MathLibError get_last_error(void); void clear_error(void); #ifdef __cplusplus } #endif #endif // MATHLIB_H

// mathlib.c - Implementation #include "mathlib.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> static MathLibError last_error = MATHLIB_SUCCESS; // Helper function to set error static void set_error(MathLibError error) { last_error = error; } MathLibError get_last_error(void) { return last_error; } void clear_error(void) { last_error = MATHLIB_SUCCESS; } // Basic operations int add(int a, int b) { return a + b; } int subtract(int a, int b) { return a - b; } int multiply(int a, int b) { return a * b; } int divide(int a, int b, int *remainder) { if (b == 0) { set_error(MATHLIB_ERROR_DIVISION_BY_ZERO); return 0; } if (remainder) { *remainder = a % b; } set_error(MATHLIB_SUCCESS); return a / b; } // Power function double power(double base, int exponent) { if (exponent == 0) return 1.0; double result = 1.0; int abs_exponent = exponent < 0 ? -exponent : exponent; for (int i = 0; i < abs_exponent; i++) { result *= base; } return exponent < 0 ? 1.0 / result : result; } // Factorial long long factorial(int n) { if (n < 0) { set_error(MATHLIB_ERROR_INVALID_ARGUMENT); return -1; } if (n > 20) { // Would overflow 64-bit integer set_error(MATHLIB_ERROR_INVALID_ARGUMENT); return -1; } long long result = 1; for (int i = 2; i <= n; i++) { result *= i; } set_error(MATHLIB_SUCCESS); return result; } // Prime number check int is_prime(int n) { if (n < 2) return 0; if (n == 2) return 1; if (n % 2 == 0) return 0; for (int i = 3; i * i <= n; i += 2) { if (n % i == 0) return 0; } return 1; } // Greatest Common Divisor (Euclidean algorithm) int gcd(int a, int b) { a = abs(a); b = abs(b); while (b != 0) { int temp = b; b = a % b; a = temp; } return a; } // Least Common Multiple int lcm(int a, int b) { if (a == 0 || b == 0) return 0; int g = gcd(a, b); return abs(a / g * b); } // String reversal char* str_reverse(const char *str) { if (str == NULL) { set_error(MATHLIB_ERROR_INVALID_ARGUMENT); return NULL; } size_t len = strlen(str); char *result = malloc(len + 1); if (result == NULL) { set_error(MATHLIB_ERROR_OUT_OF_MEMORY); return NULL; } for (size_t i = 0; i < len; i++) { result[i] = str[len - 1 - i]; } result[len] = '\0'; set_error(MATHLIB_SUCCESS); return result; } // Palindrome check int str_is_palindrome(const char *str) { if (str == NULL) { set_error(MATHLIB_ERROR_INVALID_ARGUMENT); return 0; } size_t len = strlen(str); for (size_t i = 0; i < len / 2; i++) { if (str[i] != str[len - 1 - i]) { return 0; } } return 1; }

Building Static Libraries

1. Linux/Unix/macOS Static Library

# Compile object files gcc -c -Wall -Wextra -O2 -fPIC mathlib.c -o mathlib.o # Create static library archive ar rcs libmathlib.a mathlib.o # View archive contents ar t libmathlib.a # Optional: Create index for faster linking ranlib libmathlib.a # Clean up rm mathlib.o

2. Using the Static Library

// test_static.c #include <stdio.h> #include "mathlib.h" int main() { printf("=== Static Library Test ===\n\n"); // Test basic operations printf("Basic Operations:\n"); printf(" 5 + 3 = %d\n", add(5, 3)); printf(" 5 - 3 = %d\n", subtract(5, 3)); printf(" 5 * 3 = %d\n", multiply(5, 3)); int remainder; int quotient = divide(10, 3, &remainder); printf(" 10 / 3 = %d remainder %d\n", quotient, remainder); // Test advanced functions printf("\nAdvanced Functions:\n"); printf(" 2^10 = %.0f\n", power(2.0, 10)); printf(" 10! = %lld\n", factorial(10)); printf(" 17 is prime: %s\n", is_prime(17) ? "yes" : "no"); printf(" GCD(48, 18) = %d\n", gcd(48, 18)); printf(" LCM(12, 18) = %d\n", lcm(12, 18)); // Test string utilities printf("\nString Utilities:\n"); char *reversed = str_reverse("hello"); printf(" 'hello' reversed: '%s'\n", reversed); printf(" 'racecar' is palindrome: %s\n", str_is_palindrome("racecar") ? "yes" : "no"); free(reversed); // Test error handling printf("\nError Handling:\n"); divide(10, 0, NULL); printf(" Division by zero error: %d\n", get_last_error()); return 0; }

Build and run:

gcc -o test_static test_static.c -L. -lmathlib ./test_static

Building Shared Libraries

1. Linux Shared Library (.so)

# Compile position-independent code (PIC) gcc -c -Wall -Wextra -O2 -fPIC mathlib.c -o mathlib.o # Create shared library gcc -shared -Wl,-soname,libmathlib.so.1 -o libmathlib.so.1.0.0 mathlib.o # Create symbolic links for versioning ln -sf libmathlib.so.1.0.0 libmathlib.so.1 ln -sf libmathlib.so.1 libmathlib.so # Clean up rm mathlib.o

2. macOS Shared Library (.dylib)

# Compile position-independent code gcc -c -Wall -Wextra -O2 -fPIC mathlib.c -o mathlib.o # Create dynamic library gcc -dynamiclib -install_name @rpath/libmathlib.dylib \ -current_version 1.0.0 -compatibility_version 1.0 \ -o libmathlib.dylib mathlib.o # Clean up rm mathlib.o

3. Windows DLL (with MinGW)

# Compile with DLL export gcc -c -Wall -O2 -DBUILDING_DLL mathlib.c -o mathlib.o # Create DLL gcc -shared -o mathlib.dll mathlib.o -Wl,--out-implib,libmathlib.a # Clean up rm mathlib.o

Advanced Library Features

1. Symbol Visibility Control

// mathlib_visibility.h #ifndef MATHLIB_VISIBILITY_H #define MATHLIB_VISIBILITY_H #if defined(_WIN32) || defined(__CYGWIN__) #ifdef BUILDING_DLL #define MATHLIB_API __declspec(dllexport) #else #define MATHLIB_API __declspec(dllimport) #endif #else #if __GNUC__ >= 4 #define MATHLIB_API __attribute__((visibility("default"))) #define MATHLIB_LOCAL __attribute__((visibility("hidden"))) #else #define MATHLIB_API #define MATHLIB_LOCAL #endif #endif // Export public symbols MATHLIB_API int add(int a, int b); MATHLIB_API int subtract(int a, int b); // Hide internal symbols MATHLIB_LOCAL void internal_helper(void); #endif

2. Library Initialization and Cleanup

// mathlib_init.c #include <stdio.h> #include <stdlib.h> static int initialization_count = 0; static int cleanup_called = 0; // Constructor - runs when library is loaded __attribute__((constructor)) static void library_init(void) { initialization_count++; printf("Math library initialized (count: %d)\n", initialization_count); // Initialize global resources // Allocate static buffers // Set up logging } // Destructor - runs when library is unloaded __attribute__((destructor)) static void library_cleanup(void) { cleanup_called = 1; printf("Math library cleaned up\n"); // Free global resources // Flush logs // Close file handles } // Manual initialization (alternative) int mathlib_initialize(void) { if (initialization_count == 0) { library_init(); } return MATHLIB_SUCCESS; } int mathlib_shutdown(void) { if (cleanup_called) { return MATHLIB_SUCCESS; } library_cleanup(); return MATHLIB_SUCCESS; }

3. Library Versioning

// mathlib_version.h #ifndef MATHLIB_VERSION_H #define MATHLIB_VERSION_H #define MATHLIB_VERSION_MAJOR 1 #define MATHLIB_VERSION_MINOR 0 #define MATHLIB_VERSION_PATCH 0 #define MATHLIB_VERSION_STRING "1.0.0" typedef struct { int major; int minor; int patch; const char *string; } MathLibVersion; MATHLIB_API MathLibVersion mathlib_get_version(void); #endif // Implementation MATHLIB_API MathLibVersion mathlib_get_version(void) { MathLibVersion version = { MATHLIB_VERSION_MAJOR, MATHLIB_VERSION_MINOR, MATHLIB_VERSION_PATCH, MATHLIB_VERSION_STRING }; return version; }

4. Thread Safety

// mathlib_threadsafe.c #include <pthread.h> // Thread-local storage static __thread int tls_error; static __thread char tls_buffer[256]; // Mutex for shared resources static pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER; // Thread-safe error handling void set_thread_error(MathLibError error) { tls_error = error; } MathLibError get_thread_error(void) { return tls_error; } // Thread-safe string reversal with buffer char* str_reverse_threadsafe(const char *str) { if (str == NULL) { tls_error = MATHLIB_ERROR_INVALID_ARGUMENT; return NULL; } size_t len = strlen(str); if (len >= sizeof(tls_buffer)) { tls_error = MATHLIB_ERROR_INVALID_ARGUMENT; return NULL; } for (size_t i = 0; i < len; i++) { tls_buffer[i] = str[len - 1 - i]; } tls_buffer[len] = '\0'; tls_error = MATHLIB_SUCCESS; return tls_buffer; } // Thread-safe with mutex for shared resource int increment_global_counter(void) { static int global_counter = 0; int result; pthread_mutex_lock(&global_mutex); result = ++global_counter; pthread_mutex_unlock(&global_mutex); return result; }

Library Project Structure

mathlib/ ├── include/ │ └── mathlib/ │ ├── mathlib.h │ ├── mathlib_version.h │ └── mathlib_visibility.h ├── src/ │ ├── mathlib.c │ ├── mathlib_init.c │ ├── mathlib_threadsafe.c │ └── mathlib_private.h ├── tests/ │ ├── test_mathlib.c │ ├── test_mathlib_threadsafe.c │ └── test_runner.c ├── examples/ │ ├── example_basic.c │ └── example_advanced.c ├── docs/ │ ├── Doxyfile │ └── README.md ├── CMakeLists.txt ├── Makefile └── LICENSE

CMake Build System

# CMakeLists.txt cmake_minimum_required(VERSION 3.10) project(mathlib VERSION 1.0.0 LANGUAGES C) # Set C standard set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD_REQUIRED ON) # Library options option(BUILD_SHARED_LIBS "Build shared library" ON) option(BUILD_TESTS "Build tests" ON) option(BUILD_EXAMPLES "Build examples" ON) # Include directories include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) # Source files set(SOURCES src/mathlib.c src/mathlib_init.c src/mathlib_threadsafe.c ) # Create library add_library(mathlib ${SOURCES}) # Set library properties set_target_properties(mathlib PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} ) # Install targets install(TARGETS mathlib EXPORT mathlibTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin INCLUDES DESTINATION include ) # Install headers install(DIRECTORY include/ DESTINATION include) # Export package install(EXPORT mathlibTargets FILE mathlibTargets.cmake NAMESPACE mathlib:: DESTINATION lib/cmake/mathlib ) # Tests if(BUILD_TESTS) enable_testing() add_executable(test_mathlib tests/test_mathlib.c) target_link_libraries(test_mathlib mathlib) add_test(NAME mathlib_test COMMAND test_mathlib) endif() # Examples if(BUILD_EXAMPLES) add_executable(example_basic examples/example_basic.c) target_link_libraries(example_basic mathlib) endif()

Makefile Build System

# Makefile CC = gcc CFLAGS = -Wall -Wextra -O2 -fPIC LDFLAGS = -lm # Library version VERSION = 1.0.0 SONAME = libmathlib.so.1 NAME = libmathlib.so.$(VERSION) # Directories SRCDIR = src INCDIR = include OBJDIR = obj LIBDIR = lib # Source files SOURCES = $(wildcard $(SRCDIR)/*.c) OBJECTS = $(SOURCES:$(SRCDIR)/%.c=$(OBJDIR)/%.o) # Targets .PHONY: all clean install uninstall test examples all: static shared static: $(LIBDIR)/libmathlib.a shared: $(LIBDIR)/$(NAME) # Static library $(LIBDIR)/libmathlib.a: $(OBJECTS) @mkdir -p $(LIBDIR) ar rcs $@ $^ ranlib $@ # Shared library $(LIBDIR)/$(NAME): $(OBJECTS) @mkdir -p $(LIBDIR) $(CC) -shared -Wl,-soname,$(SONAME) -o $@ $^ $(LDFLAGS) ln -sf $(NAME) $(LIBDIR)/$(SONAME) ln -sf $(NAME) $(LIBDIR)/libmathlib.so # Object files $(OBJDIR)/%.o: $(SRCDIR)/%.c @mkdir -p $(OBJDIR) $(CC) $(CFLAGS) -I$(INCDIR) -c $< -o $@ # Test program test: shared $(CC) $(CFLAGS) -I$(INCDIR) -L$(LIBDIR) tests/test_mathlib.c -o test_mathlib -lmathlib LD_LIBRARY_PATH=$(LIBDIR) ./test_mathlib # Examples examples: shared for example in examples/*.c; do \ $(CC) $(CFLAGS) -I$(INCDIR) -L$(LIBDIR) $$example -o $${example%.c} -lmathlib; \ done # Install install: all install -d $(DESTDIR)/usr/local/lib install -d $(DESTDIR)/usr/local/include/mathlib install -m 755 $(LIBDIR)/libmathlib.so* $(DESTDIR)/usr/local/lib/ install -m 644 $(INCDIR)/mathlib/*.h $(DESTDIR)/usr/local/include/mathlib/ ldconfig # Uninstall uninstall: rm -f $(DESTDIR)/usr/local/lib/libmathlib.so* rm -rf $(DESTDIR)/usr/local/include/mathlib # Clean clean: rm -rf $(OBJDIR) $(LIBDIR) rm -f test_mathlib examples/example_*

Testing the Library

// tests/test_mathlib.c #include <stdio.h> #include <stdlib.h> #include <assert.h> #include "mathlib.h" #define TEST_ASSERT(cond, msg) \ do { \ if (!(cond)) { \ fprintf(stderr, "FAILED: %s\n", msg); \ return 1; \ } \ } while(0) int test_basic_operations(void) { TEST_ASSERT(add(5, 3) == 8, "add(5,3) != 8"); TEST_ASSERT(subtract(5, 3) == 2, "subtract(5,3) != 2"); TEST_ASSERT(multiply(5, 3) == 15, "multiply(5,3) != 15"); int remainder; int quotient = divide(10, 3, &remainder); TEST_ASSERT(quotient == 3, "divide(10,3) quotient != 3"); TEST_ASSERT(remainder == 1, "divide(10,3) remainder != 1"); return 0; } int test_advanced_functions(void) { TEST_ASSERT(power(2.0, 10) == 1024.0, "power(2,10) != 1024"); TEST_ASSERT(factorial(5) == 120, "factorial(5) != 120"); TEST_ASSERT(is_prime(17) == 1, "17 is prime"); TEST_ASSERT(is_prime(4) == 0, "4 is not prime"); TEST_ASSERT(gcd(48, 18) == 6, "gcd(48,18) != 6"); TEST_ASSERT(lcm(12, 18) == 36, "lcm(12,18) != 36"); return 0; } int test_string_utilities(void) { char *reversed = str_reverse("hello"); TEST_ASSERT(reversed != NULL, "str_reverse failed"); TEST_ASSERT(strcmp(reversed, "olleh") == 0, "reverse 'hello' != 'olleh'"); free(reversed); TEST_ASSERT(str_is_palindrome("racecar") == 1, "'racecar' is palindrome"); TEST_ASSERT(str_is_palindrome("hello") == 0, "'hello' is not palindrome"); return 0; } int test_error_handling(void) { clear_error(); divide(10, 0, NULL); TEST_ASSERT(get_last_error() == MATHLIB_ERROR_DIVISION_BY_ZERO, "Division by zero error not set"); clear_error(); factorial(-1); TEST_ASSERT(get_last_error() == MATHLIB_ERROR_INVALID_ARGUMENT, "Invalid argument error not set"); return 0; } int main(void) { int failed = 0; printf("Running tests...\n\n"); printf("Testing basic operations... "); failed |= test_basic_operations(); printf("done\n"); printf("Testing advanced functions... "); failed |= test_advanced_functions(); printf("done\n"); printf("Testing string utilities... "); failed |= test_string_utilities(); printf("done\n"); printf("Testing error handling... "); failed |= test_error_handling(); printf("done\n"); if (failed) { printf("\n*** TESTS FAILED ***\n"); return 1; } else { printf("\n*** ALL TESTS PASSED ***\n"); return 0; } }

Documentation with Doxygen

/** * @file mathlib.h * @brief Mathematical utility library * @author Your Name * @version 1.0.0 */ /** * @defgroup mathlib Math Library * @brief Core mathematical operations * @{ */ /** * @brief Adds two integers * @param a First operand * @param b Second operand * @return Sum of a and b */ int add(int a, int b); /** * @brief Divides two integers * @param a Dividend * @param b Divisor (must not be zero) * @param remainder Pointer to store remainder (can be NULL) * @return Quotient of a divided by b * @retval 0 Division by zero (error set) * @note Sets error MATHLIB_ERROR_DIVISION_BY_ZERO on failure */ int divide(int a, int b, int *remainder); /** * @brief Computes factorial * @param n Non-negative integer (max 20) * @return n! or -1 on error * @retval -1 Invalid argument (n < 0 or n > 20) */ long long factorial(int n); /** @} */

Best Practices

Header Guards: Always use include guards
API Stability: Maintain backward compatibility
Documentation: Document public API thoroughly
Error Handling: Provide consistent error reporting
Thread Safety: Document thread safety guarantees
Versioning: Use semantic versioning
Testing: Include comprehensive test suite
Build Systems: Support both Make and CMake
Cross-Platform: Handle Windows, Linux, macOS differences
Memory Management: Clearly document ownership

Conclusion

Creating C libraries is a fundamental skill for systems programming. This guide covered:

Static vs shared libraries and their trade-offs
Building libraries with Make and CMake
Symbol visibility and API design
Thread safety and error handling
Testing and documentation
Cross-platform considerations

Well-designed libraries are the foundation of reusable, maintainable software. By following the practices outlined here, you can create professional-quality C libraries that are reliable, well-documented, and easy to integrate into other projects.

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers

Building Blocks of C: A Complete Guide to Functions
Explains how functions work in C programming, including function declaration, definition, parameters, return values, and how functions help organize reusable code.
https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/

The Heart of Text Processing: A Complete Guide to Strings in C
Explains how strings are used in C, covering character arrays, string handling functions, and common techniques for text processing tasks.
https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/

The Cornerstone of Data Organization: A Complete Guide to Arrays in C
Describes how arrays store multiple values in C, including indexing, initialization, and using arrays to manage structured data efficiently.
https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/

Guaranteed Execution: A Complete Guide to the Do-While Loop in C
Explains the do-while loop structure in C, highlighting how it ensures code runs at least once before checking the loop condition.
https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/

Mastering Iteration: A Complete Guide to the For Loop in C
Explains how the for loop works in C, including initialization, condition checking, and increment steps for repeated execution of code blocks.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/

Mastering Iteration: A Complete Guide to While Loops in C
Explains the while loop structure in C, focusing on condition-based repetition and proper loop control techniques.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/

Beyond If-Else: A Complete Guide to Switch Case in C
Explains how switch-case statements work in C programming, enabling efficient handling of multiple conditional branches.
https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/

Mastering the Fundamentals: A Complete Guide to Arithmetic Operations in C
Explains how arithmetic operators such as addition, subtraction, multiplication, and division work in C, along with operator precedence and usage examples.
https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/

Foundation of C Programming: A Complete Guide to Basic Input Output
Explains how input and output functions like printf and scanf work in C, forming the foundation for interacting with users and displaying program results.
https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/