with copy assignment operator not allowed in anonymous aggregate

• Windows Programming
• UNIX/Linux Programming
• General C++ Programming
• std::string not working in anonymous uni

  std::string not working in anonymous union

Success! Subscription added.

Success! Subscription removed.

Sorry, you must verify to complete this action. Please click the verification link in your email. You may re-send via your profile .

• Intel Community
• Developer Software Forums
• Software Development Tools
• Intel® C++ Compiler

anonymous union with an anonymous struct

• Subscribe to RSS Feed
• Mark Topic as New
• Mark Topic as Read
• Float this Topic for Current User
• Printer Friendly Page

• Mark as New
• Report Inappropriate Content
• Optimization
• Parallel Computing
• Vectorization

View solution in original post

• All forum topics
• Previous topic

Link Copied

Community support is provided during standard business hours (Monday to Friday 7AM - 5PM PST). Other contact methods are available here .

Intel does not verify all solutions, including but not limited to any file transfers that may appear in this community. Accordingly, Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.

For more complete information about compiler optimizations, see our Optimization Notice .

• ©Intel Corporation
• Terms of Use
• *Trademarks
• Supply Chain Transparency

This browser is no longer supported.

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

Copy constructors and copy assignment operators (C++)

• 8 contributors

Starting in C++11, two kinds of assignment are supported in the language: copy assignment and move assignment . In this article "assignment" means copy assignment unless explicitly stated otherwise. For information about move assignment, see Move Constructors and Move Assignment Operators (C++) .

Both the assignment operation and the initialization operation cause objects to be copied.

Assignment : When one object's value is assigned to another object, the first object is copied to the second object. So, this code copies the value of b into a :

Initialization : Initialization occurs when you declare a new object, when you pass function arguments by value, or when you return by value from a function.

You can define the semantics of "copy" for objects of class type. For example, consider this code:

The preceding code could mean "copy the contents of FILE1.DAT to FILE2.DAT" or it could mean "ignore FILE2.DAT and make b a second handle to FILE1.DAT." You must attach appropriate copying semantics to each class, as follows:

Use an assignment operator operator= that returns a reference to the class type and takes one parameter that's passed by const reference—for example ClassName& operator=(const ClassName& x); .

Use the copy constructor.

If you don't declare a copy constructor, the compiler generates a member-wise copy constructor for you. Similarly, if you don't declare a copy assignment operator, the compiler generates a member-wise copy assignment operator for you. Declaring a copy constructor doesn't suppress the compiler-generated copy assignment operator, and vice-versa. If you implement either one, we recommend that you implement the other one, too. When you implement both, the meaning of the code is clear.

The copy constructor takes an argument of type ClassName& , where ClassName is the name of the class. For example:

Make the type of the copy constructor's argument const ClassName& whenever possible. This prevents the copy constructor from accidentally changing the copied object. It also lets you copy from const objects.

Compiler generated copy constructors

Compiler-generated copy constructors, like user-defined copy constructors, have a single argument of type "reference to class-name ." An exception is when all base classes and member classes have copy constructors declared as taking a single argument of type const class-name & . In such a case, the compiler-generated copy constructor's argument is also const .

When the argument type to the copy constructor isn't const , initialization by copying a const object generates an error. The reverse isn't true: If the argument is const , you can initialize by copying an object that's not const .

Compiler-generated assignment operators follow the same pattern for const . They take a single argument of type ClassName& unless the assignment operators in all base and member classes take arguments of type const ClassName& . In this case, the generated assignment operator for the class takes a const argument.

When virtual base classes are initialized by copy constructors, whether compiler-generated or user-defined, they're initialized only once: at the point when they are constructed.

The implications are similar to the copy constructor. When the argument type isn't const , assignment from a const object generates an error. The reverse isn't true: If a const value is assigned to a value that's not const , the assignment succeeds.

For more information about overloaded assignment operators, see Assignment .

Was this page helpful?

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

aggregate initialization

Initializes an aggregate from braced-init-list

[ edit ] Syntax

[ edit ] explanation.

Aggregate initialization is a form of list-initialization , which initializes aggregates

An aggregate is an object of the type that is one of the following

• class type (typically, struct or union ), that has
• no private or protected members
• no user-provided constructors
• no base classes
• no virtual member functions
• no brace-or-equal initializers for non-static members

The effects of aggregate initialization are:

