Should I still return const objects in C++11? [duplicate]

by

Returning const objects is a workaround that might cause other problems. Since C++11, there is a better solution for the assignment issue: Reference Qualifiers for member functions. I try to explain it with some code:

int foo(); // function declaration
foo() = 42; // ERROR

The assignment in the second line results in a compile-time error for the builtin type int in both C and C++. Same for other builtin types. That’s because the assignment operator for builtin types requires a non-const lvalue-reference on the left hand side. To put it in code, the assignment operator might look as follows (invalid code):

int& operator=(int& lhs, const int& rhs);

It was always possible in C++ to restrict parameters to lvalue references. However, that wasn’t possible until C++11 for the implicit first parameter of member functions (*this).

That changed with C++11: Similar to const qualifiers for member functions, there are now reference qualifiers for member functions. The following code shows the usage on the copy and move operators (note the & after the parameter list):

struct Int
{
    Int(const Int& rhs) = default;
    Int(Int&& rhs) noexcept = default;
    ~Int() noexcept = default;
    auto operator=(const Int& rhs) & -> Int& = default;
    auto operator=(Int&& rhs) & noexcept -> Int& = default;
};

With this class declaration, the assignment expression in the following code fragment is invalid, whereas assigning to a local variable works – as it was in the first example.

Int bar();
Int baz();
bar() = baz(); // ERROR: no viable overloaded '='

So there is no need to return const objects. You can restrict the assigment operators to lvalue references, so that everything else still works as expected – in particular move operations.

See also:

More Related Contents:

  1. What’s the difference between constexpr and const?
  2. Does C++11 allow vector?
  3. What is the advantage of using forwarding references in range-based for loops?
  4. const vs constexpr on variables
  5. Does const mean thread-safe in C++11?
  6. Do rvalue references to const have any use?
  7. C++0x lambda capture by value always const?
  8. const& , & and && specifiers for member functions in C++
  9. How much is the overhead of smart pointers compared to normal pointers in C++?
  10. Why is std::unordered_map slow, and can I use it more effectively to alleviate that?
  11. Does a C++11 range-based for loop condition get evaluated every cycle?
  12. Do I really need to implement user-provided constructor for const objects?
  13. Can the use of C++11’s ‘auto’ improve performance?
  14. Is the ranged based for loop beneficial to performance?
  15. Isn’t the const modifier here unnecessary? [duplicate]
  16. c++11 regex slower than python
  17. constexpr vs. static const: Which one to prefer?
  18. constexpr const vs constexpr variables?
  19. Does auto deduce the type at compile time or runtime in C++ 11?
  20. Why is this C++ wrapper class not being inlined away?
  21. using extern template (C++11)
  22. Will std::string always be null-terminated in C++11?
  23. SFINAE working in return type but not as template parameter
  24. When to use the brace-enclosed initializer?
  25. Allow for Range-Based For with enum classes?
  26. A class name introduced inside a class is not treated as a nested class name
  27. constexpr not compiling in VC2013
  28. Understanding gsl::narrow implementation
  29. Why isn’t std::array::size static?
  30. non-const pointer argument to a const double pointer parameter

Leave a Comment