Cで関数のオーバーロードを達成する方法は？
Cで関数のオーバーロードを達成する方法はありますか？私は次のようにオーバーロードされる単純な関数を見ています
foo (int a)
foo (char b)
foo (float c , int d)
直接的な方法はないと思います。回避策があれば探しています。
いくつかの可能性があります。
- printfスタイル関数（引数として入力）
- openglスタイルの関数（関数名を入力）
- c ++のcサブセット（c ++コンパイラを使用できる場合）
はい！
この質問が尋ねられてから、標準C（拡張機能なし）は、C11に_Genericキーワードが追加されたおかげで、関数のオーバーロード（演算子ではない）を効果的に獲得しました。 （バージョン4.9以降のGCCでサポート）
（オーバーロードは、質問に示されている方法では本当に「組み込まれている」わけではありませんが、そのように機能するものを実装するのは非常に簡単です。）
_Genericは、sizeofおよび_Alignofと同じファミリーのコンパイル時演算子です。標準セクション6.5.1.1で説明されています。式（実行時に評価されない）と、switchブロックのように見える型/式の関連付けリストの2つの主要なパラメーターを受け入れます。 _Genericは、式の全体的な型を取得し、その型に「切り替え」て、その型のリストで最終結果の式を選択します。
_Generic(1, float: 2.0,
char *: "2",
int: 2,
default: get_two_object());
上記の式は2に評価されます-制御式のタイプはintであるため、値としてintに関連付けられた式を選択します。これは実行時に残りません。 （default句はオプションです。この句を省略すると、タイプが一致しない場合、コンパイルエラーが発生します。）
これが関数のオーバーロードに役立つ方法は、Cプリプロセッサによって挿入され、制御マクロに渡される引数のタイプに基づいて結果式を選択できることです。したがって（C標準の例）：
#define cbrt(X) _Generic((X), \
long double: cbrtl, \
default: cbrt, \
float: cbrtf \
)(X)
このマクロは、引数の型をマクロにディスパッチし、適切な実装関数を選択して、元のマクロ引数をその関数に渡すことにより、オーバーロードされたcbrt操作を実装します。
したがって、元の例を実装するには、次のようにします。
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
この場合、3番目の場合にdefault:関連付けを使用できますが、それは原理を複数の引数に拡張する方法を示していません。最終的な結果は、引数の型について心配することなく（多く[1]）コードでfoo(...)を使用できることです。
より複雑な状況の場合、例えば多数の引数またはさまざまな数をオーバーロードする関数では、ユーティリティマクロを使用して静的ディスパッチ構造を自動的に生成できます。
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"
}
（ ここでの実装 ）そのため、多少の努力をすることで、ボイラープレートの量を、オーバーロードのネイティブサポートを備えた言語のように減らすことができます。
余談ですが、C99の引数（型ではなく）のnumberをオーバーロードするために、- 既に可能でした .
[1] Cが型を評価する方法はあなたをつまずかせるかもしれないことに注意してください。これは、文字リテラルを渡そうとすると、foo_intを選択します。たとえば、 そして少し混乱する必要があります オーバーロードで文字列リテラルをサポートしたい場合。それでも全体的にはかなりクールです。
既に述べたように、意味する意味でのオーバーロードはCではサポートされていません。問題を解決する一般的なイディオムは、関数に tagged union を受け入れさせることです。これは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);
}
コンパイラがgccであり、新しいオーバーロードを追加するたびに手動で更新することを気にしない場合は、マクロマジックを実行し、呼び出し元の観点から必要な結果を得ることができます。
__builtin_types_compatible_pを見て、それを使用して次のようなマクロを定義します
#define foo(a) \
((__builtin_types_compatible_p(int, a)?foo(a):(__builtin_types_compatible_p(float, a)?foo(a):)
でも嫌だ
EDIT： C1Xは、次のようなタイプの汎用式のサポートを取得します。
#define cbrt(X) _Generic((X), long double: cbrtl, \
default: cbrt, \
float: cbrtf)(X)
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;
}
はい、そうですね。
以下に例を示します。
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);
}
PrintAとprintBから0とhello ..を出力します。
これはまったく役に立たないかもしれませんが、clangを使用している場合は、オーバーロード可能な属性を使用できます-これはCとしてコンパイルする場合でも機能します
http://clang.llvm.org/docs/AttributeReference.html#overloadable
ヘッダ
extern void DecodeImageNow(CGImageRef image, CGContextRef usingContext) __attribute__((overloadable));
extern void DecodeImageNow(CGImageRef image) __attribute__((overloadable));
実装
void __attribute__((overloadable)) DecodeImageNow(CGImageRef image, CGContextRef usingContext { ... }
void __attribute__((overloadable)) DecodeImageNow(CGImageRef image) { ... }
次のアプローチは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 をサポートしている場合、より複雑な操作をマクロに追加できます。その後、シンボルfoo（x）を使用して、異なるタイプの同じ操作をサポートできますが、異なるオーバーロード間で動作を変えることはできません。マクロではなく実際の機能が必要な場合は、タイプを名前に貼り付け、2回目の貼り付けを使用してアクセスできる場合があります（試していません）。
Leushenkoの答え は本当にクールです-単独：fooの例はGCCでコンパイルできず、foo(7)で失敗し、FIRSTマクロと実際の関数呼び出し（(_1, __VA_ARGS__)、余分なコンマが残っています）につまずきます。 foo(double)などの追加のオーバーロードを提供する場合、問題が発生します。
そこで、ボイドのオーバーロード（foo(void) –かなりのトラブルを引き起こした...）を許可するなど、答えをもう少し詳しく説明することにしました。
アイデアは次のとおりです。異なるマクロで複数のジェネリックを定義し、引数の数に応じて正しいものを選択してください！
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
それは素晴らしいことです。SELECT_1またはSELECT_2に解決します（必要に応じて、さらに引数を追加します）。
#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、ボイドオーバーロードを既に追加しました。しかし、これは実際には空の可変引数を許可しないC標準の対象ではありません。 e。その後、コンパイラ拡張機能に依存します！
最初は、空のマクロ呼び出し（foo()）はトークンを生成しますが、空のトークンを生成します。そのため、空のマクロ呼び出しでも、カウントマクロは実際には0ではなく1を返します。リストが空かどうかに応じて、__VA_ARGS__conditionallyの後にコンマを配置すると、この問題を「簡単に」排除できます。
#define NARG(...) ARG4_(__VA_ARGS__ COMMA(__VA_ARGS__) 4, 3, 2, 1, 0)
見た目は簡単ですが、COMMAマクロは非常に重いものです。幸いなことに、このトピックは Jens Gustedtのブログ （ありがとう、Jens）で既に説明されています。基本的なトリックは、括弧が続かない場合は関数マクロが展開されないことです。詳細については、Jensのブログをご覧ください。必要に応じてマクロを少し変更するだけです（短い名前を使用します）簡潔さのための議論が少ない）。
#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 ,
そして今、私たちは大丈夫です...
1ブロックの完全なコード：
/*
* 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;
}
C++だけを使用して、これ以外のすべてのC++機能を使用することはできませんか？
まだ厳密なCがない場合は、代わりに variadic functions をお勧めします。