struct assignment cpp

C++ Tutorial

C++ functions, c++ classes, c++ data s tructures, c++ reference, c++ examples, c++ structures (struct), c++ structures.

Structures (also called structs) are a way to group several related variables into one place. Each variable in the structure is known as a member of the structure.

Unlike an array , a structure can contain many different data types (int, string, bool, etc.).

Create a Structure

To create a structure, use the struct keyword and declare each of its members inside curly braces.

After the declaration, specify the name of the structure variable ( myStructure in the example below):

Access Structure Members

To access members of a structure, use the dot syntax ( . ):

Assign data to members of a structure and print it:

One Structure in Multiple Variables

You can use a comma ( , ) to use one structure in many variables:

This example shows how to use a structure in two different variables:

Use one structure to represent two cars:

Named Structures

By giving a name to the structure, you can treat it as a data type. This means that you can create variables with this structure anywhere in the program at any time.

To create a named structure, put the name of the structure right after the struct keyword:

To declare a variable that uses the structure, use the name of the structure as the data type of the variable:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Learn C++ practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c++ interactively, introduction to c++.

• Getting Started With C++
• Your First C++ Program
• C++ Comments

C++ Fundamentals

• C++ Keywords and Identifiers
• C++ Variables, Literals and Constants
• C++ Data Types
• C++ Type Modifiers
• C++ Constants
• C++ Basic Input/Output
• C++ Operators

Flow Control

• C++ Relational and Logical Operators
• C++ if, if...else and Nested if...else
• C++ for Loop
• C++ while and do...while Loop
• C++ break Statement
• C++ continue Statement
• C++ goto Statement
• C++ switch..case Statement
• C++ Ternary Operator
• C++ Functions
• C++ Programming Default Arguments
• C++ Function Overloading
• C++ Inline Functions
• C++ Recursion

Arrays and Strings

• C++ Array to Function
• C++ Multidimensional Arrays
• C++ String Class

Pointers and References

• C++ Pointers
• C++ Pointers and Arrays
• C++ References: Using Pointers
• C++ Call by Reference: Using pointers
• C++ Memory Management: new and delete

Structures and Enumerations

C++ structures.

C++ Structure and Function

C++ Pointers to Structure

• C++ Enumeration

Object Oriented Programming

• C++ Classes and Objects
• C++ Constructors
• C++ Constructor Overloading
• C++ Destructors
• C++ Access Modifiers
• C++ Encapsulation
• C++ friend Function and friend Classes

Inheritance & Polymorphism

• C++ Inheritance
• C++ Public, Protected and Private Inheritance
• C++ Multiple, Multilevel and Hierarchical Inheritance
• C++ Function Overriding
• C++ Virtual Functions
• C++ Abstract Class and Pure Virtual Function

STL - Vector, Queue & Stack

• C++ Standard Template Library
• C++ STL Containers
• C++ std::array
• C++ Vectors
• C++ Forward List
• C++ Priority Queue

STL - Map & Set

• C++ Multimap
• C++ Multiset
• C++ Unordered Map
• C++ Unordered Set
• C++ Unordered Multiset
• C++ Unordered Multimap

STL - Iterators & Algorithms

• C++ Iterators
• C++ Algorithm
• C++ Functor

Additional Topics

• C++ Exceptions Handling
• C++ File Handling
• C++ Ranged for Loop
• C++ Nested Loop
• C++ Function Template
• C++ Class Templates
• C++ Type Conversion
• C++ Type Conversion Operators
• C++ Operator Overloading

Advanced Topics

• C++ Namespaces
• C++ Preprocessors and Macros
• C++ Storage Class
• C++ Bitwise Operators
• C++ Buffers
• C++ istream
• C++ ostream

C++ Tutorials

• Store Information of a Student in a Structure
• Store and Display Information Using Structure
• Add Two Distances (in inch-feet) System Using Structures

A structure is a collection of variables of different data types and member functions under a single name.

It is similar to a class as both hold a collection of data of different data types.

Suppose you want to store some information about a person: their first_name , last_name , age , and salary .

You can easily create different variables— first_name , last_name , age , salary —to store this information separately.

However, in the future, you might want to store information about multiple people.

Now, you'd need to create different variables for each information per person: first_name1 , last_name1 , age1 , salary1 , first_name2 , last_name2 , age2 , salary2 , …

You can visualize how big and messy the code would look. Additionally, as there is no relation between the variables (information), it would be a daunting task to manage.

A better approach is to have a collection of all related information under a single name, such as Person and use it for every individual.

Now, the code looks much cleaner, more readable, and efficient as well.

This collection of all related information under a single name Person is a structure.

• How to Declare a Structure in C++ Programming?

The struct keyword defines a structure type followed by an identifier (name of the structure).

