Do you want to learn how trivial copy constructors work in a C++ app? Do you need to know what trivial constructors are? Should we declare a trivial copy constructor in a Class in C++ or not? Let’s start with refreshing our memories on constructors and copy constructor,
Table of Contents
What is a C++ constructor?
The Constructor in C++ is a function, a method in the class, but it is a ‘special method’ that is automatically called when an object of a class is created. We don’t need to call this function. Whenever a new object of a class is created, the Constructor allows the class to initialize member variables or allocate storage. This is why the name Constructor is given to this special method. Here is a simple constructor class example below,
|
1 2 3 4 5 6 7 8 9 10 |
class myclass { public: myclass() { std::cout << "myclass is constructed!\n"; }; }; |
There are different constructor types in classes and the Copy Constructor is one of these. Copy Constructors are not only used in classes but also used with struct and union data types.
What is a copy constructor in C++?
The Copy Constructor in classes (i.e class_name) is a non-template constructor whose first parameter is class_name&, const class_name&, volatile class_name&, or const volatile class_name& . It can be used with no other parameters or with the rest of the parameters all have default values.
The Copy Constructor is a constructor type for classes that class_name must name the current class, or it should be a qualified class name when it is declared at namespace scope or in a friend declaration.
What is a trivial copy constructor in C++?
A Trivial Copy Constructor for a non-union class effectively copies all properties (scalar sub objects, all sub objects of sub objects) of the argument and performs no other action. However, padding bytes need not be copied, and even the object representations of the copied sub objects need not be the same as long as their values are identical. In general, the syntax to declare Copy Constructor is the following:
|
1 2 3 |
class_name (const class_name &) |
If you don’t declare anything as above, the class has a Copy Constructor, and a new subclass may have this Copy Constructor which is called a Trivial Copy Constructor. Syntax to use Copy Constructor which copies source_class to new_class as below,
|
1 2 3 |
class_name new_class(source_class); |
The copy constructor for The class is trivial if all below is maintained,
- The Class is not user-provided
- The Class has no virtual member functions
- The Class has no virtual base classes
and also note that,
- The copy constructor selected for every direct base of The Class is trivial
- The copy constructor selected for every non-static class type (or array of class type) member of The Class is trivial
What is the basic syntax of a trivial copy constructor in a C++ app?
Here is a simplified Syntax,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class myclass { public: // properties here // this class has a copy constructor }; class my_otherclass : public myclass { // This class has a Trivial Copy Constructor from myclass }; |
Here is a full example of using a C++ trivial copy constructor
Let’s see how we use this Trivial Copy Constructor in a full example as below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#include <iostream> class myclass { public: int param = 0; // this class has a copy constructor }; class my_otherclass : public myclass { // This class has a Trivial Copy Constructor from myclass }; int main() { my_otherclass class1; class1.param=100; std::cout << class1.param << '\n' ; // Copy Class1 to Class2 by using Trivial Copy Constructor my_otherclass class2(class1); std::cout << class2.param << '\n' ; getchar(); return 0; } |
and the output will be as below,
|
1 2 3 4 |
100 100 |
as you see we don’t declare or define any Copy Constructor for the myclass or my_otherclass, we just use,
|
1 |
my_otherclass class2(class1); |
and all properties of this class have been copied by the Trivial Copy Constructor. If you want to copy some of the parameters or if you don’t want to use Trivial Copy Constructor, you can manually copy parameters as below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include <iostream> class myclass { public: int param = 0; myclass(const myclass& a) // Copy Constructor { param =a.param; }; }; class my_otherclass : public myclass { // This class has a Trivial Copy Constructor from myclass }; int main() { my_otherclass class1; class1.param=100; std::cout << class1.param << '\n' ; // Copy Class1 to Class2 by using Copy Constructor my_otherclass class2(class1); std::cout << class2.param << '\n' ; getchar(); return 0; } |
