智能指针声明为 const

发布于 2025-01-12 20:16:46 字数 381 浏览 3 评论 0原文

声明为 const 的智能指针只能调用用 const 标记的成员函数。所以它们的用途非常有限。

1.对于唯一指针，您不能更改将托管对象的所有权转移给另一个unique_ptr 甚至不从特定函数返回它。

所以我的问题是何时应该使用 const unique_ptr？一些简单的例子可能会帮助我更好地理解它。

2.对于共享指针，我认为使用 const shared_ptr是没有意义的，因为你永远无法增加特定 const 共享指针的计数器。如果我错了，请告诉我。

原文

分享到QQ

分享到微博

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

发布评论

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

眼泪都笑了 2025-01-19 20:16:46

回复：不可转移的唯一指针

是的，这就是重点。如果您有 const 对象，则无法修改它。因此，不允许从 const unique_ptr 转移指针的所有权。

示例：

struct ResourceUser {
    ResourceUser() : mResource(CoupleMeWithSomeResource(this)) {}
private:
    const unique_ptr<SomeResource> mResource;
};

现在 ResourceUser 的实例完全拥有一个以某种方式链接回该对象地址的资源。您永远不希望该对象在内存中移动。不需要任何额外的语法，例如 ResourceUser a, b; a = move(b); 是不允许的。耶！

甚至不从特定函数返回它

从函数返回唯一指针的唯一有用原因是当您创建了一些传递回调用者的值或者您正在产生某些东西的所有权时 - 实际上这些是同一件事。使其成为常量是没有意义的。所以是的，无关紧要。请勿使用锤子拧入螺钉。

Re: Non-transferrable unique pointers

Yes, that's the point. If you have a const object you cannot modify it. Transferring ownership of a pointer either from or to a const unique_ptr is therefore not allowed.

Example:

struct ResourceUser {
    ResourceUser() : mResource(CoupleMeWithSomeResource(this)) {}
private:
    const unique_ptr<SomeResource> mResource;
};

Now an instance of ResourceUser outright owns a resource that is in some way linked back to this object's address. You don't ever want that object to move in memory. Without needing any additional syntax, something like ResourceUser a, b; a = move(b); is disallowed. Yaay!

Not even return it from a specific function

The only useful reason to return a unique pointer from a function is when you have created some value that is passed back to the caller or you are yielding ownership of something -- actually these are the same thing. It makes no sense to make it const. So yeah, irrelevant. Don't use a hammer to drive in a screw.

回复收藏 0 原文

逐鹿 2025-01-19 20:16:46

一种潜在的用例是，当您调用一个向您返回 shared_ptr 或 unique_ptr 的函数时，并且您希望编译器保证对该对象的访问无法转义你的函数，例如：

void Foo()
{
   // tagging blah as const to be sure that
   // no reference to the object blah points
   // to will be retained after this function
   // returns
   const unique_ptr<Bar> blah = getBar();

   [...]

   someGlobalVariable = blah;  // compile-time error -- nice try!
}

...至于为什么你想要这样做... Foo() 可能会做一些事情，使将来能够访问 *blah< /code> 不安全，所以最好的避免方法令人不快的运行时错误是让编译器确保这些访问不会发生，即使有人修改您的函数以尝试允许它。能够防御未来维护程序员的代码不太可能出现错误:)

One potential use-case would be when you've called a function that returns a shared_ptr or unique_ptr to you, and you want the compiler to guarantee that the access to that object can't escape your function, e.g.:

void Foo()
{
   // tagging blah as const to be sure that
   // no reference to the object blah points
   // to will be retained after this function
   // returns
   const unique_ptr<Bar> blah = getBar();

   [...]

   someGlobalVariable = blah;  // compile-time error -- nice try!
}

... as for why you'd want to do that... Foo() might do something that will make future access to *blah unsafe, and so the best way to avoid unpleasant runtime bugs is to have the compiler ensure that those accesses cannot happen, even if someone modifies your function to try to allow it. Code that can defends itself against future maintenance programmers is less likely to gather bugs :)

回复收藏 0 原文

~没有更多了~