Что … означает в списке аргументов в C?

Это список переменных аргументов.

Нет, это "многоточие", которое вы видите здесь, если предположить, что вы ссылаясь на ... часть объявления.

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

Функция должна быть написана таким образом, чтобы она знала, чего ожидать, в противном случае будут странные результаты.

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

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

Означает ли это, что вы можете использовать это для реализации какой-то полиморфной функции? (То есть функция, которая выполняет некоторую операцию в зависимости от типа ее аргументов.)

Нет.

Причина, по которой вы не можете этого сделать, заключается в том, что вы не можете во время выполнения проверять типы переданных аргументов. Функция ожидается, что чтение в списке аргументов переменных уже знает типы дополнительных аргументов, которые она собирается получить.

В случае функции, которая действительно должна иметь возможность принимать любое количество аргументов любого типа (т. е. printf ), типы аргументов передаются через строку формата. Это означает, что вызывающий должен указывать типы, которые он будет передавать при каждом вызове, что устраняет преимущество полиморфных функций (вызывающий также не должен знать типы).

Сравните:

// Ideal invocation
x = multiply(number_a, number_b)
y = multiply(matrix_a, matrix_b)

// Standard C invocation
x = multiply_number(number_a, number_b)
y = multiply_matrix(matrix_a, matrix_b)

// Simulated "polymorphism" with varargs
x = multiply(T_NUMBER, number_a, number_b)
y = multiply(T_MATRIX, matrix_a, matrix_b)

Вы необходимо указать тип до того, как функция varargs сможет действовать правильно, так что это ничего вам не даст.

Это вариативный функция . Подробнее см. stdarg.h .

Полагаю, вы имеете в виду многоточие (...)? Если это так, это означает, что последуют 0 или более параметров. Он называется varargs и определен в stdarg.h

http://msdn.microsoft.com/en-us/library/kb57fad8.aspx

printf использует эту функциональность. Без него вы не смогли бы добавлять параметры в конец функции.

Нет, это функция, которая принимает переменное количество аргументов.

Технически это не полиморфизм. fcntl принимает переменное количество аргументов & это причина ... аналогичной функции printf.

C поддерживает грубую форму полиморфизма. Т.е. тип может появляться и вести себя как другой тип. Он работает так же, как и в C ++ под капотом (полагаясь на выравнивание памяти), но вы должны помочь компилятору с помощью преобразования. Например, вы можете определить структуру:

typedef struct {
     char forename[20];
     char surname[20];
     } Person;

А затем другую структуру:

    typedef struct {
             char forename[20];
             char surname[20];
             float salary;
             char managername[20];
             } Employee;

Затем

int main (int argc, int *argv)
{
    Employee Ben;
    setpersonname((Person *) &Ben);
}

void setpersonname(Person *person)
{
   strcpy((*person).Name,"Ben");
}

В приведенном выше примере показано, как Employee используется как Person.

Объявление printf в стандартной библиотеке:

int printf(const char*, ...); 

Подумайте об этом.

Вы можете написать код, поддерживающий полиморфное поведение в C, но ... (многоточие) не сильно поможет. Это для переменных аргументов функции.

Если вам нужно полиморфное поведение, вы можете использовать объединения и структуры для создания структуры данных, которая имеет раздел «тип» и поля переменных в зависимости от типа. Вы также можете включать в структуры таблицы указателей функций. Пуф! Вы изобрели C ++.

Да C Поддерживаете ли полиморфизм

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

Хорошо известно, что виртуальная функциональность в C ++ реализуется с помощью указателей функций.

Поддерживает ли C полиморфизм? Нет, это не так.

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

Технология проста:

typedef struct {
    char * (*to_string)();
} Type;

#define OBJ_HEADER Type *ob_type

typedef struct {
    OBJ_HEADER;
}  Object; 

typedef struct {
    OBJ_HEADER;
    long ival;        
} Integer;

typedef struct {
    OBJ_HEADER;
    char *name;
    char *surname;
} Person;

Integer и Person получают объект Type с соответствующими указателями функций (например, на такие функции, как integer_to_string и person_to_string).

Теперь просто объявите функция, принимающая объект *:

void print(Object *obj) {
    printf("%s", obj->type->to_string());
}

теперь вы можете вызывать эту функцию как с целым числом, так и с человеком:

Integer *i = make_int(10);
print((Object *) i);

Person *p = make_person("dfa");
print((Object *) p);

РЕДАКТИРОВАТЬ

в качестве альтернативы вы можете объявить i и p как объект *; конечно make_int и make_person выделят место для Integer и Person и сделают соответствующее приведение:

Object * 
make_integer(long i) {
     Integer *ob = malloc(sizeof(Integer));
     ob->ob_type = &integer_type;
     ob->ival = i;
     return (Object *) ob;
}

NB: Я не могу скомпилировать эти примеры прямо сейчас, пожалуйста, дважды проверьте их.

Я наткнулся на следующую сигнатуру функции и задался вопросом, является ли это (многоточие или «...») своего рода полиморфизмом?

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

В дополнение к сказанному: C поддерживает полиморфизм другими способами. Например, возьмем функцию стандартной библиотеки qsort , которая сортирует данные произвольного типа.

Она может делать это с помощью нетипизированных ( void ) указателей на данные. Ему также необходимо знать размер данных для сортировки (предоставляется через sizeof ) и логику, которая сравнивает порядок объектов. Это достигается путем передачи указателя на функцию qsort .

Это яркий пример полиморфизма времени выполнения.

Существуют и другие способы реализации объектно-ориентированного поведения (в частности, виртуальная функция вызовов), управляя таблицами виртуальных функций вручную. Это можно сделать, сохранив указатели на функции в структурах и передав их. Многие API-интерфейсы делают это, например WinAPI, который даже использует расширенные аспекты объектной ориентации, например диспетчеризацию вызовов базового класса ( DefWindowProc , для имитации вызова виртуального метода базового класса).

C не поддерживает перегрузку функций - который является типом специального полиморфизма , основанный на типах времени компиляции - ни множественную отправку (то есть перегрузку на основе типов времени выполнения).

Чтобы смоделировать перегрузку функций в C, вы должны создать несколько функций с разными именами. Имена функций часто содержат информацию о типе, например fputc () для символов и fputs () для строк.

Множественная диспетчеризация может быть реализована с использованием макросов с переменными числами. Опять же, задача программиста - предоставить информацию о типе, но на этот раз через дополнительный аргумент, который будет оцениваться во время выполнения - в отличие от имени функции времени компиляции в случае подхода, описанного выше. Семейство функций printf () может быть не лучшим примером для множественной отправки,