why am I able to copy one object into other object if the class has a const variable?

Question

As per cppreference documentation :

The implicitly-declared or defaulted copy constructor for class T is defined as deleted if any of the following conditions are true:

T has non-static data members that cannot be copied (have deleted, inaccessible, or ambiguous copy constructors);

I am using a const variable inside my Demo class, so I am expecting that obj1 should not copy into obj2 because we have a const variable, as shown in the below example:

#include <iostream>
using namespace std;

class Demo
{
public:
  const int val = 100;//nonstatic data member that cannot be copied
  Demo(){}    
};

int main()
{
    Demo obj1;
    Demo obj2(obj1);
    std::cout << "obj1.val :" << obj1.val << std::endl;
    std::cout << "obj2.val :" << obj2.val << std::endl;
    return 0;
}

Output:

obj1.val : 100
obj2.val : 100

Why is obj1 copied into obj2? As per cppreference doc:

"implicitly declared copy constructor deleted if you have nonstatic data member which cannot be copied"

ohh..i think we can copy but we cannot update..i understood...so could you tell me any datamember example that we cannot copy just to understand this point? — Mangy, Jan 21 '23 at 03:31
You might want to compare your quote to what cppreference.com says about [deleted copy assignment operators](https://en.cppreference.com/w/cpp/language/copy_assignment#Deleted_implicitly-declared_copy_assignment_operator) (const matters there). — JaMiT, Jan 21 '23 at 03:38
Objects can be copy-constructible and/or copy-assignable (just "copyable" is a bit ambiguous). Const data members remove the copy-assignment, but not the copy constructor. — HolyBlackCat, Jan 21 '23 at 05:19

Jason · Accepted Answer · 2023-01-21T04:40:49.473

why obj1 copied into obj2? as per cppreference doc "implicitly declared copy constructor deleted

Because the implicitly declared copy ctor Demo::Demo(const Demo&) is not actually deleted in the given code as the const data member val can be copied.

so could you tell me any datamember example that we cannot copy just to understand this point?

Here is a contrived example where the copy ctor Demo::Demo(const Demo&) is implicitly deleted as the const data member val cannot be copied.

class DeletedCopy
{
    public:
        DeletedCopy(const DeletedCopy&) = delete;//delete the copy ctor
        DeletedCopy() = default;
};
class Demo
{
public:
  const DeletedCopy val{};
  Demo(){}

};

int main()
{
    Demo obj1;
    Demo obj2(obj1);//this won't work now as copy ctor Demo::Demo(const Demo&) is implicitly deleted.
    return 0;
}

Demo

wohlstad · Answer 2 · 2023-01-21T05:35:37.817

1. Your initial question:

Why is obj1 copied into obj2

Because having a const member does not mean it cannot be copied. const just means that once the member is initialized it cannot be modified.

2. Your question in the comment:

could you tell me any datamember example that we cannot copy just to understand this point?

You'll need to add a member which is non-copyable in order to have the "implicitly declared copy constructor deleted".
An example is std::mutex:

The following code produces the error message below:

#include <mutex>

class Demo
{
public:
    std::mutex val;
};

int main()
{
    Demo obj1;
    Demo obj2(obj1);  // <---- error below on this line
    return 0;
}

Error message (MSVC):

error C2280: 'Demo::Demo(const Demo &)': attempting to reference a deleted function

A side note: better to avoid using namespace std - see here Why is "using namespace std;" considered bad practice?.

why am I able to copy one object into other object if the class has a const variable?

2 Answers2