Thread: int&, passing of arguments by reference, etc

Hi

Today the instructor was trying to teach us how the following code works. To be truthful I couldn't understand anything.

First thing he changed in the today's program was that he made declared the user defined function within the int main though in the past he told us to declare it before entering int main. Please have a look on CODE 2 which you would understand what I'm saying. I don't understand the reason for this.

1: I copied the following CODE 1 onto my flash drive. You can see that the declaration for the user defined function has been made inside the int main. What's the reason for this change?

2: What kind of data type is this "int&"?

3: Could you please tell me in simple words what that passing of arguments by reference means? What's the advantage of this practice.

Please keep your replies as simple as possible. Thank you very much.

CODE 1:

Code:

// orders two arguments passed by reference
#include <iostream>
using namespace std;

int main()
   {
   void order(int&, int&);          //prototype

   int n1=99, n2=11;                //this pair not ordered
   int n3=22, n4=88;                //this pair ordered

   order(n1, n2);                   //order each pair of numbers
   order(n3, n4);

   cout << "n1=" << n1 << endl;     //print out all numbers
   cout << "n2=" << n2 << endl;
   cout << "n3=" << n3 << endl;
   cout << "n4=" << n4 << endl;
   return 0;
   }
//--------------------------------------------------------------
void order(int& numb1, int& numb2)  //orders two numbers
   {
   if(numb1 > numb2)                //if 1st larger than 2nd,
      {
      int temp = numb1;             //swap them
      numb1 = numb2;
      numb2 = temp;
      }
   }

CODE 2:

Code:

// calculating area of a circle using user-defined function

#include <iostream>
#include <cstdlib>

using namespace std;

float area(float dummy);

int main()

{
    float r; float a;

	cout << "enter radius: "; cin >> r;

	a = area(r);

	cout << a;

	system("pause");

	return 0;
}

//------------------------------------
// area(int), function definition

        float area(float dummy)

		{
			float Area;

			Area = 3.1416*(dummy*dummy);

			return Area;

		}
//--------------------------------------

Originally Posted by manasij7479

If you don't...say.....you pass an integer by reference and the function changes the value of the integer..but does not return it...When the called function exits; the value of the original variable you passed..reflects the changes to the variable you worked with...inside the function.

Thank you.

I don't know anything about the pointers. Okay. So, the int main passes the value of a variable by reference (perhaps, by sending the information where it is stored in the memory) to a called function. The called function acts on those variables passed to it through reference (i.e. by sending their memory addresses) by the int main. The called function can affect the values (i.e. numerical values etc) without really changing the memory addresses so that the variables are still accessed by the int main but perhaps it (int main) will see new values for the variables.

Is what I'm saying correct? Please tell me. Thanks

Thanks a lot, Manasij. So, it's just like swapping the contents of the drawers without really affecting the configuration (or, arrangement) of the drawers.

One thing about your instructor's code is bad. You can find info here: http://cpwiki.sourceforge.net/do_not...arameter_names
(Feel free to point it out to your lecturer!)

Now, references... consider this:

Code:

void foo(int & b) { b = 10; }
void bar(int b) { b = 10; }

int main()
{
    int a = 20;
    std::cout << a << std::endl;
    bar(a);
    std::cout << a << std::endl;
    foo(a);
    std::cout << a << std::endl;
}

In bar, the value of a will be copied, and so bar will work with its local copy of the contents of a (since the contents was copied over to bar's b). So no changes are reflected in main.
foo is a different store. The "int&" says it's a reference. What that means is that "b" in foo is another name for a in main. Thus, foo's b is main's a. Just with a different name. Hence, when changing it in foo, main's a will also change.
That is what a reference is. An alias.

Thank you, Elysia, for pointing this out.

Best regards
Jackson