Introduction

Writing C code that runs seamlessly across multiple operating systems—Windows, Linux, macOS, and beyond—is a challenging but essential skill for modern developers. Cross-platform development requires careful consideration of compiler differences, operating system APIs, file system conventions, and hardware architectures. This comprehensive guide explores the strategies, techniques, and best practices for writing truly portable C code.

1. Understanding Platform Differences

1.1 Common Platform Variations

// Operating system detection macros #ifdef _WIN32 #define PLATFORM_WINDOWS 1 #elif defined(__linux__) #define PLATFORM_LINUX 1 #elif defined(__APPLE__) && defined(__MACH__) #define PLATFORM_MACOS 1 #elif defined(__FreeBSD__) #define PLATFORM_FREEBSD 1 #elif defined(__OpenBSD__) #define PLATFORM_OPENBSD 1 #else #define PLATFORM_UNKNOWN 1 #endif // Compiler detection #ifdef __GNUC__ #define COMPILER_GCC 1 #define COMPILER_VERSION __GNUC__ #elif defined(_MSC_VER) #define COMPILER_MSVC 1 #define COMPILER_VERSION _MSC_VER #elif defined(__clang__) #define COMPILER_CLANG 1 #define COMPILER_VERSION __clang_major__ #endif // Endianness detection #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #define PLATFORM_LITTLE_ENDIAN 1 #elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ #define PLATFORM_BIG_ENDIAN 1 #else // Fallback runtime detection #endif

1.2 Data Type Sizes

#include <stdint.h> #include <limits.h> // Use fixed-width types for platform-independent sizes typedef int32_t i32; typedef uint32_t u32; typedef int64_t i64; typedef uint64_t u64; typedef int16_t i16; typedef uint16_t u16; typedef int8_t i8; typedef uint8_t u8; // Never assume sizes void demonstrate_size_variations(void) { printf("Size variations across platforms:\n"); printf("sizeof(char): %zu\n", sizeof(char)); // Always 1 printf("sizeof(short): %zu\n", sizeof(short)); // Usually 2 printf("sizeof(int): %zu\n", sizeof(int)); // 2, 4, or 8 printf("sizeof(long): %zu\n", sizeof(long)); // 4, 8, or more printf("sizeof(void*): %zu\n", sizeof(void*)); // 4 on 32-bit, 8 on 64-bit printf("sizeof(size_t): %zu\n", sizeof(size_t)); // Platform-dependent // Use limits.h for maximum values printf("INT_MAX: %d\n", INT_MAX); printf("LONG_MAX: %ld\n", LONG_MAX); }

2. Build Systems and Compilation

2.1 Cross-Platform Build with CMake

# CMakeLists.txt - Cross-platform build configuration cmake_minimum_required(VERSION 3.10) project(CrossPlatformApp VERSION 1.0.0 LANGUAGES C) # Set C standard set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS OFF) # Platform detection if(WIN32) add_definitions(-DPLATFORM_WINDOWS) set(PLATFORM_SOURCES src/windows/platform_win.c) elseif(APPLE) add_definitions(-DPLATFORM_MACOS) set(PLATFORM_SOURCES src/macos/platform_macos.c) elseif(UNIX) add_definitions(-DPLATFORM_LINUX) set(PLATFORM_SOURCES src/linux/platform_linux.c) endif() # Compiler-specific flags if(MSVC) add_compile_options(/W4 /WX /utf-8) add_link_options(/LTCG) else() add_compile_options(-Wall -Wextra -Wpedantic -Werror) add_compile_options(-O2 -D_FORTIFY_SOURCE=2) endif() # Add executable add_executable(${PROJECT_NAME} src/main.c src/common.c ${PLATFORM_SOURCES} ) # Install install(TARGETS ${PROJECT_NAME} DESTINATION bin)

2.2 Makefile with Platform Detection

