首页 > 试题广场 >

编写类String的构造函数、析构函数和赋值函数

[问答题]
编写类String的构造函数、析构函数和赋值函数，已知类String的原型为： 
class String 
{  
 public:  
 String(const char *str = NULL); // 普通构造函数  
 String(const String &other); // 拷贝构造函数  
 ~ String(void); // 析构函数  
 String & operator =(const String &other); // 赋值函数  
 private:  
 char *m_data; // 用于保存字符串  
};
查看答案及解析
添加回答
NWU头像 NWU
在C++中，下面三种对象需要调用拷贝构造函数
1. 对象以值传递的方式传入函数参数 
2. 对象以值传递的方式从函数返回
3. 对象需要通过另外一个对象进行初始化

Ps.最后一句中的60%不太赞同
发表于 2015-12-22 22:16:05 回复(2)
酷毙了的刘珂头像 酷毙了的刘珂
我就只针对复制赋值函数写下看法： 
MyString& MyString::operator=(const MyString& other) {
	if (&other != this) {
		MyString temp(other);//考虑异常安全的做法
		char* pTemp = temp.m_data;
		temp.m_data = this->m_data;
		this->m_data = pTemp;
	}
	return *this;
}
这样是有好处的哦
发表于 2017-04-05 17:53:57 回复(8)
刀客头像 刀客 
//constructor
String::String(const char *str = NULL)
{
    if(str == NULL)
    {
         m_data = new char[1];
         *m_data = '\0';
    }
    else
    {
        m_data = new char[strlen(str) + 1];
        memcpy(m_data, str, strlen(str) + 1);
    }
}

//copy constructor
String::String(const String &other)
{
    m_data = new char[strlen(other.m_data) + 1];
    if(m_data == NULL)
    {
        std::cerr << "allocator memory failed in String::String(const String &other)";
    }
    else
    {
        strcpy(m_data, other.m_data);
    }
}

//destructor
String::~String(void)
{
    delete [] m_data;
}

//copy-assign operator
String &String::operator=(const String &other)
{
    if(this == &other)//self assignment
        return *this;
    size_t len = strlen(other.m_data);
    delete [] m_data;
    m_data = new char[len+1];
    strcpy(m_data, other.m_data);
    return *this;
}

发表于 2016-06-15 11:28:46 回复(1)
小小头像 小小 
//普通构造函数 
String::String(const char *str)  
{ 
 if(str==NULL)  
 { 
 m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空 
 //加分点：对m_data加NULL 判断 
 *m_data = '\0';  
 }  
 else 
 { 
 int length = strlen(str);  
 m_data = new char[length+1]; // 若能加 NULL 判断则更好  
 strcpy(m_data, str);  
 } 
} 
// String的析构函数 
String::~String(void)  
{ 
 delete [] m_data; // 或delete m_data; 
} 
//拷贝构造函数 
String::String(const String &other) 　　　// 得分点：输入参数为const型 
{  
 int length = strlen(other.m_data);  
 m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断 
 strcpy(m_data, other.m_data);  
} 
//赋值函数 
String & String::operate =(const String &other) // 得分点：输入参数为const型 
{  
 if(this == &other) 　　//得分点：检查自赋值 
 return *this;  
 delete [] m_data; 　　　　//得分点：释放原有的内存资源 
 int length = strlen( other.m_data );  
 m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断 
 strcpy( m_data, other.m_data );  
 return *this; 　　　　　　　　//得分点：返回本对象的引用 
}
剖析
能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！  
在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。  
仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！  
发表于 2015-10-28 18:04:52 回复(4)
期待最好的自己头像 期待最好的自己
自己实现了一遍，能跑通。
加了个析构里边，delete之后，再置指针为NULL.
#include <iostream>
#include <assert.h>
using namespace std;


class String
{
public:
	String(const char* str = NULL);
	String(const String &other);
	~String();
	String &operator= (const String &other);
private:
	char *m_data;
};

