C语言中高效检查多个函数参数是否为NULL的方法

Great question! When you've got more than a couple of pointer parameters to check for NULL, that long chain of || conditions starts to look messy and error-prone. Let's go through a few cleaner, more scalable approaches you can use:

1. Array Initialization + Loop Check #

This approach is straightforward and readable—no fancy macros required. You just wrap all your pointer parameters into an array, then loop through it to check for NULLs:

int Func(const char *one, const char *two, const char *three, int *four) {
    // Pack all pointer params into an array
    void *const params[] = {one, two, three, four};
    const size_t param_count = sizeof(params) / sizeof(params[0]);

    // Check each pointer in the array
    for (size_t i = 0; i < param_count; i++) {
        if (!params[i]) {
            return -1;
        }
    }

    // Rest of your function logic here
    return 0;
}

Pros: Super clear, easy to modify (just add/remove elements from the array), no preprocessor tricks.
Cons: Only works for fixed sets of parameters (you have to update the array when you change function args).

2. Variadic Macro for Arbitrary Parameter Counts #

If you want a one-liner that works for any number of pointer parameters, a variadic macro paired with a helper function is a great option. This lets you check all params in a single line:

#include <stdarg.h>
#include <stdbool.h>

// Helper function to check variadic list of pointers
static bool has_null_ptr(size_t count, ...) {
    va_list args;
    va_start(args, count);
    
    for (size_t i = 0; i < count; i++) {
        void *ptr = va_arg(args, void*);
        if (!ptr) {
            va_end(args);
            return true;
        }
    }
    
    va_end(args);
    return false;
}

// Macro that auto-calculates parameter count and calls the helper
#define CHECK_ALL_NULLS(...) \
    if (has_null_ptr(sizeof((void*[]){__VA_ARGS__}) / sizeof(void*), __VA_ARGS__)) { \
        return -1; \
    }

// Usage example
int Func(const char *a, void *b, const int *c, char *d) {
    CHECK_ALL_NULLS(a, b, c, d); // One line to check all params
    
    // Rest of function code
    return 0;
}

Pros: Works for any number of pointer parameters, keeps your function start clean.
Cons: Relies on C99's compound literals, so make sure your compiler supports it. Also, you have to ensure all passed arguments are pointers (non-pointer types will cause issues).

3. Single-Parameter Check Macro #

If you prefer simplicity over a one-liner, a small macro to wrap individual NULL checks makes the code much neater than a long || chain:

#define CHECK_NULL(ptr) \
    do { \
        if (!(ptr)) { \
            return -1; \
        } \
    } while(0)

// Usage example
int Func(const char *one, const char *two, const char *three) {
    CHECK_NULL(one);
    CHECK_NULL(two);
    CHECK_NULL(three);
    
    // Rest of function code
    return 0;
}

Pros: Extremely readable, each check is isolated, no complex logic.
Cons: Adds a line per parameter (but still way cleaner than a giant if condition).

Quick Notes #

• All these approaches assume you're checking pointer parameters—they won't work for non-pointer types like int or float.
• For most cases, the array or single-check macro will be your best bet (they're simpler to debug and maintain). The variadic macro is handy if you have functions with frequently changing parameter lists.

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