# Makefile with platform detection UNAME_S := $(shell uname -s) UNAME_M := $(shell uname -m) # Platform detection ifeq ($(UNAME_S), Linux) PLATFORM = linux LIBS = -lpthread -ldl CFLAGS = -DPLATFORM_LINUX endif ifeq ($(UNAME_S), Darwin) PLATFORM = macos LIBS = -lpthread CFLAGS = -DPLATFORM_MACOS endif ifeq ($(UNAME_S), MINGW32_NT) PLATFORM = windows LIBS = -lws2_32 -lwinmm CFLAGS = -DPLATFORM_WINDOWS endif ifeq ($(UNAME_S), CYGWIN_NT) PLATFORM = cygwin LIBS = -lpthread CFLAGS = -DPLATFORM_CYGWIN endif # Architecture detection ifeq ($(UNAME_M), x86_64) ARCH = x64 CFLAGS += -m64 endif ifeq ($(UNAME_M), i686) ARCH = x86 CFLAGS += -m32 endif # Common flags CFLAGS += -std=c11 -Wall -Wextra -Wpedantic -O2 # Source files SOURCES = src/main.c src/common.c PLATFORM_SOURCES = src/$(PLATFORM)/platform_$(PLATFORM).c # Build target $(PROJECT_NAME): $(SOURCES) $(PLATFORM_SOURCES) $(CC) $(CFLAGS) $^ -o $@ $(LIBS) clean: rm -f $(PROJECT_NAME)

3. File System Abstraction

3.1 Platform-Agnostic File Operations

#include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef PLATFORM_WINDOWS #include <windows.h> #include <direct.h> #define PATH_SEPARATOR '\\' #define PATH_SEPARATOR_STR "\\" #define chdir _chdir #define getcwd _getcwd #else #include <unistd.h> #include <sys/stat.h> #include <dirent.h> #include <libgen.h> #define PATH_SEPARATOR '/' #define PATH_SEPARATOR_STR "/" #endif // Platform-agnostic path utilities void normalize_path(char *path) { if (path == NULL) return; #ifdef PLATFORM_WINDOWS // Convert forward slashes to backslashes for (char *p = path; *p; p++) { if (*p == '/') *p = '\\'; } #else // Convert backslashes to forward slashes for (char *p = path; *p; p++) { if (*p == '\\') *p = '/'; } #endif } // Join path components char* join_path(const char *base, const char *component) { size_t base_len = strlen(base); size_t comp_len = strlen(component); size_t sep_len = 1; char *result = malloc(base_len + sep_len + comp_len + 1); if (result == NULL) return NULL; strcpy(result, base); // Add separator if needed if (base_len > 0 && base[base_len - 1] != PATH_SEPARATOR) { result[base_len] = PATH_SEPARATOR; strcpy(result + base_len + 1, component); } else { strcpy(result + base_len, component); } return result; } // Get directory listing typedef struct { char **entries; size_t count; size_t capacity; } DirList; #ifdef PLATFORM_WINDOWS DirList* list_directory(const char *path) { DirList *list = calloc(1, sizeof(DirList)); if (list == NULL) return NULL; WIN32_FIND_DATA find_data; char search_path[MAX_PATH]; snprintf(search_path, sizeof(search_path), "%s\\*", path); HANDLE find_handle = FindFirstFile(search_path, &find_data); if (find_handle == INVALID_HANDLE_VALUE) { free(list); return NULL; } do { if (strcmp(find_data.cFileName, ".") != 0 && strcmp(find_data.cFileName, "..") != 0) { if (list->count >= list->capacity) { list->capacity = list->capacity ? list->capacity * 2 : 16; list->entries = realloc(list->entries, list->capacity * sizeof(char*)); if (list->entries == NULL) break; } list->entries[list->count] = strdup(find_data.cFileName); list->count++; } } while (FindNextFile(find_handle, &find_data)); FindClose(find_handle); return list; } #else DirList* list_directory(const char *path) { DirList *list = calloc(1, sizeof(DirList)); if (list == NULL) return NULL; DIR *dir = opendir(path); if (dir == NULL) { free(list); return NULL; } struct dirent *entry; while ((entry = readdir(dir)) != NULL) { if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) { if (list->count >= list->capacity) { list->capacity = list->capacity ? list->capacity * 2 : 16; list->entries = realloc(list->entries, list->capacity * sizeof(char*)); if (list->entries == NULL) break; } list->entries[list->count] = strdup(entry->d_name); list->count++; } } closedir(dir); return list; } #endif void free_dirlist(DirList *list) { if (list == NULL) return; for (size_t i = 0; i < list->count; i++) { free(list->entries[i]); } free(list->entries); free(list); }

