Crucial Question!!!!HELP!!!

include <iostream>

Why do we use mult (int x, int y) 2 times!!One at the begining and the other close to the end fo the script!!!And also why the one at the end does not have semicolon after its paranteses!!!!???
!!!!Please Help!!!

Code:

---

using namespace std;

int mult( int x, int y);

int main()
{
    int x;
    int y;
   
    cout<<"Please enter 2 variables x and y\n";
    cin>> x >> y;
    cin.ignore();
   
    cout<<"the mult of the 2 variables is"<< mult (x, y) <<"\n";
    cin.get();
}
int mult( int x, int y)
{
    return x*y;
}

---

Abuse of ! post of the week award

> int mult( int x, int y);
This is a prototype for the function. It tells the compiler how to call the function, without actually telling the compiler what it does.

> int mult( int x, int y)
This is the beginning of the definition of the function. Here the compiler finally knows what the function does.

In large programs, prototypes are put into header files (.h files), and function definitions can be in difference source files (.cpp files).

>>> Abuse of ! post of the week award

No, all of his posts are like that.

himanch: Read your mail.

Now now adrianxw there was the one time. Of course maybe they were sick

Quote:

---

And also why the one at the end does not have semicolon after its paranteses!!!!???

---

Because one is a function declaration(or function prototype), and the other is a function definition. A function declaration is just the function header:

Code:

---

int mult( int x, int y)
{
    return x*y;
}

---

followed by a semicolon, and alerts the compiler not to produce an error because the function definition will follow later.

You could just put all your function definitions before main(), and avoid most problems like that, but what if you have a function A() that in certain cases calls a function B(), and function B() in turn calls A() in certain cases. If you put the definition of A() first, then the compiler will see a call to B() inside A(), and it will complain that B() isn't defined. The same thing will happen if you put the definition of B() first. Therefore, C++ provides a way around that problem with function declarations. You would do this:

Code:

---

void B(int x, int y);
void A(int h, int i)
{
    ...
    if(something == something_else)
        B(1, 2);
}
void B(int x, int y)
{
    ...
    ...
    if(this == that)
        A(10,20);
}

---

Reallllyyy?
In my calculator program I put it like this

Code:

---

#include<iostream>

    int mult(int x, int y)
    {
    return x*y;
    }

    int main()

---

you can define them in the begginning too. without having to make a prototype.

You will get errors at compile time if you try to call a function before it is defined. If your function definitions are before the first use of the function, all is hunky dory. However, the larger your programs or projects get, the more difficult this becomes to maintain.

So instead, you place the prototype in the code which basically tells the compiler "I know you haven't seen this function, but trust me it will be defined before the compile is finished."

If you've ever had any experience with Pascal, you'd realize what an enormous convenience this is.