Why am I not provided with a default copy constructor from a volatile?

by

The short answer is: Because the standard says you won’t.

The C++ Standard 12.8/9 (Draft N3242) tells:

The implicitly-declared copy constructor for a class X will have the form

  • X::X(const X&)

if

  • each direct or virtual base class B of X has a copy constructor whose first parameter is of type const
    B& or const volatile B&, and
  • for all the non-static data members of X that are of a class type M (or array thereof), each such class
    type has a copy constructor whose first parameter is of type const M& or const volatile M&. [Note: 119]

Otherwise, the implicitly-declared copy constructor will have the form

  • X::X(X&)

Note 119 says:

This implies that the reference parameter of the implicitly-declared copy constructor cannot bind to a volatile lvalue;
see C.1.9.

In C.1.9 you’ll find:

The implicitly-declared copy constructor and implicitly-declared copy assignment operator cannot make a
copy of a volatile lvalue. For example, the following is valid in ISO C:

struct X { int i; };
volatile struct X x1 = {0};
struct X x2(x1); // invalid C++
struct X x3;
x3 = x1; // also invalid C++

Rationale: Several alternatives were debated at length. Changing the parameter to volatile const X& would greatly complicate the generation of efficient code for class objects. Discussion of providing two alternative signatures for these implicitly-defined operations raised unanswered concerns about creating ambiguities and complicating the rules that specify the formation of these operators according to the bases and members.

More Related Contents:

  1. Is the copy constructor always called when returning by value in C++ [duplicate]
  2. What is the copy-and-swap idiom?
  3. Dynamically allocating an array of objects
  4. Why should the copy constructor accept its parameter by reference in C++?
  5. What is a converting constructor in C++ ? What is it for?
  6. Why copy constructor is not called in this case?
  7. Why does volatile exist?
  8. When do we have to use copy constructors?
  9. Volatile in C++11
  10. Why user-defined move-constructor disables the implicit copy-constructor?
  11. What kinds of optimizations does ‘volatile’ prevent in C++?
  12. Why is this code trying to call the copy constructor?
  13. Does the C++ volatile keyword introduce a memory fence?
  14. C++ template copy constructor on template class
  15. What’s the most reliable way to prohibit a copy constructor in C++?
  16. Can we return objects having a deleted/private copy/move constructor by value from a function?
  17. Disable copy constructor
  18. Why is the volatile qualifier used through out std::atomic?
  19. What’s the use of the private copy constructor in c++
  20. Why is copy constructor called instead of conversion constructor?
  21. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  22. Why C++ copy constructor must use const object?
  23. Why is the copy constructor called when we pass an object as an argument by value to a method?
  24. Why is volatile deprecated in C++20?
  25. Why aren’t copy constructors “chained” like default constructors and destructors?
  26. C++ Copy constructor gets called instead of initializer_list
  27. C/C++: casting away volatile considered harmful?
  28. Is ‘volatile’ needed in this multi-threaded C++ code?
  29. C++ copy-construct construct-and-assign question
  30. Do non-static member variables in a C++ struct/class need to be marked as volatile to be treated as volatile in a member function?

Leave a Comment