标签: ownership

我正在阅读Xcode的文档,这里有些令我困惑的事情:

__block typeof(self) tmpSelf = self;
[self methodThatTakesABlock:^ {
    [tmpSelf doSomething];
}];

从文档中复制以下内容:

块形成对其捕获的变量的强引用.如果self在块中使用 ,则块形成强引用self,因此如果 self还具有对块的强引用(通常它具有),则会产生强引用循环.要避免循环,您需要__block在块外部创建一个弱(或)引用,如上例所示.

我不明白'弱(或__block)'是什么意思？

是

__block typeof(self) tmpSelf = self;

和

__weak typeof(self) tmpSelf = self;

这里完全一样吗？

我在文件中找到了另一篇文章:

注意:在垃圾收集环境中,如果将两个__weak和 __block修饰符都应用于变量,则该块将无法确保它保持活动状态.

所以,我完全不解.

我对借贷和所有权感到困惑.在Rust 文档中有关引用和借用的内容

let mut x = 5;
{
    let y = &mut x;
    *y += 1;
}
println!("{}", x);

他们说

println!可以借x.

我很困惑.如果println!借入x,为什么它通过x不&x？

我尝试在下面运行此代码

fn main() {
    let mut x = 5;
    {
        let y = &mut x;
        *y += 1;
    }
    println!("{}", &x);
}

除了传递&x给代码之外,这段代码与上面的代码相同println!.它将'6'打印到控制台,这是正确的,与第一个代码的结果相同.

我需要Python中的函数或方法来查找文件或目录的所有者.

功能应该是:

>>> find_owner("/home/somedir/somefile")
owner3

这是 Rust 测验 28 中的一个问题：

struct Guard;

impl Drop for Guard {
    fn drop(&mut self) {
        print!("1");
    }
}

fn main() {
    let _guard = Guard;
    print!("3");
    let _ = Guard;
    print!("2");
}

这样的代码3121在 main 的第三行中打印 ，分配给_意味着立即删除。但是，当转移所有权时_使用以下代码

struct Guard;

impl Drop for Guard {
    fn drop(&mut self) {
        print!("1");
    }
}

fn main() {
    let _guard = Guard;
    print!("3");
    let _ = _guard;
    print!("2");
}

它打印321，这意味着Guard没有立即删除，并且_拥有Guard? …

我一直认为所有者负责销毁视觉控制,如果我nil作为所有者传递,我可以手动控制销毁.

请考虑以下示例:

TMyForm = class (TForm)
private
  FButton : TButton;
end;

...
FButton := TButton.Create(nil);   // no owner!!
FButton.Parent := Self;

我希望这个按钮产生内存泄漏,但它没有,实际上是析构函数TButton被调用.

进一步调查显示TWinControl析构函数包含以下代码片段:

I := ControlCount;
while I <> 0 do
begin
  Instance := Controls[I - 1];
  Remove(Instance);
  Instance.Destroy;
  I := ControlCount;
end;

看起来它正在摧毁子组件(Parent设置为控件本身的组件).

我没想到父控件会破坏控件.任何人都可以解释为什么会这样吗？如果我通过一个所有者,谁在摧毁这个物体？

将所有权转移std::vector<unique_ptr<int> >到正在建造的阶级的正确方法是什么？

下面是我想要做的代码表示.我意识到它不正确(不会编译)并违反"唯一性",无论我是通过值还是通过引用将向量传递给构造函数.我希望Foo成为向量的新所有者,并希望调用函数放弃所有权.我需要构造函数std::unique_ptr<std::vector<std::unique_ptr<int> > >来执行此操作吗？

foo.h中

class Foo
{
public:
  Foo(vector<std::unique_ptr<int> > vecOfIntPtrsOwnedByCaller);

private:
  vector<std::unique_ptr<int> > _vecOfIntPtrsOwnedByFoo;
}

Foo.cpp中

