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

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

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

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

Да, вроде.

Здесь вы приводите пример:

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

Он будет выводить 0 и привет.. из печатиA и печатьB.

Если ваш компилятор - 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. Обычная идиома для решения проблемы заключается в том, что функция принимает меченый союз . Это реализуется с помощью параметра struct , где сама struct состоит из некоторого типа индикатора типа, такого как enum , и union различных типов значений. Пример:

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

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

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

Следующий подход похож на a2800276 , но с некоторыми макросами макросов C99:

// we need `size_t` #include // 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 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; }

За время, _Generic момента _Generic этого вопроса, стандартный C (без расширений) эффективно получил поддержку перегрузки функций (а не операторов) благодаря добавлению _Generic слова _Generic в C11. (поддерживается в GCC с версии 4.9)

(Перегрузка не является по-настоящему «встроенной» в способе, показанном в вопросе, но легко уничтожить то, что работает так.)

Generic - это оператор времени компиляции в том же семействе, что и sizeof и _Alignof . Он описан в стандартном разделе 6.5.1.1. Он принимает два основных параметра: выражение (которое не будет оцениваться во время выполнения) и список ассоциаций типов / выражений, который немного похож на блок switch . _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

В этом случае мы могли бы использовать связь по default: для третьего случая, но это не демонстрирует, как расширить принцип до нескольких аргументов. Конечным результатом является то, что вы можете использовать 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.

Обратите внимание, что способ оценки C может вас трогать. Это выберет foo_int если вы попытаетесь передать ему буквенный символ, например, и вам нужно немного foo_int если вы хотите, чтобы ваши перегрузки поддерживали строковые литералы. Тем не менее, в целом довольно прохладно.

