How to achieve function overloading in C

Question

Is there any way to achieve function overloading in C  I am looking at simple functions to be overloaded like    foo  int a    foo  char b    foo  float c   int d    I think there is no straight forward way  I m looking for workarounds if any exist

User · Answer

Try to declare these functions as extern  C    if your compiler supports this  http   msdn microsoft com en-us library s6y4zxec VS 80  aspx

User · Answer

Can t you just use C   and not use all other C   features except this one   If still no just strict C then I would recommend variadic functions instead

User · Answer

In the sense you mean     no  you cannot   You can declare a va arg function like  void my func char  format           but you ll need to pass some kind of information about number of variables and their types in the first argument     like printf   does

User · Answer

If your compiler is gcc and you don t mind doing hand updates every time you add a new overload you can do some macro magic and get the result you want in terms of callers  it s not as nice to write    but it s possible  look at   builtin types compatible p  then use it to define a macro that does something like   define foo a        builtin types compatible p int  a  foo a     builtin types compatible p float  a  foo a      but yea nasty  just don t  EDIT  C1X will be getting support for type generic expressions they look like this    define cbrt X   Generic  X   long double  cbrtl                                  default  cbrt                                  float  cbrtf  X

User · Answer

There are few possibilities    printf style functions  type as an argument  opengl style functions  type in function name  c subset of c    if You can use a c   compiler

User · Answer

Here is the clearest and most concise example I ve found demonstrating function overloading in C    include  lt stdio h gt   include  lt stdlib h gt   include  lt string h gt   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

User · Answer

This may not help at all  but if you re using clang you can use the overloadable attribute - This works even when compiling as C  http   clang llvm org docs AttributeReference html overloadable  Header  extern void DecodeImageNow CGImageRef image  CGContextRef usingContext    attribute    overloadable    extern void DecodeImageNow CGImageRef image    attribute    overloadable      Implementation  void   attribute    overloadable   DecodeImageNow CGImageRef image  CGContextRef usingContext         void   attribute    overloadable   DecodeImageNow CGImageRef image

User · Answer

In the sense you mean     no  you cannot   You can declare a va arg function like  void my func char  format           but you ll need to pass some kind of information about number of variables and their types in the first argument     like printf   does

User · Answer

In the sense you mean     no  you cannot   You can declare a va arg function like  void my func char  format           but you ll need to pass some kind of information about number of variables and their types in the first argument     like printf   does

User · Answer

Yes   In the time since this question was asked  standard C  no extensions  has effectively gained support for function overloading  not operators   thanks to the addition of the  Generic keyword in C11   supported in GCC since version 4 9    Overloading isn t truly  built-in  in the fashion shown in the question  but it s dead easy to implement something that works like that     Generic is a compile-time operator in the same family as sizeof and  Alignof  It is described in standard section 6 5 1 1  It accepts two main parameters  an expression  which will not be evaluated at runtime   and a type expression association list that looks a bit like a switch block   Generic gets the overall type of the expression and then  switches  on it to select the end result expression in the list for its type    Generic 1  float  2 0              char     2               int  2              default  get two object       The above expression evaluates to 2 - the type of the controlling expression is int  so it chooses the expression associated with int as the value  Nothing of this remains at runtime   The default clause is optional  if you leave it off and the type doesn t match  it will cause a compilation error    The way this is useful for function overloading is that it can be inserted by the C preprocessor and choose a result expression based on the type of the arguments passed to the controlling macro  So  example from the C standard     define cbrt X   Generic  X                                             long double  cbrtl                             default  cbrt                                  float  cbrtf                                     X    This macro implements an overloaded cbrt operation  by dispatching on the type of the argument to the macro  choosing an appropriate implementation function  and then passing the original macro argument to that function   So to implement your original example  we could do this   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   In this case we could have used a default  association for the third case  but that doesn t demonstrate how to extend the principle to multiple arguments  The end result is that you can use foo      in your code without worrying  much 1   about the type of its arguments     For more complicated situations  e g  functions overloading larger numbers of arguments  or varying numbers  you can use utility macros to automatically generate static dispatch structures   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       implementation here  So with some effort  you can reduce the amount of boilerplate to looking pretty much like a language with native support for overloading   As an aside  it was already possible to overload on the number of arguments  not the type  in C99      1  note that the way C evaluates types might trip you up though  This will choose foo int if you try to pass it a character literal  for instance  and you need to mess about a bit if you want your overloads to support string literals  Still overall pretty cool though

