C Programming Conditional Compilation For Cross Platform Support Complete Guide

Example 1: Basic Conditional Compilation

Let's start with a simple example where we want to conditionally compile code for different operating systems (Windows vs. Linux).

File: platform_specific.c

#include <stdio.h>

// Check the operating system and define macros accordingly
#if defined(_WIN32) || defined(WIN32)
    #define OS_WINDOWS
#elif defined(__linux__)
    #define OS_LINUX
#endif

int main() {
    #ifdef OS_WINDOWS
        printf("This is Windows.\n");
        // Windows-specific code goes here
    #elif defined(OS_LINUX)
        printf("This is Linux.\n");
        // Linux-specific code goes here
    #else
        printf("Unknown operating system.\n");
    #endif
    
    return 0;
}

Step by Step Explanation:

1. Include the Standard I/O Library: We'll use printf to print output to the console.
2. Define System-Specific Macros:
   • #if defined(_WIN32) || defined(WIN32): Checks if the _WIN32 or WIN32 macro is defined, which is typically defined in Windows compilations.
   • #elif defined(__linux__): Checks if the linux macro is defined, which is typically defined in Linux compilations.
3. Conditional Code Blocks:
   • #ifdef OS_WINDOWS: If OS_WINDOWS was defined, this block of code will be compiled, printing "This is Windows."
   • #elif defined(OS_LINUX): If OS_LINUX was defined, this block will be compiled, printing "This is Linux."
   • #else: If neither OS_WINDOWS nor OS_LINUX were defined, this block will be compiled, printing "Unknown operating system."

How to Compile and Run

1. For Windows:

   Use a compiler like gcc. You can add -D_WIN32 to define the _WIN32 macro manually:

   gcc -D_WIN32 platform_specific.c -o platform_specific.exe
   ./platform_specific.exe
   

   Alternatively, if you're using Visual Studio, you don't need to define this macro explicitly as it's set by default.

2. For Linux:

   Simply compile using gcc:

   gcc platform_specific.c -o platform_specific
   ./platform_specific
   

Output

• On Windows: This is Windows.
• On Linux: This is Linux.

Example 2: Including Different Header Files

In this example, we will include different header files based on the operating system.

File: platform_headers.h

#ifndef PLATFORM_HEADERS_H
#define PLATFORM_HEADERS_H

#if defined(_WIN32) || defined(WIN32)
    #include <windows.h>
#else
    #include <unistd.h>
#endif

#endif // PLATFORM_HEADERS_H

File: main.c

#include <stdio.h>
#include "platform_headers.h"

int main() {
    #ifdef _WIN32
        DWORD dwVersion = GetVersion();
        printf("Windows version: %lu\n", dwVersion);
    #else
        printf("Sleeping for 5 seconds...\n");
        sleep(5);  // Sleep function from unistd.h
        printf("Awake now!\n");
    #endif
    
    return 0;
}

Step by Step Explanation:

1. Create a Header File: Define platform_headers.h and include different header files depending on the platform.
2. Conditional Includes:
   • #if defined(_WIN32) || defined(WIN32): Include windows.h for Windows.
   • #else: Include unistd.h for other systems, primarily Linux and macOS.
3. Main Code:
   • #ifdef _WIN32: Use the GetVersion() function provided by windows.h if compiling for Windows.
   • #else: Use the sleep() function provided by unistd.h for other systems.

Compilation

• For Windows:

  Ensure windows.h is available, usually part of the Windows SDK. You can compile the program as follows:

  gcc -D_WIN32 main.c -o platform_app.exe
  ./platform_app.exe
  

• For Linux:

  Simply compile using gcc:

  gcc main.c -o platform_app
  ./platform_app
  

Output

• On Windows: Windows version: <version number>
• On Linux:

  Sleeping for 5 seconds...
  Awake now!
  

Example 3: Defining Functionality Based on Compiler

Sometimes conditional compilation may be necessary to support different compilers. Let's define a function that prints the name of the compiler being used.

File: main.c

#include <stdio.h>

// Compiler-specific definitions
#if defined(__GNUC__)
    #define COMPILER_NAME "GCC"
#elif defined(__clang__)
    #define COMPILER_NAME "Clang"
#elif defined(_MSC_VER)
    #define COMPILER_NAME "MSVC"
#else
    #define COMPILER_NAME "Unknown"
#endif

void printCompiler() {
    printf("Compiler: %s\n", COMPILER_NAME);
}

int main() {
    printCompiler();
    return 0;
}

Step by Step Explanation:

1. Check Compiler Macros:
   • __GNUC__ is defined for GNU Compiler Collection (GCC).
   • __clang__ is defined for Clang compiler.
   • _MSC_VER is defined for Microsoft Visual C++ (MSVC).
2. Define Compiler Name Macro: Define COMPILER_NAME to a string representing the detected compiler.
3. Functionality Based on Compiler:
   • The printCompiler() function uses the COMPILER_NAME macro to print the compiler name.

Compilation

• Using GCC:

  gcc main.c -o compiler_info
  ./compiler_info
  

• Using Clang:

  clang main.c -o compiler_info
  ./compiler_info
  

• Using MSVC (Command Line):

  First, open the Visual Studio Developer Command Prompt:

  cl /EHsc main.c
  main.exe
  

Output

• Compiled with GCC: Compiler: GCC
• Compiled with Clang: Compiler: Clang
• Compiled with MSVC: Compiler: MSVC

Example 4: Conditional Compilation Based on Data Types

Lastly, let's write an example where we use conditional compilation to define appropriate data types based on the platform or word size.

File: main.c

#include <stdio.h>

// Check word size
#if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) || defined(__aarch64__)
    typedef unsigned long long int uint_ptr_t;
#else
    typedef unsigned int uint_ptr_t;
#endif

int main() {
    uint_ptr_t ptr_value = 123456789;
    printf("Pointer value: %llu\n", (unsigned long long)ptr_value);
    return 0;
}

Step by Step Explanation:

1. Check Word Size Macros:
   • _WIN64, __x86_64__, __ppc64__, __aarch64__ indicate 64-bit architectures in different environments.
   • For 32-bit architectures, use unsigned int.
2. Define Typedef: Depending on whether the architecture is 64-bit or not, define uint_ptr_t to either unsigned long long int or unsigned int.
3. Print Pointer Value: Print the value of uint_ptr_t variable to demonstrate appropriate type usage.

Compilation

• For 64-bit Platforms:

  Use a compiler like gcc:

  gcc main.c -o arch_info
  ./arch_info
  

• For 32-bit Platforms:

  Similarly, use gcc:

  gcc -m32 main.c -o arch_info
  ./arch_info
  

Output

• On 64-bit Platforms: Pointer value: 123456789
• On 32-bit Platforms: Pointer value: 123456789

Note: On 32-bit platforms, casting to unsigned long long might still work, but the type should match the architecture for optimal performance and correctness.