Then, inside the curly braces, you can declare one or more members (declare variables inside curly braces) of that structure. For example:

Here, the structure Person is defined which has four members: first_name, last_name , age , and salary .

When a structure is defined, no memory is allocated.

The structure definition is only the blueprint for the creation of variables. You can imagine it as a data type.

When you define an integer as below:

The int specifies that variable foo can hold integer elements only. Similarly, structure definition only specifies what property a structure variable holds when it is defined.

Note: Remember to end the declaration with a semicolon (;) .

• How to Define a Structure Variable?

Once you declare a structure Person as above, you can define a structure variable as:

Here, a structure variable bill is defined, which is of type structure Person .

Only when the structure variable is declared is the required memory allocated by the compiler.

• How to Access Members of a Structure?

The members of a structure variable are accessed using a dot (.) operator .

Suppose you want to access the age of the structure variable bill and assign 50 to it. You can perform this task by using the following code:

• Example: C++ Structure

Here the structure Person is declared which has four members: first_name , last_name , age and salary .

Inside the main() function , a structure variable p1 is defined. Then, the user is asked to enter information, and data entered by the user is displayed.

• Member Functions in C++ Structures

In C++, structures can also have member functions.

These member functions are similar to regular functions but are defined within the scope of a structure. They can access and manipulate the data members of the structure directly.

We can declare a member function by defining the function within the structure definition.

In this example, the Person structure includes a member function, displayInfo() which displays the information about the person.

Let's look at an example.

• How to pass structures to functions?
• How to use pointers with structures?

Table of Contents

• Introduction

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

C++ Tutorial

C++ Virtual Functions and Function Overriding

C++ std Namespace

This browser is no longer supported.

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

struct (C++)

• 8 contributors

The struct keyword defines a structure type and/or a variable of a structure type.

template-spec Optional template specifications. For more information, refer to Template Specifications .

struct The struct keyword.

ms-decl-spec Optional storage-class specification. For more information, refer to the __declspec keyword.

tag The type name given to the structure. The tag becomes a reserved word within the scope of the structure. The tag is optional. If omitted, an anonymous structure is defined. For more information, see Anonymous Class Types .

base-list Optional list of classes or structures this structure will derive its members from. See Base Classes for more information. Each base class or structure name can be preceded by an access specifier ( public , private , protected ) and the virtual keyword. See the member-access table in Controlling Access to Class Members for more information.

member-list List of structure members. Refer to Class Member Overview for more information. The only difference here is that struct is used in place of class .

declarators Declarator list specifying the names of the structure. Declarator lists declare one or more instances of the structure type. Declarators may include initializer lists if all data members of the structure are public . Initializer lists are common in structures because data members are public by default. See Overview of Declarators for more information.

A structure type is a user-defined composite type. It is composed of fields or members that can have different types.

In C++, a structure is the same as a class except that its members are public by default.

For information on managed classes and structs in C++/CLI, see Classes and Structs .

Using a Structure

In C, you must explicitly use the struct keyword to declare a structure. In C++, you do not need to use the struct keyword after the type has been defined.

You have the option of declaring variables when the structure type is defined by placing one or more comma-separated variable names between the closing brace and the semicolon.

Structure variables can be initialized. The initialization for each variable must be enclosed in braces.

For related information, see class , union , and enum .

Was this page helpful?

Additional resources

21.12 — Overloading the assignment operator

Announcing the Proxy 3 Library for Dynamic Polymorphism

Mingxin Wang

September 2nd, 2024 0 3

We are thrilled to announce that Proxy 3 , our latest and greatest solution for polymorphism in C++, is now feature complete ! Since the library was initially open-sourced , we have heard much positive feedback and received many brilliant feature requests. Big thanks to all of you who have contributed any code or idea that made the library better!

Our Mission

“Proxy” is a modern C++ library that helps you use polymorphism (a way to use different types of objects interchangeably) without needing inheritance.

“Proxy” was created by Microsoft engineers and has been used in the Windows operating system since 2022. For many years, using inheritance was the main way to achieve polymorphism in C++. However, new programming languages like Rust offer better ways to do this. We have improved our understanding of object-oriented programming and decided to use pointers in C++ as the foundation for “Proxy”. Specifically, the “Proxy” library is designed to be:

• Portable : “Proxy” was implemented as a single-header library in standard C++20. It can be used on any platform while the compiler supports C++20. The majority of the library is freestanding , making it feasible for embedded engineering or kernel design of an operating system.
• Non-intrusive : An implementation type is no longer required to inherit from an abstract binding.
• Well-managed : “Proxy” provides a GC -like capability that manages the lifetimes of different objects efficiently without the need for an actual garbage collector.
• Fast : With typical compiler optimizations, “Proxy” produces high-quality code that is as good as or better than hand-written code. In many cases, “Proxy” performs better than traditional inheritance-based approaches, especially in managing the lifetimes of objects.
• Accessible : Learned from user feedback, accessibility has been significantly improved in “Proxy 3” with intuitive syntax, good IDE compatibility, and accurate diagnostics.
• Flexible : Not only member functions, the “abstraction” of “Proxy” allows any expression to be polymorphic, including free functions, operators, conversions, etc. Different abstractions can be freely composed on demand. Performance tuning is supported for experts to balance between extensibility and performance.

The New Look

Comparing to our previous releases, there are some major improvements in the syntax and utilities. Let’s get started with some examples!

Hello World

Here is a step-by-step explanation:

• #include <iostream> : For std::cout .
• #include <string> : For std::string .
• #include "proxy.h" : For the “Proxy” library. Most of the facilities of the library are defined in namespace pro . If the library is consumed via vcpkg or conan , this line should be changed into #include <proxy/proxy.h> .
• pro::facade_builder : Provides capability to build a facade type at compile-time.
• add_convention : Adds a generalized “calling convention”, defined by a “dispatch” and several “overloads”, to the build context.
• pro::operator_dispatch<"<<", true> : Specifies a dispatch for operator << expressions where the primary operand ( proxy ) is on the right-hand side (specified by the second template parameter true ). Note that polymorphism in the “Proxy” library is defined by expressions rather than member functions, which is different from C++ virtual functions or other OOP languages.
• std::ostream&(std::ostream& out) const : The signature of the calling convention, similar with std::move_only_function . const specifies that the primary operand is const .
• build : Builds the context into a facade type.
• pro::proxy<Streamable> p1 = &str : Creates a proxy object from a raw pointer of std::string . p1 behaves like a raw pointer, and does not have ownership of the underlying std::string . If the lifetime of str ends before p1 , p1 becomes dangling.
• std::cout << *p1 : This is how it works. It prints “Hello World” because the calling convention is defined in the facade Streamable , so it works as if by calling std::cout << str .
• pro::proxy<Streamable> p2 = std::make_unique <int>(123) : Creates a std::unique_ptr <int> and converts to a proxy . Different from p1 , p2 has ownership of the underlying int because it is instantiated from a value of std::unique_ptr , and will call the destructor of std::unique_ptr when p2 is destroyed, while p1 does not have ownership of the underlying int because it is instantiated from a raw pointer. p1 and p2 are of the same type pro::proxy<Streamable> , which means you can have a function that returns pro::proxy<Streamable> without exposing any information about the implementation details to its caller.
• std::cout << *p2 : Prints “123” with no surprise.
• Similar with p2 , p3 also has ownership of the underlying double value, but can effectively avoid heap allocation.
• Since the size of the underlying type ( double ) is known to be small (on major 32- or 64-bit platforms), pro::make_proxy realizes the fact at compile-time and guarantees no heap allocation.
• Library “Proxy” explicitly defines when heap allocation occurs or not to avoid users falling into performance hell, which is different from std::function and other existing polymorphic wrappers in the standard.
• std::cout << *p3 : Prints “3.14” with no surprise.
• When main returns, p2 and p3 will destroy the underlying objects, while p1 does nothing because it holds a raw pointer that does not have ownership of the underlying std::string .

More Expressions

In addition to the operator expressions demonstrated in the previous example, the library supports almost all forms of expressions in C++ and can make them polymorphic. Specifically,

• The PRO_DEF_MEM_DISPATCH macro: Defines a dispatch type for member function call expressions.
• The PRO_DEF_FREE_DISPATCH macro: Defines a dispatch type for free function call expressions.
• The pro::operator_dispatch class template: Dispatch type for operator expressions.
• The pro::conversion_dispatch class template: Dispatch type for conversion expressions.

Note that some facilities are provided as macros, because C++ templates today do not support generating a function with an arbitrary name. Here is another example that makes member function call expressions polymorphic:

• #include <sstream> : For std::stringstream .
• #include "proxy.h" : For the “Proxy” library.
• PRO_DEF_MEM_DISPATCH(MemDraw, Draw) : Defines a dispatch type MemDraw for expressions of calling member function Draw .
• PRO_DEF_MEM_DISPATCH(MemArea, Area) : Defines a dispatch type MemArea for expressions of calling member function Area .
• add_convention : Adds calling conventions to the build context.
• support_copy<pro::constraint_level::nontrivial> : Specifies the underlying pointer type shall be copyable, which also makes the resulting proxy type copyable.
• class Rectangle : An implementation of Drawable .
• Function PrintDrawableToString : Converts a Drawable into a std::string . Note that this is a function rather than a function template, which means it can generate ABI in a larger build system.
• pro::proxy<Drawable> p = pro::make_proxy<Drawable, Rectangle>(3, 5) : Creates a proxy<Drawable> object containing a Rectangle .
• std::string str = PrintDrawableToString(p) : Converts p into a std::string , implicitly creates a copy of p .
• std::cout << str : Prints the string.

