Great question—let's break this down clearly: you cannot compile a single static library once with one compiler (like MSVC on Windows or GCC/Clang on Linux) that works natively across Windows, macOS, and Linux. Here's why, plus practical alternatives to meet your cross-platform needs:

1. Platform-Specific Binary Formats #

Static libraries are tied to the platform's binary format, which are completely incompatible across the three OSes:

• Windows uses .lib files in the COFF format
• Linux uses .a files in the ELF format
• macOS uses .a files too, but in the Mach-O format (not compatible with Linux's ELF)
  Compilers like MSVC only output the format native to their host OS—MSVC can't generate ELF or Mach-O libraries, just as GCC on Linux can't output COFF libraries.

2. ABI Incompatibilities #

Even if you could convert the binary format, the Application Binary Interface (ABI) differs between platforms:

• Function calling conventions: Windows defaults to __cdecl/__stdcall, while Linux/macOS use their own flavor of cdecl with subtle differences
• Data alignment rules: While C99 defines standards, compilers may implement platform-specific alignment for performance, leading to mismatched memory layouts
• Platform-specific helper code: Compilers inject small bits of platform-specific code (like stack setup or initialization logic) into static libraries, which won't execute on other OSes

3. Compiler & Instruction Set Differences #

Each compiler generates machine code tailored to its host platform's architecture and OS. For example:

• MSVC's x86-64 code generation differs from GCC/Clang's
• macOS now widely uses ARM64, while Windows/Linux still rely heavily on x86-64—you'd need separate builds for different CPU architectures even within the same OS

Since single-compilation cross-platform static libraries aren't feasible, here are your best options:

1. Cross-Compile with a Multi-Target Toolchain #

You can use a cross-compilation toolchain on one host OS to generate libraries for all three platforms:

• On Linux: Use mingw-w64 to cross-compile for Windows, and tools like osxcross to cross-compile for macOS, alongside native GCC for Linux libraries
• On macOS: Use Clang to cross-compile for Linux and Windows (via mingw-w64)
  This lets you generate all three libraries from one machine, using the same family of compilers (e.g., GCC/Clang) without switching OSes.

2. Distribute Source Code (Simplest for Simple Code) #

Your code is pure C99 with no platform dependencies—just share the .c and .h files, plus a simple build script. Users can compile the static library themselves with their platform's native compiler.

For example, you could include a basic CMakeLists.txt to make this easy:

cmake_minimum_required(VERSION 3.10)
project(AddArrayLib)

set(CMAKE_C_STANDARD 99)
add_library(AddArray STATIC AddArray.c)

Users can build it with:

# Linux/macOS
mkdir build && cd build
cmake .. && make

# Windows (MSVC)
mkdir build
cd build
cmake .. -G "Visual Studio 17 2022"
cmake --build . --config Release

3. Automate Multi-Platform Builds with CI/CD #

Use tools like GitHub Actions, GitLab CI, or Azure Pipelines to automatically compile your library on all three platforms in the cloud. You define the build steps once, and the CI system runs MSVC on Windows, GCC on Linux, and Clang on macOS—then packages all the static libraries for you to distribute.

This way, you only maintain one codebase, and the tooling handles the multi-platform compilation work.

内容的提问来源于stack exchange，提问作者Royi