Shulou(Shulou.com)06/01 Report--

Editor to share with you C++ deep and shallow copies and string type of writing, I believe that most people do not know much, so share this article for your reference, I hope you will learn a lot after reading this article, let's go to understand it!

1. Deep and shallow copy

The word copy should be familiar to us, for example, our usual copy and paste is copy, but it's a little complicated if we put the word copy in C++. Let's take a look at what a shallow copy is:

The following uses a string class to simulate the implementation.

Class Astring {public: / / constructor Astring (const char* str = ") {_ str = new char [strlen (str) + 1]; strcpy (_ str, str);} / / using shallow copy constructor Astring (const Astring& s) {_ str = s._str } / / Destructor ~ Astring () {delete [] _ str; _ str = nullptr;} private: char* _ str;}; int main () {Astring aa ("hello C++"); Astring bb (aa); / / copy construction return 0;}

When we execute the above procedure, we will fail, and the result is as follows:

The analysis is shown in the following figure:

So we can't use the same space with shallow copy, so what should we do? Of course, it is to reopen a space of the same size as others, and then copy the contents of other people's space, and this is the so-called deep copy. We still use string classes to simulate deep copy:

Class Astring {public: / / constructor Astring (const char* str = "") {_ str = new char [strlen (str) + 1]; strcpy (_ str, str) } / / the deep copy constructor Astring (const Astring& s) {_ str = new char [strlen (s._str) + 1]; strcpy (_ str, s._str);} / / destructor ~ Astring () {delete [] _ str _ str = nullptr;} private: char* _ str;}; int main () {Astring aa ("hello C++"); Astring bb (aa); return 0;}

The analysis is shown in the following figure:

Second, two writing methods of string class

With the deep and shallow copies we know above, we understand that copy constructors and assignment overloads in classes must be implemented with deep copies, but there are two ways to write copy constructors and assignment overloads.

1. Traditional writing method

The traditional way of writing is to create your own space to copy other people's things, and do everything on your own. The code is as follows:

/ / create a namespace that implements the string class namespace cjy {class string {public: / / constructor string (const char* str = ""): _ str (new char [strlen (str) + 1]) {strcpy (_ str, str) } / / copy constructor string (string& s): _ str (new char [strlen (s._str) + 1]) {strcpy (_ str, s._str) } / / assignment overloading, s1=s3 string& operator= (const string& s) {if (this! = & s) {char* tmp = new char [strlen (s._str) + 1] Delete [] _ str; _ str = tmp; strcpy (_ str, s._str);} return * this } / / destructor ~ string () {delete [] _ str; _ str = nullptr;} private: char* _ str;};} 2. Modern writing method

The modern way of writing is to reuse other functions and hand them over to other functions to help you with their own work. The code is as follows:

/ / Modern writing: copy construction, assign overloaded function namespace cjy {class string {public: / / constructor string (const char* str = ") {_ str = new char [strlen (str) + 1]; strcpy (_ str, str) } / / copy constructor string (const string& s): _ str (nullptr) {string tmp (s._str); std::swap (_ str, tmp._str) } / / assign overload string& operator= (string s) {std::swap (_ str, s._str); return * this;} private: char* _ str;} } the above is all the contents of this article entitled "what are the deep and shallow copies of C++ and how to write string?" Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.