问个简单的问题:重载加号运算符(+)的时候,如何处理临时变量的问题?

[RunningYang]

例如我写了一个字符串类 TStr,想实现我的类对象+char*的时候能返回 TStr对象
类似下面的情况:
TStr s1="aa";
TStr s2="bb"+s1;

如下重载显然不行,因为返回的是临时变量
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
return rst;
}

大致看了一下 CString 的实现方式,它好像是用引用计数来实现的,但是没有看出什么头绪
请大家指点一下
谢谢

[Mr_defy_L]

返回临时变量谁说不行？？
不行的是返回临时变量的指针或引用

[RunningYang]

额...
是这样,为了防止内存泄露,肯定是要在类的析构函数里面把内存释放掉的
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
return rst;
}
所以在 return rst 之前就已经调用析构函数了
所以就不正常工作了啊

[Mr_defy_L]

[Quote=引用 2 楼 的回复:]
额...
是这样,为了防止内存泄露,肯定是要在类的析构函数里面把内存释放掉的
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
return rst;
}
所以在 return rst 之前就已经调用析构函数了
所以就不正常工作了……
[/Quote]

你的返回值总要用是吧，再你用完后自然会析构，所以不会存在你没用就析构了？你写写代码验证下

[RunningYang]

[Quote=引用 3 楼 的回复:]
引用 2 楼 的回复:
额...
是这样,为了防止内存泄露,肯定是要在类的析构函数里面把内存释放掉的
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
return rst;
}
所以在 return rst 之前就已经调……
[/Quote]
晕,问题是我们没有办法决定啥时候析构啊

[Mr_defy_L]

[Quote=引用 4 楼 的回复:]
引用 3 楼 的回复:
引用 2 楼 的回复:
额...
是这样,为了防止内存泄露,肯定是要在类的析构函数里面把内存释放掉的
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
return rst;
}
所以在 ……
[/Quote]
你写个试试，绝对不会出错，析构函数是当对象生命周期结束后才运行

[RunningYang]

[Quote=引用 5 楼 的回复:]
引用 4 楼 的回复:
引用 3 楼 的回复:
引用 2 楼 的回复:
额...
是这样,为了防止内存泄露,肯定是要在类的析构函数里面把内存释放掉的
TStr operator+(char* str1,TStr& str2)
{
TStr rst;
rst.Append(str1);
rst.Append(str2.GetData());
ret……
[/Quote]

我理解你的意思
但是我就是因为出错了才过来请大家帮忙的.就是因为我的是字符串类,所以会有指针,默认的拷贝构造无法完成
要想想办法...

[Mr_defy_L]

你去查查深拷贝和浅拷贝，等等，我给你写个例子吧

[Mr_defy_L]

代码写的比较简陋，凑合着看

#include <iostream>

class string {
public:
	string (const char *ch=NULL);
	string (const string &str);
	~string();
	const string operator + (const string &str);
	string &operator += (const string &str);
	friend std::ostream& operator<<(std::ostream &out,const string &str);
	int Length()const;
private:
	char *pch;
};

string::string(const char *ch)
{
	if(ch)
	{
		pch = new char [strlen(ch)+1];
		strcpy(pch,ch);
	}
	else
		pch = NULL;
}

string ::string(const string &str)
{
	pch = new char[str.Length()+1];
	strcpy(pch,str.pch);
}
string ::~string()
{
	if(pch)
	{
		delete []pch;
		pch = NULL;
	}

}

string &string::operator+=(const string &str)
{
	string temp(*this);
	delete []pch;
	pch = new char[temp.Length()+str.Length()+1];
	strcpy(pch,temp.pch);
	strcat(pch,str.pch);
	return *this;
}
const string string::operator+(const string &str)
{
	return string(*this+=str);
}

int string::Length()const
{
	if(pch)
		return strlen(pch);	
	return 0;
}

std::ostream& operator<<(std::ostream &out,const string &str)
{
	out<<str.pch;
	return out;
}

int main()
{
	string str("I love");
	//if((str+"c++") = "")			返回重载+返回const的原因，不返回const 这句也正确 
	
	std::cout<<str+" c++"<<std::endl;

	return 0;
}

[Mr_defy_L]

[Quote=引用 8 楼 的回复:]
代码写的比较简陋，凑合着看

C/C++ code
#include <iostream>

class string {
public:
string (const char *ch=NULL);
string (const string &str);
~string();
const string operator + (const ……
[/Quote]

这句改下

const string string::operator+(const string &str)
{
	return string(*this)+=str;
}

[sj720618]

你是想两个对象共用一个char*吗? 如果是的话,加个引用计数,最后一个对象析构的时候再实际释放缓冲区

[RunningYang]

多谢,多谢