delete assignment constructor

Programming Tutorials

• How to Delete a Function in C++11 / 14?

In modern C++, the ‘delete’ keyword plays a crucial role in enhancing code safety and correctness. Introduced in C++11, this powerful feature allows programmers to explicitly forbid the use of certain functions, including automatically generated ones like default constructors and assignment operators. In this article, we will explore the practical applications of the ‘delete’ keyword and how it can be used.

Deleting Functions with the ‘delete’ Keyword

The ‘delete’ keyword can be applied to functions to make them uncallable, effectively preventing their use in a program. When a function is marked as deleted, any attempt to call it will result in a compile-time error. This is particularly useful for managing special member functions that the compiler might otherwise automatically generate.

Here’s a simple example of a function being deleted:

Practical Use Cases for the ‘delete’ Keyword

The ‘delete’ keyword is particularly useful for:

• Deleting compiler-generated functions like copy constructors, assignment operators, move constructors, move assignment operators, and default constructors.
• Deleting member functions to prevent implicit type conversions that could lead to data loss.
• Restricting object creation on the heap by deleting the new operator for a class.
• Deleting specific template specializations.

Deleting Copy Constructors and Assignment Operators in C++

Consider a User class where you want to disable copy semantics:

In the above class User , the Copy Constructor and Assignment Operator are deleted. If anybody tries to call these deleted functions, it will generate a compile-time error. For example,

Trying to copy an instance of User will result in a compile-time error:

Frequently Asked:

Apart from applying the delete keyword to compiler-generated functions, we can also apply it to other functions.

Deleting Member Functions in a class in C++

Implicit type conversions can be convenient but dangerous. They can lead to data loss or logical errors if types are converted unexpectedly. Deleting specific constructors can prevent these unwanted conversions. For example:

To prevent these conversions, declare these constructors as deleted:

Here we are deleting two constructors that could lead to implicit conversions:

• The first one prevents creating a User object with a double as the ID, which could lead to a narrowing conversion if the double value has no exact int representation.
• The second one prevents creating a User object with a char as the ID, which could be nonsensical if the char doesn’t represent an integer.

Now on creating User object with double and char will throw compile time error.

Restricting Object Creation on the Heap

To ensure that instances of a class are only created on the stack (not on the heap), you can delete the new operator:

This line ensures that the new operator cannot be used with the User class. As a result, the following code would trigger a compile-time error:

By deleting the new operator, you ensure that all User objects are automatically destroyed when they go out of scope, which can help manage resources more effectively and prevent memory leaks.

Deleting Specific Template Specializations

With the delete keyword, we can restrict certain template specializations of template classes or functions. Let’s see how to do that. Suppose we have a template class for a Complex Number.

We can use ComplexNumber with different types like int , double , and char , etc. For example,

To restrict the usage of ComplexNumber with double or char as template parameters, we need to explicitly delete those specializations. For example:

Now, attempting to use the ComplexNumber<> class with double or char as the template parameter will generate a compile-time error.

The complete ComplexNumber class with the deleted specializations is as follows:

Calling Following functions will result in error

Deleted Functions vs. Private Functions

While making functions private can also restrict their accessibility, deleted functions offer distinct advantages:

• Private member functions can still be called by other members of the same class, while deleted functions cannot be called at all.
• Deleted functions participate in name lookup. If a deleted function is found during compilation, the compiler does not continue to look for other overloads that might accept the arguments, preventing potential bugs and data loss.

The ‘delete’ keyword is a powerful feature in C++ that serves as a building block for safer and more maintainable code. By disabling certain functions or conversions, programmers can prevent a host of issues that could arise from inadvertent misuse. Use the ‘delete’ keyword to clearly communicate the intended use of your classes and functions, and to leverage the C++ type system for robust software development.

Related posts:

• What is shared_ptr in C++?
• Shared_ptr & Custom Deleter in Modern C++
• Smart Pointer vs Raw Pointer in C++
• How not to use Smart Pointers in C++?
• What is weak_ptr in Modern C++ & why do we need it?
• Using std::find & std::find_if with User Defined Classes
• C++11 Multithreading – Part 4: Data Sharing and Race Conditions
• C++11 Multithreading – Part 5: Using mutex to fix Race Conditions
• C++ Set example and Tutorial – Part 1
• C++11 Multithreading – Part 7: Condition Variables Explained
• C++11 Multithreading – Part 8: std::future , std::promise and Returning values from Thread
• Lambda Functions in C++
• std::bind in C++ – Explained with Examples
• The auto Keyword in C++11
• multimap Example and Tutorial in C++
• C++11 Multithreading – Part 9: std::async Tutorial & Example
• How to Capture Member Variables in Lambda function in C++?
• C++11 Lambda: Capture Variables by Reference or Value
• What is unique_ptr in C++?
• C++ : Check if given path is a file or directory using Boost & C++17 FileSystem Library

Share your love

2 thoughts on “how to delete a function in c++11 / 14”.

Excellent Definition.

nice explanation

Leave a Comment Cancel Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed .

• Graphics and multimedia
• Language Features
• Unix/Linux programming
• Source Code
• Standard Library
• Tips and Tricks
• Tools and Libraries
• Windows API
• Copy constructors, assignment operators,

Copy constructors, assignment operators, and exception safe assignment

cppreference.com

C++ keyword: delete, [ edit ] usage.

• delete expression
• deallocation functions as the name of operator-like functions
• 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 21 April 2019, at 04:47.
• This page has been accessed 203,673 times.
• Privacy policy
• About cppreference.com
• Disclaimers

This browser is no longer supported.

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

Move Constructors and Move Assignment Operators (C++)

• 9 contributors

This topic describes how to write a move constructor and a move assignment operator for a C++ class. A move constructor enables the resources owned by an rvalue object to be moved into an lvalue without copying. For more information about move semantics, see Rvalue Reference Declarator: && .

This topic builds upon the following C++ class, MemoryBlock , which manages a memory buffer.

