48

我typedef在boost::shared_ptr模板的命名约定之间来回切换。例如：

typedef boost::shared_ptr<Foo> FooPtr;

在确定约定之前，我想看看其他人使用什么。你的约定是什么？

编辑：

对于那些嵌套在typedef里面的人来说，现在“意识到”它将如何被传递，Foo你不会感到困扰吗？Foo它似乎打破了封装。这个怎么样：

class Foo
{
public:
    typedef std::vector<Foo> Vector;
};

你现在不会这样做，对吗？:-)

4

16 回答 16

29
于 2017-06-20T09:42:36.637 回答
27

答：不要这样做。这对您和其他人都很方便。说出你的意思。

于 2010-04-27T00:06:12.800 回答
15

我的偏好：

class Foo
{
public:

    typedef boost::shared_ptr<Foo> SharedPointer;
};

just 的问题FooPtr是您可能有不同类型的指针（例如，weak_ptrs）。我也不太关心缩写，但这完全是另一回事。

于 2010-04-26T22:44:09.947 回答
5

就个人而言，在我负责的代码中，您通常会在与 Foo 相同的命名空间范围内看到一个 FooPtr typedef，而Foo 将包含一个与 FooPtr 相同类型的通用命名为“SmartPtr”的 typedef。拥有 FooPtr 可以轻松进行非冗长的手动使用。拥有 'SmartPtr' 或某些等效的嵌套 typedef 允许在模板、宏等中轻松通用使用，而无需知道智能指针的实际类型。

另外，我建议在这个问题中添加一个“主观”标签。

于 2010-04-27T01:39:36.143 回答
4

我已经使用了外部和封装的 typedef，但最终使用了第一个，

typedef boost::shared_ptr<Foo> FooPtr;

仅仅因为在组合表达式中 this 看起来比Foo::Ptr.

Foo 现在“知道”它将如何被传递，这不会让您感到困扰吗？

通常，这些类只能通过工厂方法创建：

struct Foo
{
     static FooPtr Create() { return FooPtr(new Foo); }

   protected:
     Foo() {}
}

这比封装 typedef 更“强大”，但却是一种非常常见的模式。

于 2010-04-26T23:09:49.327 回答
3

我通常不喜欢非常短的标识符，但这是我将使用它们的一种情况。

class Foo
{
public:
    typedef std::shared_ptr<Foo> p;
};

这使 shared_ptr 尽可能地类似于普通指针，而不会造成混淆。

Foo* myFoo;
Foo::p myFoo;

至于破坏封装——不，在类中定义 shared_ptr 类型不会破坏封装，就像在类之外定义它一样。它会违反“封装”的什么含义？您没有透露有关 Foo 的实施的任何信息。你只是在定义一个类型。这完全类似于 Foo* 和 Foo 之间的关系。Foo* 是某种指向 Foo 的指针（碰巧是默认类型）。Foo::p 是另一种指向 Foo 的指针。你没有破坏封装，你只是添加到类型系统中。

于 2011-10-21T18:07:31.833 回答
2

我不是匈牙利命名约定的忠实粉丝，我通常使用：

typedef boost::shared_ptr<Foo> FooSharedPtr;

详细到足够清晰，但又足够短，不会造成很大的麻烦。无论如何，我肯定会指出它专门是一个共享指针，特别是如果您不是唯一将来会使用该类型的人。

于 2010-04-26T22:58:41.723 回答
2

我通常封装typedef类里面。原因是我们有一些对内存敏感的代码，它可以很boost::shared_ptr容易地boost::intrusive_ptr 在intrusive_ptr班级。

于 2010-04-26T23:37:28.923 回答
1

我的第一反应是问，“为什么 typedef 那个？”

回复您的编辑：实际上这是一种相当有趣的方法，在许多情况下都可能有用。使用它返回您可能遇到的原始问题：


struct object
{
  typedef object* ptr_t;
  typedef shared_ptr<object> shared_ptr_t;
  typedef weak_ptr<object> weak_ptr_t;
  typedef unique_ptr<object> unique_ptr_t;
  etc...
}
于 2010-04-26T23:27:35.387 回答
1 
  typedef shared_ptr<Foo> sptr_Foo;
  typedef weak_ptr<Foo>   wptr_Foo;
  typedef unique_ptr<Foo> uptr_Foo;
于 2015-04-01T14:51:34.323 回答
0

当它以 . 结尾时很好_t。

class Bar
{
public:
    typedef boost::shared_ptr<Bar> Ptr_t;
};
于 2010-04-26T22:50:20.300 回答
0

这是我正在改变的约定之一：

typedef boost::shared_ptr<Foo> FooProxy;

...看到这boost::shared_ptr是代理模式的应用程序。

于 2010-04-26T23:13:18.623 回答
0 
class foo;

typedef boost::shared_ptr<foo> foo_p;
typedef boost::weak_ptr<foo> foo_wp;
于 2012-03-20T14:22:11.083 回答
0

typedef boost::shared_ptr&lt;MyClass> MyClass$;

于 2011-04-22T11:34:23.043 回答
0

怎么样：

template <typename T>
class Shared
{
    public: 
        typedef std::shared_ptr<T> Ptr; // or boost::shared_ptr if you will
};

然后允许任何Shared类拥有自己的 Ptr 对象，如下所示：

class myClass : public Shared<myClass>
{
};

int main()
{
    myClass::Ptr object;
    //...
    object->foo();
}
于 2015-02-16T08:41:19.323 回答
0

我会摆脱命名空间而不是缩短类型。

using boost::shared_ptr; // or using std::shared_ptr, 
struct Foo
{
    shared_ptr<Foo> impl;
};

这样做的好处是您可以轻松地在实现之间进行更改。

如果这仍然太长（我认为它是正确的）：

using boost::shared_ptr;
template<class T> using sptr = shared_ptr<T>;
struct Foo
{
    sptr<Foo> impl;
};
于 2018-01-25T09:44:58.657 回答