User · Answer

As already stated  overloading in the sense that you mean isn t supported by C  A common idiom to solve the problem is making the function accept a tagged union  This is implemented by a struct parameter  where the struct itself consists of some sort of type indicator  such as an enum  and a union of the different types of values  Example    include  lt stdio h gt   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- gt type                 case T INT              whatever- gt my union a   1              break          case T FLOAT              whatever- gt my union b   2 0              break          case T CHAR              whatever- gt my union c    3            void printf overload  my struct  whatever        switch  whatever- gt type                 case T INT              printf   d n   whatever- gt my union a               break          case T FLOAT              printf   f n   whatever- gt my union b               break          case T CHAR              printf   c n   whatever- gt my union c               break            int main  int argc  char  argv          my struct s       s type T INT      set overload  amp s       printf overload  amp s        s type T FLOAT      set overload  amp s       printf overload  amp s        s type T CHAR      set overload  amp s       printf overload  amp s

User · Answer

As already stated  overloading in the sense that you mean isn t supported by C  A common idiom to solve the problem is making the function accept a tagged union  This is implemented by a struct parameter  where the struct itself consists of some sort of type indicator  such as an enum  and a union of the different types of values  Example    include  lt stdio h gt   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- gt type                 case T INT              whatever- gt my union a   1              break          case T FLOAT              whatever- gt my union b   2 0              break          case T CHAR              whatever- gt my union c    3            void printf overload  my struct  whatever        switch  whatever- gt type                 case T INT              printf   d n   whatever- gt my union a               break          case T FLOAT              printf   f n   whatever- gt my union b               break          case T CHAR              printf   c n   whatever- gt my union c               break            int main  int argc  char  argv          my struct s       s type T INT      set overload  amp s       printf overload  amp s        s type T FLOAT      set overload  amp s       printf overload  amp s        s type T CHAR      set overload  amp s       printf overload  amp s

User · Answer

Here is the clearest and most concise example I ve found demonstrating function overloading in C    include  lt stdio h gt   include  lt stdlib h gt   include  lt string h gt   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

User · Answer

The following approach is similar to a2800276 s  but with some C99 macro magic added      we need  size t   include  lt stddef h gt      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  lt  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  lt stdio h gt   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

User · Answer

As already stated  overloading in the sense that you mean isn t supported by C  A common idiom to solve the problem is making the function accept a tagged union  This is implemented by a struct parameter  where the struct itself consists of some sort of type indicator  such as an enum  and a union of the different types of values  Example    include  lt stdio h gt   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- gt type                 case T INT              whatever- gt my union a   1              break          case T FLOAT              whatever- gt my union b   2 0              break          case T CHAR              whatever- gt my union c    3            void printf overload  my struct  whatever        switch  whatever- gt type                 case T INT              printf   d n   whatever- gt my union a               break          case T FLOAT              printf   f n   whatever- gt my union b               break          case T CHAR              printf   c n   whatever- gt my union c               break            int main  int argc  char  argv          my struct s       s type T INT      set overload  amp s       printf overload  amp s        s type T FLOAT      set overload  amp s       printf overload  amp s        s type T CHAR      set overload  amp s       printf overload  amp s

User · Answer

The following approach is similar to a2800276 s  but with some C99 macro magic added      we need  size t   include  lt stddef h gt      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  lt  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  lt stdio h gt   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

User · Answer