4. Threading Abstraction

4.1 Unified Thread API

#ifdef PLATFORM_WINDOWS #include <windows.h> typedef HANDLE ThreadHandle; typedef DWORD (WINAPI *ThreadFunc)(void*); int thread_create(ThreadHandle *thread, ThreadFunc func, void *arg) { *thread = CreateThread(NULL, 0, func, arg, 0, NULL); return (*thread != NULL) ? 0 : -1; } int thread_join(ThreadHandle thread) { return (WaitForSingleObject(thread, INFINITE) == WAIT_OBJECT_0) ? 0 : -1; } void thread_detach(ThreadHandle thread) { CloseHandle(thread); } #else #include <pthread.h> typedef pthread_t ThreadHandle; typedef void* (*ThreadFunc)(void*); int thread_create(ThreadHandle *thread, ThreadFunc func, void *arg) { return pthread_create(thread, NULL, func, arg); } int thread_join(ThreadHandle thread) { return pthread_join(thread, NULL); } void thread_detach(ThreadHandle thread) { pthread_detach(thread); } #endif // Mutex abstraction #ifdef PLATFORM_WINDOWS typedef CRITICAL_SECTION Mutex; void mutex_init(Mutex *mutex) { InitializeCriticalSection(mutex); } void mutex_lock(Mutex *mutex) { EnterCriticalSection(mutex); } void mutex_unlock(Mutex *mutex) { LeaveCriticalSection(mutex); } void mutex_destroy(Mutex *mutex) { DeleteCriticalSection(mutex); } #else typedef pthread_mutex_t Mutex; void mutex_init(Mutex *mutex) { pthread_mutex_init(mutex, NULL); } void mutex_lock(Mutex *mutex) { pthread_mutex_lock(mutex); } void mutex_unlock(Mutex *mutex) { pthread_mutex_unlock(mutex); } void mutex_destroy(Mutex *mutex) { pthread_mutex_destroy(mutex); } #endif

5. Socket Programming Abstraction

5.1 Cross-Platform Networking

#ifdef PLATFORM_WINDOWS #include <winsock2.h> #include <ws2tcpip.h> #pragma comment(lib, "ws2_32.lib") typedef SOCKET Socket; #define INVALID_SOCKET_VAL INVALID_SOCKET #define SOCKET_ERROR_VAL SOCKET_ERROR int network_init(void) { WSADATA wsa_data; return WSAStartup(MAKEWORD(2, 2), &wsa_data); } void network_cleanup(void) { WSACleanup(); } int socket_close(Socket sock) { return closesocket(sock); } #else #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> typedef int Socket; #define INVALID_SOCKET_VAL (-1) #define SOCKET_ERROR_VAL (-1) int network_init(void) { return 0; // No initialization needed on Unix } void network_cleanup(void) { // Nothing to clean up } int socket_close(Socket sock) { return close(sock); } #endif // Cross-platform socket creation Socket create_tcp_socket(void) { Socket sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == INVALID_SOCKET_VAL) { return INVALID_SOCKET_VAL; } // Set socket options int opt = 1; #ifdef PLATFORM_WINDOWS setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt)); #else setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); // Set non-blocking mode fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_NONBLOCK); #endif return sock; } // Cross-platform socket connect int socket_connect(Socket sock, const char *host, int port) { struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); // Convert host to IP if (inet_pton(AF_INET, host, &addr.sin_addr) <= 0) { return -1; } return connect(sock, (struct sockaddr*)&addr, sizeof(addr)); }

6. Dynamic Library Loading

6.1 Cross-Platform Plugin System

