Как достигнуть перегрузки функции в C?

Как уже указано, перегружение в том смысле, что Вы имеете в виду, не поддерживается C. Общая идиома для решения проблемы заставляет функцию принять размеченное объединение . Это реализовано struct параметр, где struct сам состоит какой-то из индикатора типа, такой как enum, и union из различных типов значений. Пример:

#include <stdio.h>

typedef enum {
    T_INT,
    T_FLOAT,
    T_CHAR,
} my_type;

typedef struct {
    my_type type;
    union {
        int a; 
        float b; 
        char c;
    } my_union;
} my_struct;

void set_overload (my_struct *whatever) 
{
    switch (whatever->type) 
    {
        case T_INT:
            whatever->my_union.a = 1;
            break;
        case T_FLOAT:
            whatever->my_union.b = 2.0;
            break;
        case T_CHAR:
            whatever->my_union.c = '3';
    }
}

void printf_overload (my_struct *whatever) {
    switch (whatever->type) 
    {
        case T_INT:
            printf("%d\n", whatever->my_union.a);
            break;
        case T_FLOAT:
            printf("%f\n", whatever->my_union.b);
            break;
        case T_CHAR:
            printf("%c\n", whatever->my_union.c);
            break;
    }

}

int main (int argc, char* argv[])
{
    my_struct s;

    s.type=T_INT;
    set_overload(&s);
    printf_overload(&s);

    s.type=T_FLOAT;
    set_overload(&s);
    printf_overload(&s);

    s.type=T_CHAR;
    set_overload(&s);
    printf_overload(&s); 
}

Следующий подход является аналогичным a2800276, но с некоторым макро-добавленным волшебством C99:

// we need `size_t`
#include <stddef.h>

// argument types to accept
enum sum_arg_types { SUM_LONG, SUM_ULONG, SUM_DOUBLE };

// a structure to hold an argument
struct sum_arg
{
    enum sum_arg_types type;
    union
    {
        long as_long;
        unsigned long as_ulong;
        double as_double;
    } value;
};

// determine an array's size
#define count(ARRAY) ((sizeof (ARRAY))/(sizeof *(ARRAY)))

// this is how our function will be called
#define sum(...) _sum(count(sum_args(__VA_ARGS__)), sum_args(__VA_ARGS__))

// create an array of `struct sum_arg`
#define sum_args(...) ((struct sum_arg []){ __VA_ARGS__ })

// create initializers for the arguments
#define sum_long(VALUE) { SUM_LONG, { .as_long = (VALUE) } }
#define sum_ulong(VALUE) { SUM_ULONG, { .as_ulong = (VALUE) } }
#define sum_double(VALUE) { SUM_DOUBLE, { .as_double = (VALUE) } }

// our polymorphic function
long double _sum(size_t count, struct sum_arg * args)
{
    long double value = 0;

    for(size_t i = 0; i < count; ++i)
    {
        switch(args[i].type)
        {
            case SUM_LONG:
            value += args[i].value.as_long;
            break;

            case SUM_ULONG:
            value += args[i].value.as_ulong;
            break;

            case SUM_DOUBLE:
            value += args[i].value.as_double;
            break;
        }
    }

    return value;
}

// let's see if it works

#include <stdio.h>

int main()
{
    unsigned long foo = -1;
    long double value = sum(sum_long(42), sum_ulong(foo), sum_double(1e10));
    printf("%Le\n", value);
    return 0;
}

В смысле Вы имеете в виду — нет, Вы не можете.

можно объявить va_arg функция как

void my_func(char* format, ...);

, но необходимо будет передать некоторую информацию о количестве переменных, и их типы в первом аргументе — как printf() делает.

Обычно бородавка для указания на тип добавляется или предварительно ожидается к имени. Можно сойти с рук макросы, некоторые экземпляры, но они скорее зависят, что Вы пытаетесь сделать. Нет никакого полиморфизма в C, только приведение.

Простые универсальные операции могут быть сделаны с макросами:

#define max(x,y) ((x)>(y)?(x):(y))

, Если Ваш компилятор поддерживает typeof, более сложные операции могут быть помещены в макрос. У Вас может затем быть нечто символа (x) для поддержки тех же операционных различных типов, но Вы не можете варьироваться поведение между различными перегрузками. Если Вы хотите фактические функции, а не макросы, Вы смогли вставлять тип к имени и использовать вторую вставку для доступа к ним (я не попробовал).

Вы не можете только использовать C++ и не использовать все другие функции C++ кроме этого?

, Если бы все еще не просто строгий C затем я рекомендовал бы функции variadic вместо этого.

Попытайтесь объявить эти функции как extern "C++", если Ваш компилятор поддерживает это, http://msdn.microsoft.com/en-us/library/s6y4zxec (По сравнению с 80) .aspx

Если ваш компилятор - gcc, и вы не против делать обновления вручную каждый раз, когда вы добавляете новую перегрузку, вы можете сделать некоторую магию макросов и получить результат вы хотите с точки зрения вызывающих абонентов, это не так приятно писать ... но возможно

посмотрите на __builtin_types_compatible_p, а затем используйте его для определения макроса, который делает что-то вроде

#define foo(a) \
((__builtin_types_compatible_p(int, a)?foo(a):(__builtin_types_compatible_p(float, a)?foo(a):)

, но да неприятно, просто не делайте этого

РЕДАКТИРОВАТЬ: C1X получит поддержку общих выражений типов, которые выглядят следующим образом:

#define cbrt(X) _Generic((X), long double: cbrtl, \
                              default: cbrt, \
                              float: cbrtf)(X)