String::String(const char* str)
{
	if (str == NULL)
	{
		m_data = new char[1];
		assert(m_data != NULL);

		m_data = '\0';
	}
	else
	{
		int len = strlen(str);
		m_data = new char[len];
		assert(m_data != NULL);

		//memcpy(m_data, str, len);	// 法1
		strcpy(m_data, str);
	}
}

String::String(const String &other)
{
	assert(this != &other);
	int len = strlen(other.m_data);

	m_data = new char[len];
	assert(m_data != NULL);

	strcpy(m_data, other.m_data);
}

String::~String(void)
{
	delete[] m_data;
	m_data = NULL;
}

String& String::operator=(const String &other)
{
	if (this == &other)
	{
		return *this;
	}

	delete[] m_data;
	m_data = NULL;

	int len = strlen(other.m_data);
	m_data = new char[len];
	assert(m_data != NULL);

	memcpy(m_data, other.m_data, len);
	// 法2：strcpy(m_data, other.m_data);

	return *this;
}

int main(char argc, char *argv)
{
	String s1;
	String s2("222");
	s1 = s2;

	return 0;
}

发表于 2017-06-13 22:51:58 回复(2)
木有银弹头像 木有银弹
拷贝赋值运算符没有考虑到异常安全！new 操作可能失败抛出异常，如果在 new 之前 delete 掉了数据成员，同时又发生异常，那么赋值左侧运算对象的状态会被破坏。
编辑于 2020-02-18 16:22:56 回复(1)
柠檬的味道头像 柠檬的味道
//赋值函数
String & String::operator =(const String &other) // 得分点：输入参数为const型
{ 
 if(this == &other) //得分点：检查自赋值
 return *this; 
 delete [] m_data; //得分点：释放原有的内存资源
 int length = strlen( other.m_data ); 
 m_data = new char[length+1]; 
 strcpy( m_data, other.m_data ); 
 return *this; //得分点：返回本对象的引用
}

上述答案中为什么要delete [] m_data; //得分点：释放原有的内存资源
发表于 2018-04-04 17:32:58 回复(0)
雷军头像 雷军
最多具备20% C++基本功
发表于 2017-04-09 17:38:32 回复(0)
牛客453259160号头像 牛客453259160号
<p>普通构造函数：判断str是否为空，为空加一个终止符</p><p>拷贝构造函数：形参要const，申请内存后直接拷贝</p><p>赋值运算符：自赋值判断，如不是自己则删除旧内存，拷贝新的</p>
发表于 2020-07-22 18:13:53 回复(0)
千年的希望头像 千年的希望
注意strlen传入Null时会报错
发表于 2020-04-05 18:10:35 回复(0)
闫++头像 闫++
C++类默认构造函数的考核，主要难点在于普通里的空检查，拷贝里的空间大小，赋值里的相等判断。
String::String(const char* str){
    if(str==NULL)
    {
        m_data=new char[1];
        *m_data='\0';
    }

    else
    {
        int len=strlen(str)+1;
        m_data=new char[len];
        strcpy(m_data,str);
    }
}

String::~String(){
    delete []m_data;
}

String::String(const String &other){
    m_data=new char[strlen(other.m_data)+1];
    strcpy(m_data,other.m_data);
}

String & String::operator=(const String &other){
    if(this==other)
    {
        return *this;
    }
    delete []m_data;
    m_data=new char[strlen(other.m_data)+1];
    strcpy(m_data,other.m_data);
    return *this;
}

发表于 2019-12-11 10:30:33 回复(0)
你还记得吗头像 你还记得吗
自己实现一遍
class string
{
public:
string(const char* str);
~string(void);
string(const string&other);
string&operator=(const string&other);
private:
char*m_data;
}

string::string(const  char*str)//构造函数
{
if(str==NULL)
{
m_data=new char(1);
*m_data='\0';
}
else
{
int length=strlen(str);
m_data=new char(length+1);
strcpy(m_data,str);
}
}


string::~string(void).//析构函数
{
delete[] m_data;
m_data=NULL;
}