#ifdef PLATFORM_WINDOWS #include <windows.h> typedef HMODULE LibHandle; LibHandle load_library(const char *path) { return LoadLibrary(path); } void* get_symbol(LibHandle lib, const char *name) { return GetProcAddress(lib, name); } void unload_library(LibHandle lib) { FreeLibrary(lib); } const char* library_extension(void) { return ".dll"; } #else #include <dlfcn.h> typedef void* LibHandle; LibHandle load_library(const char *path) { return dlopen(path, RTLD_LAZY); } void* get_symbol(LibHandle lib, const char *name) { return dlsym(lib, name); } void unload_library(LibHandle lib) { dlclose(lib); } const char* library_extension(void) { #ifdef __APPLE__ return ".dylib"; #else return ".so"; #endif } #endif // Example plugin structure typedef struct { const char *name; void (*init)(void); void (*shutdown)(void); int (*process)(const void *data, size_t size); } Plugin; Plugin* load_plugin(const char *name) { char path[512]; snprintf(path, sizeof(path), "plugins/%s%s", name, library_extension()); LibHandle lib = load_library(path); if (lib == NULL) { return NULL; } Plugin *plugin = malloc(sizeof(Plugin)); if (plugin == NULL) { unload_library(lib); return NULL; } // Get plugin functions plugin->name = name; plugin->init = get_symbol(lib, "plugin_init"); plugin->shutdown = get_symbol(lib, "plugin_shutdown"); plugin->process = get_symbol(lib, "plugin_process"); if (plugin->init == NULL || plugin->shutdown == NULL || plugin->process == NULL) { free(plugin); unload_library(lib); return NULL; } // Store library handle for cleanup *(LibHandle*)(plugin + 1) = lib; return plugin; } void unload_plugin(Plugin *plugin) { if (plugin == NULL) return; LibHandle lib = *(LibHandle*)(plugin + 1); plugin->shutdown(); unload_library(lib); free(plugin); }

7. Shared Memory and IPC

7.1 Cross-Platform Shared Memory

#ifdef PLATFORM_WINDOWS #include <windows.h> typedef HANDLE SharedMemoryHandle; SharedMemoryHandle create_shared_memory(const char *name, size_t size) { return CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, (DWORD)size, name); } void* map_shared_memory(SharedMemoryHandle handle, size_t size) { return MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, size); } void unmap_shared_memory(void *ptr) { UnmapViewOfFile(ptr); } void close_shared_memory(SharedMemoryHandle handle) { CloseHandle(handle); } #else #include <sys/mman.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> typedef int SharedMemoryHandle; SharedMemoryHandle create_shared_memory(const char *name, size_t size) { return shm_open(name, O_CREAT | O_RDWR, 0600); } void* map_shared_memory(SharedMemoryHandle handle, size_t size) { if (ftruncate(handle, size) == -1) { return MAP_FAILED; } return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle, 0); } void unmap_shared_memory(void *ptr) { munmap(ptr, 0); // Size must be known in real implementation } void close_shared_memory(SharedMemoryHandle handle) { close(handle); } #endif

8. Unicode and Character Encoding

8.1 Cross-Platform Unicode Handling