The following procedures describe how to write a move constructor and a move assignment operator for the example C++ class.

To create a move constructor for a C++ class

Define an empty constructor method that takes an rvalue reference to the class type as its parameter, as demonstrated in the following example:

In the move constructor, assign the class data members from the source object to the object that is being constructed:

Assign the data members of the source object to default values. This prevents the destructor from freeing resources (such as memory) multiple times:

To create a move assignment operator for a C++ class

Define an empty assignment operator that takes an rvalue reference to the class type as its parameter and returns a reference to the class type, as demonstrated in the following example:

In the move assignment operator, add a conditional statement that performs no operation if you try to assign the object to itself.

In the conditional statement, free any resources (such as memory) from the object that is being assigned to.

The following example frees the _data member from the object that is being assigned to:

Follow steps 2 and 3 in the first procedure to transfer the data members from the source object to the object that is being constructed:

Return a reference to the current object, as shown in the following example:

Example: Complete move constructor and assignment operator

The following example shows the complete move constructor and move assignment operator for the MemoryBlock class:

Example Use move semantics to improve performance

The following example shows how move semantics can improve the performance of your applications. The example adds two elements to a vector object and then inserts a new element between the two existing elements. The vector class uses move semantics to perform the insertion operation efficiently by moving the elements of the vector instead of copying them.

This example produces the following output:

Before Visual Studio 2010, this example produced the following output:

The version of this example that uses move semantics is more efficient than the version that does not use move semantics because it performs fewer copy, memory allocation, and memory deallocation operations.

Robust Programming

To prevent resource leaks, always free resources (such as memory, file handles, and sockets) in the move assignment operator.

To prevent the unrecoverable destruction of resources, properly handle self-assignment in the move assignment operator.

If you provide both a move constructor and a move assignment operator for your class, you can eliminate redundant code by writing the move constructor to call the move assignment operator. The following example shows a revised version of the move constructor that calls the move assignment operator:

The std::move function converts the lvalue other to an rvalue.

Rvalue Reference Declarator: && std::move

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

14.16 — Converting constructors and the explicit keyword

In lesson 10.1 -- Implicit type conversion , we introduced type conversion and the concept of implicit type conversion, where the compiler will implicitly convert a value of one type to a value of another type as needed if such a conversion exists.

This allows us to do things like this:

In the above example, our printDouble function has a double parameter, but we’re passing in an argument of type int . Because the type of the parameter and the type of the argument do not match, the compiler will see if it can implicitly convert the type of the argument to the type of the parameter. In this case, using the numeric conversion rules, int value 5 will be converted to double value 5.0 and because we’re passing by value, parameter d will be copy initialized with this value.

User-defined conversions

Now consider the following similar example:

In this version, printFoo has a Foo parameter but we’re passing in an argument of type int . Because these types do not match, the compiler will try to implicitly convert int value 5 into a Foo object so the function can be called.

Unlike the first example, where our parameter and argument types were both fundamental types (and thus can be converted using the built-in numeric promotion/conversion rules), in this case, one of our types is a program-defined type. The C++ standard doesn’t have specific rules that tell the compiler how to convert values to (or from) a program-defined type.

Instead, the compiler will look to see if we have defined some function that it can use to perform such a conversion. Such a function is called a user-defined conversion .

Converting constructors

In the above example, the compiler will find a function that lets it convert int value 5 into a Foo object. That function is the Foo(int) constructor.

Up to this point, we’ve typically used constructors to explicitly construct objects:

Think about what this does: we’re providing an int value ( 5 ) and getting a Foo object in return.

In the context of a function call, we’re trying to solve the same problem:

We’re providing an int value ( 5 ), and we want a Foo object in return. The Foo(int) constructor was designed for exactly that!

So in this case, when printFoo(5) is called, parameter f is copy initialized using the Foo(int) constructor with 5 as an argument!

A constructor that can be used to perform an implicit conversion is called a converting constructor . By default, all constructors are converting constructors.

Only one user-defined conversion may be applied

Now consider the following example:

In this version, we’ve swapped out our Foo class for an Employee class. printEmployee has an Employee parameter, and we’re passing in a C-style string literal. And we have a converting constructor: Employee(std::string_view) .

You might be surprised to find that this version doesn’t compile. The reason is simple: only one user-defined conversion may be applied to perform an implicit conversion, and this example requires two. First, our C-style string literal has to be converted to a std::string_view (using a std::string_view converting constructor), and then our std::string_view has to be converted into an Employee (using the Employee(std::string_view) converting constructor).

There are two ways to make this example work:

• Use a std::string_view literal:

This works because only one user-defined conversion is now required (from std::string_view to Employee ).

• Explicitly construct an Employee rather than implicitly create one:

This also works because only one user-defined conversion is now required (from the string literal to the std::string_view used to initialize the Employee object). Passing our explicitly constructed Employee object to the function does not require a second conversion to take place.

This latter example brings up a useful technique: it is trivial to convert an implicit conversion into an explicit definition. We’ll see more examples of this later in this lesson.

Key insight

An implicit conversion can be trivially converted into an explicit definition by using direct list initialization (or direct initialization).

When converting constructors go wrong

Consider the following program:

When we call print(5) , the Dollars(int) converting constructor will be used to convert 5 into a Dollars object. Thus, this program prints:

Although this may have been the caller’s intent, it’s hard to tell because the caller did not provide any indication that this is what they actually wanted. It’s entirely possible that the caller assumed this would print 5 , and did not expect the compiler to silently and implicitly convert our int value to a Dollars object so that it could satisfy this function call.

While this example is trivial, in a larger and more complex program, it’s fairly easy to be surprised by the compiler performing some implicit conversion that you did not expect, resulting in unexpected behavior at runtime.

It would be better if our print(Dollars) function could only be called with a Dollars object, not any value that can be implicitly converted to a Dollars (especially a fundamental type like int ). This would reduce the possibility of inadvertent errors.

The explicit keyword

To address such issues, we can use the explicit keyword to tell the compiler that a constructor should not be used as a converting constructor.