Foo::Foo(std::vector<std::unique_ptr< int> > vecOfIntPtrsOwnedByCaller)
{
    _vecOfIntPtrsOwnedByFoo = vecOfIntPtrsOwnedByCaller;
}

任何帮助将不胜感激 - 我已经在网上搜寻正确的方法来做到这一点.谢谢!

每史蒂夫Klabnik的书面记录上的差异之间的预锈1.0文档中String和&str,拉斯特你应该使用&str,除非你真的需要有一个以上的所有权String.同样,建议使用对slice(&[])的引用而不是Vecs,除非你真的需要对the的所有权Vec.

我有一个Vec<String>和我想写一个使用字符串的这个序列的功能,它并不需要在所有权Vec或String实例,应该说功能拍摄&[&str]？如果是这样,参考Vec<String>进入的最佳方式是&[&str]什么？或者,这种胁迫是否过度杀伤？

在Rust中,有两种可能性来引用

1. 借用,即参考,但不允许改变参考目的地.该&运营商借用值所有权.

2. 可变地借用,即参考改变目的地.该&mut运营商性情不定地借用一个值所有权.

有关借用规则的Rust文档说:

首先,任何借入必须持续不超过所有者的范围.其次,您可能拥有这两种借款中的一种或另一种,但不能同时使用这两种:

• 一个或多个&T资源的引用(),
• 一个可变的引用(&mut T).

我相信引用一个引用是创建一个指向值的指针并通过指针访问该值.如果存在更简单的等效实现,则编译器可以优化它.

但是,我不明白什么是移动的意思以及它是如何实现的.

对于实现Copy特征的类型,它意味着复制,例如通过从源分配结构成员,或者a memcpy().对于小结构或原始数据,此副本是有效的.

而对于招？

这个问题不是什么是移动语义的重复？因为Rust和C++是不同的语言,移动语义在两者之间是不同的.

假设我有一个有Document类的库.的一个实例Document可以拥有的几个实例Field.Field有多个子类(例如IntegerField和StringField),甚至API用户也可以将它子类化并提供子类实例Document(假设用户可以开发一个自定义类型的数据来存储在一个字段中).

我希望通过API 公开所Field拥有的实例Document,以便用户可以与它们进行交互,但不会转移所有权.

这样做的正确方法是什么？

我想过:

• 揭露const std::unique_ptr<Field>&参考 - 这感觉非常难看
• 公开Field*指针 - 这感觉不对,因为用户可能不确定他是否应该删除实例
• std::shared_ptr相反使用- 这感觉很糟糕,因为所有权并非真正共享

例如,

class Document {
private:
    std::map<std::string, std::unique_ptr<Field> > fields;
    // ...
public:
    // ...

    // How is this done properly?
    const std::unique_ptr<Field> &field(const std::string &name) {
        return fields[name];
    }
}

我期待着你的建议.
(我也欢迎有关@Fulvio建议的替代方法的建议.)

在编写函数时，如何决定是引用还是使用输入参数？

例如，我应该这样做吗？

fn foo(val: Bar) -> bool { check(val) } // version 1

或者使用引用参数代替？

fn foo(val: &Bar) -> bool { check(*val) } // version 2

在客户端，如果我只有第二个版本但想要消耗我的价值，我必须这样做：

// given in: Bar
let out = foo(&in); // using version 2 but wanting to consume ownership
drop(in);

另一方面，如果我只有第一个版本但想保留我的参考，我必须这样做：

// given in: &Bar
let out = foo(in.clone()); // using version 1 but wanting to keep reference alive

那么哪个是首选，为什么？

做出此选择时是否有任何性能考虑？或者编译器是否使它们在性能方面等效，以及如何实现？

您什么时候想提供两个版本（通过特征）？在那些时候，您如何编写这两个函数的底层实现——您是否复制每个方法签名中的逻辑，或者您是否有一个代理到另一个函数？哪个到哪个，为什么？