CODEWITHSUNDEEP
c
Kartik Anand
Kartik Anand

Reputation: 4609

Catching variables passed to function with no arguments

I don't know if it's possible but the wikipedia article here Compatibility of C and C++ says the following :

In C, a function prototype without arguments, e.g. int foo();, implies that the parameters are unspecified. Therefore, it is legal to call such a function with one or more arguments, e.g. foo(42, "hello world").

In contrast, in C++ a function prototype without arguments means that the function takes no arguments, and calling such a function with arguments is ill-formed.

In C, the correct way to declare a function that takes no arguments is by using void, as in int foo(void);.

I made the following code to test it and catch the passed variables (which doesn't work quite right)

#include<stdio.h>
#include<stdarg.h>

void foo();

int main()
{
    int i = 3;
    foo(i);
    return 0;
}

void foo()
{
//    va_list args;
//    va_start(args);
//
//    int x = va_arg (args, int);
//    printf("%d", x);
//    va_end(args);
}

Is it possible to catch the passed i or is Wikipedia talking about something completely different?

Upvotes: 5

Views: 997

Answers (5)

BЈовић
BЈовић

Reputation: 64303

There is a way to access those parameters in C program, but I look at it as a big hack, which should be avoided.

Next example shows how to access an int parameter :

#include<stdio.h>
#include<stdarg.h>

void foo();

int main()
{
    int i = 3;
    foo(i);
    return 0;
}

void foo(int p)
{
    printf("%d",p);
}

Now, I am not sure what happens if you pass something else then int (for example char*), but it may cause an undefined behavior.

In c++ (as said), you can not pass parameters to functions taking no parameters.

Upvotes: 0

rodrigo
rodrigo

Reputation: 98526

That comes from the old C days when the strictness of the language was, well..., relaxed.

The basic idea was that if you had a function in a translation unit, say foo.c:

float foo(int x) 
{
     return 2.0F * x;
}

And then you want to use it in another translation unit, say main.c but you don't want to bother with writing a header file, you could just do:

int main()
{
    float foo();
    float r;
    r = foo(42);
}

And you don't have to write the arguments of the function. To be fair, you didn't have to write the prototype at all, but then the compiler would assume that the function always returns int which may not be what you need.

Then, as the language matured, this kind of function declaration was decided to be a very bad idea, so generally speaking you should not (try to) use it. If you want a variadic function, then by all means use it, but declare it as such. And you have to give it at least a real argument, to anchor the call to va_start().

Upvotes: 2

Yu Hao
Yu Hao

Reputation: 122503

You can't, at least not in standard C. What the Wikipedia article means is this code:

void foo();

int main()
{
    int i = 3;
    foo(i);
    return 0;
}

void foo(int i)
{
    (void)i;
}

Compiles fine in C, but it's invalid in C++ because the number of arguments don't match.

Upvotes: 5

pigoz
pigoz

Reputation: 302

You can call the function with any arguments, but you can't access them in the function scope. Anyway some compilers will give you warnings if you don't declare the prototype as int foo (void); since you probably don't want to do this anyway.

Upvotes: 0

Some programmer dude
Some programmer dude

Reputation: 409482

If you read the documentation for va_start you will see that it needs the last "real" argument in the argument list. So it's not possible in plain C to get the arguments if you don't declare any arguments.

What you can do is to declare the function prototype without arguments, and have arguments in the actual definition.

Upvotes: 4

Related Questions