What Does a Single Ampersand (&) Mean in C Member Function Parameters?

Exploring the Role of the Single Ampersand in Member Function Parameters

Within C programming, the syntax of member functions often includes the use of ampersand symbols (&) as ref-qualifiers for non-static member functions. These symbols can influence the behavior of the function call based on the value category of the object being used to invoke it. This article delves into the significance of using a single ampersand (&) in this context.

Specifically, the presence of a single ampersand & after the parameter list of a member function declaration implies that the function will be invoked when the object is an lvalue reference or a regular, non-reference object. This allows the function to be called directly using the object's name or via an lvalue reference. For instance:

class wrap {
  public:
    operator obj() const & { ... } // Invocable via lvalue reference
};

In contrast, the absence of any ref-qualifier, meaning no ampersand in the declaration, indicates that the function can be invoked regardless of the value category of the object. This means it can be called using either an lvalue or an rvalue reference.

To further understand the distinction, consider the following code snippet:

struct foo {
  void bar() {} // Function without a ref-qualifier
  void bar1() & {} // Function with an lvalue reference ref-qualifier
  void bar2() && {} // Function with an rvalue reference ref-qualifier
};

In this example:

• bar can be invoked using both lvalue and rvalue references.
• bar1 can only be invoked using lvalue references or regular objects (i.e., objects without any reference).
• bar2 can only be invoked using rvalue references.

To illustrate this behavior, the following code demonstrates how these functions can be called based on the value category of the object:

foo().bar(); // Always fine
foo().bar1(); // Doesn't compile because bar1 requires an lvalue
foo().bar2();

foo f;
f.bar(); // Always fine
f.bar1();
f.bar2(); // Doesn't compile because bar2 requires an rvalue

In summary, the presence of a single ampersand & after the parameter list of a member function declaration indicates that the function can be invoked when the object is an lvalue reference. This provides a means to restrict the invocation of the function based on the value category of the object being used.

The above is the detailed content of What Does a Single Ampersand (&) Mean in C Member Function Parameters?. For more information, please follow other related articles on the PHP Chinese website!