#include <wchar.h> #include <locale.h> #ifdef PLATFORM_WINDOWS // Windows uses UTF-16 internally #define CHAR_TYPE wchar_t #define TEXT_LITERAL(s) L##s #define STDIO_WFUNC wprintf #else // Unix systems typically use UTF-8 #define CHAR_TYPE char #define TEXT_LITERAL(s) s #define STDIO_WFUNC printf #endif // Convert between UTF-8 and UTF-16 #ifdef PLATFORM_WINDOWS char* utf16_to_utf8(const wchar_t *wstr) { if (wstr == NULL) return NULL; int size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL); if (size <= 0) return NULL; char *result = malloc(size); if (result == NULL) return NULL; WideCharToMultiByte(CP_UTF8, 0, wstr, -1, result, size, NULL, NULL); return result; } wchar_t* utf8_to_utf16(const char *str) { if (str == NULL) return NULL; int size = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); if (size <= 0) return NULL; wchar_t *result = malloc(size * sizeof(wchar_t)); if (result == NULL) return NULL; MultiByteToWideChar(CP_UTF8, 0, str, -1, result, size); return result; } #else // On Unix, convert using iconv or assume UTF-8 char* utf16_to_utf8(const wchar_t *wstr) { // Simplified - use iconv in production size_t len = wcslen(wstr); char *result = malloc(len * 4 + 1); if (result == NULL) return NULL; // Simple conversion for ASCII only for (size_t i = 0; i < len; i++) { result[i] = (char)(wstr[i] & 0xFF); } result[len] = '\0'; return result; } wchar_t* utf8_to_utf16(const char *str) { size_t len = strlen(str); wchar_t *result = malloc((len + 1) * sizeof(wchar_t)); if (result == NULL) return NULL; for (size_t i = 0; i < len; i++) { result[i] = (wchar_t)str[i]; } result[len] = L'\0'; return result; } #endif // Cross-platform file open with Unicode support FILE* open_file_unicode(const char *filename, const char *mode) { #ifdef PLATFORM_WINDOWS wchar_t *wfilename = utf8_to_utf16(filename); wchar_t *wmode = utf8_to_utf16(mode); FILE *f = _wfopen(wfilename, wmode); free(wfilename); free(wmode); return f; #else return fopen(filename, mode); #endif }

9. Time and Date Handling

9.1 Cross-Platform Time Utilities

#include <time.h> #ifdef PLATFORM_WINDOWS #include <sys/timeb.h> #include <windows.h> // Windows high-resolution timer typedef struct { LARGE_INTEGER frequency; LARGE_INTEGER start; } HighResTimer; void timer_start(HighResTimer *timer) { QueryPerformanceFrequency(&timer->frequency); QueryPerformanceCounter(&timer->start); } double timer_elapsed_ms(HighResTimer *timer) { LARGE_INTEGER now; QueryPerformanceCounter(&now); return (double)(now.QuadPart - timer->start.QuadPart) * 1000.0 / (double)timer->frequency.QuadPart; } #else #include <sys/time.h> // POSIX high-resolution timer typedef struct { struct timeval start; } HighResTimer; void timer_start(HighResTimer *timer) { gettimeofday(&timer->start, NULL); } double timer_elapsed_ms(HighResTimer *timer) { struct timeval now; gettimeofday(&now, NULL); return (now.tv_sec - timer->start.tv_sec) * 1000.0 + (now.tv_usec - timer->start.tv_usec) / 1000.0; } #endif // Get current time as ISO 8601 string char* get_iso_timestamp(void) { time_t now = time(NULL); struct tm *tm_info; char *buffer = malloc(32); if (buffer == NULL) return NULL; #ifdef PLATFORM_WINDOWS tm_info = localtime(&now); strftime(buffer, 32, "%Y-%m-%dT%H:%M:%S%z", tm_info); #else tm_info = localtime(&now); strftime(buffer, 32, "%Y-%m-%dT%H:%M:%S%z", tm_info); // Insert colon in timezone offset char *tz = strchr(buffer, '+'); if (tz == NULL) tz = strchr(buffer, '-'); if (tz && strlen(tz) == 5) { memmove(tz + 3, tz + 2, 4); tz[2] = ':'; } #endif return buffer; }

10. Complete Cross-Platform Example

