Existe alguma maneira de obter sobrecarga de função em C? Eu estou olhando para funções simples para serem sobrecarregadas como

foo (int a)  
foo (char b)  
foo (float c , int d)

Eu acho que não há caminho direto; Estou procurando soluções alternativas, se houver alguma.

Existem poucas possibilidades:

1. funções de estilo printf (digite como argumento)
2. funções de estilo opengl (digite o nome da função)
3. subconjunto c de c ++ (se você pode usar um compilador c ++)

Sim!

Desde que essa pergunta foi feita, o padrão C (sem extensões) ganhou efetivamente suporte para sobrecarga de funções (não operadores), graças à adição da _Genericpalavra - chave em C11. (suportado no GCC desde a versão 4.9)

(A sobrecarga não é realmente "incorporada" da maneira mostrada na pergunta, mas é muito fácil implementar algo que funciona dessa maneira.)

_Genericé um operador de tempo de compilação na mesma família que sizeofe _Alignof. É descrito na seção 6.5.1.1 padrão. Ele aceita dois parâmetros principais: uma expressão (que não será avaliada em tempo de execução) e uma lista de associação de tipo / expressão que se parece um pouco com um switchbloco. _Genericobtém o tipo geral da expressão e, em seguida, "alterna" para selecionar a expressão do resultado final na lista para seu tipo:

_Generic(1, float: 2.0,
            char *: "2",
            int: 2,
            default: get_two_object());

A expressão acima é avaliada como 2- o tipo da expressão de controle e int, portanto, escolhe a expressão associada intcomo o valor. Nada disso permanece em tempo de execução. (A defaultcláusula é opcional: se você a deixar desativada e o tipo não corresponder, isso causará um erro de compilação.)

A maneira como isso é útil para a sobrecarga de funções é que ela pode ser inserida pelo pré-processador C e escolher uma expressão de resultado com base no tipo de argumentos transmitidos para a macro de controle. Então (exemplo do padrão C):

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

Essa macro implementa uma cbrtoperação sobrecarregada , despachando o tipo de argumento para a macro, escolhendo uma função de implementação apropriada e passando o argumento da macro original para essa função.

Então, para implementar seu exemplo original, poderíamos fazer o seguinte:

foo_int (int a)  
foo_char (char b)  
foo_float_int (float c , int d)

#define foo(_1, ...) _Generic((_1),                                  \
                              int: foo_int,                          \
                              char: foo_char,                        \
                              float: _Generic((FIRST(__VA_ARGS__,)), \
                                     int: foo_float_int))(_1, __VA_ARGS__)
#define FIRST(A, ...) A

Nesse caso, poderíamos ter usado uma default:associação para o terceiro caso, mas isso não demonstra como estender o princípio a vários argumentos. O resultado final é que você pode usar foo(...)seu código sem se preocupar (muito [1]) com o tipo de argumento.

Para situações mais complicadas, por exemplo, funções que sobrecarregam um número maior de argumentos ou números variáveis, você pode usar macros de utilitário para gerar automaticamente estruturas de despacho estáticas:

void print_ii(int a, int b) { printf("int, int\n"); }
void print_di(double a, int b) { printf("double, int\n"); }
void print_iii(int a, int b, int c) { printf("int, int, int\n"); }
void print_default(void) { printf("unknown arguments\n"); }

#define print(...) OVERLOAD(print, (__VA_ARGS__), \
    (print_ii, (int, int)), \
    (print_di, (double, int)), \
    (print_iii, (int, int, int)) \
)

#define OVERLOAD_ARG_TYPES (int, double)
#define OVERLOAD_FUNCTIONS (print)
#include "activate-overloads.h"

int main(void) {
    print(44, 47);   // prints "int, int"
    print(4.4, 47);  // prints "double, int"
    print(1, 2, 3);  // prints "int, int, int"
    print("");       // prints "unknown arguments"
}

( implementação aqui ) Portanto, com algum esforço, você pode reduzir a quantidade de clichê para parecer uma linguagem com suporte nativo para sobrecarga.

Como um aparte, já era possível sobrecarregar o número de argumentos (não o tipo) em C99.

[1] observe que a maneira como C avalia os tipos pode enganá-lo. Isso escolherá foo_intse você tentar passar um literal de caractere, por exemplo, e precisar mexer um pouco se quiser que suas sobrecargas suportem literais de string. Ainda bem legal no geral.

Como já foi dito, a sobrecarga no sentido em que você quer dizer não é suportada por C. Um idioma comum para resolver o problema é fazer com que a função aceite uma união marcada . Isso é implementado por um structparâmetro, em que o structpróprio consiste em algum tipo de indicador de tipo, como um enum, e um uniondos diferentes tipos de valores. Exemplo:

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

Aqui está o exemplo mais claro e conciso que encontrei demonstrando sobrecarga de função em 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

Se o seu compilador é o gcc e você não se importa de fazer atualizações manuais toda vez que adiciona uma nova sobrecarga, você pode fazer alguma macro mágica e obter o resultado desejado em termos de chamadas, não é tão bom escrever ... mas é possível

observe __builtin_types_compatible_p e use-o para definir uma macro que faça algo como

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

mas sim desagradável, apenas não

EDIT: C1X estará recebendo suporte para expressões genéricas de tipo com a seguinte aparência:

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

Sim, mais ou menos.

Aqui você vai por exemplo:

void printA(int a){
printf("Hello world from printA : %d\n",a);
}

void printB(const char *buff){
printf("Hello world from printB : %s\n",buff);
}

