Question

我想知道——是否有任何关于C++(非成员)的辛迪税准则,使我能够理解(如果可能的话)其论点和回报价值的所有权政策。根据所有权一,所有者负责销毁所有物体。

我对以下论点规则加以区分:

take ownership
don t take ownership
share

和收益价值:

release ( return by value is in this group)
don t release
share

举例来说,通过提及而通过反对并不具有所有权:

void func(object & obj) { ... }

这些准则可使用诸如独一无二的吸收器、共享吸收器等标准建筑。如果没有这样的准则,那么就可能的同义词误解的例子也受到欢迎。

Answer 1

我可以不明白为什么使用智能点就足够了。我可以想到,我会把什么东西归类为。利用智能点对原始点人,完全清楚所有权和反应:

auto_ptr/unique_ptr - single owner, ownership is transferred
shared_ptr - multiple owners, ownership may be transferred
scoped_ptr - single owner, ownership cannot be transferred
weak_ptr - observer (but shared_ptr may be created from weak_ptr)

I think that these suffice to clearly show the responsibilities, e.g.

void func(std::auto_ptr<Class> input) {...} // func() takes ownership of input
void func(std::shared_ptr<Class> input) {...} // func() and caller share ownership
std::auto_ptr<Class> func() {...} // caller takes ownership of returned value
std::shared_ptr<Class> func() {...} // func() and caller shares ownership of returned object
std::weak_ptr<Class> func() {...} // func() owns created object, but caller may observe it

As you mention, references are also great in this sense. Note if there s a need to free the pointers using some custom mechanism, shared_ptr and unique_ptr supports custom deleters. auto_ptr does not have this capability.

注如果你在11年前使用C++,就必须使用<代码>boost:共有_ptr和boost:weak_ptr。

Answer 2

如果我理解你的话,那么Boost 或许是你寻求的:

实例(摘自《手册》):

template <class T>
struct contained
{
   // define our typedefs first, arrays are stored by value
   // so value_type is not the same as result_type:
   typedef typename boost::call_traits<T>::param_type       param_type;
   typedef typename boost::call_traits<T>::reference        reference;
   typedef typename boost::call_traits<T>::const_reference  const_reference;
   typedef T                                                value_type;
   typedef typename boost::call_traits<T>::value_type       result_type;

   // stored value:
   value_type v_;

   // constructors:
   contained() {}
   contained(param_type p) : v_(p){}
   // return byval:
   result_type value() { return v_; }
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type p){}

};

更清楚的是<条码>第1款类型、<条码>参引-> 类型和<条码> 类型,以指明含义。

Answer 3

我在需要时利用这一合成物参数:

举例说:

t_array(const t_ownership_policy::t_take& policy, THESpecialType* const arg);

在电话中使用:

t_array array(t_ownership_policy::Take, THESpecialTypeCreate(...));

<代码>t_ Ownership_policy:t_take is only a dummy overload disambiguator打字。

In this system, there are multiple policies, each with separate types. I favored unique types per policy because a typed enumeration (for example) does not support initialization as easily, and it s too easy to pass an unsupported policy to a function or constructor. Polymorphic policies can reduce symbol count, but it s a pain because it pushes error detection to runtime.

For returning :

void func(t_container<t_type>& outValue);

<代码>t_container 是你选择的每箱集装箱类型。然后,集装箱类型已经安装了必要的碎块。该集装箱可以是共有的-ptr,也可以是你写的某种专业。

and for more elaborate types, i ll often use syntax like so:

void func(t_special_container& outValue) {
  ...
  outValue.take(ptr);
  - or -
  outValue.copy(ptr);

友情链接