Making a constructor explicit has two notable consequences:

• An explicit constructor cannot be used to do copy initialization or copy list initialization.
• An explicit constructor cannot be used to do implicit conversions (since this uses copy initialization or copy list initialization).

Let’s update the Dollars(int) constructor from the prior example to be an explicit constructor:

Because the compiler can no longer use Dollars(int) as a converting constructor, it can not find a way to convert 5 to a Dollars . Consequently, it will generate a compilation error.

Explicit constructors can be used for direct and list initialization

An explicit constructor can still be used for direct and direct list initialization:

Now, let’s go back to our prior example, where we made our Dollars(int) constructor explicit, and therefore the following generated a compilation error:

What if we actually want to call print() with int value 5 but the constructor is explicit? The workaround is simple: instead of having the compiler implicitly convert 5 into a Dollars that can be passed to print() , we can explicitly define the Dollars object ourselves:

This is allowed because we can still use explicit constructors to list initialize objects. And since we’ve now explicitly constructed a Dollars , the argument type matches the parameter type, so no conversion is required!

This not only compiles and runs, it also better documents our intent, as it is explicit about the fact that we meant to call this function with a Dollars object.

Return by value and explicit constructors

When we return a value from a function, if that value does not match the return type of the function, an implicit conversion will occur. Just like with pass by value, such conversions cannot use explicit constructors.

The following programs shows a few variations in return values, and their results:

Perhaps surprisingly, return { 5 } is considered a conversion.

Best practices for use of explicit

The modern best practice is to make any constructor that will accept a single argument explicit by default. This includes constructors with multiple parameters where most or all of them have default values.

This will disallow the compiler from using that constructor for implicit conversions. If an implicit conversion is required, only non-explicit constructors will be considered. If no non-explicit constructor can be found to perform the conversion, the compiler will error.

If such a conversion is actually desired in a particular case, it is trivial to convert the implicit conversion into an explicit definition using list initialization.

The following should not be made explicit:

• Copy (and move) constructors (as these do not perform conversions).
• Default constructors with no parameters (as these are only used to convert {} to a default object, not something we need to restrict).
• Constructors that only accept multiple arguments (as these are typically not a candidate for conversions anyway).

There are some occasions when it does make sense to make a single-argument constructor non-explicit. This can be useful when all of the following are true:

• The converted value is semantically equivalent to the argument value.
• The conversion is performant.

For example, the std::string_view constructor that accepts a C-style string argument is not explicit, because there is unlikely to be a case when we wouldn’t be okay with a C-style string being treated as a std::string_view instead.

Conversely, the std::string constructor that takes a std::string_view is marked as explicit, because while a std::string value is semantically equivalent to a std::string_view value, constructing a std::string is not performant.

Best practice

Make any constructor that accepts a single argument explicit by default. If an implicit conversion between types is both semantically equivalent and performant, you can consider making the constructor non-explicit.

Do not make copy or move constructors explicit, as these do not perform conversions.

DYNAMIC MEMORY ISSUES IN C++

C++11/C++14 default and delete specifiers- 2020

"If you're an experienced C++ programmer and are anything like me, you initially approached C++11 thinking, "Yes, yes, I get it. It's C++, only more so." But as you learned more, you were surprised by the scope of the changes. auto declarations, range-based for loops, lambda expressions , and rvalue references change the face of C++, to say nothing of the new concurrency features. And then there are the idiomatic changes. 0 and typedefs are out, nullptr and alias declarations are in. Enums should now be scoped. Smart pointers are now preferable to built-in ones. Moving objects is normally better than copying them. - Effective Modern C++ by Scott Meyers

If a class is defined with any constructors, the compiler will not generate a default constructor. This is useful in many cases, but it is some times vexing. For example, we defined the class as below:

Then, if we do:

The compiler complains that we have no default constructor. That's because compiler did not make the one for us because we've already had one that we defined.

Then, compiler won't complain for this any more:

Suppose we have a class with a constructor taking an integer:

Then, the following three operations will be successful:

However, what if that was not we wanted. We do not want the constructor allow double type parameter nor the assignment to work.

C++11 allows us to disable certain features by using delete :

Then, if we write the code as below:

In that way, we could achieve what we intended.

C++11/C++14 New Features

Ph.D. / Golden Gate Ave, San Francisco / Seoul National Univ / Carnegie Mellon / UC Berkeley / DevOps / Deep Learning / Visualization

Sponsor Open Source development activities and free contents for everyone.

C++ Tutorials

• C++ Classes and Objects
• C++ Polymorphism

C++ Inheritance

• C++ Abstraction
• C++ Encapsulation
• C++ OOPs Interview Questions
• C++ OOPs MCQ

C++ Interview Questions

C++ function overloading.

• C++ Programs
• C++ Preprocessor

C++ Templates

• Solve Coding Problems
• C++ Programming Language

C++ Overview

• Introduction to C++ Programming Language
• Features of C++
• History of C++
• Interesting Facts about C++
• Setting up C++ Development Environment
• Difference between C and C++
• Writing First C++ Program - Hello World Example
• C++ Basic Syntax
• C++ Comments
• Tokens in C
• C++ Keywords
• Difference between Keyword and Identifier

C++ Variables and Constants

• C++ Variables
• Constants in C
• Scope of Variables in C++
• Storage Classes in C++ with Examples
• Static Keyword in C++

C++ Data Types and Literals

• C++ Data Types
• Literals in C
• Derived Data Types in C++
• User Defined Data Types in C++
• Data Type Ranges and their macros in C++
• C++ Type Modifiers
• Type Conversion in C++
• Casting Operators in C++

C++ Operators

• Operators in C++
• C++ Arithmetic Operators
• Unary operators in C
• Bitwise Operators in C
• Assignment Operators in C
• C++ sizeof Operator
• Scope resolution operator in C++

C++ Input/Output

• Basic Input / Output in C++
• cout in C++
• cerr - Standard Error Stream Object in C++
• Manipulators in C++ with Examples

