四个类型的字符串返回值操作性能比较

情景如下：

第一种是拷贝返回，调用时候直接使用。

第二种是拷贝返回，调用时候先取出来赋值给另外一个变量，再操作。

第三种是，引用返回，调用的时候直接使用。

第四种是，引用返回，赋值后再操作。

总的程序：

/*
* File:   retstringtest.cpp
* Author: jaylong35
*
* Created on 2011年5月30日, 上午9:51
*/
#include <cstdlib>
#include <string>
#include <iostream>
#include <sys/time.h>
using namespace std;
/*
*
*/
typedef void(* _testfunc)();
char str[1024] = {0};
void setstr()
{
memset(str, 'a', 1024);
}
double TestTime(_testfunc func, int ncount)
{
int num = ncount;
struct timeval start,end;
gettimeofday(&start, NULL);
while(num>0)
{
func();
num--;
}
gettimeofday(&end, NULL);
double time = (double)(end.tv_sec - start.tv_sec)*1000 + (double)(end.tv_usec - start.tv_usec)/1000;
return time;
}
std::string strtest = str;
std::string getstr()
{
return strtest;
}
const std::string & getstr1()
{
return strtest;
}
void setstr(const std::string &str)
{
std::string tstr = str;
}
void test1()
{
setstr(getstr());
setstr(getstr());
setstr(getstr());
}
void test2()
{
std::string str = getstr();
setstr(str);
setstr(str);
setstr(str);
}

void test3()
{
std::string str = getstr1();
setstr(str);
setstr(str);
setstr(str);
}
void test4()
{
setstr(getstr1());
setstr(getstr1());
setstr(getstr1());
}
int main(int argc, char** argv)
{
setstr();
int i = 30;
cout<<"test1 /ttest2 /ttest3 /ttest4 "<<endl;
while(i >= 0)
{
double t1 = TestTime(test1,100000);
double t2 = TestTime(test2,100000);
double t3 = TestTime(test3,100000);
double t4 = TestTime(test4,100000);
cout<<t1<<"/t"<<t2<<"/t"<<t3<<"/t"<<t4<<endl;
i--;
}
return 0;
}

结果返回：

test1 test2 test3 test4

0.81 0.612 0.603 0.48

3.316 0.597 0.578 0.482

0.805 0.599 0.572 0.505

0.804 0.574 0.549 0.446

0.8 0.572 0.607 0.479

0.808 0.655 0.569 1.677

0.805 0.649 0.576 0.483

0.806 0.603 0.568 0.48

0.836 0.724 0.574 0.486

0.797 0.593 0.574 0.479

0.808 0.594 0.577 0.483

结论：

1、拷贝返回，因为返回的时候要进行拷贝操作所以要比引用返回消耗的时间多。

2、如果一个函数是拷贝返回的时候，先把这个值赋出来，再用新的变量操作，比每次直接调用性能要高。因为这样只有一次拷贝，多次使用，特别是使用频率高的时候。

3、引用返回，因为没有拷贝操作，所以性能比较好。不过，引用返回的，不需要再去赋值，赋值后性能反而下降了。