#define Max_ITEMS() 6, 5, 4, 3, 2, 1, 0 
#define __VA_ARG_N(_1, _2, _3, _4, _5, _6, N, ...) N
#define _Num_ARGS_(...) __VA_ARG_N(__VA_ARGS__) 
#define NUM_ARGS(...) (_Num_ARGS_(_0, ## __VA_ARGS__, Max_ITEMS()) - 1) 
#define CHECK_ARGS_MAX_LIMIT(t) if(NUM_ARGS(args)>t)
#define CHECK_ARGS_MIN_LIMIT(t) if(NUM_ARGS(args) 
#define print(x , args ...) \
CHECK_ARGS_MIN_LIMIT(1) printf("error");fflush(stdout); \
CHECK_ARGS_MAX_LIMIT(4) printf("error");fflush(stdout); \
({ \
if (__builtin_types_compatible_p (typeof (x), int)) \
printA(x, ##args); \
else \
printB (x,##args); \
})

int main(int argc, char** argv) {
    int a=0;
    print(a);
    print("hello");
    return (EXIT_SUCCESS);
}

Ele produzirá 0 e Olá. De printA e printB.

A abordagem a seguir é semelhante à de a2800276 , mas com alguma macro mágica C99 adicionada:

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

Isso pode não ajudar em nada, mas se você estiver usando o clang, poderá usar o atributo sobrecarregável - Isso funciona mesmo ao compilar como C

http://clang.llvm.org/docs/AttributeReference.html#overloadable

Cabeçalho

extern void DecodeImageNow(CGImageRef image, CGContextRef usingContext) __attribute__((overloadable));
extern void DecodeImageNow(CGImageRef image) __attribute__((overloadable));

Implementação

void __attribute__((overloadable)) DecodeImageNow(CGImageRef image, CGContextRef usingContext { ... }
void __attribute__((overloadable)) DecodeImageNow(CGImageRef image) { ... }

No sentido que você quer dizer - não, você não pode.

Você pode declarar uma va_argfunção como

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

, mas você precisará passar algum tipo de informação sobre o número de variáveis ​​e seus tipos no primeiro argumento, como printf()faz.

Normalmente, uma verruga para indicar o tipo é anexada ou anexada ao nome. Você pode se safar das macros em alguns casos, mas isso depende do que você está tentando fazer. Não há polimorfismo em C, apenas coerção.

Operações genéricas simples podem ser feitas com macros:

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

Se o seu compilador suportar typeof , operações mais complicadas poderão ser colocadas na macro. Você pode ter o símbolo foo (x) para oferecer suporte à mesma operação em diferentes tipos, mas não pode variar o comportamento entre diferentes sobrecargas. Se você quiser funções reais em vez de macros, poderá colar o tipo no nome e usar uma segunda colagem para acessá-lo (eu não tentei).

A resposta de Leushenko é muito legal - apenas: o fooexemplo não é compilado com o GCC, que falha foo(7), tropeçando na FIRSTmacro e na chamada de função real ( (_1, __VA_ARGS__)permanecendo com uma vírgula excedente. Além disso, estamos com problemas se queremos fornecer sobrecargas adicionais , como foo(double).

Então, decidi elaborar a resposta um pouco mais, inclusive para permitir uma sobrecarga vazia ( foo(void)- o que causou alguns problemas ...).

A idéia agora é: Defina mais de um genérico em diferentes macros e deixe selecionar o correto de acordo com o número de argumentos!

O número de argumentos é bastante fácil, com base nesta resposta :

#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

Isso é legal, resolvemos um SELECT_1ou SELECT_2(ou mais argumentos, se você quiser / precisar deles), por isso precisamos de definições apropriadas:

#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, já adicionei a sobrecarga vazia - no entanto, essa não é realmente coberta pelo padrão C, que não permite argumentos variados vazios, ou seja, confiamos nas extensões do compilador !

No começo, uma chamada de macro vazia ( foo()) ainda produz um token, mas um vazio. Portanto, a macro de contagem realmente retorna 1 em vez de 0, mesmo na chamada de macro vazia. Podemos "facilmente" eliminar esse problema, se colocarmos a vírgula após __VA_ARGS__ condicionalmente , dependendo da lista estar vazia ou não:

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

Que parecia fácil, mas a COMMAmacro é muito pesado um; felizmente, o tópico já foi abordado em um blog de Jens Gustedt (obrigado, Jens). O truque básico é que as macros de função não são expandidas se não forem seguidas por parênteses, para obter mais explicações, dê uma olhada no blog de Jens ... Só precisamos modificar as macros um pouco para nossas necessidades (vou usar nomes mais curtos e menos argumentos por brevidade).

#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 ,

E agora estamos bem ...

O código completo em um bloco:

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

Você não pode simplesmente usar C ++ e não usar todos os outros recursos de C ++, exceto este?

Se ainda não houver apenas C estrito, eu recomendaria funções variadas .

Tente declarar essas funções como extern "C++"se o seu compilador suporta isso, http://msdn.microsoft.com/en-us/library/s6y4zxec(VS.80).aspx

Espero que o código abaixo o ajude a entender a sobrecarga de funções

#include <stdio.h>
#include<stdarg.h>

int fun(int a, ...);
int main(int argc, char *argv[]){
   fun(1,10);
   fun(2,"cquestionbank");
   return 0;
}
int fun(int a, ...){
  va_list vl;
  va_start(vl,a);

  if(a==1)
      printf("%d",va_arg(vl,int));
   else
      printf("\n%s",va_arg(vl,char *));
}