C++ Control Statements

• Decision Making in C (if , if..else, Nested if, if-else-if )
• C++ if Statement
• C++ if else Statement
• C++ if else if Ladder
• Switch Statement in C++
• Jump statements in C++
• for Loop in C++
• Range-based for loop in C++
• C++ While Loop
• C++ Do/While Loop

C++ Functions

• Functions in C++
• return statement in C++ with Examples
• Parameter Passing Techniques in C
• Difference Between Call by Value and Call by Reference in C
• Default Arguments in C++
• Inline Functions in C++
• Lambda expression in C++

C++ Pointers and References

• Pointers and References in C++
• C++ Pointers
• Dangling, Void , Null and Wild Pointers in C
• Applications of Pointers in C
• Understanding nullptr in C++
• References in C++
• Can References Refer to Invalid Location in C++?
• Pointers vs References in C++
• Passing By Pointer vs Passing By Reference in C++
• When do we pass arguments by pointer?
• Variable Length Arrays (VLAs) in C
• Pointer to an Array | Array Pointer
• How to print size of array parameter in C++?
• Pass Array to Functions in C
• What is Array Decay in C++? How can it be prevented?

C++ Strings

• Strings in C++
• std::string class in C++
• Array of Strings in C++ - 5 Different Ways to Create
• String Concatenation in C++
• Tokenizing a string in C++
• Substring in C++

C++ Structures and Unions

• Structures, Unions and Enumerations in C++
• Structures in C++
• C++ - Pointer to Structure
• Self Referential Structures
• Difference Between C Structures and C++ Structures
• Enumeration in C++
• typedef in C++
• Array of Structures vs Array within a Structure in C

C++ Dynamic Memory Management

• Dynamic Memory Allocation in C using malloc(), calloc(), free() and realloc()
• new and delete Operators in C++ For Dynamic Memory
• new vs malloc() and free() vs delete in C++
• What is Memory Leak? How can we avoid?
• Difference between Static and Dynamic Memory Allocation in C

C++ Object-Oriented Programming

• Object Oriented Programming in C++
• Access Modifiers in C++
• Friend Class and Function in C++

Constructors in C++

• Default Constructors in C++
• Copy Constructor in C++
• Destructors in C++
• Private Destructor in C++
• When is a Copy Constructor Called in C++?
• Shallow Copy and Deep Copy in C++
• When Should We Write Our Own Copy Constructor in C++?
• Does C++ compiler create default constructor when we write our own?
• C++ Static Data Members
• Static Member Function in C++
• 'this' pointer in C++
• Scope Resolution Operator vs this pointer in C++
• Local Classes in C++
• Nested Classes in C++
• Enum Classes in C++ and Their Advantage over Enum DataType
• Difference Between Structure and Class in C++
• Why C++ is partially Object Oriented Language?

C++ Encapsulation and Abstraction

• Encapsulation in C++
• Abstraction in C++
• Difference between Abstraction and Encapsulation in C++
• Function Overriding in C++
• Virtual Functions and Runtime Polymorphism in C++
• Difference between Inheritance and Polymorphism
• Function Overloading in C++
• Constructor Overloading in C++
• Functions that cannot be overloaded in C++
• Function overloading and const keyword
• Function Overloading and Return Type in C++
• Function Overloading and float in C++
• C++ Function Overloading and Default Arguments
• Can main() be overloaded in C++?
• Function Overloading vs Function Overriding in C++
• Advantages and Disadvantages of Function Overloading in C++

C++ Operator Overloading

• Operator Overloading in C++
• Types of Operator Overloading in C++
• Functors in C++
• What are the Operators that Can be and Cannot be Overloaded in C++?
• Inheritance in C++
• C++ Inheritance Access
• Multiple Inheritance in C++
• C++ Hierarchical Inheritance
• C++ Multilevel Inheritance
• Constructor in Multiple Inheritance in C++
• Inheritance and Friendship in C++
• Does overloading work with Inheritance?

C++ Virtual Functions

• Virtual Function in C++
• Virtual Functions in Derived Classes in C++
• Default Arguments and Virtual Function in C++
• Can Virtual Functions be Inlined in C++?
• Virtual Destructor
• Advanced C++ | Virtual Constructor
• Advanced C++ | Virtual Copy Constructor
• Pure Virtual Functions and Abstract Classes in C++
• Pure Virtual Destructor in C++
• Can Static Functions Be Virtual in C++?
• RTTI (Run-Time Type Information) in C++
• Can Virtual Functions be Private in C++?

C++ Exception Handling

• Exception Handling in C++
• Exception Handling using classes in C++
• Stack Unwinding in C++
• User-defined Custom Exception with class in C++

C++ Files and Streams

• File Handling through C++ Classes
• I/O Redirection in C++
• Templates in C++ with Examples
• Template Specialization in C++
• Using Keyword in C++ STL

C++ Standard Template Library (STL)

• The C++ Standard Template Library (STL)
• Containers in C++ STL (Standard Template Library)
• Introduction to Iterators in C++
• Algorithm Library | C++ Magicians STL Algorithm

C++ Preprocessors

• C Preprocessors
• C Preprocessor Directives
• #include in C
• Difference between Preprocessor Directives and Function Templates in C++

C++ Namespace

• Namespace in C++ | Set 1 (Introduction)
• namespace in C++ | Set 2 (Extending namespace and Unnamed namespace)
• Namespace in C++ | Set 3 (Accessing, creating header, nesting and aliasing)
• C++ Inline Namespaces and Usage of the "using" Directive Inside Namespaces

Advanced C++

• Multithreading in C++
• Smart Pointers in C++
• auto_ptr vs unique_ptr vs shared_ptr vs weak_ptr in C++
• Type of 'this' Pointer in C++
• "delete this" in C++
• Passing a Function as a Parameter in C++
• Signal Handling in C++
• Generics in C++
• Difference between C++ and Objective C
• Write a C program that won't compile in C++
• Write a program that produces different results in C and C++
• How does 'void*' differ in C and C++?
• Type Difference of Character Literals in C and C++
• Cin-Cout vs Scanf-Printf