• Each array element or non-static class member, in order of array subscript/appearance in the class definition, is copy-initialized from the corresponding clause of the initializer list.
• If the initializer clause is an expression, implicit conversions are allowed, except (since C++11) if they are narrowing (as in list-initialization ).
• If the initializer clause is a nested braced-init-list, the corresponding class member is itself an aggregate: aggregate initialization is recursive.
• If the object is an array of unknown size, and the supplied brace-enclosed initializer list has n clauses, the size of the array is n
• Static data members and anonymous bit-fields are skipped during aggregate initialization.
• If the number of initializer clauses exceeds the number of members to initialize, the program is ill-formed (compiler error)
• If the number of initializer clauses is less than the number of members, the remaining members are initialized by empty lists, which performs value-initialization . If a member of a reference type is one of these remaining members, the program is ill-formed (references cannot be value-initialized)
• If the aggregate initialization uses the form with the equal sign ( T a = { args.. } ), the braces around the nested initializer lists may be elided (omitted), in which case, as many initializer clauses as necessary are used to initialize every member or element of the corresponding subaggregate, and the subsequent initializer clauses are used to initialize the following members of the object. However, if the object has a sub-aggregate without any members (an empty struct, or a struct holding only static members), brace elision is not allowed, and an empty nested list {} must be used.
• When a union is initialized by aggregate initialization, only its first non-static data members is initialized.

[ edit ] Notes

Until C++11, narrowing conversions were permitted in aggregate initialization, but they are no longer allowed.

Until C++11, aggregate initialization could not be used in a constructor initializer list due to syntax restrictions.

[ edit ] Example

[ edit ] see also.

• list initialization

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

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

GCC compiling. Member with constructor not allowed in anonymous aggregate. #156

lewa-j commented Mar 31, 2019

JulioJerez commented Apr 4, 2019

Sorry, something went wrong.

lewa-j commented Apr 4, 2019

No branches or pull requests

cppreference.com

Union declaration.

A union is a special class type that can hold only one of its non-static data members at a time.

[ edit ] Syntax

The class specifier for a union declaration is similar to class or struct declaration:

A union can have member functions (including constructors and destructors), but not virtual functions.

A union cannot have base classes and cannot be used as a base class.

A union cannot have non-static data members of reference types.

Just like in struct declaration, the default member access in a union is public .

[ edit ] Explanation

The union is at least as big as necessary to hold its largest data member, but is usually not larger. The other data members are intended to be allocated in the same bytes as part of that largest member. The details of that allocation are implementation-defined, except that all non-static data members have the same address. It is undefined behavior to read from the member of the union that wasn't most recently written. Many compilers implement, as a non-standard language extension, the ability to read inactive members of a union.

Possible output:

Each member is allocated as if it is the only member of the class.

If two union members are standard-layout types, it's well-defined to examine their common subsequence on any compiler.

[ edit ] Member lifetime

The lifetime of a union member begins when the member is made active. If another member was active previously, its lifetime ends.

When active member of a union is switched by an assignment expression of the form E1 = E2 that uses either the built-in assignment operator or a trivial assignment operator, for each union member X that appears in the member access and array subscript subexpressions of E1 that is not a class with non-trivial or deleted default constructors, if modification of X would have undefined behavior under type aliasing rules, an object of the type of X is implicitly created in the nominated storage; no initialization is performed and the beginning of its lifetime is sequenced after the value computation of the left and right operands and before the assignment.

Trivial move constructor, move assignment operator, (since C++11) copy constructor and copy assignment operator of union types copy object representations. If the source and the destination are not the same object, these special member functions start lifetime of every object (except for objects that are neither subobjects of the destination nor of implicit-lifetime type ) nested in the destination corresponding to the one nested in the source before the copy is performed. Otherwise, they do nothing. Two union objects have the same corresponding active member (if any) after construction or assignment via trivial special functions.

[ edit ] Anonymous unions

An anonymous union is an unnamed union definition that does not simultaneously define any variables (including objects of the union type, references, or pointers to the union).

Anonymous unions have further restrictions: they cannot have member functions, cannot have static data members, and all their data members must be public. The only declarations allowed are non-static data members and static_assert declarations (since C++11) .

Members of an anonymous union are injected in the enclosing scope (and must not conflict with other names declared there).

Namespace-scope anonymous unions must be declared static unless they appear in an unnamed namespace.

[ edit ] Union-like classes

A union-like class is either a union, or a (non-union) class that has at least one anonymous union as a member. A union-like class has a set of variant members :

• the non-static data members of its member anonymous unions;
• in addition, if the union-like class is a union, its non-static data members that are not anonymous unions.

Union-like classes can be used to implement tagged union .

[ edit ] Defect reports

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

[ edit ] See also

• 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 26 November 2023, at 23:36.
• This page has been accessed 1,172,514 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Re: [C++ PATCH] Fix implicit assignment operators with anonymous aggregates

• To : Jason Merrill <jason at redhat dot com>
• Subject : Re: [C++ PATCH] Fix implicit assignment operators with anonymous aggregates
• From : Jakub Jelinek <jakub at redhat dot com>
• Date : Wed, 21 Mar 2001 10:33:48 -0500
• Cc : mark at codesourcery dot com, gcc-patches at gcc dot gnu dot org
• References : < [email protected] > < [email protected] >
• Reply-To : Jakub Jelinek <jakub at redhat dot com>
• From: Jason Merrill
• From: Jakub Jelinek