Normally a wart to indicate the type is appended or prepended to the name  You can get away with macros is some instances  but it rather depends what you re trying to do  There s no polymorphism in C  only coercion   Simple generic operations can be done with macros    define max x y    x  gt  y   x   y     If your compiler supports typeof  more complicated operations can be put in the macro  You can then have the symbol foo x  to support the same operation different types  but you can t vary the behaviour between different overloads  If you want actual functions rather than macros  you might be able to paste the type to the name and use a second pasting to access it  I haven t tried

User · Answer

As already stated  overloading in the sense that you mean isn t supported by C  A common idiom to solve the problem is making the function accept a tagged union  This is implemented by a struct parameter  where the struct itself consists of some sort of type indicator  such as an enum  and a union of the different types of values  Example    include  lt stdio h gt   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- gt type                 case T INT              whatever- gt my union a   1              break          case T FLOAT              whatever- gt my union b   2 0              break          case T CHAR              whatever- gt my union c    3            void printf overload  my struct  whatever        switch  whatever- gt type                 case T INT              printf   d n   whatever- gt my union a               break          case T FLOAT              printf   f n   whatever- gt my union b               break          case T CHAR              printf   c n   whatever- gt my union c               break            int main  int argc  char  argv          my struct s       s type T INT      set overload  amp s       printf overload  amp s        s type T FLOAT      set overload  amp s       printf overload  amp s        s type T CHAR      set overload  amp s       printf overload  amp s

User · Answer

The following approach is similar to a2800276 s  but with some C99 macro magic added      we need  size t   include  lt stddef h gt      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  lt  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  lt stdio h gt   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

User · Answer

Can t you just use C   and not use all other C   features except this one   If still no just strict C then I would recommend variadic functions instead

User · Answer

Yes  sort of   Here you go by example    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  gt 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       It will output 0 and hello    from printA and printB

User · Answer

Try to declare these functions as extern  C    if your compiler supports this  http   msdn microsoft com en-us library s6y4zxec VS 80  aspx

User · Answer

There are few possibilities    printf style functions  type as an argument  opengl style functions  type in function name  c subset of c    if You can use a c   compiler

User · Answer

Try to declare these functions as extern  C    if your compiler supports this  http   msdn microsoft com en-us library s6y4zxec VS 80  aspx

User · Answer

Can t you just use C   and not use all other C   features except this one   If still no just strict C then I would recommend variadic functions instead

User · Answer

There are few possibilities    printf style functions  type as an argument  opengl style functions  type in function name  c subset of c    if You can use a c   compiler

User · Answer

If your compiler is gcc and you don t mind doing hand updates every time you add a new overload you can do some macro magic and get the result you want in terms of callers  it s not as nice to write    but it s possible  look at   builtin types compatible p  then use it to define a macro that does something like   define foo a        builtin types compatible p int  a  foo a     builtin types compatible p float  a  foo a      but yea nasty  just don t  EDIT  C1X will be getting support for type generic expressions they look like this    define cbrt X   Generic  X   long double  cbrtl                                  default  cbrt                                  float  cbrtf  X

User · Answer

Leushenko s answer is really cool - solely  the foo example does not compile with GCC  which fails at foo 7   stumbling over the FIRST macro and the actual function call    1    VA ARGS     remaining with a surplus comma  Additionally  we are in trouble if we want to provide additional overloads  such as foo double    So I decided to elaborate the answer a little further  including to allow a void overload  foo void   ndash  which caused quite some trouble       Idea now is  Define more than one generic in different macros and let select the correct one according to the number of arguments   Number of arguments is quite easy  based on this answer    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   That s nice  we resolve to either SELECT 1 or SELECT 2  or more arguments  if you want need them   so we simply need appropriate defines    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  I added the void overload already  ndash  however  this one actually is not covered by the C standard  which does not allow empty variadic arguments  i  e  we then rely on compiler extensions   At very first  an empty macro call  foo    still produces a token  but an empty one  So the counting macro actually returns 1 instead of 0 even on empty macro call  We can  easily  eliminate this problem  if we place the comma after   VA ARGS   conditionally  depending on the list being empty or not    define NARG      ARG4    VA ARGS   COMMA   VA ARGS    4  3  2  1  0    That looked easy  but the COMMA macro is quite a heavy one  fortunately  the topic is already covered in a blog of Jens Gustedt  thanks  Jens   Basic trick is that function macros are not expanded if not followed by parentheses  for further explanations  have a look at Jens  blog    We just have to modify the macros a little to our needs  I m going to use shorter names and less arguments for brevity     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     And now we are fine     The complete code in one block         demo c        Created on  2017-09-14         Author  sboehler       include  lt stdio h gt   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

