Consider the following scenario:<\/p>\n
template<typename T>\r\nstruct Base\r\n{\r\n \/\/ Default-constructible\r\n Base() = default;\r\n\r\n \/\/ Not copy-constructible\r\n Base(Base const &) = delete;\r\n};\r\n\r\ntemplate<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n Derived() = default;\r\n Derived(Derived const& d) : Base<T><\/a>(d) {}\r\n};\r\n\r\n\/\/ This assertion passes?\r\nstatic_assert(\r\n std::is_copy_constructible_v<Derived<int>>);\r\n<\/pre>\nWhy does this assertion pass? It is plainly evident that you cannot copy a Derived<int><\/code> because doing so will try to copy the Base<int><\/code>, which is not copyable. Indeed, if you try to copy it, you get an error:<\/p>\nvoid example(Derived<int>& d)\r\n{\r\n Derived<int> d2(d);\r\n \/\/ msvc: error C2280: 'Base<T>::Base(const Base<T> &)':\r\n \/\/ attempting to reference a deleted function\r\n \/\/ gcc: error: use of deleted function 'Base<T>::Base(const Base<T>&)\r\n \/\/ [with T = int]'\r\n \/\/ clang: error: call to deleted constructor of 'Base<int>'\r\n}\r\n<\/pre>\nOkay, so the compiler thinks that Derived<int><\/code> is copy-constructible, but then when we try to do it, we find out that it isn’t!<\/p>\nWhat’s going on is that the compiler is determining copy-constructibility by checking whether the class has a non-deleted copy constructor. And in the case of Derived<T><\/code> it does haev a non-deleted copy constructor. You declared it yourself!<\/p>\n Derived(Derived const& d) : Base<T>(d) {}\r\n<\/pre>\nSo yes, there is a copy constructor. It can’t be instantiated, but the compiler doesn’t care. It is going based on what you tell it, and you told it that you can copy it.<\/p>\n
After all, another possibly copy constructor would have been<\/p>\n
Derived(Derived const& d) : Base<T>() {}\r\n<\/pre>\nand this one instantiates successfully. Copying a Derived<\/code> default-constructs the Base<\/code> base class rather than copy-constructing it.<\/p>\nImagine that we moved the definition out of line.<\/p>\n
template<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n Derived() = default;\r\n Derived(Derived const& d);\r\n};\r\n<\/pre>\nWhat should the answer to the question “Is this copy-constructible?” be? You don’t know what the definition is, only its declaration. Should the compiler halt compilation with the error message “Unable to predict the future”? But what if you didn’t want the expose the implementation of the copy constructor in the header file?<\/p>\n
The rule for determining copy constructibility is whether a non-deleted copy constructor is present. In the case of Derived<\/code>, it is present. It may not be instantiatable, but that’s not what is_Now, non-copyability inherits by default, so we could have just allowed the copy constructor to be defaulted:<\/p>\n
template<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n Derived() = default;\r\n Derived(Derived const& d) = default<\/span>;\r\n};\r\n<\/pre>\nThe implicitly-defined or explicitly-defaulted copy constructor is defined as deleted if any base class is not copy-constructible, in which case the declaration is treated as if it had said = delete<\/code>. That = delete<\/code> can be detected by is_But if you come out and make a custom copy constructor that is not deleted, the compiler assumes you will make good on your promise.<\/p>\n