Other Useful Features

In addition to the features mentioned above, here is a curated list of the most popular features based on user feedback:

• Overloading : facade_builder::add_convention is more powerful than demonstrated above. It can take any number of overload types and perform standard overload resolution when invoking a proxy .
• Facade composition : facade_builder::add_facade allows flexible composition of different abstractions.
• Weak dispatch : When an object does not implement a convention, and we do not want it to trigger a hard compile error, it is allowed to define a “weak dispatch” with macro PRO_DEF_WEAK_DISPATCH from an existing dispatch type and a default implementation.
• Allocator awareness : Function template allocate_proxy is able to create a proxy from a value with any custom allocator. In C++11, std::function and std::packaged_task had constructors that accepted custom allocators for performance tuning, but these were removed in C++17 because “the semantics are unclear, and there are technical issues with storing an allocator in a type-erased context and then recovering that allocator later for any allocations needed during copy assignment”. These issues do not apply to allocate_proxy .
• Configurable constraints : facade_builder provides full support for constraints configuration, including memory layout (by restrict_layout ), copyability (by support_copy ), relocatability (by support_relocation ), and destructibility (by support_destruction ).
• Reflection : proxy supports type-based compile-time reflection for runtime queries, specifically with facade_builder::add_reflection and function template proxy_reflect .

We hope this library could empower more C++ users outside Microsoft to write polymorphic code easier. The full documentation of Proxy 3 will be published soon. Please stay tuned for more technical details. We are also actively working on several ISO C++ proposals for further standardization.

Mingxin Wang Senior Software Engineer, Windows Engineering

Leave a comment Cancel reply

Log in to start the discussion.

Insert/edit link

Enter the destination URL

Or link to existing content

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

C++ – Pointer to Structure

Pointer to structure in C++ can also be referred to as Structure Pointer. A structure Pointer in C++ is defined as the pointer which points to the address of the memory block that stores a structure . Below is an example of the same:

In the above code g is an instance of struct point and ptr is the struct pointer because it is storing the address of struct point. 

Please Login to comment...

Similar reads.

• How to Delete Discord Servers: Step by Step Guide
• Google increases YouTube Premium price in India: Check our the latest plans
• California Lawmakers Pass Bill to Limit AI Replicas
• Best 10 IPTV Service Providers in Germany
• 15 Most Important Aptitude Topics For Placements [2024]

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.

C++ Structure Initialization [duplicate]

Is it possible to initialize structs in C++ as indicated below:

The links here and here mention that it is possible to use this style only in C. If so why is this not possible in C++? Is there any underlying technical reason why it is not implemented in C++, or is it bad practice to use this style. I like using this way of initializing because my struct is big and this style gives me clear readability of what value is assigned to which member.

Please share with me if there are other ways through which we can achieve the same readability.

I have referred the following links before posting this question:

• C/C++ for AIX
• C Structure Initialization with Variable
• Static structure initialization with tags in C++
• C++11 Proper Structure Initialization
• initialization

• 24 Personal view of the world: you don't need this style of object initialization in C++ because you should be using a constructor instead. –  Philip Kendall Commented Jul 17, 2012 at 5:50
• 7 Yes I thought of that, but I have an array of big Structure. It would be easy and readable for me to use this way. Do you have any style/good practice of initializing using Constructor which gives better readability too. –  Dinesh P.R. Commented Jul 17, 2012 at 5:54
• 26 Not so programming related: this address works fine in the US only. In France, we don't have an "province", in other parts of the world, there is no postal code, a grand-mother of a friend lives in such a small village that her address is "Ms X, postal-code small-village-name" (yep, no street). So consider carefully what a valid address is to the market you will apply this to ;) –  Matthieu M. Commented Jul 17, 2012 at 7:03
• 6 @MatthieuM. There are no provinces in the US (this might be a Canadian format?), but there are states, territories, and even tiny villages that don't bother to name streets. So the issue of address conformance applies even here. –  Tim Commented Nov 3, 2013 at 23:18
• 7 Not yet it was purposefully left out of c++11. But this feature will be available in c++20. open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0329r0.pdf –  Jon Commented Oct 4, 2018 at 15:28

17 Answers 17

If you want to make it clear what each initializer value is, just split it up on multiple lines, with a comment on each:

• 12 I personally like and recommend this style –  Dinesh P.R. Commented Jul 17, 2012 at 6:22
• 94 What is the difference between doing that, and actually using dot notation to access MORE ACCURATELY the field itself, its not like you are saving any space if that's what the concern is. I really don't get C++ programmers when it comes to being consistent and writing maintainable code, they seem to always want to do something different to make their code stand out, the code is meant to reflect the problem being solved it shouldn't be an idiom on its own, aim for reliability and ease of maintenance. –  user1043000 Commented Apr 29, 2015 at 3:36
• 24 @user1043000 well, for one, in this case the order in which you put your members is of upmost importance. If you add a field in the middle of your structure, you will have to go back to this code and look for the exact spot in which to insert your new initialization, which is hard and boring. With the dot notation, you can simply put your new initialization at the end of the list without bothering with the order. And dot notation is way safer if you happen to add the same type (like char* ) as one of the other members above or below in the structure, because there's no risk of swapping them. –  Gui13 Commented Nov 16, 2016 at 9:21
• 11 orip's comment. If the data structure definition gets changed, and nobody thinks to look for the initializations, or can't find them all, or makes a mistake editing them, things will fall apart. –  Edward Falk Commented Jun 2, 2017 at 18:46
• 12 Most (if not all) POSIX structs don't have a defined order, only defined members. (struct timeval){ .seconds = 0, .microseconds = 100 } will always be a hundred microsecond, but timeval { 0, 100 } might be a hundred SECONDS . You don't want to find something like that out the hard way. –  yyny Commented Sep 14, 2018 at 18:54