C++ vs Java

• Similarities and Difference between Java and C++
• Comparison of Inheritance in C++ and Java
• How Does Default Virtual Behavior Differ in C++ and Java?
• Comparison of Exception Handling in C++ and Java
• Foreach in C++ and Java
• Templates in C++ vs Generics in Java
• Floating Point Operations & Associativity in C, C++ and Java

Competitive Programming in C++

• Competitive Programming - A Complete Guide
• C++ tricks for competitive programming (for C++ 11)
• Writing C/C++ code efficiently in Competitive programming
• Why C++ is best for Competitive Programming?
• Test Case Generation | Set 1 (Random Numbers, Arrays and Matrices)
• Fast I/O for Competitive Programming
• Setting up Sublime Text for C++ Competitive Programming Environment
• How to setup Competitive Programming in Visual Studio Code for C++
• Which C++ libraries are useful for competitive programming?
• Common mistakes to be avoided in Competitive Programming in C++ | Beginners
• C++ Interview Questions and Answers (2024)
• Top C++ STL Interview Questions and Answers
• 30 OOPs Interview Questions and Answers (2024)
• Top C++ Exception Handling Interview Questions and Answers
• C++ Programming Examples

Constructor in C++ is a special method that is invoked automatically at the time of object creation. It is used to initialize the data members of new objects generally. The constructor in C++ has the same name as the class or structure. It constructs the values i.e. provides data for the object which is why it is known as a constructor.

• Constructor is a member function of a class, whose name is the same as the class name.
• Constructor is a special type of member function that is used to initialize the data members for an object of a class automatically when an object of the same class is created.
• Constructor is invoked at the time of object creation. It constructs the values i.e. provides data for the object that is why it is known as a constructor.
• Constructors do not return value, hence they do not have a return type.
• A constructor gets called automatically when we create the object of the class.
• Constructors can be overloaded.
• A constructor can not be declared virtual.

Syntax of Constructors in C++

The prototype of the constructor looks like this:

The constructor can be defined inside the class declaration or outside the class declaration

Syntax for Defining the Constructor Within the Class

Syntax for defining the constructor outside the class, examples of constructors in c++.

The below examples demonstrate how to declare constructors for a class in C++:

Example 1: Defining the Constructor Within the Class

 example 2: defining the constructor outside the class.

Note: We can make the constructor defined outside the class as inline to make it equivalent to the in class definition. But note that inline is not an instruction to the compiler, it is only the request which compiler may or may not implement depending on the circumtances.

Characteristics of Constructors in C++

The following are some main characteristics of the constructors in C++:

• The name of the constructor is the same as its class name.
• Constructors are mostly declared in the public section of the class though they can be declared in the private section of the class.
• Constructors do not return values; hence they do not have a return type.
• A constructor cannot be inherited.
• The addresses of the Constructor cannot be referred to.
• The constructor makes implicit calls to new and delete operators during memory allocation.

Types of Constructor in C++

Constructors can be classified based on in which situations they are being used. There are 4 types of constructors in C++:

• Default Constructor
• Parameterized Constructor
• Copy Constructor
• Move Constructor

Let us understand the types of constructors in C++ by taking a real-world example. Suppose you went to a shop to buy a marker. When you want to buy a marker, what are the options? The first one you go to a shop and say give me a marker. So just saying give me a marker means that you did not set which brand name and which color, you didn’t mention anything just say you want a marker. So when we said just I want a marker whatever the frequently sold marker is there in the market or his shop he will simply hand over that. And this is what a default constructor is!

The second method is you go to a shop and say I want a marker red in color and XYZ brand. So you are mentioning this and he will give you that marker. So in this case you have given the parameters. And this is what a parameterized constructor is!

Then the third one you go to a shop and say I want a marker like this(a physical marker on your hand). So the shopkeeper will see that marker. Okay, and he will give a new marker for you. So copy of that marker. And that’s what a copy constructor is!

Now, assume that you don’t to buy a new marker but instead take ownership of your friend’s marker. It means taking ownership of already present resources instead of getting a new one. That’s what a move constructor is!

1. Default Constructor in C++

A default constructor is a constructor that doesn’t take any argument. It has no parameters. It is also called a zero-argument constructor.

Syntax of Default Constructor

Examples of default constructor.

The below examples demonstrate how to use the default constructors in C++.

Note: Even if we do not define any constructor explicitly, the compiler will automatically provide a default constructor implicitly.

As we can see, we are able the object of class student is created without passing any argument even when we haven’t defined any explicit default constructor for it.

2. Parameterized Constructor in C++

Parameterized Constructors make it possible to pass arguments to constructors. Typically, these arguments help initialize an object when it is created. To create a parameterized constructor, simply add parameters to it the way you would to any other function. When you define the constructor’s body, use the parameters to initialize the object.

Syntax of Parameterized Constructor

Examples of parameterized constructor.

The below examples demonstrate how to use the parameterized constructors in C++.

Example 1: Defining Parameterized Constructor Inside the Class.

Example 2: Defining Parameterized Constructor Outside the Class.

When an object is declared in a parameterized constructor, the initial values have to be passed as arguments to the constructor function. The normal way of object declaration may not work. The parameterized constructors can be called explicitly or implicitly:

When the parameterized constructor is defined and no default constructor is defined explicitly, the compiler will not implicitly create the default constructor and hence create a simple object as:

will flash an error.

Important Note: Whenever we define one or more non-default constructors( with parameters ) for a class, a default constructor( without parameters ) should also be explicitly defined as the compiler will not provide a default constructor in this case. However, it is not necessary but it’s considered to be the best practice to always define a default constructor.

Uses of Parameterized Constructor

• It is used to initialize the various data elements of different objects with different values when they are created.
• It is used to overload constructors.

Default Arguments with C++ Parameterized Constructor

