为了正确处理对象复制,经验法则是三规则.使用C++ 11,移动语义是一个东西,所以它是五条规则.然而,在这里和互联网上的讨论中,我也看到了对四条规则(一半)的引用,它是五条规则和复制交换习语的组合.
究竟是什么(四分之一)呢？需要实现哪些功能,每个功能的主体应该是什么样的？一半的功能是什么？与五法则相比,这种方法有任何缺点或警告吗？
这是一个类似于我当前代码的参考实现.如果这不正确,那么正确的实现会是什么样的？
//I understand that in this example, I could just use `std::unique_ptr`.
//Just assume it's a more complex resource.
#include <utility>
class Foo {
public:
//We must have a default constructor so we can swap during copy construction.
//It need not be useful, but it should be swappable and deconstructable.
//It can be private, if it's not truly a valid state for the object.
Foo() : resource(nullptr) {}
//Normal …c++ copy-constructor assignment-operator copy-and-swap c++11
为什么 C++ 提供复制构造函数？赋值运算符可以完成相同的任务。与赋值运算符相比，复制构造函数有什么优势吗？
我正在尝试创建一个具有私有成员的类,该类是一个数组.我不知道数组的大小,直到值传递给构造函数.定义类构造函数以及.h文件中的定义以允许这个可变大小的数组的最佳方法是什么？
我正在阅读谷歌C++风格指南,并在例外部分感到困惑.根据指南,使用它的一个缺点是:
异常安全需要RAII和不同的编码实践.需要大量的支持机制才能使编写正确的异常安全代码变得容易.此外,为了避免要求读者理解整个调用图,异常安全代码必须将写入持久状态的逻辑隔离到"提交"阶段.这将带来好处和成本(可能是您被迫混淆代码以隔离提交的地方).允许例外将迫使我们总是支付这些费用,即使它们不值得
具体来说,我不明白的陈述是这样的:
(...)异常安全代码必须将写入持久状态的逻辑隔离到"提交"阶段.
还有这个:
(...)也许你被迫混淆代码来隔离提交(...).
我想我不习惯术语"持久状态","提交阶段","混淆代码以隔离提交".关于这些术语的一些小解释,例子或参考可能是很好的,也可能是为什么这是真的.
假设您想要一个与类关联的预定义值/对象(const或非const)的静态数组.可能的选项是使用std:vector,std::array或C-style array (ie. []),或.例如,
在.hpp:
class MyClass {
public:
static const std::vector<MyClass> vec_pre; // No efficient way to construct with initializer list, since it always uses Copy Contructor, even when using std::move
static const std::array<MyClass, 2> arr_pre; // Have to specify size which is inconvenient
static const MyClass carr_pre[]; // Not compatible with C++11 for-range since size is undefined
};
在.cpp
const std::vector<MyClass> MyClass::vec_pre = { std::move(MyClass{1,2,3}), std::move(MyClass{4,5,6}) }; // NOTE: This still uses …在什么是复制和交换习语这个例子显示:
friend void swap(dumb_array& first, dumb_array& second) // nothrow
{
// enable ADL (not necessary in our case, but good practice)
using std::swap;
// by swapping the members of two classes,
// the two classes are effectively swapped
swap(first.mSize, second.mSize);
swap(first.mArray, second.mArray);
}
如何using std::swap启用ADL？ADL只需要一个不合格的名称.我看到的唯一好处using std::swap是,因为std::swap是一个函数模板,你可以在call(swap<int, int>(..))中使用模板参数列表.
如果不是这样的话,那是using std::swap为了什么？
我最近使用了一个允许以下类型语法的库:
MyClass myObject;
myObject
.setMember1("string value")
.setMember2(4.0f)
.setMember3(-1);
显然,这是通过让setter返回MyClass&type来实现的; 类似return*this.我喜欢这段代码的样子,但我看不太多.当发生这种情况时,我通常会怀疑为什么.
那么,这是一种不好的做法吗？像这样做的一些含义是什么？
编译器是否为自我赋值生成了赋值操作符？
class T {
int x;
public:
T(int X = 0): x(X) {}
};
int main()
{
T a(1);
a = a;
}
即使班级成员不是指针类型,我是否总是需要防止自我分配？
通常,当我编程时,我使用多态,因为它自然地模拟我需要的对象.另一方面,我经常使用标准容器来存储这些对象,我倾向于避免使用指针,因为这要求我释放对象而不是将它们从堆栈中弹出或要求我确定对象将保持不变我使用指针时的堆栈.当然有各种各样的指针容器对象可以为你完成这项任务,但根据我的经验,它们也不理想甚至烦人.那是; 如果存在这样一个简单的解决方案,它本来就是用c ++语言,对吧？;)
所以让我们有一个经典的例子:
#include <iostream>
#include <vector>
struct foo {};
struct goo : public foo {};
struct moo : public foo {};
int main() {
std::vector<foo> foos;
foos.push_back(moo());
foos.push_back(goo());
foos.push_back(goo());
foos.push_back(moo());
return 0;
}
请参阅:http://ideone.com/aEVoSi.这工作正常,如果对象具有不同的sizeof,编译器可能会应用切片.但是,由于c ++不知道像Java这样的实例,并且据我所知,没有足够的替代存在,在从向量中获取它们作为foo之后,无法访问继承类的属性.
因此,人们将使用虚函数,但是这不允许一个人分配foo,因此不允许在向量中使用它们.请参阅为什么我们不能声明std :: vector <AbstractClass>？.
例如,我可能希望能够打印两个子类,简单的功能,对吗？
#include <iostream>
#include <vector>
struct foo {
virtual void print() =0;
virtual ~foo() {}
};
struct goo : public foo {
int a;
void print() { std::cout << "goo"; }
};
struct …class_name & class_name :: operator= ( const class_name & ) (2)
(2)当不能使用复制和交换习语时,复制赋值运算符的典型声明
我们何时应该避免使用复制和交换习惯用法？
什么时候"完全不能使用"？
是否有现实生活中的情况,即复制和交换以及零规则都不适用？
我确实找到了这个问题,但它过于具体,没有包含任何关于如何识别此类案例的指南.