because its copy assignment operator is implicitly deleted

cppreference.com

Copy assignment operator.

A copy assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T , T & , const T & , volatile T & , or const volatile T & . For a type to be CopyAssignable , it must have a public copy assignment operator.

[ edit ] Syntax

[ edit ] Explanation

• Typical declaration of a copy assignment operator when copy-and-swap idiom can be used.
• Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used (non-swappable type or degraded performance).
• Forcing a copy assignment operator to be generated by the compiler.
• Avoiding implicit copy assignment.

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

[ edit ] Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type ( struct , class , or union ), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T & T :: operator = ( const T & ) if all of the following is true:

• each direct base B of T has a copy assignment operator whose parameters are B or const B & or const volatile B & ;
• each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M & or const volatile M & .

Otherwise the implicitly-declared copy assignment operator is declared as T & T :: operator = ( T & ) . (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument.)

A class can have multiple copy assignment operators, e.g. both T & T :: operator = ( const T & ) and T & T :: operator = ( T ) . If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword default . (since C++11)

The implicitly-declared (or defaulted on its first declaration) copy assignment operator has an exception specification as described in dynamic exception specification (until C++17) exception specification (since C++17)

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

[ edit ] Deleted implicitly-declared copy assignment operator

A implicitly-declared copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a user-declared move constructor;
• T has a user-declared move assignment operator.

Otherwise, it is defined as defaulted.

A defaulted copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a non-static data member of non-class type (or array thereof) that is const ;
• T has a non-static data member of a reference type;
• T has a non-static data member or a direct or virtual base class that cannot be copy-assigned (overload resolution for the copy assignment fails, or selects a deleted or inaccessible function);
• T is a union-like class , and has a variant member whose corresponding assignment operator is non-trivial.

[ edit ] Trivial copy assignment operator

The copy assignment operator for class T is trivial if all of the following is true:

• it is not user-provided (meaning, it is implicitly-defined or defaulted) , , and if it is defaulted, its signature is the same as implicitly-defined (until C++14) ;
• T has no virtual member functions;
• T has no virtual base classes;
• the copy assignment operator selected for every direct base of T is trivial;
• the copy assignment operator selected for every non-static class type (or array of class type) member of T is trivial;

A trivial copy assignment operator makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially copy-assignable.

[ edit ] Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used . For union types, the implicitly-defined copy assignment copies the object representation (as by std::memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated (since C++11) if T has a user-declared destructor or user-declared copy constructor.

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either a prvalue such as a nameless temporary or an xvalue such as the result of std::move ), and selects the copy assignment if the argument is an lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined copy assignment operator (same applies to move assignment ).

See assignment operator overloading for additional detail on the expected behavior of a user-defined copy-assignment operator.

[ edit ] Example

[ edit ] defect reports.

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• Pages with unreviewed CWG DR marker
• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 9 January 2019, at 07:16.
• This page has been accessed 570,566 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Copy assignment operator

A copy assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T , T & , const T & , volatile T & , or const volatile T & . A type with a public copy assignment operator is CopyAssignable .

[ edit ] Syntax

[ edit ] Explanation

• Typical declaration of a copy assignment operator when copy-and-swap idiom can be used
• Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used
• Forcing a copy assignment operator to be generated by the compiler
• Avoiding implicit copy assignment

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

[ edit ] Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type ( struct , class , or union ), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T & T :: operator = ( const T & ) if all of the following is true:

• each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B &
• each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M &

Otherwise the implicitly-declared copy assignment operator is declared as T & T :: operator = ( T & ) . (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)

A class can have multiple copy assignment operators, e.g. both T & T :: operator = ( const T & ) and T & T :: operator = ( T ) . If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword default .

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

[ edit ] Deleted implicitly-declared copy assignment operator

The implicitly-declared or defaulted copy assignment operator for class T is defined as deleted in any of the following is true:

• T has a non-static data member that is const
• T has a non-static data member of a reference type.
• T has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy assignment operator)
• T has direct or virtual base class that cannot be copy-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
• T has a user-declared move constructor
• T has a user-declared move assignment operator

[ edit ] Trivial copy assignment operator

The implicitly-declared copy assignment operator for class T is trivial if all of the following is true:

• T has no virtual member functions
• T has no virtual base classes
• The copy assignment operator selected for every direct base of T is trivial
• The copy assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial

A trivial copy assignment operator makes a copy of the object representation as if by std:: memmove . All data types compatible with the C language (POD types) are trivially copy-assignable.

[ edit ] Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined copy assignment copies the object representation (as by std:: memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated (since C++11) if T has a user-declared destructor or user-declared copy constructor.

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std:: move ), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

[ edit ] Copy and swap

Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

T & T :: operator = ( T arg ) { // copy/move constructor is called to construct arg     swap ( arg ) ;     // resources exchanged between *this and arg     return * this ; }   // destructor is called to release the resources formerly held by *this

For non-throwing swap(), this form provides strong exception guarantee . For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as "unifying assignment operator" (as in, both copy and move).

[ edit ] Example

• Windows Programming
• UNIX/Linux Programming
• General C++ Programming
• Assignment operator implicitly deleted

  Assignment operator implicitly deleted

About Jonathan Boccara

Hello, my name is Jonathan Boccara, I'm your host on Fluent C++. I have been a developer for 10 years. My focus is on how to write expressive code . I wrote the book The Legacy Code Programmer's Toolbox . I'm happy to take your feedback, don't hesitate to drop a comment on a post, follow me or get in touch directly !

Jonathan Boccara's blog

Recent Posts

• Usage First, Implementation After: A Principle of Software Development
• Design Patterns VS Design Principles: Factory method
• How to Store an lvalue or an rvalue in the Same Object
• Copy-Paste Developments
• Design Patterns VS Design Principles: Abstract Factory
• How to Generate All the Combinations from Several Collections

How to Make a Copyable Object Assignable in C++

Some types in C++ have a copy constructor that doesn’t have the same semantics as their assignment operator ( operator= ).

Take references, for example. References can be copied:

But it doesn’t do the same thing as assigning to them:

With the copy, r2 points to the same thing as r1 , but with the assignment r2 still points to the same object it was pointing to before.

Or take the example of copying a lambda:

The above code compiles fine.

Now if we add the following line:

It doesn’t compile. As the compiler (clang) says:

Lambdas don’t even have an operator= to begin with (except in C++20 where they do if they don’t capture anything).

Right. But is any of this a problem?

Why we need operator=

After all, the behaviour of the references makes some sense, and why on earth would we like to assign on a lambda we’ve just created?

However, there is a case when the absence of operator= becomes a problem: when the object that doesn’t have an operator= is a member of a class. It makes it difficult for that class to have an operator= itself. For one thing, the compiler is not going to write it for you.

Even for references, the compiler won’t generate an operator= for a class if one of its members is a reference. It assumes that you’d better write it yourself to choose what to do with the reference member.

This problem came up in a project I’ve been working on, the pipes library . This library has classes that have lambdas as data members, and passes objects of those classes as output iterators of STL algorithms. And in Visual Studio, the STL in debug mode calls the operator= on output iterators in the _Recheck function. So the class that contains a lambda needs an operator= .

Haven’t you ever faced too the situation where the compiler couldn’t write the operator= you needed because of a problematic data member?

The standard has us covered for references

In C++11, and equivalently in Boost long before that, std::reference_wrapper<T>  has the same behaviour as a reference (you initialize it with a reference, and it even has a operator T& ) with one exception: it has an operator= that rebinds the reference.

This means that after calling operator= between two std::reference_wrapper s, they point to the same object:

The fact that std::reference_wrapper<T> has an operator= allows the compiler to generate an operator= for the classes that contains it. And the fact that it rebinds gives the operator= of the containing class a natural behaviour.

Why is this behaviour natural? Because it is consistent with the copy of the reference: in both case, the two reference(_wrapper)s point to the same object after the operation.

The general case

Even if the case of references is solved with std::reference_wrapper , the case of the lambda remains unsolved, along with all the types that have a copy constructor and no operator= .

Let’s design a component, inspired from std::reference_wrapper , that would add to any type an operator= which is consistent with its copy constructor.

If you have an idea on how to name this component, just leave a comment below at the bottom of the post. For the time being, let’s call it assignable .

assignable needs an operator= that relies on the copy constructor of its underlying type. Fortunately, we know how to implement that with a std::optional , like we saw in How to Implement operator= When a Data Member Is a Lambda :

But now that we’ve written the copy assignment operator, the compiler is going to refrain from generating the move constructor and the move assignment operator. It’s a shame, so let’s add them back:

Now that we’ve written all this, we might as well write the copy constructor too. The compiler would have generated it for us, but I think it looks odd to write everything except this one:

Finally, in order to hide from its users the fact that assignable contains an optional , let’s add constructors that accepts a T :

Giving access to the underlying value

Like optional , assignable wraps a type to add an extra feature, but its goal is not to mimic the interface of the underlying object. So we should give access to the underlying object of assignable . We will define a get()  member function, because  operator*  and operator->  could suggest that there is an indirection (like for pointers and iterators).

The underlying object of the  assignable happens to to be the underlying object of the optional inside of the assignable :

We don’t check for the nullity of the optional, because the interface of assignable is such that all the paths leading to those dereferencing operators guarantee that the optional has been initialized.

Which gives us food for thought: optional is not the optimal solution here. It contains a piece of information that we never use: whether the optional is null or not.

A better solution would be to create a component that does placement news like optional, but without the possibility to be null.

Lets keep this as food for thought for the moment. Maybe we’ll come back to it in a later article. Please leave a comment if you have thoughts on that.

Making the assignable callable

std::reference_wrapper has a little known feature that we explored in How to Pass a Polymorphic Object to an STL Algorithm : it has an operator() that calls its underlying reference when it’s callable.

This is all the more relevant for assignable since our motivating case was a lambda.

If we don’t implement operator() , we’d have to write code like this:

Whereas with an operator() , calling code becomes more natural, resembling the one of a lambda:

Let’s do it then!

We rely on C++14 decltype(auto) . Note that we could also implement this in C++11 the following way:

The case of assignable references

Now we have implemented an assignable<T> that works when T is a lambda.

But what if T is a reference?

It can happen in the case of a function reference. In that case, we need exactly the same features as the ones we needed with the lambda.

However, assignable<T> doesn’t even compile when T is a reference. Why? Because it uses an std::optional<T> and optional references didn’t make it in the C++ standard .

Luckily, implementing assignable for references is not difficult. In fact, it’s a problem already solved by… std::reference_wrapper !

So we need to create a specialization of assignable<T> when T is a reference. It would be great if we could just write this:

But this is not possible in C++.

Instead we have to implement a type that wraps std::reference_wrapper and relies on its behaviour:

This way, we can use assignable on reference types.

Putting it all together

In summary, here is all the code of assignable all put together:

And classes can use it as a data member this way:

For such as class, the compiler would be able to generate a operator= as long as Function has a copy constructor, which many classes–including lambdas–do.

Thanks to Eric Niebler for the inspiration, as assignable was inspired from techniques I’ve seen in range-v3 , which is my go-to model for library implementation.

If you have any piece of feedback on assignable , I’d love to hear it in a comment below!

You will also like

• How to Pass a Polymorphic Object to an STL Algorithm
• How to Implement operator= When a Data Member Is a Lambda
• An Alternative Design to Iterators and Ranges, Using std::optional
• Why Optional References Didn’t Make It In C++17
• Pointers, References and Optional References in C++
• Smart Output Iterators: A Symmetrical Approach to Range Adaptors

C++报错 error: copy assignment operator is implicitly deleted 拷贝赋值操作符被删除

前两天在用CLion写一段C++代码时编译报错，报错的位置很奇怪，是在 STL list 中的一个赋值语句处报错：

查看报错信息，发现原因不在于 STL list ，而在于一个自定义的类 PointPos ：

object of type 'PointPos' cannot be assigned because its copy operator is implicitly deleted PointPos类的对象不能被赋值，因为 拷贝操作符被隐式地删除了

因为我的代码里面使用了列表容器来放这个类的对象，类似 list<PointPos> 的用法，因此在列表的底层操作中可能会对该类的对象拷贝赋值，又不知道为什么操作符被删除了，所以赋值失败报错。

那么为什么赋值操作符（就是“=”）被隐式删除了呢？再仔细看下面的注释，发现了原因：

原来是 PointPos 类的一个成员变量被定义成了const常量：

因此编译器认为需要禁止使用拷贝赋值操作符，自动把它给删除了。

简单地把成员变量前的const关键字去掉，则编译不会再报错了，问题顺利解决。

• 人面猴 序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解... 沈念sama 阅读 187,931 评论 5 赞 452
• 死咒 序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都... 沈念sama 阅读 78,948 评论 2 赞 357
• 救了他两次的神仙让他今天三更去死 文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些... 开封第一讲书人 阅读 135,341 评论 0 赞 310
• 道士缉凶录：失踪的卖姜人 文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不... 开封第一讲书人 阅读 50,398 评论 1 赞 259
• 港岛之恋（遗憾婚礼） 正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我... 茶点故事 阅读 59,378 评论 4 赞 349
• 恶毒庶女顶嫁案：这布局不是一般人想出来的 文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一... 开封第一讲书人 阅读 44,711 评论 1 赞 263
• 城市分裂传说 那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决... 沈念sama 阅读 35,501 评论 3 赞 376
• 双鸳鸯连环套：你想象不到人心有多黑 文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我... 开封第一讲书人 阅读 34,045 评论 0 赞 243
• 万荣杀人案实录 序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经... 沈念sama 阅读 38,350 评论 1 赞 283
• 护林员之死 正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日... 茶点故事 阅读 33,639 评论 2 赞 299
• 白月光启示录 正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。... 茶点故事 阅读 35,371 评论 1 赞 315
• 活死人 序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带... 沈念sama 阅读 31,292 评论 3 赞 305
• 日本核电站爆炸内幕 正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境... 茶点故事 阅读 36,647 评论 3 赞 293
• 男人毒药：我在死后第九天来索命 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日... 开封第一讲书人 阅读 28,126 评论 0 赞 17
• 一桩弑父案，背后竟有这般阴谋 文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响... 开封第一讲书人 阅读 29,340 评论 1 赞 246
• 情欲美人皮 我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还... 沈念sama 阅读 40,303 评论 2 赞 334
• 代替公主和亲 正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚... 茶点故事 阅读 39,610 评论 2 赞 330

推荐阅读 更多精彩内容

• 《C++ Primer》读书笔记 前言 把《C++ Primer》[https://book.douban.com/subject/25708312... 尤汐Yogy 阅读 9,481 评论 1 赞 51
• C++ Primer第五版（3）——类设计者工具 3. 类设计者工具 3.1 拷贝控制 五种函数拷贝构造函数拷贝赋值运算符移动构造函数移动赋值运算符析构函数拷贝和移... 王侦 阅读 1,757 评论 0 赞 1
• C++运算符重载-下篇 C++运算符重载-下篇 本章内容：1. 运算符重载的概述2. 重载算术运算符3. 重载按位运算符和二元逻辑运算符4... Haley_2013 阅读 1,421 评论 0 赞 49
• 面试题 Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对... cosWriter 阅读 11,058 评论 1 赞 32
• 【通俗易懂C++ STL模板库】容器、算法、迭代器 容器 在实际的开发过程中， 数据结构本身的重要性不会逊于操作于数据结构的算法的重要性， 当程序中存在着对时间要求很... 编程小兔崽 阅读 1,052 评论 0 赞 1

Copy assignment operator

A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter (that isn't an explicit object parameter ) of type T , T& , const T& , volatile T& , or const volatile T& . For a type to be CopyAssignable , it must have a public copy assignment operator.

Explanation

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type ( struct , class , or union ), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T& T::operator=(const T&) if all of the following is true:

• each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B& ;
• each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M& .

Otherwise the implicitly-declared copy assignment operator is declared as T& T::operator=(T&) . (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument.).

A class can have multiple copy assignment operators, e.g. both T& T::operator=(T&) and T& T::operator=(T) . If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword default . (since C++11) .

The implicitly-declared (or defaulted on its first declaration) copy assignment operator has an exception specification as described in dynamic exception specification (until C++17) noexcept specification (since C++17) .

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

Deleted implicitly-declared copy assignment operator

An implicitly-declared copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a user-declared move constructor;
• T has a user-declared move assignment operator.

Otherwise, it is defined as defaulted.

A defaulted copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a non-static data member of a const-qualified non-class type (or array thereof);
• T has a non-static data member of a reference type;
• T has a non-static data member or a direct base class that cannot be copy-assigned (overload resolution for the copy assignment fails, or selects a deleted or inaccessible function);
• T is a union-like class , and has a variant member whose corresponding assignment operator is non-trivial.

Trivial copy assignment operator

The copy assignment operator for class T is trivial if all of the following is true:

• it is not user-provided (meaning, it is implicitly-defined or defaulted);
• T has no virtual member functions;
• T has no virtual base classes;
• the copy assignment operator selected for every direct base of T is trivial;
• the copy assignment operator selected for every non-static class type (or array of class type) member of T is trivial.

A trivial copy assignment operator makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially copy-assignable.

Eligible copy assignment operator

Triviality of eligible copy assignment operators determines whether the class is a trivially copyable type .

Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used or needed for constant evaluation (since C++14) . For union types, the implicitly-defined copy assignment copies the object representation (as by std::memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and copy assignment operator for class types.

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either a prvalue such as a nameless temporary or an xvalue such as the result of std::move ), and selects the copy assignment if the argument is an lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined copy assignment operator (same applies to move assignment ).

See assignment operator overloading for additional detail on the expected behavior of a user-defined copy-assignment operator.

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• converting constructor
• copy constructor
• copy elision
• default constructor
• aggregate initialization
• constant initialization
• copy initialization
• default initialization
• direct initialization
• initializer list
• list initialization
• reference initialization
• value initialization
• zero initialization
• move assignment
• move constructor

© cppreference.com Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0. https://en.cppreference.com/w/cpp/language/as_operator

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Explicitly Defaulted and Deleted Functions

• 8 contributors

In C++11, defaulted and deleted functions give you explicit control over whether the special member functions are automatically generated. Deleted functions also give you simple language to prevent problematic type promotions from occurring in arguments to functions of all types—special member functions, and normal member functions and nonmember functions—which would otherwise cause an unwanted function call.

Benefits of explicitly defaulted and deleted functions

In C++, the compiler automatically generates the default constructor, copy constructor, copy-assignment operator, and destructor for a type if it doesn't declare its own. These functions are known as the special member functions , and they're what make simple user-defined types in C++ behave like structures do in C. That is, you can create, copy, and destroy them without extra coding effort. C++11 brings move semantics to the language and adds the move constructor and move-assignment operator to the list of special member functions that the compiler can automatically generate.

This is convenient for simple types, but complex types often define one or more of the special member functions themselves, and this can prevent other special member functions from being automatically generated. In practice:

If any constructor is explicitly declared, then no default constructor is automatically generated.

If a virtual destructor is explicitly declared, then no default destructor is automatically generated.

If a move constructor or move-assignment operator is explicitly declared, then:

No copy constructor is automatically generated.

No copy-assignment operator is automatically generated.

If a copy constructor, copy-assignment operator, move constructor, move-assignment operator, or destructor is explicitly declared, then:

No move constructor is automatically generated.

No move-assignment operator is automatically generated.

Additionally, the C++11 standard specifies the following additional rules:

• If a copy constructor or destructor is explicitly declared, then automatic generation of the copy-assignment operator is deprecated.
• If a copy-assignment operator or destructor is explicitly declared, then automatic generation of the copy constructor is deprecated.

In both cases, Visual Studio continues to automatically generate the necessary functions implicitly, and doesn't emit a warning by default. Since Visual Studio 2022 version 17.7, C5267 can be enabled to emit a warning.

The consequences of these rules can also leak into object hierarchies. For example, if for any reason a base class fails to have a default constructor that's callable from a deriving class—that is, a public or protected constructor that takes no parameters—then a class that derives from it can't automatically generate its own default constructor.

These rules can complicate the implementation of what should be straight-forward, user-defined types and common C++ idioms—for example, making a user-defined type noncopyable by declaring the copy constructor and copy-assignment operator privately and not defining them.

Before C++11, this code snippet was the idiomatic form of noncopyable types. However, it has several problems:

The copy constructor has to be declared privately to hide it, but because it's declared at all, automatic generation of the default constructor is prevented. You have to explicitly define the default constructor if you want one, even if it does nothing.

Even if the explicitly defined default constructor does nothing, the compiler considers it to be nontrivial. It's less efficient than an automatically generated default constructor and prevents noncopyable from being a true POD type.

Even though the copy constructor and copy-assignment operator are hidden from outside code, the member functions and friends of noncopyable can still see and call them. If they're declared but not defined, calling them causes a linker error.

Although this is a commonly accepted idiom, the intent isn't clear unless you understand all of the rules for automatic generation of the special member functions.

In C++11, the noncopyable idiom can be implemented in a way that is more straightforward.

Notice how the problems with the pre-C++11 idiom are resolved:

Generation of the default constructor is still prevented by declaring the copy constructor, but you can bring it back by explicitly defaulting it.

Explicitly defaulted special member functions are still considered trivial, so there's no performance penalty, and noncopyable isn't prevented from being a true POD type.

The copy constructor and copy-assignment operator are public but deleted. It's a compile-time error to define or call a deleted function.

The intent is clear to anyone who understands =default and =delete . You don't have to understand the rules for automatic generation of special member functions.

Similar idioms exist for making user-defined types that are nonmovable, that can only be dynamically allocated, or that can't be dynamically allocated. Each of these idioms have pre-C++11 implementations that suffer similar problems, and that are similarly resolved in C++11 by implementing them in terms of defaulted and deleted special member functions.

Explicitly defaulted functions

You can default any of the special member functions—to explicitly state that the special member function uses the default implementation, to define the special member function with a nonpublic access qualifier, or to reinstate a special member function whose automatic generation was prevented by other circumstances.

You default a special member function by declaring it as in this example:

Notice that you can default a special member function outside the body of a class as long as it's inlinable.

Because of the performance benefits of trivial special member functions, we recommend that you prefer automatically generated special member functions over empty function bodies when you want the default behavior. You can do this either by explicitly defaulting the special member function, or by not declaring it (and also not declaring other special member functions that would prevent it from being automatically generated.)

Deleted functions

You can delete special member functions and normal member functions and nonmember functions to prevent them from being defined or called. Deleting of special member functions provides a cleaner way of preventing the compiler from generating special member functions that you don't want. The function must be deleted as it's declared; it can't be deleted afterwards in the way that a function can be declared and then later defaulted.

Deleting of normal member function or nonmember functions prevents problematic type promotions from causing an unintended function to be called. This works because deleted functions still participate in overload resolution and provide a better match than the function that could be called after the types are promoted. The function call resolves to the more-specific—but deleted—function and causes a compiler error.

Notice in the preceding sample that calling call_with_true_double_only by using a float argument would cause a compiler error, but calling call_with_true_double_only by using an int argument wouldn't; in the int case, the argument will be promoted from int to double and successfully call the double version of the function, even though that might not be what you intend. To ensure that any call to this function by using a non-double argument causes a compiler error, you can declare a template version of the deleted function.

Was this page helpful?

Additional resources

C++ copy assignment operator is implicitly deleted

写代码的时候操作class对象的时候老是出现 XXX::operator=(XXX&)...implicitly deleted 的报错，直译过来就是class XXX的copy assignment这个操作被 隐式删除 ，我们解决这个bug需要先了解C++class operator隐式删除的规则

首先给出copy assignment operator隐式删除的规则的定义

A implicitly-declared copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a user-declared move constructor;
• T has a user-declared move assignment operator.

Otherwise, it is defined as defaulted.

A defaulted copy assignment operator for class T is defined as deleted if any of the following is true:

• T has a non-static data member of non-class type (or array thereof) that is const;
• T has a non-static data member of a reference type;
• T has a non-static data member or a direct or virtual base class that cannot be copy-assigned (overload resolution for the copy assignment fails, or selects a deleted or inaccessible function);
• T is a union-like class, and has a variant member whose corresponding assignment operator is non-trivial.

如果下面任何一个条件为 真 ，则触发copy assignment operator的 隐式删除

• 类T 有 用户定义的移动构造
• 类T 有 用户定义的移动赋值操作

如果下面任何一个条件为 真 ，则将 默认 copy assignment operato定义为 delete

class T有一个数据成员是 非static 且为const的non-class type

class T有一个数据成员是 非静态 的 引用类型

class T有一个不能被copy-assigned的类型或者class T的基类不能被copy-assigned

class T是一个union类似的class，并且还有多个成员，这些成员对应的assignment operator是non-trivial的

就是union类型，在c++中union也有构造函数…

trivial和non-trivial之前在博客中写过，trivial指的是member function非常"straightforward"，没有任何的隐式init操作，比如class a有虚函数或者有一个基类，那么代表他的构造函数是non-trivial的，因为基类和虚函数在构造的时候有一个隐式init操作(虚表，虚指针等操作) 插个3题外话，如果我们的union中有成员，该成员有non-trivial constract function，那么这个union就会报错，因为non-trivial代表有隐式操作，而union是多个成员共用空间，当一个成员被初始化后别的成员都是invalid value，比如union里面有std::string和std::vector等这种带有non-trivial的class # include <iostream> # include <string> union test { test ( ) { } ~ test ( ) { } std :: string s ; int a ; } ; int main ( ) { test t ; t . s = "123456" ; } 上述代码会报错，但是我们还是用类似的功能怎么办？使用 std::variant ,比如 # include <iostream> # include <string> # include <variant> # include <vector> # include <unordered_map> int main ( ) { std :: variant < int , std :: string , std :: vector < int > , std :: unordered_map < int , std :: string >> data ; std :: unordered_map < int , std :: string > m ; m . insert ( std :: make_pair ( 1 , "aaaaa" ) ) ; data = m ; std :: cout << std :: get < std :: unordered_map < int , std :: string >> ( data ) [ 1 ] << std :: endl ; }

请填写红包祝福语或标题

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Copy assignment operator is getting deleted while using std::Map #804

bhupeshpant19jan commented Oct 2, 2018 • edited Loading

pirama-arumuga-nainar commented Oct 2, 2018

Sorry, something went wrong.

pirama-arumuga-nainar commented Oct 3, 2018

bhupeshpant19jan commented Oct 4, 2018 • edited Loading

bhupeshpant19jan commented Oct 4, 2018

pirama-arumuga-nainar commented Oct 4, 2018

No branches or pull requests

• C++ Data Types
• C++ Input/Output
• C++ Pointers
• C++ Interview Questions
• C++ Programs
• C++ Cheatsheet
• C++ Projects
• C++ Exception Handling
• C++ Memory Management

Copy Constructor vs Assignment Operator in C++

Copy constructor and Assignment operator are similar as they are both used to initialize one object using another object. But, there are some basic differences between them:

Consider the following C++ program. 

Explanation: Here, t2 = t1;  calls the assignment operator , same as t2.operator=(t1); and   Test t3 = t1;  calls the copy constructor , same as Test t3(t1);

Must Read: When is a Copy Constructor Called in C++?

Please Login to comment...

Similar reads, improve your coding skills with practice.

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Why Assignment Operator implicitly deleted for const-members in c++? [duplicate]

This is not a duplicate of the question attached to the close request..

I have a class with a const-qualified field. I'm trying to assign it to a data structure that already has a value in the place I'm assigning. But because my class has a const-qualified field , my compiler is not allowing me to do so.

Depending on the compiler, I either get:

Which are basically the same thing.

Minimal Viable Example:

This doesn't make sense to me... why can't it implicitly copy over a const value?

Who cares if it's const, just make a copy of the damn short!

I've tried std::move and so many other things

I don't want to implement a copy assignment operator and copy each member by hand because there's so many fields and a dynamic array in my actual code that I know I'll mess something up if I try to implement it.

I just want to put an A into my vector...

1 - How do I fix this? I want any quick hack that works and doesn't require implementing a copy assignment operator. I don't care about the element already in the container. I just want to move the data from the temporary stack into the vector (to use elsewhere)

2 - If you have the time, I'd love an explanation as to why this makes sense...

• compiler-errors
• copy-assignment

• 1 The assignment operator= is deleted because by default it just copies/assigns to each data member of the class. But since a const variable cannot be assigned to, there is no poing in having an assignment operator(which was supposed to do the assignment). –  user12002570 Commented Mar 25, 2023 at 7:10
• 1 I don't care about the element already in the container -- Forgetting about the const aspect of this, the purpose of an assignment operator is one thing and one thing only -- to assign one object to another., nothing more, nothing less. As soon as you put "business logic" into the assignment operator, you risk creating copies that are not actually copies. This opens you up for one of the hardest bugs to track down, and that is one where objects that are supposed to be equal are not equal. Remember that the compiler will also call the assignment operator, not just by you explicitly. –  PaulMcKenzie Commented Mar 25, 2023 at 7:17
• 2 As a rule of thumb - avoid const modifier for member variables, as their constness should be managed by the constness of the owning object –  The Dreams Wind Commented Mar 25, 2023 at 7:18
• If you need to do a "weird" assignment, write an assign() function. Do not use operator= for this. Again, using the fundamental assignment operator to have logic that will produce side-effects will end in tears. Also, your example doesn't even need vector: A a(2); A anotherA(3); a = anotherA; –  PaulMcKenzie Commented Mar 25, 2023 at 7:18

2 Answers 2

You can't do assignment here. You've specified that size is const , which means you can initialize it, but you can't assign to it.

One (kind of ugly) workaround would be to destroy the existing object, then use placement new to create a new object with the new value in the same location.

• I like this answer. But one question: your new call here introduces a memory leak right? or does the vector container manage the newly allocated memory in its destructor? –  Joe Commented Mar 25, 2023 at 7:24
• 2 @JoeVictor: No, a placement new doesn't allocating any memory--it just constructs an object in the specified location. –  Jerry Coffin Commented Mar 25, 2023 at 7:25
• Amazing. I learned something new and I solved my problem. Thanks! –  Joe Commented Mar 25, 2023 at 7:27
• 2 In C++20 we have std::construct_at which is a slightly more obvious way of doing the same thing. There is also std::destroy_at from C++17. –  john Commented Mar 25, 2023 at 7:39
• awesome. thanks, will need to look into upgrading from C++14 then! –  Joe Commented Mar 25, 2023 at 9:45

The assignment operator= is deleted because by default it just assigns to each member of the class. But since a const variable cannot be assigned to, there is no point in having the implicit assignment operator. This goes for both copy assignment as well as move assignment.

• How do I tell the compiler to: "move all the contents of the temp variable to a_vec[0] "? –  Joe Commented Mar 25, 2023 at 7:12
• 1 @JoeVictor You can't! As the move assignment operator can also not be used here. Trying to change a const variable is undefined behavior . Just don't try to change a const variable. –  user12002570 Commented Mar 25, 2023 at 7:14

Not the answer you're looking for? Browse other questions tagged c++ compiler-errors copy-assignment or ask your own question .

• The Overflow Blog
• Ryan Dahl explains why Deno had to evolve with version 2.0
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Feedback requested: How do you use tag hover descriptions for curating and do...
• What does a new user need in a homepage experience on Stack Overflow?

Hot Network Questions

• What to do if sample size obtained is much larger than indicated in the power analysis?
• How to remove a file named "."?
• Seven different digits are placed in a row. The products of the first 3, middle 3 and last 3 are all equal. What is the middle digit?
• Should I be worried about this giant crack?
• What is the rationale behind requiring ATC to retire at age 56?
• Population impacts on temperature
• What prevents applications from misusing private keys?
• Is plausibility more fundamental than probability?
• Which BASIC dialect first featured a single-character comment introducer?
• Is there a good explanation for the existence of the C19 globular cluster with its very low metallicity?
• Reference of "she"
• Did polls adjust their methodology after overestimating Democrat's shares in the 2016 and 2020 presidential elections in the Rust Belt?
• Homotopy groups of the space of diffeomorphisms
• Did anyone ever ask Neil Armstrong whether he said "for man" or "for a man?"
• Do linguists have a noun for referring to pieces of commendatory language, as a sort of antonym of 'pejoratives'?
• Is sudoku only one puzzle?
• Why is Cohen's h useful to compare proportions when risk difference is so interpretable?
• Is "UN law" a thing?
• Is this misleading "convenience fee" legal?
• My first actual cryptic
• How many people could we get off of the planet in a month?
• What might cause these striations in this solder joint?
• How old were Phineas and Ferb? What year was it?
• LoginForm submission which sends sign in link to email and then sets value in localStorage