MyString(const MyString &_str);跟运算符=的重载不是一个意思吗？为什么复制构造函数的定义不能像=重载那样写？

问题描述：

//6-24.2classfile.cpp

#include <iostream>
#include <string.h>
#include "6-24.2classfile.h"
using namespace std;
//constructor&destructor
MyString::MyString()
{
    str=new char;//???
    str[0]='\0';
    len=0;   //为什么长度等于0？ 
}
MyString::MyString(const char *_str)   //char *_str是一个char数组 
{
    len=strlen(_str);
    str=new char[len+1];
    str[len]='\0';
    strncpy(str,_str,len+1);        //strncpy有三个参数
    // char *strncpy(char *dest, const char *src, size_t n) 
    //把 src 所指向的字符串复制到 dest，最多复制 n 个字符。
    /*当_str长度小于第三个参数n时 ，str的剩余部分将用空字节填充*/ 
}
MyString::MyString(const MyString &_str)
{
    len =_str.len;
    str=new char[len+1];
    str[len]='\0';
    strncpy(str,_str.str,len+1);        //_str.str(_str
    //cout<<str<<endl;
}
void MyString::operator =(const MyString &_str)
{
    str=_str.str;
    len=_str.len;
}
MyString::~MyString(){                  //???
}
//operator
const MyString MyString::operator +(const MyString &_str)
{
    int newLen=len+_str.len;
    char *newStr=new char[newLen+1];
    newStr[newLen]='\0';
    strncpy(newStr,str,len);        //先将str(原字符串)复制到新的字符数组 
    strncat(newStr,_str.str,_str.len);    //在将_str.str将接到newStr后面
    /*char *strncat(char *dest, const char *src, size_t n)
     把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。*/ 
    return MyString(newStr);       //返回一个MyString类对象 
}

//friend
istream & operator >>(istream &_in,MyString &_str)
{
    _in>>_str.str;                      //istream是什么鬼？ 输入流 
    _str.len=strlen(_str.str);
    return _in;
}
ostream & operator <<(ostream &_out,MyString &_str)
{
    _out<<_str.str<<endl<<"length:"<<_str.len;  //
    return _out; 
}

//6-24.2classfile.h

#include <iostream>
#include <string>
using namespace std;

class MyString{
    public:
        MyString();
        MyString(const char *_str);
        MyString(const MyString &_str);
        ~MyString();
    public:
        const MyString operator +(const MyString &_str);
        void operator =(const MyString &_str);
        void operator +=(const MyString& _str);
        const char operator [](int i);
    public:
        friend istream & operator >>(istream &_in,MyString &_str);
        friend ostream & operator <<(ostream &_out, MyString &_str); 
    private:
        char *str;
        int len;
};

答

大概因为拷贝构造函数是新建一个对象，而赋值运算符(=)是复制。
简单的例子，某个类如果需要唯一序列号，调用拷贝构造函数则会生成新的序列号，而调用赋值运算符应该是同一序列号

答

两者并不一样，看下面的代码

#include <iostream>
using namespace std;
class MyString
{
public:
    MyString& operator =(const MyString _str)
    {
        cout << "=" << endl;
        return *this;
    }
    MyString(MyString &_str)
    {
        cout << "ctor" << endl;
    }
    MyString(){}
};
MyString func1()
{
    MyString str;
    return str;
}
int main()
{
    cout << "1" << endl;
   MyString str0 = func1();
    cout << "2" << endl;
   MyString str1;
   str1 = func1();
   return 0;
}

1
ctor
2
ctor
=
Press any key to continue . . .

MyString(const MyString &_str);跟运算符=的重载不是一个意思吗？为什么复制构造函数的定义不能像=重载那样写？

相关推荐