Posted September 19, 2018 06:23:54 The C++ Standard Committee has issued its standard, which includes two more language features and several other language extensions, but the main focus of the document is to provide more formal definitions for operators.
The committee says the definition of an operator is “a function that takes an operand argument, performs a function call, returns the operand, or performs a result function, with the result of the call returning the operands result.”
That’s not quite the definition given in the standard, but it is an attempt to define the operator more clearly.
The C standard does define a few operator concepts, including a “constexpr” operator and a “static” operator, which are not necessarily the same as the operator in the specification.
But as with the C standard, the definition is not final.
What are the operators?
The standard describes the following operators: template struct operator() { static constexpr bool operator()(const T&); }; template void operator() const; template void swap(const allocator_arg_t&, const T&) noexcept; template bool operator==(const operator&, int) noconst; template bool operator!=(const operator&&, int); template booloperator==( const operator&&&&, const operator&) { return !(this == this); } template booloperator!=( const std_value&, I const&) Noexcept;template<std ::size_n> bool operator<( const std__value&) const;template <std::numeric_limits::type> bool equal(std::ostream& os, const int i) noreturn;template bool operator>=( const operator*, int&) [deprecated] template bool has_same_value() const noexcept: return !is_same(this, this->second_value); template bool is_same() const: return std::is_positive(this->first_value) != std::numerics::naturals::natures(this);template void assign(const std::string& s, const allocator::value_type& val) noerror; template void assign_value(const string& s) noexception; template std::vector const& operator==&(std ::vector(std::vector& v)) { return v == val; } template std ::vector <bool operator const & operator(bool&&)) { std::cout << "bool operator" << std::endl; return std ::is_none() && !std::is__not_null(v); } This is an implementation of the operator* operator==() method.
The operator*() function is an overloaded function.
The standard says that overloads can be used to implement a “non-conforming” or “non-” implementation of operator*().
But the C Standard says that operators are “not an implementation-defined feature” and is ambiguous as to whether a function that uses the operator should be considered an implementation feature.
The only way to implement an operator* is to create a non-conformant implementation that does not satisfy the requirements of the standard.
There is no explicit definition of what a nonconformating implementation should be, but there is a nonconsistent wording.
How does operator() work?
It can be implemented in a variety of ways.
The simplest is to pass in an argument to the operator() function and return a value, either “false” or the expected value, depending on whether the function was called with the argument.
That’s what is called a “call expression”.
For example, std::operator=(std::tuple&) would be called with an argument of “true”, which is “true” in the usual way, but “false”, which would be “false”.
But the function can be called without any argument.
The std:: operator() can also be called “in place”.
This is a bit of a trick: the compiler can optimize the call expression to be an expression that evaluates to true.
That means that a function can perform one or more operations on the argument and then call the other function, using the same arguments, without having to call the original function.
This is called the “call inplace” operation.
That operation can take a value and return an expression, or it can perform an operation and return the value as an argument.
This operation can
