Difference between revisions of "cpp/language/operator other"

Latest revision as of 02:13, 8 August 2024

The function call operator provides function semantics for any object.

The conditional operator (colloquially referred to as ternary conditional ) checks the boolean value of the first expression and, depending on the resulting value, evaluates and returns either the second or the third expression.

[edit] Built-in function call operator

Function call expressions have the following form:

For a call to a non-member function or to a static member function, function can be an lvalue that refers to a function (in which case the function-to-pointer conversion is suppressed), or a prvalue of function pointer type.

The function (or member) name specified by function can be overloaded, overload resolution rules used to decide which overload is to be called.

If function specifies a member function, it may be virtual, in which case the final overrider of that function will be called, using dynamic dispatch at runtime.

To call the function,

Each function parameter is initialized with its corresponding argument after implicit conversion if necessary.

• If there is no corresponding argument, the corresponding default argument is used, and if there is none, the program is ill-formed.
• If the call is made to a member function, then the this pointer to current object is converted as if by explicit cast to the this pointer expected by the function.
• The initialization and destruction of each parameter occurs in the context of the full-expression where the function call appears, which means, for example, that if a constructor or destructor of a parameter throws an exception, the function try blocks of the called function are not considered.

If the function is a variadic function, default argument promotions are applied to all arguments matched by the ellipsis parameter.

It is implementation-defined whether a parameter is destroyed when the function in which it is defined exits or at the end of the enclosing full-expression. Parameters are always destroyed in the reverse order of their construction.

The return type of a function call expression is the return type of the chosen function, decided using static binding (ignoring the virtual keyword), even if the overriding function that is actually called returns a different type. This allows the overriding functions to return pointers or references to classes that are derived from the return type returned by the base function, i.e. C++ supports covariant return types. If function specifies a destructor, the return type is void.

The value category of a function call expression is lvalue if the function returns an lvalue reference or an rvalue reference to function, is an xvalue if the function returns an rvalue reference to object, and is a prvalue otherwise. If the function call expression is a prvalue of object type, it must have complete type except when the prvalue is not materialized, such as(since C++17) when used as the operand of decltype (or as the right operand of a built-in comma operator that is the operand of decltype).

Function call expression is similar in syntax to value initialization T(), to function-style cast expression T(A1), and to direct initialization of a temporary T(A1, A2, A3, ...), where T is the name of a type.

#include <cstdio>
 
struct S
{
    int f1(double d)
    {
        return printf("%f \n", d); // variable argument function call
    }
 
    int f2()
    {
        return f1(7); // member function call, same as this->f1()
                      // integer argument converted to double
    }
};
 
void f()
{
    puts("function called"); // function call
}
 
int main()
{
    f();    // function call
    S s;
    s.f2(); // member function call
}

function called
7.000000

[edit] Built-in comma operator

Comma expressions have the following form:

In a comma expression E1, E2, the expression E1 is evaluated, its result is discarded (although if it has class type, it won't be destroyed until the end of the containing full expression), and its side effects are completed before evaluation of the expression E2 begins (note that a user-defined operator, cannot guarantee sequencing)(until C++17).

The type, value, and value category of the result of the comma expression are exactly the type, value, and value category of the second operand, E2. If E2 is a temporary expression(since C++17), the result of the expression is that temporary expression(since C++17). If E2 is a bit-field, the result is a bit-field.

The comma in various comma-separated lists, such as function argument lists (f(a, b, c)) and initializer lists int a[] = {1, 2, 3}, is not the comma operator. If the comma operator needs to be used in such contexts, it has to be parenthesized: f(a, (n++, n + b), c).

#include <iostream>
 
int main()
{
    // comma is often used to execute more than one expression
    // where the language grammar allows only one expression:
 
    // * in the third component of the for loop
    for (int i = 0, j = 10; i <= j; ++i, --j)
    //            ^list separator      ^comma operator
        std::cout << "i = " << i << " j = " << j << '\n';
 
    // * in a return statement
    // return log("an error!"), -1;
 
    // * in an initializer expression
    // MyClass(const Arg& arg)
    // : member{ throws_if_bad(arg), arg }
 
    // etc.
 
    // comma operators can be chained; the result of the last
    // (rightmost) expression is the result of the whole chain:
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2 * n);
 
    // m is now 6
    std::cout << "m = " << (++m, m) << '\n';
}

i = 0 j = 10
i = 1 j = 9
i = 2 j = 8
i = 3 j = 7
i = 4 j = 6
i = 5 j = 5
n = 2
m = 7

[edit] Conditional operator

The conditional operator expressions have the form

The first operand of the conditional operator is evaluated and contextually converted to bool. After both the value evaluation and all side effects of the first operand are completed, if the result was true, the second operand is evaluated. If the result was false, the third operand is evaluated.

The type and value category of the conditional expression E1 ? E2 : E3 are determined according to the following rules:

• If either E2 or E3 has type void:

• If both E2 and E3 are of type void, the result is a prvalue of type void.
• Otherwise, if the operand of type void is a (possibly parenthesized) throw expression, the result has the type and the value category of the other expression. If the other expression is a bit-field, the result is a bit-field.^[1]
• Otherwise, the program is ill-formed.

2 + 2 == 4 ? throw 123 : throw 456;
 
std::string str = 2 + 2 == 4 ? "OK" : throw std::logic_error("2 + 2 != 4");

• Otherwise, if E2 or E3 are lvalue bit-fields(until C++11)glvalue bit-fields of the same value category(since C++11) and of types cv1 T and cv2 T, respectively, the operands are considered to be of type cv T for the remainder of this section, where cv is the union of cv1 and cv2.

