D 是否具有类似于 C++0x' 的移动语义？

发布于 2024-10-03 01:09:39 字数 224 浏览 1 评论 0原文

外部资源（例如 std::vector 或 std::string）的“值类型”问题是复制它们往往非常昂贵，并且副本是在各种上下文中隐式创建的，因此这往往是一个性能问题。 C++0x 对这个问题的回答是移动语义，它在概念上基于资源窃取的思想，并且在技术上由右值引用提供支持。

D 有类似移动语义或右值引用的东西吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

梨涡 2024-10-10 01:09:39

我相信 D 中有几个地方（例如返回结构）D 设法使它们移动，而 C++ 会使它们成为副本。 IIRC，在任何情况下，编译器可以确定不需要复制时，都会执行移动而不是复制，因此结构复制在 D 中发生的次数比在 C++ 中少。当然，由于类是引用，因此它们根本不存在问题。

但无论如何，复制构造在 D 中的工作方式已经与在 C++ 中不同。通常，您不声明复制构造函数，而是声明 postblit 构造函数：this(this)。它在调用 this(this) 之前执行完整的 memcpy，并且您只需进行必要的更改以确保新结构与原始结构分离（例如对成员变量进行深层复制，其中需要），而不是创建一个必须复制所有内容的全新构造函数。所以，一般方法已经与 C++ 有点不同了。人们普遍认为结构不应该有昂贵的 postblit 构造函数 - 复制结构应该很便宜 - 因此它比 C++ 中的问题要小。复制成本高昂的对象通常是具有引用或 COW 语义的类或结构。

容器通常是引用类型（在 Phobos 中，它们是结构而不是类，因为它们不需要多态性，但复制它们不会复制它们的内容，因此它们仍然是引用类型），因此复制它们并不昂贵就像在 C++ 中一样。

在 D 中很可能有一些情况，它可以使用类似于移动构造函数的东西，但一般来说，D 的设计方式是为了减少 C++ 在复制对象时遇到的问题，所以它远没有解决问题它是用 C++ 编写的。

回复收藏 0 原文

空‖城人不在 2024-10-10 01:09:39

我认为所有答案完全没有回答原来的问题。

首先，如上所述，该问题仅与结构相关。班级没有任何有意义的举动。如上所述，对于结构体，编译器在某些条件下会自动发生一定量的移动。

如果您希望控制移动操作，您必须执行以下操作。您可以通过使用 @disable 注释 this(this) 来禁用复制。接下来，您可以通过定义 this(Struct that) 来重写 C++ 的 constructor(constructor &&that)。同样，您可以使用 opAssign(Struct that) 覆盖分配。在这两种情况下，您都需要确保销毁 that 的值。

对于赋值，由于还需要销毁 this 的旧值，所以最简单的方法就是交换它们。因此，C++ 的 unique_ptr 的实现看起来像这样：

struct UniquePtr(T) {
    private T* ptr = null;

    @disable this(this); // This disables both copy construction and opAssign

    // The obvious constructor, destructor and accessor
    this(T* ptr) {
        if(ptr !is null)
            this.ptr = ptr;
    }

    ~this() {
        freeMemory(ptr);
    }

    inout(T)* get() inout {
        return ptr;
    }

    // Move operations
    this(UniquePtr!T that) {
        this.ptr = that.ptr;
        that.ptr = null;
    }

    ref UniquePtr!T opAssign(UniquePtr!T that) { // Notice no "ref" on "that"
        swap(this.ptr, that.ptr); // We change it anyways, because it's a temporary
        return this;
    }
}

编辑：
请注意，我没有定义 opAssign(ref UniquePtr!T that)。这就是复制赋值运算符，如果您尝试定义它，编译器将出错，因为您在 @disable 行中声明了您没有这样的东西。

I think all answers completely failed to answer the original question.

First, as stated above, the question is only relevant for structs. Classes have no meaningful move. Also stated above, for structs, a certain amount of move will happen automatically by the compiler under certain conditions.

If you wish to get control over the move operations, here's what you have to do. You can disable copying by annotating this(this) with @disable. Next, you can override C++'s constructor(constructor &&that) by defining this(Struct that). Likewise, you can override the assign with opAssign(Struct that). In both cases, you need to make sure that you destroy the values of that.

For assignment, since you also need to destroy the old value of this, the simplest way is to swap them. An implementation of C++'s unique_ptr would, therefore, look something like this:

struct UniquePtr(T) {
    private T* ptr = null;

    @disable this(this); // This disables both copy construction and opAssign

    // The obvious constructor, destructor and accessor
    this(T* ptr) {
        if(ptr !is null)
            this.ptr = ptr;
    }

    ~this() {
        freeMemory(ptr);
    }

    inout(T)* get() inout {
        return ptr;
    }

    // Move operations
    this(UniquePtr!T that) {
        this.ptr = that.ptr;
        that.ptr = null;
    }

    ref UniquePtr!T opAssign(UniquePtr!T that) { // Notice no "ref" on "that"
        swap(this.ptr, that.ptr); // We change it anyways, because it's a temporary
        return this;
    }
}

Edit:
Notice I did not define opAssign(ref UniquePtr!T that). That is the copy assignment operator, and if you try to define it, the compiler will error out because you declared, in the @disable line, that you have no such thing.

回复收藏 0 原文