Wie erreichen Sie das überladen von Funktionen in C?

Gibt es einige Möglichkeiten:

1. printf-style-Funktionen (geben Sie als argument)
2. opengl-style-Funktionen (Typ Funktion name)
3. c Teilmenge von c++ (wenn Sie mit einem c++ - compiler)

Wie gesagt, überladen in dem Sinne, dass du meinst, wird nicht unterstützt von C. Ein gemeinsames idiom, das problem zu lösen ist, die die Funktion annehmen tagged union. Dies wird implementiert, indem ein struct parameter, wo die struct selbst besteht aus eine Art Art Anzeige, wie ein enum, und ein union von den verschiedenen Arten von Werten. Beispiel:

#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); 
}

Hier ist der klarste und prägnanteste Beispiel, das ich gefunden habe, die belegen das überladen von Funktionen in C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int addi(int a, int b) {
    return a + b;
}

char *adds(char *a, char *b) {
    char *res = malloc(strlen(a) + strlen(b) + 1);
    strcpy(res, a);
    strcat(res, b);
    return res;
}

#define add(a, b) _Generic(a, int: addi, char*: adds)(a, b)

int main(void) {
    int a = 1, b = 2;
    printf("%d\n", add(a, b)); //3

    char *c = "hello ", *d = "world";
    printf("%s\n", add(c, d)); //hello world

    return 0;
}

https://gist.github.com/barosl/e0af4a92b2b8cabd05a7

Den folgenden Ansatz ist ähnlich a2800276's, aber mit einigen C99-makro-Magie Hinzugefügt:

//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;
}

In dem Sinne, du meinst — Nein, du nicht.

Können Sie erklären, ein va_arg Funktion wie

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

aber du wirst dich übergeben zu müssen, irgendeine Art von Informationen über die Anzahl der Variablen und deren Typen in die erste argument — wie printf() tut.

Leushenko Antwort ist wirklich cool - nur: die foo Beispiel nicht kompilieren mit GCC zu erklären, die nicht auf foo(7), stolpern über die FIRST makro-und der eigentliche Funktionsaufruf ((_1, __VA_ARGS__), die restlichen mit einem überschuss Komma. Darüber hinaus sind wir in Schwierigkeiten, wenn wir wollen, um zusätzliche überlastungen, wie foo(double).

Also habe ich beschlossen zu erarbeiten, die Antwort ein wenig weiter, einschließlich zu ermöglichen, eine leere überlast (foo(void) – das verursacht ziemliche Probleme...).

Idee ist nun: Definieren Sie mehr als einen generic in verschiedenen Makros und lassen Sie die richtige wählen entsprechend der Anzahl der Argumente!

Anzahl der Argumente ist ganz einfach, basierend auf diese Antwort:

#define foo(...) SELECT(__VA_ARGS__)(__VA_ARGS__)

#define SELECT(...) CONCAT(SELECT_, NARG(__VA_ARGS__))(__VA_ARGS__)
#define CONCAT(X, Y) CONCAT_(X, Y)
#define CONCAT_(X, Y) X ## Y

Das ist schön, wir beschließen, uns entweder SELECT_1 oder SELECT_2 (oder mehr Argumente, wenn Sie wollen/brauchen), so müssen wir einfach angemessen definiert:

#define SELECT_0() foo_void
#define SELECT_1(_1) _Generic ((_1),    \
        int: foo_int,                   \
        char: foo_char,                 \
        double: foo_double              \
)
#define SELECT_2(_1, _2) _Generic((_1), \
        double: _Generic((_2),          \
                int: foo_double_int     \
        )                               \
)

OK, ich habe die leere überlastung schon – allerdings, das man eigentlich nicht unter die C-standard, die nicht in die leere Variable Argumente, ich. e. wir haben dann verlassen sich auf compiler-Erweiterungen!

Auf den ersten, wird ein leeres makro aufrufen (foo()) produziert immer noch ein token, aber ein leerer. So zählen die makro-tatsächlich gibt 1 statt 0 auch leer makro aufrufen. Wir können "einfach" beseitigen Sie dieses problem, wenn wir das Komma nach __VA_ARGS__ bedingt, je nach Liste leer ist oder nicht:

#define NARG(...) ARG4_(__VA_ARGS__ COMMA(__VA_ARGS__) 4, 3, 2, 1, 0)