User · Answer

Leushenko s answer is really cool - solely  the foo example does not compile with GCC  which fails at foo 7   stumbling over the FIRST macro and the actual function call    1    VA ARGS     remaining with a surplus comma  Additionally  we are in trouble if we want to provide additional overloads  such as foo double    So I decided to elaborate the answer a little further  including to allow a void overload  foo void   ndash  which caused quite some trouble       Idea now is  Define more than one generic in different macros and let select the correct one according to the number of arguments   Number of arguments is quite easy  based on this answer    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   That s nice  we resolve to either SELECT 1 or SELECT 2  or more arguments  if you want need them   so we simply need appropriate defines    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  I added the void overload already  ndash  however  this one actually is not covered by the C standard  which does not allow empty variadic arguments  i  e  we then rely on compiler extensions   At very first  an empty macro call  foo    still produces a token  but an empty one  So the counting macro actually returns 1 instead of 0 even on empty macro call  We can  easily  eliminate this problem  if we place the comma after   VA ARGS   conditionally  depending on the list being empty or not    define NARG      ARG4    VA ARGS   COMMA   VA ARGS    4  3  2  1  0    That looked easy  but the COMMA macro is quite a heavy one  fortunately  the topic is already covered in a blog of Jens Gustedt  thanks  Jens   Basic trick is that function macros are not expanded if not followed by parentheses  for further explanations  have a look at Jens  blog    We just have to modify the macros a little to our needs  I m going to use shorter names and less arguments for brevity     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     And now we are fine     The complete code in one block         demo c        Created on  2017-09-14         Author  sboehler       include  lt stdio h gt   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

User · Answer

Yes   In the time since this question was asked  standard C  no extensions  has effectively gained support for function overloading  not operators   thanks to the addition of the  Generic keyword in C11   supported in GCC since version 4 9    Overloading isn t truly  built-in  in the fashion shown in the question  but it s dead easy to implement something that works like that     Generic is a compile-time operator in the same family as sizeof and  Alignof  It is described in standard section 6 5 1 1  It accepts two main parameters  an expression  which will not be evaluated at runtime   and a type expression association list that looks a bit like a switch block   Generic gets the overall type of the expression and then  switches  on it to select the end result expression in the list for its type    Generic 1  float  2 0              char     2               int  2              default  get two object       The above expression evaluates to 2 - the type of the controlling expression is int  so it chooses the expression associated with int as the value  Nothing of this remains at runtime   The default clause is optional  if you leave it off and the type doesn t match  it will cause a compilation error    The way this is useful for function overloading is that it can be inserted by the C preprocessor and choose a result expression based on the type of the arguments passed to the controlling macro  So  example from the C standard     define cbrt X   Generic  X                                             long double  cbrtl                             default  cbrt                                  float  cbrtf                                     X    This macro implements an overloaded cbrt operation  by dispatching on the type of the argument to the macro  choosing an appropriate implementation function  and then passing the original macro argument to that function   So to implement your original example  we could do this   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   In this case we could have used a default  association for the third case  but that doesn t demonstrate how to extend the principle to multiple arguments  The end result is that you can use foo      in your code without worrying  much 1   about the type of its arguments     For more complicated situations  e g  functions overloading larger numbers of arguments  or varying numbers  you can use utility macros to automatically generate static dispatch structures   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       implementation here  So with some effort  you can reduce the amount of boilerplate to looking pretty much like a language with native support for overloading   As an aside  it was already possible to overload on the number of arguments  not the type  in C99      1  note that the way C evaluates types might trip you up though  This will choose foo int if you try to pass it a character literal  for instance  and you need to mess about a bit if you want your overloads to support string literals  Still overall pretty cool though