Just like normal functions, we can also define default values for the arguments of parameterized constructors. All the rules of the default arguments will be applied to these parameters.

Example 3: Defining Parameterized Constructor with Default Values

As we can see, when the default values are assigned to every argument of the parameterized constructor, it is legal to create the object without passing any parameters just like default constructors. So, this type of constructor works as both a default and parameterized constructor.

3. Copy Constructor in C++

A copy constructor is a member function that initializes an object using another object of the same class.

Syntax of Copy Constructor

Copy constructor takes a reference to an object of the same class as an argument.

Just like the default constructor, the C++ compiler also provides an implicit copy constructor if the explicit copy constructor definition is not present. Here, it is to be noted that, unlike the default constructor where the presence of any type of explicit constructor results in the deletion of the implicit default constructor, the implicit copy constructor will always be created by the compiler if there is no explicit copy constructor or explicit move constructor is present.

Examples of Copy Constructor

The below examples demonstrate how to use the copy constructors in C++.

Example 1: Illustration of Implicit Copy Constructor

Example 2: Defining of Explicit Copy Constructor

Example 3: Defining of Explicit Copy Constructor with Parameterized Constructor

Uses of Copy Constructor

• Constructs a new object by copying values from an existing object.
• Can be used to perform deep copy.
• Modify specific attributes during the copy process if needed.

4. Move Constructor in C++

The move constructor is a recent addition to the family of constructors in C++. It is like a copy constructor that constructs the object from the already existing objects., but instead of copying the object in the new memory, it makes use of move semantics to transfer the ownership of the already created object to the new object without creating extra copies.

It can be seen as stealing the resources from other objects.

Syntax of Move Constructor in C++

The move constructor takes the rvalue reference of the object of the same class and transfers the ownership of this object to the newly created object.

Like a copy constructor, the compiler will create a move constructor for each class that does not have any explicit move constructor.

Examples of Move Constructor

The below examples demonstrate how to use the move constructors in C++.

Example 1: Defining Move Constructor

Uses of Move Constructor

• Instead of making copies, move constructors efficiently transfer ownership of these resources.
• This prevents unnecessary memory copying and reduces overhead.
• You can define your own move constructor to handle specific resource transfers.

A destructor is also a special member function as a constructor. Destructor destroys the class objects created by the constructor. Destructor has the same name as their class name preceded by a tilde (~) symbol. It is not possible to define more than one destructor. The destructor is only one way to destroy the object created by the constructor. Hence destructor can-not be overloaded. Destructor neither requires any argument nor returns any value. It is automatically called when the object goes out of scope.  Destructors release memory space occupied by the objects created by the constructor. In destructor , objects are destroyed in the reverse of object creation.

Syntax of Destructors in C++

Like constructors, destructors can also be defined either inside or outside of the class.

The syntax for defining the destructor within the class

The syntax for defining the destructor outside the class

Examples of Destructors in C++

The below examples demonstrate how to use the destructors in C++.

Example 1: Defining a Simple Destructor

Example 2: Counting the Number of Times Object is Created and Destroyed

Characteristics of Destructors in C++

The following are some main characteristics of destructors in C++:

• Destructor is invoked automatically by the compiler when its corresponding constructor goes out of scope and releases the memory space that is no longer required by the program.
• Destructor neither requires any argument nor returns any value therefore it cannot be overloaded.
• Destructor  cannot be declared as static and const;
• Destructor should be declared in the public section of the program.
• Destructor is called in the reverse order of its constructor invocation.

Frequently Asked Questions on C++ Constructors

What are the functions that are generated by the compiler by default, if we do not provide them explicitly.

The functions that are generated by the compiler by default if we do not provide them explicitly are: Default Constructor Copy Constructor Move Constructors Assignment Operator Destructor

Can We Make the Constructors Private?

Yes, in C++, constructors can be made private. This means that no external code can directly create an object of that class.

How Constructors Are Different from a Normal Member Function?

A constructor is different from normal functions in following ways:  Constructor has same name as the class itself Default Constructors don’t have input argument however, Copy and Parameterized Constructors have input arguments Constructors don’t have return type A constructor is automatically called when an object is created. It must be placed in public section of class. If we do not specify a constructor, C++ compiler generates a default constructor for object (expects no parameters and has an empty body).

Can We Have More Than One Constructor in a Class?

Yes, we can have more than one constructor in a class. It is called Constructor Overloading .

Related Articles:

• Quiz on Constructors in C++
• Output of C++ programs | Set 26 (Constructors)
• Output of C++ programs | Set 27(Constructors and Destructors)

Please Login to comment...

• cpp-constructor
• School Programming
• 10 YouTube Alternatives to Stream Music Online in 2024
• 12 Best Paint 3D Alternatives in 2024
• 10 Best Pixlr Alternatives for Android in 2024 [Free + Paid]
• Bougie Definition and Usage Examples

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Language Feature
• Code Snippet
• Free Licenses

What Is A Deleted Implicitly-declared Move Constructor In Modern C++?

C++ is packed with Object Oriented Programming features, such as Classes, Objects, constructors, move constructors, destructors, etc. Since the C++11 standard, in a modern C++ compiler, one of the features is the move constructor that allows you to move the resources from one object to another object without copying them. One of the move constructors is the Deleted Implicitly-declared Move Constructor (also it is shown in compiler errors as Implicitly-deleted Move Constructor ) which is deleted in a base class directly or has been deleted because of some other declarations,. In this post, we explain the implicitly-declared move Constructor in Modern C++. First, let’s remind ourselves what are classes and objects in C++.

Table of Contents

What are classes and objects in modern C++?

Classes  are defined in C++ using keyword  class  followed by the name of the class. Classes are the blueprint for the objects and they are user-defined data types that we can use in our program, and they work as an object constructor.  Objects  are an instantiation of a class, In another term. In C++ programming, most of the commands are associated with classes and objects, along with their attributes and methods. Here is a simple class example.

Then we can create our objects with this T ype of myclass like so:

What is a move constructor in modern C++?