• Otherwise, if E2 and E3 have different types, at least one of which is a (possibly cv-qualified) class type, or both are lvalues(until C++11)glvalues of the same value category(since C++11) and have the same type except for cv-qualification, then an attempt is made to form an implicit conversion sequence.^[2]

Attempts are made to form an implicit conversion sequence from an operand expression X of type TX to a target type related to the type TY of the operand expression Y as follows:

• If Y is an lvalue, the target type is TY&, but an implicit conversion sequence can only be formed if the reference would bind directly to an lvalue(until C++11)a glvalue(since C++11).

• If Y is an rvalue(until C++11)a prvalue(since C++11) or if none of the conversion sequences above can be formed, and at least one of TX and TY is a (possibly cv-qualified) class type:

• If TX and TY are the same class type (ignoring cv-qualification):

• If TY is at least as cv-qualified as TX, the target type is TY.
• Otherwise, no conversion sequence is formed.

• Otherwise, if TY is a base class of TX, the target type is TY with the cv-qualifiers of TX.
• Otherwise, the target type is the type of Z, where Z is the value of Y after applying the lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard conversions.

• Otherwise, no conversion sequence is formed.

Using this process, it is determined whether an implicit conversion sequence can be formed from E2 to the target type determined for the E3, and vice versa.

• If both sequences can be formed, or one can be formed but it is the ambiguous conversion sequence, the program is ill-formed.
• If no conversion sequence can be formed, the operands are left unchanged.
• Otherwise, if exactly one conversion sequence can be formed, that conversion is applied to the chosen operand and the converted operand is used in place of the original operand for the remaining process.

struct A {};
 
struct B : A {};
 
using T = const B;
 
A a = true ? A() : T(); // Y = A(), TY = A, X = T(), TX = const B, Target = const A

• If E2 and E3 are glvalues of the same type and the same value category, then the result has the same type and value category, and is a bit-field if at least one of E2 and E3 is a bit-field.

• Otherwise, the result is a prvalue.

• If E2 and E3 do not have the same type, and either has (possibly cv-qualified) class type, overload resolution is performed using the built-in candidates to attempt to convert the operands to built-in types.

• If the overload resolution fails, the program is ill-formed.
• Otherwise, the selected conversions are applied and the converted operands are used in place of the original operands for the remaining process.

• The lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied to (possibly-converted) E2 and E3. After those conversions, at least one of the following conditions must hold, otherwise the program is ill-formed:

• E2 and E3 have the same type. In this case, the result is a prvalue of that type designating a temporary object(until C++17)whose result object is(since C++17) copy-initialized from whatever operand was selected after evaluating E1.
• Both E2 and E3 have arithmetic or enumeration type. In this case, usual arithmetic conversions are applied to bring them to their common type, and the result is of that type.
• Both E2 and E3 are pointers, or one is a pointer and the other is a null pointer constant, then pointer conversions and qualification conversions are applied to bring them to their composite pointer type, and the result is of that type.
• If both E2 and E3 are pointers to members, or one is a pointer to member and the other is a null pointer constant, then pointer-to-member conversions and qualification conversions are applied to bring them to composite pointer type, and the result is of that type.

int* intPtr;
 
using Mixed = decltype(true ? nullptr : intPtr);
 
static_assert(std::is_same_v<Mixed, int*>); // nullptr becoming int*
 
struct A
{
    int* m_ptr;
} a;
 
int* A::* memPtr = &A::m_ptr; // memPtr is a pointer to member m_ptr of A
 
// memPtr makes nullptr as type of pointer to member m_ptr of A
static_assert(std::is_same_v<decltype(false ? memPtr : nullptr), int*A::*>);
 
// a.*memPtr is now just pointer to int and nullptr also becomes pointer to int
static_assert(std::is_same_v<decltype(false ? a.*memPtr : nullptr), int*>);

1. ↑ Such conditional operator was commonly used in C++11 constexpr programming prior to C++14.
2. ↑ Member access, whether a conversion function is deleted(since C++11) and whether an operand is a bit-field are ignored.

[edit] Overloads

For every pair of promoted arithmetic types L and R and for every type P, where P is a pointer, pointer-to-member, or scoped enumeration type, the following function signatures participate in overload resolution:

where LR is the result of usual arithmetic conversions performed on L and R.

The operator “?:” cannot be overloaded, these function signatures only exist for the purpose of overload resolution.

#include <iostream>
#include <string>
 
struct Node
{
    Node* next;
    int data;
 
    // deep-copying copy constructor
    Node(const Node& other)
        : next(other.next ? new Node(*other.next) : NULL)
        , data(other.data)
    {}
 
    Node(int d) : next(NULL), data(d) {}
 
    ~Node() { delete next; }
};
 
int main()
{   
    // simple rvalue example
    int n = 1 > 2 ? 10 : 11;  // 1 > 2 is false, so n = 11
 
    // simple lvalue example
    int m = 10; 
    (n == m ? n : m) = 7; // n == m is false, so m = 7
 
    //output the result
    std::cout << "n = " << n << "\nm = " << m;
}

n = 11
m = 7

[edit] Standard library

Many classes in the standard library overload operator() to be used as function objects.

The comma operator is not overloaded by any class in the standard library. The boost library uses operator, in boost.assign, boost.spirit, and other libraries. The database access library SOCI also overloads operator,.

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

1. ↑ For example, functions can be called in the initializer of a namespace-scope variable, there is no “calling function” in this context.

[edit] See also

Operator precedence
Operator overloading