stirng::string(const string&other)//拷贝构造
{
int length=strlen(other.m_data);
m_data=new char(length+1);
strcpy(m_data,other.m_data);
}

string&string::operator=(const string&other)//赋值运算符
{
if(this==&other)
{
return *this;
}
else
{
delete[]m_data;
}
int length=strlen();
m_data=new char(lengh+1);
strcpy(m_data,other.m_data);
return *this;
}


编辑于 2018-03-26 02:35:34 回复(0)
oscarwin头像 oscarwin 
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#define NULL 0

class string
{
public:
	string(char* str = NULL);
	string(const string& str);
	~string();
	string operator=(const string& str);
private:
	char* m_data;
};

string::string(char* str)
{
    if(str == NULL)
		m_data = NULL;
	else
	{
		m_data = (char*)malloc(strlen(str) + 1);
		assert(m_data != NULL);
		strcpy(m_data, str);
	}
}

string::~string()
{
	free(m_data);
	m_data = NULL;
}

string::string(const string& str)
{
	this->operator=(str);
}

string string::operator=(const string& str)
{
	if(this == &str)
		return *this;
	char* tmp = (char*)malloc(strlen(str.m_data) + 1);
	assert(tmp != NULL);
	free(m_data);
	m_data = tmp;
	strcpy(m_data, str.m_data);
	return *this;
}


发表于 2017-07-30 18:14:40 回复(0)
小迷糊蛋头像 小迷糊蛋
String::String(const char* str){
if(str==NULL){
m_data=new char[1];
*m_data='/0';
}
else{
int len=strlen(str);
m_data=new char[len+1];
strcpy(m_data,str);
}
}
String::~String(){
delete [] m_data;
}
String::String(const String &other){
int len=strlen(other.m_data);
m_data=new char[len+1];
strcpy(m_data,other.m_data);
}
String & String::operator=(const String &other){
if(this==&other)
return *this;
delete [] m_data;
int len=strlen(other.m_data);
m_data=new char[len+1];
strpy(m_data,other.m_data);
return *this;
}

发表于 2017-07-14 16:30:34 回复(0)
萌么哒头像 萌么哒
class String
{
public:
String(const char*str=NULL)  //用str构造m_data;
{
if(str==NULL)  //如果传入的指针为空，要进行控制
{
m_data=new char[1];
*m_data='\0';
}
else
{
int len=strlen(str)+1;
m_data=new char[len];
assert(m_data!=NULL);   //
strcpy(m_data,str);
}
}
String(const String&other)   //拷贝构造
{
int len=strlen(other.m_data)+1;
m_data=new char[len];
assert(m_data!=NULL);
strcpy(m_data,other.m_data);
}
~String()
{
delete m_data;
m_data=NULL;
}
String&operator=(const String&other)
{
//1.判断是否是自己，析构原来的空间
//2.开辟新的空间
//3.深拷贝
if(this==&other)
return *this;
delete m_data;
m_data=NULL;

int len=strlen(other.m_data)+1;
m_data=new char[len];
assert(m_data!=NULL);
strcpy(m_data,other.m_data);
return *this; 
	}
private:
	char* m_data;
};

发表于 2017-07-03 13:14:51 回复(0)
Kerr0817头像 Kerr0817
来自剑指offer String &String::operator=（const String &other） { if（this != &other） { String tmp（other）; char* tmp_data = tmp.m_data; tmp.m_data=m_data; m_data=tmp.m_data; } return *this; }
发表于 2017-04-19 22:56:58 回复(0)
dayong657头像 dayong657
my ability of cpp is less than 60%，~~~~~
发表于 2017-03-18 14:12:15 回复(0)
philian头像 philian
我就想知道，为什么访问权限是private的m_data，在拷贝和赋值的函数体内都能访问到= =
发表于 2016-09-11 14:29:34 回复(2)
kareni头像 kareni
判断为空好像真的没必要吧
发表于 2016-05-22 12:23:19 回复(0)
提交观点

问题信息

C++
上传者：小小
难度：
19条回答 14061浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号