Question

我在typedef的boost :: shared_ptr模板的命名约定之间翻转。例如：

typedef boost::shared_ptr<Foo> FooPtr;

在结束会议之前，我想看看其他人使用什么。你的惯例是什么？

修改

对于那些在Foo中嵌入typedef的人来说，Foo现在“意识到”它将如何被传递并不会让你烦恼吗？它似乎打破了封装。怎么样：

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

你现在不会这样做，对吗？： - ）

Answer 1

我也想为这个老问题添加一些选项，即使它们可能引起极大的争议......

与OldPeculier's answer类似，我喜欢尽可能接近标准指针的短类型名称。

在几乎所有地方使用shared_pointer的项目中，我使用了

typedef boost::shared_ptr<Foo> Foo_;

// usage examples:
Foo* myFoo0;
Foo_ myFoo1;

我利用了三件事：

下划线字符在某种程度上看起来像一个运算符，但它主要被视为一个字母，因此它可以是标识符的一部分（我在标识符的末尾看到no rule forbidding）。
我只需要提出一个 typedef。
由于多种原因，我更喜欢Foo* myFoo1;而不是Foo *myFoo1;，并且它与Foo_ myFoo2非常匹配。

当需要针对不同类型的智能指针的typedef时，我会去

typedef shared_ptr<Foo> Foo_S;
typedef weak_ptr<Foo>   Foo_W;
typedef unique_ptr<Foo> Foo_U;

// usage examples:
Foo*  myFoo2;
Foo_S myFoo3;
Foo_W myFoo4;
Foo_U myFoo5;

随着标准和编译器实现中增加的Unicode支持，我很想尝试以下语法，假设这些星形字符将被视为类型标识符的常规部分。当然，只有所有参与的开发人员都有一个方便的文本输入方法，这才是实用的：

typedef shared_ptr<Foo> Foo★;
typedef weak_ptr<Foo>   Foo☆;
typedef unique_ptr<Foo> Foo✪;

// usage examples:
Foo* myFoo6;
Foo★ myFoo7;
Foo☆ myFoo8;
Foo✪ myFoo9;

（快速测试表明这实际上并不起作用，至少在我的构建环境中。但Foo_ä也是如此。）

Answer 2

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

Answer 3

我的偏好：

class Foo
{
public:

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

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

Answer 4

就个人而言，在我负责的代码中，你通常会看到FooPtr typedef'd在与Foo 相同的命名空间范围内，而 Foo将包含一般命名为'SmartPtr'typedef to与FooPtr相同的类型。拥有FooPtr可以轻松实现非详细的手动操作。具有'SmartPtr'的嵌套typedef或一些quivalent允许在模板，宏等中轻松通用，而无需知道智能指针的实际类型。

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

Answer 5

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

typedef boost::shared_ptr<Foo> FooPtr;

完全是因为在组合表达式中，这看起来比Foo::Ptr更清晰。

Foo现在“知道”它将如何被传递，这不是很麻烦吗？

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

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

   protected:
     Foo() {}
}

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

Answer 6

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

typedef boost::shared_ptr<Foo> FooSharedPtr;

足够清楚，但足够短，不会成为一个巨大的麻烦。在任何情况下，我肯定会指出它特别是一个共享指针，特别是如果你不是将来唯一一个将使用该类型的人。

Answer 7

我通常将typedef封装在类中。原因是我们有一些对内存敏感的代码，因此可以轻松切换boost::shared_ptr和boost::intrusive_ptr 由于intrusive_ptr是类需要支持的东西，因此让我知道要使用哪个共享指针的知识是有意义的。

Answer 8

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

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的指针。你没有破坏封装，你只是添加到类型系统。

Answer 9

我的第一反应是问：“为什么要输入那个？”

回复您的编辑：实际上，这是一种非常有趣的方法，在许多情况下都很有用。用它来回到你可能有的原始问题：


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...
}

Answer 10

  typedef shared_ptr<Foo> sptr_Foo;
  typedef weak_ptr<Foo>   wptr_Foo;
  typedef unique_ptr<Foo> uptr_Foo;

Answer 11

这是我翻转的惯例之一：

typedef boost::shared_ptr<Foo> FooProxy;

...看到boost::shared_ptr是Proxy模式的应用。

Answer 12

以_t结尾时很好。

class Bar
{
public:
    typedef boost::shared_ptr<Bar> Ptr_t;
};

Answer 13

typedef boost::shared_ptr<MyClass> MyClass$;

Answer 14

class foo;

typedef boost::shared_ptr<foo> foo_p;
typedef boost::weak_ptr<foo> foo_wp;

Answer 15

怎么样：

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();
}

Answer 16

我会删除命名空间而不是缩短类型。

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;
};

Answer 17

我使用了以下内容：typedef boost::shared_ptr<Foo> Foo_rcptr_t;

这清楚地表明它是一个refcounted ptr。

你对typedef'ing shared_ptr的约定是什么？

17 个答案: