ampersand (&) at the end of variable etc

Question

I am a C++ noob and i've a problem of understanding c++ syntax in a code. Now I am quite confused.

class date
{
private:
int day, month, year;
int correct_date( void );
public:
void set_date( int d, int m, int y );
void actual( void );
void print( void );
void inc( void );
friend int date_ok( const date& );
};

Regarding to the '&' character, I understand its general usage as a reference, address and logical operator...

for example int *Y = &X

What is the meaning of an & operator at end of parameter?

friend int date_ok( const date& );

Thanks

edit:

Thanks for the answers. If I have understood this correctly, the variable name was simply omitted because it is just a prototype. For the prototype I don't need the variable name, it's optional. Is that correct?

However, for the definition of the function I definitely need the variable name, right?

It's a reference, which was in your list. Anyway, `&&` is the logical one. `&` is the bitwise one. — chris, Jan 01 '14 at 00:38
it is not at the end of a _variable_, it is at the end of a _type_ — behzad.nouri, Jan 01 '14 at 00:39
The declaration in question does not name the parameter. The name is completely omitted. The `const data` part is the type, meaning that `const data &` stands for a parameter of reference type. The parameter is left unnamed in this declaration. — AnT stands with Russia, Jan 01 '14 at 01:24
You can also rewrite that line as `friend int date_ok(const date &dateParam);` if you want. The formal parameter dateParam in the declaration is just for documentation purposes and does not affect the operation of the function — Brandin, Jan 01 '14 at 10:59

score 59 · Answer 1 · edited Dec 22 '18 at 07:08

59

const date& being accepted by the method date_ok means that date_ok takes a reference of type const date. It works similar to pointers, except that the syntax is slightly more .. sugary

in your example, int* Y = &x makes Y a pointer of type int * and then assigns it the address of x. And when I would like to change the value of "whatever it is at the address pointed by Y" I say *Y = 200;

so,

int x = 300;
int *Y = &x;
*Y = 200; // now x = 200
cout << x; // prints 200

Instead now I use a reference

int x = 300;
int& Y = x;
Y = 200; // now x = 200
cout << x; // prints 200

edited Dec 22 '18 at 07:08

Patrick Trentin

7,126
3
23
40

answered Jan 01 '14 at 00:39

Aniket Inge

25,375
5
50
78

6

A reference is similar to a pointer, but you should comment that a reference is not nullable and it should always "point" to something – Manu343726 Jan 01 '14 at 00:48
5

A reference is also not reseatable. – Joseph Mansfield Jan 01 '14 at 01:22
1

@Manu343726 the reference can point to something that itself points to null. So I can't add that as "not nullable" – Aniket Inge Sep 06 '15 at 19:11
2

This is so sick actually. Can I make a refference point to itself? What happens then? – Tomáš Zato Oct 27 '15 at 11:27
To call a method on : `int *Y`, we must do this, `Y->method()`, is that right? But to call a method on : `int& Y`, we can do this, `Y.method()`; is that right? – Nate Anderson Dec 12 '20 at 21:30
Thanks Aniket; it seems just like you said: syntax sugar. But a nice one :) Thanks – Nate Anderson Dec 14 '20 at 17:20

Lightness Races in Orbit · Answer 2 · 2015-10-27T11:47:57.677

In this context, & is not an operator. It is part of the type.

For any given type T, the type T& is a "reference to T".

The symbol & in fact has three meanings in C++, and it's important to recognise those different meanings.

"address of" when applied to an expression
"reference" when part of a type
"bitwise AND" when applied to two numbers

Similarly, * has at least three meanings, and once you've grasped those, you'll have pointers and references down. :-)

If I have understood this correctly, the variable name simply was omitted there because it is just the prototype. And for the prototype i don't need the variable name, it's optional. Is that correct?

Yes.

However, for the definition of the function I need definitely the variable name, right?

No. Although you'll usually want it (otherwise what's the point?!) there are some circumstances in which you don't, usually when you've only introduced the parameter to engage in overload-related trickery.

But speaking purely technically you can omit the argument name from the declaration and/or the definition as you wish.

I suppose ref-qualifiers are a fourth meaning, though that really counts as meaning #2 still... — Lightness Races in Orbit, Oct 26 '18 at 18:37

score 8 · Answer 3 · answered Jan 01 '14 at 00:48

So, for starters, I think you might be more confused in that the author of that code omitted something quite important (although optional): the variable name.

Let's rewrite that:

friend int date_ok( const date& check);

The type of the variable 'check' is const date&. We are passing it to the function as a 'constant reference'. In other words, it's an alias to whatever we passed in (via pointer magic), but we cannot modify it.

The reason that we do this is so that we can pass large objects (like a std::vector) into functions without making a copy of them. Pass by value incurs a copy operation. For an int, that doesn't matter (it takes next to no time), for a class, it might be more significant. The rule of thumb is to always pass objects by reference, and to pass them by const reference if you don't intend to modify them. (This rule of thumb ignores move semantics, but I'll assume you don't know about that yet).

score 1 · Answer 4 · answered Jan 01 '14 at 01:05

using & at the end of a type in a function prototype allows passing-by-reference, instead of passing-by-value (copy). This way you can modify the date object in the friend function.

friend int date_ok( const date& );

Friend: In your class definition this mean that you're telling that a function date_ok can access to all parameters of your class. In deed it means that it is almost a member of your class, so consider adding this friend function rather as a member function. (unless you have other good reasons, like not polluting your class with foreign definitions)

If yes, also consider making that a static function, it could have all the same access to the guts of your date object class. But that would be more natural.

cf. the book "101 C++ coding standard". Prefer defining static member functions, it favours loose coupling.

score 0 · Answer 5 · answered Jan 01 '14 at 13:25

Thanks for the answesers. If I have understood this correctly, the variable name simply was omitted there because it is just the prototype. And for the prototype i don't need the variable name, it's optional. Is that correct?

However, for the definition of the function I need definitely the variable name, right?

ampersand (&) at the end of variable etc

5 Answers5

Linked

Related