3

我有以下问题。我尝试了按值和按引用进行赋值，如here所述，赋值ba值应该更快，尽管当我尝试我的代码时，它给了我一个相当复杂的结果，因为有时assign1更快，有时assign2。

    class MyAddress{
    char *name;
    long int number;
    char *street;
    char *town;
    char state[2];
    long zip;
    std::vector<int> v_int;
public:
    MyAddress(int i){
        v_int.resize(1000000);
        std::fill(v_int.begin(),v_int.end(),i);
    }
    MyAddress& assign1(MyAddress const& x)
    { 
        MyAddress tmp(x);          // copy construction of tmp does the hard work
        std::swap(*this, tmp);  // trade our resources for tmp's
        return *this;      // our (old) resources get destroyed with tmp 
    }
    MyAddress& assign2(MyAddress x)//x is a copy of the source; hard work already done
    { 
        std::swap(*this, x);  // trade our resources for x's
        return *this;      // our (old) resources get destroyed with x 
    }
};

主要的：

for(int i=0;i<10;i++){
        {
            MyAddress a1(1);
            MyAddress a2(2);
            MyAddress a3(3);
            clock_t tstart=std::clock();
            a1.assign1(a2);
            a1.assign1(a3);
            clock_t tend=std::clock();
            float time_elapsed=((float)tend-(float)tstart);
            std::cout<<std::fixed<<"\nassign1 time elapsed : "<<time_elapsed/CLOCKS_PER_SEC;
        }
        {
            MyAddress a1(1);
            MyAddress a2(2);
            MyAddress a3(3);
            clock_t tstart=std::clock();
            a1.assign2(a2);
            a1.assign2(a3);
            clock_t tend=std::clock();
            float time_elapsed=((float)tend-(float)tstart);
            std::cout<<"\nassign2 time elapsed : "<<time_elapsed/CLOCKS_PER_SEC;
        }
    std::cout<<std::endl;
    }

分配 1 已用时间：0.093000 分配 2 已用时间：0.094000

分配 1 已用时间：0.095000 分配 2 已用时间：0.092000

分配 1 已用时间：0.109000 分配 2 已用时间：0.093000

分配 1 已用时间：0.099000 分配 2 已用时间：0.094000

分配 1 已用时间：0.099000 分配 2 已用时间：0.101000

分配 1 已用时间：0.096000 分配 2 已用时间：0.120000

分配 1 已用时间：0.098000 分配 2 已用时间：0.105000

分配 1 已用时间：0.113000 分配 2 已用时间：0.108000

分配 1 已用时间：0.111000 分配 2 已用时间：0.103000

分配 1 已用时间：0.106000 分配 2 已用时间：0.106000

我对测试代码进行了一些更改：现在我执行 1000 次迭代而不是 10 次。结果仍然喜忧参半：对我来说特别奇怪的是，有时第一次分配更快，但有时第二次：

1)
assign1 time elapsed : 111.228996
assign2 time elapsed : 112.097000
2)
assign1 time elapsed : 127.087997
assign2 time elapsed : 126.691002

你怎么解释这个？对我来说，在这种情况下，结果似乎与值或参考方法无关。

最后我使用了类似的东西，因为如果我理解正确，我认为这是这里建议的方法

MyAddress get_names(MyAddress& ref){return ref;}

现在在assign2中是这样完成的：

a1.assign2(get_names(a2));
a1.assign2(get_names(a3));

事实上，assign2 的性能稍好一些，至少每次都是这样，不像以前那样互换。但这就是我应该看到的区别吗？

assign1 time elapsed : 127.087997
assign2 time elapsed : 126.691002

assign1 time elapsed : 137.634995
assign2 time elapsed : 136.054993

最后：

assign1 time elapsed : 1404.224976
assign2 time elapsed : 1395.886963
4

2 回答 2

6

您的两个分配功能基本相同。在一个中，您自己复制构建临时文件，而在另一个中，副本由编译器自动注入。

此外，对于您的测试，10 也不是一个足够大的因素。

于 2012-05-19T18:39:02.937 回答
1

对于一般情况，
引用赋值几乎总是优于值赋值。

原因 ：

  1. 引用赋值不会在堆栈上创建新空间
  2. 它不必将值从旧变量复制到新变量

对于大多数程序来说，上述开销可能是微不足道的。但是，const 和 reference 是一种通用的编程实践。

在当前程序中，
两种配置都将执行相同的操作。用大量迭代尝试你的程序，看看时间上的差异。

于 2012-05-19T18:38:11.480 回答