Short Answer:
It passes a reference to a vector object.

Long Answer:

The ''stuff'' inside the parenthesis is the variable that is passed to the function.

Say you have a function that squares a single number.
int Square(int NumberToSquare);

To use the parameters(stuff inside the parens) you''d simply refer to them like any other initialized variable.
int Square(int NumberToSquare)
{
int SquaredNumber = NumberToSquare * NumberToSquare;

return SquaredNumber;
}

So in this example, you pass an int(NumberToSquare), initialize a final variable to the passed variable multiplied by itself(bad practice, but easier to read), and then return the squared number.

The Ampersand(&) is telling the compiler that it''s passing a reference. When a variable is passed normally, it in effect copies the entire memory of that variable for use in the function, which slows down the program and eats up more memory than needed. A reference in short(and incomplete) terms, passes only the memory address of the variable, which for all intents and purposes, acts just like the variable it points to.

I''m a little bad at explaining things, so some real gurus might need to correct me here and there.

-This is where the world drops off
-ryan@lecherousjester.com

Okay. C/C++ functions have three basic parts.


return-type name(parameter list)


If you need to return a value, say you are multiplying two numbers together and with to return their value, you need to specify what data type the return value is. The name does just what is sounds like, it gives your function a name that you can call it by. The parameter list (the stuff in parenthesis) are the values you need passed into the function for it to work properly. Take my multiplication example for instance. In order to be able to multiply two numbers, you need to have two numbers passed in to multiply. Heres an example of call by value






The items between the curly brackets just tell what to do when the function is called. If you call MyFunction in your example, then anything between the brackets occurs. Nor for the & operator. Say your function here normalizes a vector. Just pretend the name is normalize. You don''t want to return a vector everytime maybe, and write it like this






The & operator is the address operator. Say your function prototype is written






It does not actually take the variable you pass into the function, it just copies the value of what you pass in, so your variable is unchanged. So rather than writing the example I had above where I set my variable equal to the return value when I call the function, I just call the address of my variable through my parameter list, so that myVariable in the parameter list is actually just an alias for you actual variable, and you actually do change the value of your variable in your function, thus you don''t need to return it. This is call by reference. Taking the normalization example from above, say my function prototype looked like this.






is the same thing now as the above example where I did






except I don''t need to worry about a return type. You should also look into pointers, but since you don''t yet grasp functions and references yet, the I recommend waiting a while longer before you look into pointers.

quote:Original post by _Danneman_
Great analogy, nobodynews - thanx Cleared the mist in my mind some more. Can only hope for a fogg-free tomorrow.

Passing a reference enables you to edit the original variable from your inside your function. Passing a pointer or a variable essentially just gives you a copy of a variable to play with locally inside your function. Great, I think I got it :D

Almost right. References and pointers BOTH allow you to edit the original variable passed, and passing by value (that''s the term for passing normally, neither by pointer nor reference) just gives you a copy to play with locally in the function.

Check out cplusplus.com or other C++ reference sites out there if you want a detailed explanation of the differences between pointers and references.

sorry to post here, i just hate to register in every f***** forum only for posting one message

Anyways, my question is about C++ Syntax too.

A class A should not have access to the private members of a class B, even if a member of A is an instance of B, right?

I mean, let A = Dog, and B = Cat, then this should not compile:

class Cat {

int age;

};

class Dog {

int age;

public:

void change() {
Cat B;
B.age = 3;
};

};

int
main() {

Dog A;
A.change();
return 0;

}

since age is a private member of cat. But let''s say you replace "Cat B" with "Dog B". Now, it compiles just fine (at least in gcc, don''t remember with Visual C++), even when A.try() is accesing a private member of B. Is this C++ standard behaviour? It seems really strange