After my question resulted in no satisfying result (because C++ doesn't implement tag-based init for structures), I took the trick I found here: Are members of a C++ struct initialized to 0 by default?

For you it would amount to do that:

This is certainly the closest to what you wanted originally (zero all the fields except those you want to initialize).

• 16 This does not work for statically inintialized objects –  user877329 Commented Apr 10, 2014 at 9:24
• 5 static address temp_address = {}; will work. Filling it up afterwards is up to the runtime, yes. You can bypass this by providing a static function that does the init for you: static address temp_address = init_my_temp_address(); . –  Gui13 Commented Apr 10, 2014 at 9:27
• 1 In C++11, init_my_temp_address can be a lambda function: static address temp_address = [] () { /* initialization code */ }(); –  dureuill Commented Sep 4, 2015 at 14:57
• 4 Bad idea, it violates the RAII principle. –  Galaxy Commented Nov 3, 2017 at 3:20
• 3 Really bad idea: add one member to your address and you'll never know of all the places that create an address and now do not initialize your new member. –  mystery_doctor Commented May 7, 2019 at 6:13

As others have mentioned this is designated initializer.

This feature is part of C++20

• 5 More information here : en.cppreference.com/w/cpp/language/aggregate_initialization –  user6547518 Commented Aug 26, 2021 at 8:55
• 1 No, it's from c++11 other than c++20！ –  John Commented Mar 24, 2022 at 3:01
• 3 @John not according to cppreference . –  Matthieu Commented Apr 13, 2022 at 15:05

The field identifiers are indeed C initializer syntax. In C++ just give the values in the correct order without the field names. Unfortunately this means you need to give them all (actually you can omit trailing zero-valued fields and the result will be the same):

• 1 Yes you can always use aligned struct initialization. –  SwiftMango Commented Jul 17, 2012 at 5:53
• 4 Yes, currently I am using this method only(Aligned Struct Initialization). But I feel the readability is not good. Since my Structure is big the initializer has so many data and it is difficult for me to track which value is assigned to which member. –  Dinesh P.R. Commented Jul 17, 2012 at 5:57
• 8 @DineshP.R. Then write a constructor! –  Mr Lister Commented Jul 17, 2012 at 5:59
• 5 @MrLister (or anyone) Perhaps I'm stuck in a cloud of stupidity at the moment, but care to explain how a constructor would be much better? Seems to me there's little difference between providing a bunch of order-dependent unnamed values to an initializer list or providing a bunch of order-dependent unnamed values to a constructor... ? –  yano Commented Apr 19, 2018 at 20:01
• 2 @yano To be honest, I don't really recall why I thought a constructor would be the answer to the problem. If I remember, I'll come back to you. –  Mr Lister Commented Apr 20, 2018 at 9:44

This feature is called designated initializers . It is an addition to the C99 standard. However, this feature was left out of the C++11. According to The C++ Programming Language, 4th edition, Section 44.3.3.2 (C Features Not Adopted by C++):

A few additions to C99 (compared with C89) were deliberately not adopted in C++: [1] Variable-length arrays (VLAs); use vector or some form of dynamic array [2] Designated initializers; use constructors

The C99 grammar has the designated initializers [See ISO/IEC 9899:2011, N1570 Committee Draft - April 12, 2011]

6.7.9 Initialization

On the other hand, the C++11 does not have the designated initializers [See ISO/IEC 14882:2011, N3690 Committee Draft - May 15, 2013]

8.5 Initializers

In order to achieve the same effect, use constructors or initializer lists:

• 1 Should be accepted answer as it actually addresses questions the OP asked. –  Paul Childs Commented May 15, 2023 at 22:11

I know this question is quite old, but I found another way of initializing, using constexpr and currying:

This method also works for global static variables and even constexpr ones. The only disadvantage is the bad maintainability: Everytime another member has to be made initializable using this method, all member initialization methods have to be changed.

• 3 This is the builder pattern . The member methods can return a reference to the property to be modified instead of creating a new struct every time –  phuclv Commented Aug 15, 2016 at 10:40
• @phuclv Actually, if @Fabian did that, they wouldn't be able to do more than one call as they did in the usage example. However, they could only change the value and return *this; as a reference instead if they don't use constexpr . That would result in the same usage pattern and avoid reconstructing a new object every time. –  sprite Commented Oct 21, 2021 at 9:20

I might be missing something here, by why not:

• 2 I compiled the above program with a MinGW C++ compiler, and an Arduino AVR C++ compiler, and both ran as expected. Notice the #include <cstdio> –  run_the_race Commented Sep 21, 2018 at 19:54
• 10 @run_the_race, this is about what the c++ standard says not what a given compiler's behavior may be. However, this feature is coming in c++20. –  Jon Commented Oct 4, 2018 at 15:28
• this only works if the struct is POD. So it will stop compiling if you add a constructor to it. –  ewrhuwaereww Commented Jun 16, 2020 at 23:15

You can just initialize via a constructor:

• 14 This is the case only if you control the definition of struct address . Also, POD types often intentionally have no constructor and destructor. –  user4815162342 Commented Jun 21, 2014 at 16:38

You can even pack Gui13's solution into single initialization statement:

Disclaimer: I don't recommend this style

• 1 This is still dangerous because it allows you to add a member to address and the code will still compile with a million places only initializing the original five members. The best part of struct initialization is that you can have all members const and it will force you to initialize them all –  mystery_doctor Commented May 7, 2019 at 6:16

It's not implemented in C++. (also, char* strings? I hope not).

Usually if you have so many parameters it is a fairly serious code smell. But instead, why not simply value-initialize the struct and then assign each member?

• 7 "(also, char* strings? I hope not)." - Well, it is a C example. –  Ed Swangren Commented Jul 17, 2012 at 6:06
• 1 cant we use char* in C++? Currently I am using it and it is working (may be I am doing something wrong). My assumption is that the compiler will create constant strings of "Hamilton" & "Ontario" and assign their address to the struct members. Will it be correct to use const char* instead? –  Dinesh P.R. Commented Jul 17, 2012 at 6:13
• 8 You can use char* but const char* is much more type-safe and everybody just uses std::string because it's much more reliable. –  Puppy Commented Jul 17, 2012 at 6:14
• Ok. When I read "as mentioned below" I assumed it was an example copied from somewhere. –  Ed Swangren Commented Jul 17, 2012 at 6:15

In C++ the C-style initializers were replaced by constructors which by compile time can ensure that only valid initializations are performed (i.e. after initialization the object members are consistent).

It is a good practice, but sometimes a pre-initialization is handy, like in your example. OOP solves this by abstract classes or creational design patterns .

In my opinion, using this secure way kills the simplicity and sometimes the security trade-off might be too expensive, since simple code does not need sophisticated design to stay maintainable.

As an alternative solution, I suggest to define macros using lambdas to simplify the initialization to look almost like C-style:

The ADDRESS macro expands to

which creates and calls the lambda. Macro parameters are also comma separated, so you need to put the initializer into brackets and call like

You could also write generalized macro initializer

but then the call is slightly less beautiful

however you can define the ADDRESS macro using general INIT macro easily

• That is truly hideous, but you are one of the few that has read the OPs actual question –  Paul Childs Commented May 15, 2023 at 22:07

Inspired by this really neat answer: ( https://stackoverflow.com/a/49572324/4808079 )

You can do lamba closures:

Or, if you want to be very fancy

There are some drawbacks involved with this, mostly having to do with uninitialized members. From what the linked answers comments say, it compiles efficiently, though I have not tested it.

Overall, I just think it's a neat approach.

I found this way of doing it for global variables, that does not require to modify the original structure definition :

then declare the variable of a new type inherited from the original struct type and use the constructor for fields initialisation :

Not quite as elegant as the C style though ...

For a local variable it requires an additional memset(this, 0, sizeof(*this)) at the beginning of the constructor, so it's clearly not worse it and @gui13 's answer is more appropriate.

(Note that 'temp_address' is a variable of type 'temp_address', however this new type inherit from 'address' and can be used in every place where 'address' is expected, so it's OK.)

In GNUC++ (seems to be obsolete since 2.5, a long time ago :) See the answers here: C struct initialization using labels. It works, but how? ), it is possible to initialize a struct like this:

The standard initialization list

The dot notation

The designated aggregate initialization, where the initialization list contains that labels of each member of the structure (see documentation ) available from C++20 onward.

Treating a struct like a C++ class - in C++ structures are actually special types of classes, where all members are public (unlike a standard C++ class where all members are private if not specified otherwise explicitly) as well as that when using inheritance they default to public :

When it comes to the way you initialize your structure you should consider the following aspects:

• Portability - different compilers, different degree of C++ standard completeness and different C++ standards altogether do limit your options. If you have to work with let's say a C++11 compiler but want to use the C++20 designated aggregate initialization you are out of luck
• Readability - what is more readable: temp_address.city = "Toronto" or temp_address { ..., "Toronto", ... } ? Readability of your code is very important. Especially when you have large structures (worse - nested ones), having unlabeled values all over the place is just asking for trouble
• Scalability - anything that depends on a specific order is not a good idea. The same goes for lack of labels. You want to move a member up or down the address space of the structure? Good luck with an unlabeled initialization list (hunting down swapped values in structure initialization is a nightmare)... You want to add a new member? Again good luck with anything that depends on a specific order.

While the dot notation means you type more the benefits you get from using it outweigh this issue and as such I can recommend it unless you have a small structure that is future-proof in terms of lack of changes in its structure, in which case you can afford to go with an initialization list. Remember: whenever working with other people writing code that is easy to follow is essential.

I faced a similar problem today, where I have a struct that I want to fill with test data which will be passed as arguments to a function I'm testing. I wanted to have a vector of these structs and was looking for a one-liner method to initialize each struct.

I ended up going with a constructor function in the struct, which I believe was also suggested in a few answers to your question.

It's probably bad practice to have the arguments to the constructor have the same names as the public member variables, requiring use of the this pointer. Someone can suggest an edit if there is a better way.

Which I used in in my test function to call the function being tested with various arguments like this:

It is possible, but only if the struct you're initializing is a POD (plain old data) struct. It cannot contain any methods, constructors, or even default values.

Not the answer you're looking for? Browse other questions tagged c++ struct initialization or ask your own question .

• The Overflow Blog
• Mobile Observability: monitoring performance through cracked screens, old...
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• How would humans actually colonize mars?
• Looking for a sci-fi book I read back in high school in the 1980's. I think it was written early 1980's or even in the 1970's
• Word for a collection of awards, such as an Olympic athlete’s earned medals
• How to prevent my frozen dessert from going solid?
• Do you have to tell your friend if you have hate for him in your heart?
• World Building Knowledgebase - How to write good Military World Building
• Do eternal ordinances such as the festival of unleavened bread pose a biblical contradiction?
• Fill the grid with numbers to make all four equations true
• How can coordinates be meaningless in General Relativity?
• How did Dwight Dixon acquire Charles Charles' watch?
• Is consciousness a prerequisite for knowledge?
• Expensive constructors. Should they exist? Should they be replaced?
• A classic problem about matrix
• Beta function of a marginal operator
• Identifications in differential geometry
• Is a company liable for "potential" harms?
• Why is the wiper fluid hose on the Mk7 Golf covered in cloth tape?
• Does it make sense for the governments of my world to genetically engineer soldiers?
• Reference request: locally erasable delta-functor is universal
• Sum of reciprocals of rough numbers
• Why is there an "unnamed volcano" in Syria?
• What is inside the SPIKE Essential battery?
• What does "if you ever get up this way" mean?
• Difference between 失敬する and 盗む

cppreference.com

Structured binding declaration (since c++17).

Binds the specified names to subobjects or elements of the initializer.

Like a reference, a structured binding is an alias to an existing object. Unlike a reference, a structured binding does not have to be of a reference type.

A structured binding declaration introduces all identifiers in the identifier-list as names in the surrounding scope and binds them to subobjects or elements of the object denoted by expression . The bindings so introduced are called structured bindings .

[ edit ] Binding process

A structured binding declaration first introduces a uniquely-named variable (here denoted by e ) to hold the value of the initializer, as follows:

• If expression has array type A and no ref-qualifier is present, then e has type cv A , where cv is the cv-qualifiers in the cv-auto sequence, and each element of e is copy-initialized (for (1) ) or direct-initialized (for (2,3) ) from the corresponding element of expression .
• Otherwise e is defined as if by using its name instead of [ identifier-list ] in the declaration.

We use E to denote the type of e . (In other words, E is the equivalent of std:: remove_reference_t < decltype ( ( e ) ) > .)

A structured binding declaration then performs the binding in one of three possible ways, depending on E :

• Case 1: If E is an array type, then the names are bound to the array elements.
• Case 2: If E is a non-union class type and std:: tuple_size < E > is a complete type with a member named value (regardless of the type or accessibility of such member), then the "tuple-like" binding protocol is used.
• Case 3: If E is a non-union class type but std:: tuple_size < E > is not a complete type, then the names are bound to the accessible data members of E .

Each of the three cases is described in more detail below.

Each structured binding has a referenced type , defined in the description below. This type is the type returned by decltype when applied to an unparenthesized structured binding.

[ edit ] Case 1: binding an array

Each identifier in the identifier-list becomes the name of an lvalue that refers to the corresponding element of the array. The number of identifiers must equal the number of array elements.

The referenced type for each identifier is the array element type. Note that if the array type E is cv-qualified, so is its element type.

[ edit ] Case 2: binding a type implementing the tuple operations

The expression std:: tuple_size < E > :: value must be a well-formed integer constant expression, and the number of identifiers must equal std:: tuple_size < E > :: value .

For each identifier, a variable whose type is "reference to std:: tuple_element < i, E > :: type " is introduced: lvalue reference if its corresponding initializer is an lvalue, rvalue reference otherwise. The initializer for the i-th variable is

• e. get < i > ( ) , if lookup for the identifier get in the scope of E by class member access lookup finds at least one declaration that is a function template whose first template parameter is a non-type parameter
• Otherwise, get < i > ( e ) , where get is looked up by argument-dependent lookup only, ignoring non-ADL lookup.

In these initializer expressions, e is an lvalue if the type of the entity e is an lvalue reference (this only happens if the ref-qualifier is & or if it is && and the initializer expression is an lvalue) and an xvalue otherwise (this effectively performs a kind of perfect forwarding), i is a std::size_t prvalue, and < i > is always interpreted as a template parameter list.

The variable has the same storage duration as e .

The identifier then becomes the name of an lvalue that refers to the object bound to said variable.

The referenced type for the i-th identifier is std:: tuple_element < i, E > :: type .

[ edit ] Case 3: binding to data members

Every non-static data member of E must be a direct member of E or the same base class of E , and must be well-formed in the context of the structured binding when named as e. name . E may not have an anonymous union member. The number of identifiers must equal the number of non-static data members.

Each identifier in identifier-list becomes the name of an lvalue that refers to the next member of e in declaration order (bit-fields are supported); the type of the lvalue is that of e. m_i , where m_i refers to the i th member.

The referenced type of the i-th identifier is the type of e. m_i if it is not a reference type, or the declared type of m_i otherwise.

[ edit ] Initialization order

Let val_i be the object or reference named by the i th identifier in identifier-list  :

• The initialization of e is sequenced before the initialization of any val_i .
• The initialization of each val_i is sequenced before the initialization of any val_j where i is less than j .

[ edit ] Notes

The lookup for member get ignores accessibility as usual and also ignores the exact type of the non-type template parameter. A private template < char * > void get ( ) ; member will cause the member interpretation to be used, even though it is ill-formed.

The portion of the declaration preceding [ applies to the hidden variable e , not to the introduced identifiers:

The tuple-like interpretation is always used if std:: tuple_size < E > is a complete type with a member named value , even if that would cause the program to be ill-formed:

The usual rules for reference-binding to temporaries (including lifetime-extension) apply if a ref-qualifier is present and the expression is a prvalue. In those cases the hidden variable e is a reference that binds to the temporary variable materialized from the prvalue expression, extending its lifetime. As usual, the binding will fail if e is a non-const lvalue reference:

decltype ( x ) , where x denotes a structured binding, names the referenced type of that structured binding. In the tuple-like case, this is the type returned by std::tuple_element , which may not be a reference even though a hidden reference is always introduced in this case. This effectively emulates the behavior of binding to a struct whose non-static data members have the types returned by std::tuple_element , with the referenceness of the binding itself being a mere implementation detail.

[ edit ] Keywords

[ edit ] example, [ edit ] defect reports.

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

[ edit ] References

• C++23 standard (ISO/IEC 14882:2024):
• 9.6 Structured binding declarations [dcl.struct.bind] (p: 228-229)
• C++20 standard (ISO/IEC 14882:2020):
• 9.6 Structured binding declarations [dcl.struct.bind] (p: 219-220)
• C++17 standard (ISO/IEC 14882:2017):
• 11.5 Structured binding declarations [dcl.struct.bind] (p: 219-220)

[ edit ] See also

• 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 13 August 2024, at 23:30.
• Privacy policy
• About cppreference.com
• Disclaimers