Ответ Леушенко действительно классный: только пример foo не компилируется с GCC, который не срабатывает при foo(7) , наткнувшись на макрос FIRST и фактический вызов функции ((_1, __VA_ARGS__) , оставаясь с добавочной запятой. Кроме того, у нас возникают проблемы, если мы хотим обеспечить дополнительные перегрузки, такие как foo(double) .

Поэтому я решил подробнее ответить на этот вопрос, в том числе разрешить пустую перегрузку (foo(void) - что вызвало некоторые неприятности...).

Идея теперь заключается в следующем: определите более одного генерика в разных макросах и позвольте выбрать правильный в соответствии с количеством аргументов!

Количество аргументов довольно просто, основываясь на этом ответе:

#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 \) \)

Во-первых, пустой вызов макроса (foo()) все еще создает токен, но пустой. Таким образом, счетный макрос фактически возвращает 1 вместо 0 даже при пустом вызове макроса. Мы можем «легко» устранить эту проблему, если мы __VA_ARGS__ запятую после __VA_ARGS__ условно , в зависимости от того, что список пуст или нет:

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

Это выглядело легко, но макрос COMMA довольно тяжелый; к счастью, эта тема уже освещена в блоге Йенса Густедта (спасибо, Йенс). Основной трюк заключается в том, что макросы функций не расширяются, если не следовать скобками, для дальнейших объяснений смотрите блог 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 ,

И теперь мы в порядке...

Полный код в одном блоке:

/* * demo.c * * Created on: 2017-09-14 * Author: sboehler */ #include 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; }

При определении функций в своих программах вы должны указать тип возвращаемого функцией значения, а также количество параметров и тип каждого из них. В прошлом (если вы программировали на языке С), когда у вас была функция с именем add_values, которая работала с двумя целыми значениями, а вы хотели бы использовать подобную функцию для сложения трех целых значений, вам следовало создать функцию с другим именем. Например, вы могли бы использовать add_two_values иadd_three_values. Аналогично если вы хотели использовать подобную функцию для сложения значений типа float, то вам была бы необходима еще одна функция с еще одним именем. Чтобы избежать дублирования функции, C++ позволяет вам определять несколько функций с одним и тем же именем. В процессе компиляции C++ принимает во внимание количество аргументов, используемых каждой функцией, и затем вызывает именно требуемую функцию. Предоставление компилятору выбора среди нескольких функций называется перегрузкой. В этом уроке вы научитесь использовать перегруженные функции. К концу данного урока вы освоите следующие основные концепции:

Перегрузка функций позволяет вам использовать одно и то же имя для нескольких функций с разными типами параметров.

Для перегрузки функций просто определите две функции с одним и тем же именем и типом возвращаемого значения, которые отличаются количеством параметров или их типом.

Перегрузка функций является особенностью языка C++, которой нет в языке С. Как вы увидите, перегрузка функций достаточно удобна и может улучшить удобочитаемость ваших программ.

ПЕРВОЕ ЗНАКОМСТВО С ПЕРЕГРУЗКОЙ ФУНКЦИЙ

Перегрузка функций позволяет вашим программам определять несколько функций с одним и тем же именем и типом возвращаемого значения. Например, следующая программа перегружает функцию с именемadd_values. Первое определение функции складывает два значения типаint. Второе определение функции складывает три значения. В процессе компиляции C++ корректно определяет функцию, которую необходимо использовать:

#include

int add_values(int a,int b)

{
return(a + b);
)

int add_values (int a, int b, int c)

(
return(a + b + c);
)

{
cout << «200 + 801 = » << add_values(200, 801) << endl;
cout << «100 + 201 + 700 = » << add_values(100, 201, 700) << endl;
}

Как видите, программа определяет две функции с именами add_valuesПервая функция складывает два значения типа int, в то время как вторая складывает три значения. Вы не обязаны что-либо предпринимать специально для того, чтобы предупредить компилятор о перегрузке, просто используйте ее. Компилятор разгадает, какую функцию следует использовать, основываясь на предлагаемых программой параметрах.

Подобным образом следующая программа MSG_OVR.CPP перегружает функцию show_message. Первая функция с именем show_message выводит стандартное сообщение, параметры ей не передаются. Вторая выводит передаваемое ей сообщение, а третья выводит два сообщения:

#include

void show_message(void)

{
cout << «Стандартное сообщение: » << «Учимся программировать на C++» << endl;
}

void show_message(char *message)

{
cout << message << endl;
}

void show_message(char *first, char *second)

{
cout << first << endl;
cout << second << endl;
}

{
show_message();
show_message(«Учимся программировать на языке C++!»);
show_message(«B C++ нет предрассудков!»,»Перегрузка — это круто!») ;
}

КОГДА НЕОБХОДИМА ПЕРЕГРУЗКА

Одним из наиболее общих случаев использования перегрузки является применение функции для получения определенного результата, исходя из различных параметров. Например, предположим, что в вашей программе есть функция с именем day_of_week, которая возвращает текущий день недели (0 для воскресенья, 1 для понедельника, …, 6 для субботы). Ваша программа могла бы перегрузить эту функцию таким образом, чтобы она верно возвращала день недели, если ей передан юлианский день в качестве параметра, или если ей переданы день, месяц и год:

int day_of_week(int julian_day)

{
// Операторы
}

int day_of_week(int month, int day, int year)

{
// Операторы
}

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

Перегрузка функций улучшает удобочитаемость программ

Перегрузка функций C++ позволяет вашим программам определять несколько функций с одним и тем же именем. Перегруженные функции должны возвращать значения одинакового типа*, но могут отличаться количеством и типом параметров. До появления перегрузки функций в C++ программисты языка С должны были создавать несколько функций с почти одинаковыми именами. К сожалению программисты, желающие использовать такие функции, должны были помнить, какая комбинация параметров соответствует какой функции. С другой стороны, перегрузка функций упрощает задачу программистов, требуя, чтобы они помнили только одно имя функции.* Перегруженные функции не обязаны возвращать значения одинакового типа по той причине, что компилятор однозначно идентифицирует функцию по ее имени и набору ее аргументов. Для компилятора функции с одинаковыми именами, но различными типами аргументов - разные функции, поэтому тип возвращаемого значения - прерогатива каждой функции. - Прим.перев.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Перегрузка функций позволяет вам указать несколько определений для одной и той же функции. В процессе компиляции C++ определит, какую функцию следует использовать, основываясь на количестве и типе передаваемых параметров. Из данного урока вы узнали, что перегружать функции достаточно просто. Из урока 14 вы узнаете, как ссылки C++ упрощают процесс изменения параметров внутри функций. Однако, прежде чем перейти к уроку 14, убедитесь, что вы изучили следующие основные концепции:

1. Перегрузка функций предоставляет несколько «взглядов» на одну и ту же функцию внутри вашей программы.
2. Для перегрузки функций просто определите несколько функций с одним и тем же именем и типом возвращаемого значения, которые отличаются только количеством и типом параметров.
3. В процессе компиляции C++ определит, какую функцию следует вызвать, основываясь на количестве и типе передаваемых параметров.
4. Перегрузка функций упрощает программирование, позволяя программистам работать только с одним именем функции.