The move constructor is a constructor that allows you to move the resources from one object to another object without copying them. In other words, the move constructor allows you to move the resources from an rvalue object into to an lvalue object.

The move constructor is used to move data of one object to the new one. It effectively makes a new pointer to the members of an old object and transfers the resources to the heap memory. When you move a member, if the data member is a pointer, you should also set the value of the member of the old object to a NULL value. When you use the move constructor, you don’t use unnecessary data copying in memory. This allows you to create objects faster. Mostly, if your class/object has a move constructor, you can use other move methods of other features of C++, for example, std::vector , std::array , std::map , etc. You can create a vector with your class type then you can use the push_back() method that runs your move constructor.

Here is the most common syntax for the move constructor in C++ (Since C++11).

This general syntax is also a syntax for the “Typical declaration of a move constructor”.

What is a deleted implicitly-declared move constructor in C++?

The Deleted Implicitly-declared Move Constructor (also known in compiler errors as the implicitly-deleted move constructor ) is a Move Constructor which is deleted in a base class directly or has been deleted because of some other declarations.

In modern C++, the implicitly-deleted move constructor for class type T is defined as  deleted  if this class type T :

• has non-static data members that cannot be moved, or
• has direct or virtual base class that cannot be moved, or
• has direct or virtual base class or a non-static data member with a deleted or inaccessible destructor, or
• is a union-like class and has a variant member with non-trivial move constructor

If there is a defaulted move constructor that is deleted, then it is ignored by overload resolution, because in other case it will prevent copy-initialization from rvalue.

In C++, The Rule of Five states that if a type ever needs one of the following special members, then it must have all of the five special members.

• copy constructor
• copy assignment
• move constructor
• move assignment

In other words, if you have a move constructor in a class, you should carefully define all of these in accordance with your data members (properties).

Note that, classes may have different move constructors. Additionally, if there is a user-defined move constructor present, the user may still delete the implicitly declared move constructor with the keyword delete .

Is there a simple example of a deleted implicitly-declared move constructor in C++?

Let’s give a simple C++ example of a deleted implicitly-declared move constructor which is a move constructor of another base class. Let’s assume that we have Tx as a base class, and we have a new Ty class.

Here is a T x class example with a declared and defined move constructor that uses std::move .

As given here above, if you have a move constructor, you should define a Constructor too, otherwise you will have “No matching constructor for initialization of class” error in compilation.

Now, we can define a new Ty class and we can use Tx class as a base class as below.

As you can see, this Ty class above has the implicitly-deleted move constructor from Tx class. We cannot use a move constructor with std::move as in example below:

Here o2 can not be declared by std::move because Ty has Tx class which has deleted move constructor.

Is there a full example of a deleted implicitly-declared move constructor in modern C++?

Here is a full example of a default (forced) move constructor, where one object is moved to another one.

If you remove the last commented line, you will see this error below,

Is there a move constructor in a simple class, how can I delete it?

Note that, a simple empty C++ class is perfectly equivalent to default implementations ( Rule of Five ) in a class. A modern compiler is able to provide all these special member functions (default implementations). In example, this simple class below,

is exactly the same as the one below in modern C++.

If you don’t want this move constructer to be used in your objects, in other words you don’t want your objects to be moved, then you should delete it while the other special functions are in default as below,

If you need more technical details about the move constructor, it is explained by Bjarne Stroustrup and Lawrence Crowlcan in this publication here; https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html

C++ Builder  is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.

There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from  here . For professional developers, there are Professional, Architect, or Enterprise version.

Oh hi there 👋 It’s nice to meet you.

Sign up to receive awesome c++ content in your inbox, every day..

We don’t spam! Read our privacy policy for more info.

Check your inbox or spam folder to confirm your subscription.

About author

Yilmaz yoru, related posts, what are the logical operation metafunctions in modern c++, what are the deprecated c++14 features in c++17, what are the c++14 features removed from c++17, what is the conjunction (std::conjunction) metafunction in c++.

• Reduce development time and get to market faster with RAD Studio, Delphi, or C++Builder. Design. Code. Compile. Deploy. Start Free Trial Free C++Builder Community Edition

Something Fresh

What people reading, ascii art: fun code spinning donut in 3d text form in c++, how to set up dev-c++ for your first project.

Top C++ Compilers for Windows in 2020

Unicode strings in c++ on windows, how to program arduino with c++, newest questions tagged c++builder – stack overflow.

• How to create an inline keyboard with multiple rows in telegrambot using sgcWebSockets api telegram?
• How to handle an error when loading a picture into a TImage component?
• Why Does a Program Compile and Run Successfully But Then Fail to Compile and Link?

Newest questions tagged c++ – Stack Overflow

• C++ DLL Crashes when using classes in /MT Runtime Library
• WifiClientSecure Arduino Failed to connect to server
• making a std::tuple from the result of a pack

LearnCPlusPlus.org is a C++ tutorial and learning platform for Windows developers using C++ to build Windows applications. It focuses on tools that allow rapid development and programming of both Win32 and Win64 applications. Additionally, it supports deploying apps to iOS.

© Copyright 2020 Embarcadero

• Download C++Builder
• Download Dev-C++
• Learn Delphi
• Embarcadero Blogs
• DelphiFeeds

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• English (US)

Destructuring assignment

The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.

Description

The object and array literal expressions provide an easy way to create ad hoc packages of data.

The destructuring assignment uses similar syntax but uses it on the left-hand side of the assignment instead. It defines which values to unpack from the sourced variable.

Similarly, you can destructure objects on the left-hand side of the assignment.

This capability is similar to features present in languages such as Perl and Python.

For features specific to array or object destructuring, refer to the individual examples below.

Binding and assignment

For both object and array destructuring, there are two kinds of destructuring patterns: binding pattern and assignment pattern , with slightly different syntaxes.

In binding patterns, the pattern starts with a declaration keyword ( var , let , or const ). Then, each individual property must either be bound to a variable or further destructured.