User · Answer

Try to declare these functions as extern  C    if your compiler supports this  http   msdn microsoft com en-us library s6y4zxec VS 80  aspx

User · Answer

There are few possibilities    printf style functions  type as an argument  opengl style functions  type in function name  c subset of c    if You can use a c   compiler

User · Answer

This may not help at all  but if you re using clang you can use the overloadable attribute - This works even when compiling as C  http   clang llvm org docs AttributeReference html overloadable  Header  extern void DecodeImageNow CGImageRef image  CGContextRef usingContext    attribute    overloadable    extern void DecodeImageNow CGImageRef image    attribute    overloadable      Implementation  void   attribute    overloadable   DecodeImageNow CGImageRef image  CGContextRef usingContext         void   attribute    overloadable   DecodeImageNow CGImageRef image

User · Answer

Normally a wart to indicate the type is appended or prepended to the name  You can get away with macros is some instances  but it rather depends what you re trying to do  There s no polymorphism in C  only coercion   Simple generic operations can be done with macros    define max x y    x  gt  y   x   y     If your compiler supports typeof  more complicated operations can be put in the macro  You can then have the symbol foo x  to support the same operation different types  but you can t vary the behaviour between different overloads  If you want actual functions rather than macros  you might be able to paste the type to the name and use a second pasting to access it  I haven t tried

User · Answer

Normally a wart to indicate the type is appended or prepended to the name  You can get away with macros is some instances  but it rather depends what you re trying to do  There s no polymorphism in C  only coercion   Simple generic operations can be done with macros    define max x y    x  gt  y   x   y     If your compiler supports typeof  more complicated operations can be put in the macro  You can then have the symbol foo x  to support the same operation different types  but you can t vary the behaviour between different overloads  If you want actual functions rather than macros  you might be able to paste the type to the name and use a second pasting to access it  I haven t tried

User · Answer

Can t you just use C   and not use all other C   features except this one   If still no just strict C then I would recommend variadic functions instead

User · Answer

Normally a wart to indicate the type is appended or prepended to the name  You can get away with macros is some instances  but it rather depends what you re trying to do  There s no polymorphism in C  only coercion   Simple generic operations can be done with macros    define max x y    x  gt  y   x   y     If your compiler supports typeof  more complicated operations can be put in the macro  You can then have the symbol foo x  to support the same operation different types  but you can t vary the behaviour between different overloads  If you want actual functions rather than macros  you might be able to paste the type to the name and use a second pasting to access it  I haven t tried

User · Answer

Yes  sort of   Here you go by example    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  gt 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       It will output 0 and hello    from printA and printB

User · Answer

I hope the below code will help you to understand function overloading  include  lt stdio h gt   include lt stdarg h gt   int fun int a        int main int argc  char  argv        fun 1 10      fun 2  quot cquestionbank quot       return 0    int fun int a          va list vl    va start vl a      if a  1        printf  quot  d quot  va arg vl int       else       printf  quot  n s quot  va arg vl char

User · Answer

The following approach is similar to a2800276 s  but with some C99 macro magic added      we need  size t   include  lt stddef h gt      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  lt  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  lt stdio h gt   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

User · Answer

I hope the below code will help you to understand function overloading  include  lt stdio h gt   include lt stdarg h gt   int fun int a        int main int argc  char  argv        fun 1 10      fun 2  quot cquestionbank quot       return 0    int fun int a          va list vl    va start vl a      if a  1        printf  quot  d quot  va arg vl int       else       printf  quot  n s quot  va arg vl char

User · Answer

In the sense you mean     no  you cannot   You can declare a va arg function like  void my func char  format           but you ll need to pass some kind of information about number of variables and their types in the first argument     like printf   does

[c] How to achieve function overloading in C?

Examples related to c

Examples related to overloading