Thread: Prototypes or no?

For example, let's take printf, it is a function in the stdio.h! You do not have to put return or prototypes!You just call the function, give its arguments and that's it!

You're confused. The actual compiled printf() funciton is in a library file somewhere. What you find in stdio.h is actually, that's right, the prototype.

Originally Posted by cookie

For example, let's take printf, it is a function in the stdio.h! You do not have to put return or prototypes!You just call the function, give its arguments and that's it!

I don't understand your problem. The function prototype for printf() is inside stdio.h. When you #include <stdio.h>, that prototype is included.

You might be able to get away with the following code on your compiler and just include printf()'s prototype without including stdio.h.:

Code:

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

int main(void)
{
	printf("Hello, world....\n");
	return 0;
}

I wouldn't recommend doing it regularly, though, but just as a test in this case. I would strongly recommend you include stdio.h when wanting to use any of the functions contained declared inside.

Originally Posted by cookie

Can you pls give me an example, how can u use a function like subtract, let's say made by you ?
Let's say I want to make the function subtract that will subtract y from x

Is it possible to do this???

Code:

#include <stdio.h>

int subtract(int x, int y)
{
    printf ("&#37;d", x - y);
}
int main()
{
	int x;
	int y;
    scanf("%d", &x);
    scanf("%d", &y);

    subtract();
}

I tried it but it doesn't work!

Add this line after you include stdio.h:

Code:

int substract(int, int);

Originally Posted by cookie

It tells me too few arguments for subtract in an error message!

That's because the standard idea for a C89 compiler to do is guess you want a function that accepts one int and returns an int if you use a function it hasn't seen before.

Originally Posted by cookie

Can you pls put it for me, how you would do it the right way without the prototypes, just define the function, I want the function to subtract x and y!

and then just call it

subtract() like you call printf()

You can't/shouldn't eliminate function prototypes. As C99 takes over, I believe you'll get in trouble with this because function prototypes are required.

If you want to be like printf(), make your own header file. Name it something like mysubtract.h. Write the following inside of it:

Code:

int subtract(int, int);

Then make a program called mysubtract.c, where this line is included:

Code:

#include "mysubtract.h"

Inside mysubtract.c, write the function definition for subtract().

Re-read the book's description on functions. You may have to read this a few times if you've never encountered functions in math or anywhere else before.

Everything about return and such should be explained.

> this has to be before main! Why do I have to put this too! int add(int, int)
> why don't I just leave it with the prototype???
The prototype is the envelope, the function body is the letter inside the envelope. You need both if you want something to happen.

> The function definition! Why does it have to be after main???
It can be anywhere after the prototype.
Some people prefer to see main() first, then the worker functions in a top-down arrangement.
Others prefer a bottom-up style starting with the minor functions finishing with main at the end of the file.
However, when your programs no longer fit inside one source file, the whole "before or after main" doesn't mean a great deal.

> And one more thing! When I define the function, do I just call its name or its parameters too
When you prototype a function, you can omit the variable names. So these two are equivalent.

Code:

int find ( const char*, const char* );
int find ( const char*haystack, const char*needle );

Though obviously the latter provides more information about what the parameters intend to be used for.

The function definition must always name the parameters, otherwise the function body has nothing to work with.

Code:

int find ( const char*haystack, const char*needle )
{
  return strstr( haystack, needle ) != 0;
}

Normally, the prototype is created from the definition by copy/paste and appending a ;

Calling the function, you can use any variable name you like, or even literal constants

Code:

char a[] = "hello", b[]="he";
find( a, b );
find( "hello", "he" );

These do much the same thing

Code:

void mult ( int a, int b );
int main ( ) {
  mult( 3, 6 );
  return 0;
}
void mult ( int a, int b ) {
  printf( "Result=%d\n", a * b );
}

Code:

int mult ( int a, int b );
int main ( ) {
  printf( "Result=%d\n", mult( 3, 6 ) );
  return 0;
}
int mult ( int a, int b ) {
  return a * b;
}

This might clear it up:

Without a function:

Code:

#include <stdio.h>
int main(void)
{
  printf("&#37;d\n", 5 * 3);
  return 0;
}

With a function:

Code:

#include <stdio.h>
int mul(int one, int two)
{
  return one * two;
}

int main(void)
{
  printf("%d\n", mul(5, 3));
  return 0;
}

As the compiler is compiling your code it comes across function calls within said code. When it gets to these function calls, the compiler has to do type checking of arguments passed into the functions (making sure you don't try to pass a char* into a function that expects a float for example). In order to do this type checking, it must have already seen that function earlier, either the complete function or a prototype. The prototype is there to declare to the compiler that you will be using a function named X and it has parameter(s) Y of type(s) Z so that this type checking can occur as the compiler is checking your code for mistakes and comes upon a call to function X. The compiler will say "ah, function X... I've seen this before and I know what arguments it takes and what their types are supposed to be so I can now check and make sure the programmer isn't trying to do something stupid."

You don't need a prototype at all if you've already defined the function in full prior to it's first call from elsewhere in the code... the compiler is able to take the same information it needs for later type-checking from a full definition of the function as it would get from the simpler prototype. Once you start working on programs that contain more than one source file however it's better to have a prototype in a header that can be included by all the source files in case you need to call these functions from the different source files. These headers are mostly just function prototypes and do not contain the function body/code for those function. The actual code for the functions will be in a source file that you create, or a library file that the vendor provides to you and is linked to your program during the linking stage of the executable build process.

Originally Posted by cookie

I can understand it now! Functions really aren't hard! But Call by value and character arrays are!

What is this call by value, what do they mean it stores memory in an imaginary value!

Before asking these questions, read the book a few times. Then read another online tutorial on the same subject a few times.

What they are trying to explain is that if you pass a variable to a function, the function receives a copy of the value of the variable you give it. If you call a function with a variable, and that function changes the variable, the variable will not be changed inside the original function that called this function. If you want it to be changed, then you need to deal with pointers, which I doubt you really covered, yet.