Here's a complete example that demonstrates many cross-platform techniques:

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #include <time.h> /* Platform detection */ #ifdef _WIN32 #define PLATFORM_WINDOWS 1 #include <windows.h> #include <direct.h> #define PATH_SEP '\\' #define PATH_SEP_STR "\\" #define getcwd _getcwd #else #define PLATFORM_WINDOWS 0 #include <unistd.h> #include <sys/stat.h> #include <dirent.h> #define PATH_SEP '/' #define PATH_SEP_STR "/" #endif /* Fixed-width types */ typedef int32_t i32; typedef uint32_t u32; typedef int64_t i64; typedef uint64_t u64; /* Platform-agnostic path utilities */ char* join_path(const char *a, const char *b) { size_t a_len = strlen(a); size_t b_len = strlen(b); char *result = malloc(a_len + b_len + 2); if (result == NULL) return NULL; strcpy(result, a); if (a_len > 0 && a[a_len - 1] != PATH_SEP) { result[a_len] = PATH_SEP; strcpy(result + a_len + 1, b); } else { strcpy(result + a_len, b); } return result; } /* Directory operations */ int create_directory(const char *path) { #if PLATFORM_WINDOWS return _mkdir(path); #else return mkdir(path, 0755); #endif } /* File operations */ typedef struct { FILE *file; char *path; } FileHandle; FileHandle* open_file(const char *path, const char *mode) { FileHandle *fh = malloc(sizeof(FileHandle)); if (fh == NULL) return NULL; fh->file = fopen(path, mode); if (fh->file == NULL) { free(fh); return NULL; } fh->path = strdup(path); return fh; } void close_file(FileHandle *fh) { if (fh == NULL) return; if (fh->file) fclose(fh->file); free(fh->path); free(fh); } /* Configuration structure */ typedef struct { char *app_name; char *config_dir; char *data_dir; int max_threads; int verbose; } Config; /* Platform-specific defaults */ Config* load_config(void) { Config *cfg = malloc(sizeof(Config)); if (cfg == NULL) return NULL; memset(cfg, 0, sizeof(Config)); cfg->max_threads = 4; cfg->app_name = strdup("MyApp"); #if PLATFORM_WINDOWS char *appdata = getenv("APPDATA"); if (appdata) { cfg->config_dir = join_path(appdata, cfg->app_name); cfg->data_dir = join_path(appdata, cfg->app_name); } else { cfg->config_dir = strdup(".myapp"); cfg->data_dir = strdup(".myapp"); } #else char *home = getenv("HOME"); if (home) { cfg->config_dir = join_path(home, ".config"); cfg->config_dir = join_path(cfg->config_dir, cfg->app_name); cfg->data_dir = join_path(home, ".local"); cfg->data_dir = join_path(cfg->data_dir, "share"); cfg->data_dir = join_path(cfg->data_dir, cfg->app_name); } else { cfg->config_dir = strdup(".myapp"); cfg->data_dir = strdup(".myapp"); } #endif return cfg; } void free_config(Config *cfg) { if (cfg == NULL) return; free(cfg->app_name); free(cfg->config_dir); free(cfg->data_dir); free(cfg); } /* Platform information display */ void print_platform_info(void) { printf("Platform Information:\n"); #if PLATFORM_WINDOWS printf(" OS: Windows\n"); OSVERSIONINFOEX osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); GetVersionEx((OSVERSIONINFO*)&osvi); printf(" Version: %d.%d\n", osvi.dwMajorVersion, osvi.dwMinorVersion); printf(" Build: %d\n", osvi.dwBuildNumber); #elif defined(__APPLE__) printf(" OS: macOS\n"); #ifdef __arm64__ printf(" Architecture: ARM64\n"); #else printf(" Architecture: x86_64\n"); #endif #elif defined(__linux__) printf(" OS: Linux\n"); #ifdef __x86_64__ printf(" Architecture: x86_64\n"); #elif defined(__aarch64__) printf(" Architecture: ARM64\n"); #else printf(" Architecture: Unknown\n"); #endif #else printf(" OS: Unknown\n"); #endif printf(" Pointer size: %zu bytes\n", sizeof(void*)); printf(" Endianness: "); uint32_t test = 1; if (*(uint8_t*)&test == 1) { printf("Little Endian\n"); } else { printf("Big Endian\n"); } } /* Main application */ int main(int argc, char *argv[]) { printf("=== Cross-Platform Application ===\n\n"); // Load configuration Config *cfg = load_config(); if (cfg == NULL) { fprintf(stderr, "Failed to load configuration\n"); return 1; } // Display platform info print_platform_info(); // Display configuration printf("\nConfiguration:\n"); printf(" App name: %s\n", cfg->app_name); printf(" Config dir: %s\n", cfg->config_dir); printf(" Data dir: %s\n", cfg->data_dir); printf(" Max threads: %d\n", cfg->max_threads); // Create directories if needed printf("\nCreating directories...\n"); if (create_directory(cfg->config_dir) == 0) { printf(" Created config directory\n"); } else { printf(" Config directory already exists or error\n"); } // Write a config file char *config_file = join_path(cfg->config_dir, "settings.txt"); if (config_file) { FileHandle *fh = open_file(config_file, "w"); if (fh) { fprintf(fh->file, "# Application Settings\n"); fprintf(fh->file, "verbose=%d\n", cfg->verbose); fprintf(fh->file, "max_threads=%d\n", cfg->max_threads); fprintf(fh->file, "timestamp=%s\n", get_iso_timestamp()); close_file(fh); printf(" Wrote config to: %s\n", config_file); } free(config_file); } // Clean up free_config(cfg); printf("\nApplication completed successfully.\n"); return 0; }

