Thread: I Can't Take This Anymore

>Are the function parameters even useful?

Absolutely. For example, to get the square of an integer, you could do this

Code:

int sqr(int x)
{
  return x * x;
}

If you couldn't pass x into the function, what is it going to return?

>If so, can they be used as local variables within the function?

That's exactly what they are. In the example above, x is local in the sqr function.

>If I wanted a function to return Area, which is and intenger that is assigned the value of length * height, where would I declare these variables? Within the local function? Should they be global variables? Should I declare their values in the main() function?

Well you would define a function like this:

Code:

int area(int length, int height)
{
  return length * height;
}

Length and height are declared as parameters in the area function.

So to call this, you would do something like:

int a = area(5, 5);

In this case, with are using literals (5 & 5). But these could be replaced with variables local to (or in the scope of) the calling function.

Here's a sample of how to use several functions and pretty much how to write a simple program.

Code:

#include <iostream>
using namespace std;

// constant definitions
const double PI = 3.14159;

// function prototypes
double RectArea(double length, double width);
double RectPerim(double length, double width);

int main()
{
	// variable declarations
	double length, width, area, perimeter;

	// get data from the user
	cout << "Enter the length: ";
	cin >> length;
	cout << "Enter the width: ";
	cin >> width;

	// Calculations
	area = RectArea(length, width);
	perimeter = RectPerim(length, width);

	// Display results
	cout << "The area is " << area << endl
	 	<< "The perimeter is " << perimeter
		<< endl;
}

// function implementations
double RectArea(double length, double width)
// description: calculates the area of the
// rectangle
// precondition: length and width are valid doubles
// greater than zero
// postcondition: returns the area of the rectangle
{
	return length * width;
}

double RectPerim(double length, double width)
// description: calculates the perimeter of the
// rectangle
// precondition: length and width are valid doubles
// greater than zero
// postcondition: returns the perimeter of the
// rectangle
{
	return 2 * length + 2 * width;
}

And there you have it. A sample program using two functions. Sorry about all of the comments. I did that for your learning benefit.

-"Should they be global variables?"
No, global variables are evil. They are diametrically opposed to the concept of data encapsulation. The only global identifiers you should use are constants.

If you have any other questions or a more specific question, just post some code or your question and I'll try to be as helpful as I can. :-)

Just think of functions as mini-programs. Here's an example of one I had to use for an assignment:

Code:

//This is the function prototype:

void compute_coin(int coin_value, int& num_coins, int& amt);

//This function will be used to calculate the amount of coins for
//each coin (quarter, dime, nickel and penny). It will also reduce
//the amount left to be calculated.


//This is the function 'call' in the 'main' program:

  compute_coin(value_quarter, num_quarters, amt_left);
  compute_coin(value_dime, num_dimes, amt_left);
  compute_coin(value_nickel, num_nickels, amt_left);
  compute_coin(value_penny, num_pennies, amt_left);

//This is how the function works (located after the end of the 'main' program:

void compute_coin(int coin_value, int& num_coins, int& amt)
{
int total_coins_value;

num_coins = amt / coin_value;
total_coins_value = num_coins * coin_value;
amt = amt - total_coins_value;

return;

Instead of writing out the calculations four times, I just had to write it once, then use it four times. They can be really helpful, if you have logic errors, it can be easier to narrow down where the problem is located.