What's does ... mean in an argument list in C ?

Question

I came across the following function signature and I wondered if this (the ellipsis, or "...") is some kind of polymorphism?

#include <fcntl.h>
int fcntl(int fd, int cmd, ... );

Thanks in advance.

Answer 1

It's a variable argument list.

Answer 2

No, that's the "ellipsis" you're seeing there, assuming you're referring to the ... part of the declaration.

Basically it says that this function takes an unknown number of arguments after the first two that are specified there.

The function has to be written in such a way that it knows what to expect, otherwise strange results will ensue.

For other functions that support this, look at the printf function and its variants.

Answer 3

I assume you are referring to the ellipsis (...)? If so this indicates that 0 or more parameters will follow. It is called varargs, defined in stdarg.h

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

printf uses this functionality. Without it you wouldn't be able to keep adding parameters to the end of the function.

Answer 4

No, it is a function that is taking variable number of arguments.

Answer 5

That is not technically polymorphism. fcntl takes variable number of arguments & that is the reason for the ... similar to printf function.

Answer 6

That is a variadic function. See stdarg.h for more details.

Answer 7

The ... means that you can pass any number of arguments to this function, as other commenters have already mentioned. Since the optional arguments are not typed, the compiler cannot check the types and you can technically pass in any argument of any type.

So does this mean you can use this to implement some kind of polymorphic function? (I.e., a function that performs some operation based on the type of its arguments.)

No.

The reason you cannot do this, is because you cannot at runtime inspect the types of the arguments passed in. The function reading in the variable argument list is expected to already know the types of the optional arguments it is going to receive.

In case of a function that really is supposed to be able to take any number of arguments of any type (i.e., printf), the types of the arguments are passed in via the format string. This means that the caller has to specify the types it is going to pass in at every invocation, removing the benefit of polymorphic functions (that the caller doesn't have to know the types either).

Compare:

// 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)

You have to specify the type before the varargs function can do the right thing, so this gains you nothing.

Answer 8

Does C support polymorphism? No, it doesn't.

However there are several libraries, such as Python C API, that implements a rough variant of polymorphism using structs and pointers. Beware that compiler cannot perform appropriate type checking in most cases.

The tecnhique is simple:

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 and Person get a Type object with appropriate function pointers (e.g. to functions like integer_to_string and person_to_string).

Now just declare a function accepting an Object *:

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

now you can call this function with both an Integer and a Person:

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

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

EDIT

alternatively you can declare i and p as Object *; of course make_int and make_person will allocate space for Integer and Person and do the appropriate cast:

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

NB: I cannot compile these examples rigth now, please doublecheck them.

I came across the following function signature and I wondered if this (the ellipsis, or "...") is some kind of polymorphism?

yes, it is a primitive form of polymorphism. With only one function signature you are able to pass various structures. However the compiler cannot help you with detecting type errors.

Answer 9

C neither supports function overloading - which is a type of ad-hoc polymorphism based on compile-time types - nor multiple dispatch (ie overloading based on runtime types).

To simulate function overloading in C, you have to create multiple differently named functions. The functions' names often contain the type information, eg fputc() for characters and fputs() for strings.

Multiple dispatch can be implemented by using variadic macros. Again, it's the programmer's job to provide the type information, but this time via an extra argument, which will be evaluated at runtime - in contrast to the compile-time function name in case of the approach given above. The printf() family of functions might not be the best example for multiple dispatch, but I can't think of a better one right now.

Other approaches to multiple dispatch using pointers instead of variadic functions or wrapping values in structures to provide type annotations exist.

Answer 10

Adding to what's been said: C supports polymorphism through other means. For example, take the standard library qsort function which sorts data of arbitrary type.

It is able to do so by means of untyped (void) pointers to the data. It also needs to know the size of the data to sort (provided via sizeof) and the logic that compares the objects' order. This is accomplished by passing a function pointer to the qsort function.

This is a prime example of runtime polymorphism.

There are other ways to implement object-oriented behaviour (in particular, virtual function calls) by managing the virtual function tables manually. This can be done by storing function pointers in structures and passing them around. Many APIs do so, e.g. the WinAPI, which even uses advanced aspects of object orientation, e.g. base class call dispatch (DefWindowProc, to simulate calling the virtual method of the base class).

Answer 11

The printf declaration in the standard library is

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

Think about that.

Answer 12

No i dont think there is no concept of opps in c

Answer 13

You can write code that supports Polymorphic behavior in C, but the ... (ellipsis) is not going to be much help. That is for variable arguments to a function.

If you want polymorphic behavior you can use, unions and structures to construct a data structure that has a "type" section and variable fields depending on type. You can also include tables of function pointers in the structures. Poof! You've invented C++.

Answer 14

C supports a crude form of Polymorphism. I.e. a type being able to appear and behave as another type. It works in a similar was as in C++ under the hood (relying on memory being aligned) but you have to help the compiler out by casting. E.g. you can define a struct:

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

And then another struct:

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

Then

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

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

The above example shows Employee being used as a Person.

Answer 15

Yes C Do support the polymorphism

the Code which we write in the C++ using virtual to implement the polymorphism if first converted to a C code by Compiler ( one can find details here

http://www.eventhelix.com/RealtimeMantra/basics/object_oriented_programming_in_c.htm

)

its well known that virtual functionality in C++ is implemented using function pointers .