C ++：将一个对象复制到构造函数中的另一个对象

Question

In my code, I am trying to make a string class (it's an assignment) and have a class with the following data:

private:
  int   strLen;
  int   dataLen;
  char* data;

and the constructors:

myStr();
myStr(const myStr&);
myStr(const char*);

The third constructor takes a string array, allocates space to data and copies it in, sets the strLen to the amount of characters in the string, and dataLen to the size of the array. The second constructor is similar, however it takes an entire object and is supposed to copy it into the new object that the constructor is creating. An example could look like this:

myStr fred("Fred");
myStr quote(fred);

My question is, is there a way to copy object fred to object quote in the constructor without copying each individual piece of data (ie strLen, dataLen and data)? For this assignment, there are only 3 pieces of data, but say there were 50, or 100, it would be long and tedious. I tried searching for an answer and came across copy-constructors, however I was left uncertain how they work, or if they are just manually copying each piece of data anyway. I am new to the syntax of classes so I apologize if the answer was trivial and I was just looking for answers in all the wrong places. Thank you.

Answer 1

is there a way to copy object fred to object quote in the constructor without copying each individual piece of data (ie strLen, dataLen and data)?

Nope. The job of a copy constructor (and copy assignment operator) is to copy each individual field as needed. And in your case, since your data is dynamically allocated, that also means allocating a new memory block to copy the character data into.

For this assignment, there are only 3 pieces of data, but say there were 50, or 100, it would be long and tedious.

Yes, it would be, which is why:

1. classes should be as short and precise as possible. Larger, more complex, classes can then be designed using smaller classes to manage data efficiently.

2. you should be using data types that the compiler can copy for you. If you do not provide a copy constructor (or copy assignment operator), the compiler generates a default one for you (unless you tell the compiler not to do so - C++11 and later only) that does a member-by-member copy. That default implementation works fine for trivial data types, and user-defined types that implement proper copy semantics (copy constructor and copy assignment operator).

In your example, if you replaced your three fields with a single std::string field, your class would not need to implement custom copy semantics anymore, the compiler-generated copy constructor and copy assignment operator would be sufficient.

If you need to worry about implementing manual memory management when copying data, read up about the Rule of Three and why proper copy semantics are important.