Dass sah einfach, aber die COMMA makro ist ziemlich schwer; zum Glück, das Thema ist bereits bedeckt in einem blog von Jens Gustedt (danke, Jens). Grundlegende trick ist, die Funktion Makros werden nicht expandiert, wenn nicht gefolgt von Runden Klammern, weitere Erklärungen haben Sie einen Blick auf Jens' blog... Wir müssen einfach ändern Sie die Makros ein wenig auf unsere Bedürfnisse (ich werde verwenden Sie kürzere Namen und weniger Argumente für die Kürze).

#define ARGN(...) ARGN_(__VA_ARGS__)
#define ARGN_(_0, _1, _2, _3, N, ...) N
#define HAS_COMMA(...) ARGN(__VA_ARGS__, 1, 1, 1, 0)

#define SET_COMMA(...) ,

#define COMMA(...) SELECT_COMMA             \
(                                           \
        HAS_COMMA(__VA_ARGS__),             \
        HAS_COMMA(__VA_ARGS__ ()),          \
        HAS_COMMA(SET_COMMA __VA_ARGS__),   \
        HAS_COMMA(SET_COMMA __VA_ARGS__ ()) \
)

#define SELECT_COMMA(_0, _1, _2, _3) SELECT_COMMA_(_0, _1, _2, _3)
#define SELECT_COMMA_(_0, _1, _2, _3) COMMA_ ## _0 ## _1 ## _2 ## _3

#define COMMA_0000 ,
#define COMMA_0001
#define COMMA_0010 ,
//... (all others with comma)
#define COMMA_1111 ,

Und jetzt sind wir in Ordnung...

Den vollständigen code in einen block:

/*
 * demo.c
 *
 *  Created on: 2017-09-14
 *      Author: sboehler
 */

#include <stdio.h>

void foo_void(void)
{
    puts("void");
}
void foo_int(int c)
{
    printf("int: %d\n", c);
}
void foo_char(char c)
{
    printf("char: %c\n", c);
}
void foo_double(double c)
{
    printf("double: %.2f\n", c);
}
void foo_double_int(double c, int d)
{
    printf("double: %.2f, int: %d\n", c, d);
}

#define foo(...) SELECT(__VA_ARGS__)(__VA_ARGS__)

#define SELECT(...) CONCAT(SELECT_, NARG(__VA_ARGS__))(__VA_ARGS__)
#define CONCAT(X, Y) CONCAT_(X, Y)
#define CONCAT_(X, Y) X ## Y

#define SELECT_0() foo_void
#define SELECT_1(_1) _Generic ((_1), \
        int: foo_int,                \
        char: foo_char,              \
        double: foo_double           \
)
#define SELECT_2(_1, _2) _Generic((_1), \
        double: _Generic((_2),          \
                int: foo_double_int     \
        )                               \
)

#define ARGN(...) ARGN_(__VA_ARGS__)
#define ARGN_(_0, _1, _2, N, ...) N

#define NARG(...) ARGN(__VA_ARGS__ COMMA(__VA_ARGS__) 3, 2, 1, 0)
#define HAS_COMMA(...) ARGN(__VA_ARGS__, 1, 1, 0)

#define SET_COMMA(...) ,

#define COMMA(...) SELECT_COMMA             \
(                                           \
        HAS_COMMA(__VA_ARGS__),             \
        HAS_COMMA(__VA_ARGS__ ()),          \
        HAS_COMMA(SET_COMMA __VA_ARGS__),   \
        HAS_COMMA(SET_COMMA __VA_ARGS__ ()) \
)

#define SELECT_COMMA(_0, _1, _2, _3) SELECT_COMMA_(_0, _1, _2, _3)
#define SELECT_COMMA_(_0, _1, _2, _3) COMMA_ ## _0 ## _1 ## _2 ## _3

#define COMMA_0000 ,
#define COMMA_0001
#define COMMA_0010 ,
#define COMMA_0011 ,
#define COMMA_0100 ,
#define COMMA_0101 ,
#define COMMA_0110 ,
#define COMMA_0111 ,
#define COMMA_1000 ,
#define COMMA_1001 ,
#define COMMA_1010 ,
#define COMMA_1011 ,
#define COMMA_1100 ,
#define COMMA_1101 ,
#define COMMA_1110 ,
#define COMMA_1111 ,

int main(int argc, char** argv)
{
    foo();
    foo(7);
    foo(10.12);
    foo(12.10, 7);
    foo((char)'s');

    return 0;
}

Versuchen zu erklären, diese Funktionen als extern "C++" wenn Ihr compiler dies unterstützt, http://msdn.microsoft.com/en-us/library/s6y4zxec(VS.80).aspx