11. Cross-Platform Testing Strategies

11.1 Testing Matrix

// test_platform.c #include <stdio.h> #include <stdlib.h> // Test each platform-specific code path void test_platform_features(void) { // Test path handling char *path = join_path("foo", "bar"); printf("join_path(\"foo\", \"bar\") = %s\n", path); free(path); // Test directory creation const char *test_dir = "test_dir"; if (create_directory(test_dir) == 0) { printf("Created directory: %s\n", test_dir); } else { printf("Directory already exists: %s\n", test_dir); } // Test file operations FileHandle *fh = open_file("test.txt", "w"); if (fh) { fprintf(fh->file, "Test content\n"); close_file(fh); printf("Wrote test file\n"); } // Test timer HighResTimer timer; timer_start(&timer); sleep_ms(100); double elapsed = timer_elapsed_ms(&timer); printf("Timer elapsed: %.2f ms\n", elapsed); }

11.2 Continuous Integration

# .github/workflows/cross-platform.yml name: Cross-Platform Tests on: [push, pull_request] jobs: test-linux: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Build run: | mkdir build && cd build cmake .. && make - name: Test run: ./build/test_app test-macos: runs-on: macos-latest steps: - uses: actions/checkout@v3 - name: Build run: | mkdir build && cd build cmake .. && make - name: Test run: ./build/test_app test-windows: runs-on: windows-latest steps: - uses: actions/checkout@v3 - name: Build run: | mkdir build cd build cmake .. cmake --build . --config Release - name: Test run: .\build\Release\test_app.exe

12. Common Cross-Platform Libraries

Library	Purpose	Description
libuv	I/O	Cross-platform asynchronous I/O
GLib	Core	GNOME's utility library with cross-platform abstractions
SDL	Graphics	Cross-platform graphics and input handling
OpenSSL	Crypto	Cryptography across all platforms
zlib	Compression	Cross-platform compression
libcurl	Networking	Cross-platform HTTP/FTP client
SQLite	Database	Embedded database that works everywhere
ICU	Unicode	Internationalization and Unicode support

13. Best Practices Summary

Use standard C where possible: Stick to ISO C standards
Abstract platform differences: Create wrappers for platform-specific APIs
Use fixed-width types: stdint.h types for predictable sizes
Handle paths correctly: Use platform-appropriate separators
Test on all target platforms: Set up CI for each platform
Use cross-platform build systems: CMake, Meson, or similar
Document platform assumptions: Clearly state supported platforms
Handle endianness: Use byte-swapping where necessary
Consider character encodings: Use UTF-8 internally, convert at boundaries
Provide fallbacks: Have default implementations for unsupported features

Conclusion

Cross-platform development in C is challenging but achievable with careful design and abstraction. By isolating platform-specific code behind well-defined interfaces, using standard C features where possible, and leveraging cross-platform libraries, you can write code that compiles and runs correctly on Windows, Linux, macOS, and beyond.

The key is to think about portability from the start, not as an afterthought. With the techniques and patterns outlined in this guide, you can build C applications that truly work everywhere, reaching the widest possible audience with a single codebase.

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/