这是您应该真正衡量的情况。
我正在查看 OP 的复制赋值运算符,发现效率低下:
A& operator=(A const& other)
{A temp = other; std::swap(*this, temp); return *this;}
如果*this
和other
有相同的s
呢?
在我看来,如果s == other.s
. 它所要做的就是复制:
A& operator=(A const& other)
{
if (this != &other)
{
if (s != other.s)
{
delete [] p;
p = nullptr;
s = 0;
p = new int[other.s];
s = other.s;
}
std::copy(other.p, other.p + s, this->p);
}
return *this;
}
如果您不需要强大的异常安全性,只需要复制分配上的基本异常安全性(如std::string
、std::vector
等),那么上述内容可能会提高性能。多少?措施。
我用三种方式编写了这个类:
设计一:
使用上面的复制赋值运算符和 OP 的移动赋值运算符 #1。
设计二:
使用上面的复制赋值运算符和 OP 的移动赋值运算符 #2。
设计3:
DeadMG 的复制赋值运算符,用于复制和移动赋值。
这是我用来测试的代码:
#include <cstddef>
#include <algorithm>
#include <chrono>
#include <iostream>
struct A
{
std::size_t s;
int* p;
A(std::size_t s) : s(s), p(new int[s]){}
~A(){delete [] p;}
A(A const& other) : s(other.s), p(new int[other.s])
{std::copy(other.p, other.p + s, this->p);}
A(A&& other) : s(other.s), p(other.p)
{other.s = 0; other.p = nullptr;}
void swap(A& other)
{std::swap(s, other.s); std::swap(p, other.p);}
#if DESIGN != 3
A& operator=(A const& other)
{
if (this != &other)
{
if (s != other.s)
{
delete [] p;
p = nullptr;
s = 0;
p = new int[other.s];
s = other.s;
}
std::copy(other.p, other.p + s, this->p);
}
return *this;
}
#endif
#if DESIGN == 1
// Move assignment operator #1
A& operator=(A&& other)
{
swap(other);
return *this;
}
#elif DESIGN == 2
// Move assignment operator #2
A& operator=(A&& other)
{
delete [] p;
s = other.s;
p = other.p;
other.s = 0;
other.p = nullptr;
return *this;
}
#elif DESIGN == 3
A& operator=(A other)
{
swap(other);
return *this;
}
#endif
};
int main()
{
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::duration<float, std::nano> NS;
A a1(10);
A a2(10);
auto t0 = Clock::now();
a2 = a1;
auto t1 = Clock::now();
std::cout << "copy takes " << NS(t1-t0).count() << "ns\n";
t0 = Clock::now();
a2 = std::move(a1);
t1 = Clock::now();
std::cout << "move takes " << NS(t1-t0).count() << "ns\n";
}
这是我得到的输出:
$ clang++ -std=c++11 -stdlib=libc++ -O3 -DDESIGN=1 test.cpp
$ a.out
copy takes 55ns
move takes 44ns
$ a.out
copy takes 56ns
move takes 24ns
$ a.out
copy takes 53ns
move takes 25ns
$ clang++ -std=c++11 -stdlib=libc++ -O3 -DDESIGN=2 test.cpp
$ a.out
copy takes 74ns
move takes 538ns
$ a.out
copy takes 59ns
move takes 491ns
$ a.out
copy takes 61ns
move takes 510ns
$ clang++ -std=c++11 -stdlib=libc++ -O3 -DDESIGN=3 test.cpp
$ a.out
copy takes 666ns
move takes 304ns
$ a.out
copy takes 603ns
move takes 446ns
$ a.out
copy takes 619ns
move takes 317ns
DESIGN 1
对我来说看起来不错。
警告:如果该类具有需要“快速”释放的资源,例如互斥锁所有权或文件打开状态所有权,那么从正确性的角度来看,design-2 移动赋值运算符可能会更好。但是当资源只是内存时,尽可能长时间地延迟释放它通常是有利的(如在 OP 的用例中)。
警告 2:如果您有其他重要的用例,请衡量它们。你可能会得出与我在这里不同的结论。
注意:我更看重性能而不是“干”。这里的所有代码都将被封装在一个类 ( struct A
) 中。尽可能struct A
做好。而且,如果您的工作质量足够高,那么您的客户struct A
(可能是您自己)就不会受到“RIA”(Reinvent It Again)的诱惑。我更喜欢在一个类中重复一些代码,而不是一遍又一遍地重复整个类的实现。