All variables share the same declaration, so if you want some variables to be re-assignable but others to be read-only, you may have to destructure twice — once with let , once with const .

In many other syntaxes where the language binds a variable for you, you can use a binding destructuring pattern. These include:

• The looping variable of for...in for...of , and for await...of loops;
• Function parameters;
• The catch binding variable.

In assignment patterns, the pattern does not start with a keyword. Each destructured property is assigned to a target of assignment — which may either be declared beforehand with var or let , or is a property of another object — in general, anything that can appear on the left-hand side of an assignment expression.

Note: The parentheses ( ... ) around the assignment statement are required when using object literal destructuring assignment without a declaration.

{ a, b } = { a: 1, b: 2 } is not valid stand-alone syntax, as the { a, b } on the left-hand side is considered a block and not an object literal according to the rules of expression statements . However, ({ a, b } = { a: 1, b: 2 }) is valid, as is const { a, b } = { a: 1, b: 2 } .

If your coding style does not include trailing semicolons, the ( ... ) expression needs to be preceded by a semicolon, or it may be used to execute a function on the previous line.

Note that the equivalent binding pattern of the code above is not valid syntax:

You can only use assignment patterns as the left-hand side of the assignment operator. You cannot use them with compound assignment operators such as += or *= .

Default value

Each destructured property can have a default value . The default value is used when the property is not present, or has value undefined . It is not used if the property has value null .

The default value can be any expression. It will only be evaluated when necessary.

Rest property

You can end a destructuring pattern with a rest property ...rest . This pattern will store all remaining properties of the object or array into a new object or array.

The rest property must be the last in the pattern, and must not have a trailing comma.

Array destructuring

Basic variable assignment, destructuring with more elements than the source.

In an array destructuring from an array of length N specified on the right-hand side of the assignment, if the number of variables specified on the left-hand side of the assignment is greater than N , only the first N variables are assigned values. The values of the remaining variables will be undefined.

Swapping variables

Two variables values can be swapped in one destructuring expression.

Without destructuring assignment, swapping two values requires a temporary variable (or, in some low-level languages, the XOR-swap trick ).

Parsing an array returned from a function

It's always been possible to return an array from a function. Destructuring can make working with an array return value more concise.

In this example, f() returns the values [1, 2] as its output, which can be parsed in a single line with destructuring.

Ignoring some returned values

You can ignore return values that you're not interested in:

You can also ignore all returned values:

Using a binding pattern as the rest property

The rest property of array destructuring assignment can be another array or object binding pattern. The inner destructuring destructures from the array created after collecting the rest elements, so you cannot access any properties present on the original iterable in this way.

These binding patterns can even be nested, as long as each rest property is the last in the list.

On the other hand, object destructuring can only have an identifier as the rest property.

Unpacking values from a regular expression match

When the regular expression exec() method finds a match, it returns an array containing first the entire matched portion of the string and then the portions of the string that matched each parenthesized group in the regular expression. Destructuring assignment allows you to unpack the parts out of this array easily, ignoring the full match if it is not needed.

Using array destructuring on any iterable

Array destructuring calls the iterable protocol of the right-hand side. Therefore, any iterable, not necessarily arrays, can be destructured.

Non-iterables cannot be destructured as arrays.

Iterables are only iterated until all bindings are assigned.

The rest binding is eagerly evaluated and creates a new array, instead of using the old iterable.

Object destructuring

Basic assignment, assigning to new variable names.

A property can be unpacked from an object and assigned to a variable with a different name than the object property.

Here, for example, const { p: foo } = o takes from the object o the property named p and assigns it to a local variable named foo .

Assigning to new variable names and providing default values

A property can be both

• Unpacked from an object and assigned to a variable with a different name.
• Assigned a default value in case the unpacked value is undefined .

Unpacking properties from objects passed as a function parameter

Objects passed into function parameters can also be unpacked into variables, which may then be accessed within the function body. As for object assignment, the destructuring syntax allows for the new variable to have the same name or a different name than the original property, and to assign default values for the case when the original object does not define the property.

Consider this object, which contains information about a user.

Here we show how to unpack a property of the passed object into a variable with the same name. The parameter value { id } indicates that the id property of the object passed to the function should be unpacked into a variable with the same name, which can then be used within the function.

You can define the name of the unpacked variable. Here we unpack the property named displayName , and rename it to dname for use within the function body.

Nested objects can also be unpacked. The example below shows the property fullname.firstName being unpacked into a variable called name .

Setting a function parameter's default value

Default values can be specified using = , and will be used as variable values if a specified property does not exist in the passed object.

Below we show a function where the default size is 'big' , default co-ordinates are x: 0, y: 0 and default radius is 25.

In the function signature for drawChart above, the destructured left-hand side has a default value of an empty object = {} .

You could have also written the function without that default. However, if you leave out that default value, the function will look for at least one argument to be supplied when invoked, whereas in its current form, you can call drawChart() without supplying any parameters. Otherwise, you need to at least supply an empty object literal.

For more information, see Default parameters > Destructured parameter with default value assignment .

Nested object and array destructuring

For of iteration and destructuring, computed object property names and destructuring.

Computed property names, like on object literals , can be used with destructuring.

Invalid JavaScript identifier as a property name

Destructuring can be used with property names that are not valid JavaScript identifiers by providing an alternative identifier that is valid.

Destructuring primitive values

Object destructuring is almost equivalent to property accessing . This means if you try to destruct a primitive value, the value will get wrapped into the corresponding wrapper object and the property is accessed on the wrapper object.

Same as accessing properties, destructuring null or undefined throws a TypeError .

This happens even when the pattern is empty.

Combined array and object destructuring

Array and object destructuring can be combined. Say you want the third element in the array props below, and then you want the name property in the object, you can do the following:

The prototype chain is looked up when the object is deconstructed

When deconstructing an object, if a property is not accessed in itself, it will continue to look up along the prototype chain.

Specifications

Browser compatibility.

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

• Assignment operators
• ES6 in Depth: Destructuring on hacks.mozilla.org (2015)