In that context, the & makes the variable a reference.
Usually, when you pass an variable to a function, the variable is copied and the function works on the copy. When the function returns, your original variable is unchanged. When you pass a reference, no copy is made and changes made by the function show up even after the function returns.
C doesn't have references, but a C++ reference is functionally the same as a pointer in C. Really the only difference is that pointers have to be dereferenced when you use them:
*filename = "file.wav";
But references can be used as though they were the original variable:
filename = "file.wav";
Ostensibly, references are supposed to never be null, although it's not impossible for that to happen.
The equivalent C function would be:
void read_wav(const char* filename)
{
}
This is because C doesn't have string
. Usual practice in C is to send a pointer to an array of characters when you need a string. As in C++, if you type a string constant
read_wav("file.wav");
The type is const char*
.
The &
operator has three meanings in C++.
- "Bitwise AND", e.g.
2 & 1 == 3
- "Address-of", e.g.:
int x = 3; int* ptr = &x;
- Reference type modifier, e.g.
int x = 3; int& ref = x;
Here you have a reference type modifier. Your function class1 &class1::instance()
is a member function of type class1
called instance
, that returns a reference-to-class1
. You can see this more clearly if you write class1& class1::instance()
(which is equivalent to your compiler).
Best Answer
It's different.
the getNumberReference() returns a reference, under the hood it's like a pointer that points to an integer variable. Any change applyed to the reference applies to the returned variable.
The getNumberReference() is also a left-value, therefore it can be used like this: