typedef'ing shared_ptr的约定是什么？
我在命名约定之间为type :: boost :: shared_ptr模板之间进行了翻转。 例如：
typedef boost::shared_ptr<Foo> FooPtr; 在决定一个约定之前，我想看看其他人使用什么。 你的约定是什么？
编辑：
对于在Foo里嵌套typedef的人来说，Foo现在是否“意识到”它将如何传递呢？ 它似乎打破封装。 这个怎么样：
class Foo { public: typedef std::vector<Foo> Vector };
你现在不会这样做，是吗？ 🙂
我也想为这个老问题增加一些select，尽pipe它们可能会有很大的争议。
类似于OldPeculier的回答，我喜欢尽可能接近标准指针的短types名称。
在几乎所有地方都使用shared_pointer的项目中，我使用了
typedef boost::shared_ptr<Foo> Foo_; // usage examples: Foo* myFoo0; Foo_ myFoo1;
我利用了三件事情：
- 下划线字符在某种程度上看起来像是一个操作符，但是大部分都被看作是一个字母，所以它可以是一个标识符的一部分（而且在标识符末尾我看不到任何规则 ）。
- 我只需要拿出一个 typedef。
- 我更喜欢
Foo* myFoo1;超过Foo *myFoo1;有几个原因，并且与Foo_ myFoo2很好地匹配。
当需要针对不同种类的智能指针进行typedefs的时候，我会去做的
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的支持，假设那些星号字符将被视为types标识符的常规部分，我会试着尝试下面的语法。 当然，如果所有相关的开发人员都有一个方便的文本input方法，
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;
（一个快速testing表明，这实际上并不起作用，至less在我的构build环境中，但对于Foo_ä也是如此）。
答：不要这样做。 这对您和其他人都很方便。 说出你的意思。
我的偏好：
class Foo { public: typedef boost::shared_ptr<Foo> SharedPointer; };
只是FooPtr的问题是你可能有不同types的指针（例如， weak_ptr ）。 我也不太在意缩写，但这完全是另一回事。
就我个人而言，在我负责的代码中，您通常会看到与 Foo相同的命名空间范围的FooPtr typedef， 而 Foo将包含与FooPtr相同types的一般名为“SmartPtr”的typedef。 拥有FooPtr允许简单的非繁琐的手动使用。 具有用于'SmartPtr'或者一些相等的嵌套的typedef允许在模板，macros等中容易地使用generics，而不必知道智能指针的实际types。
另外，我build议在这个问题上增加一个“主观”标签。
我已经使用外部和封装的typedef，但结束了第一，
typedef boost::shared_ptr<Foo> FooPtr;
仅仅因为在组合expression式中，这个看起来比Foo::Ptr更干净。
Foo现在“知道”它将如何传递吗？
通常，这些类只能通过工厂方法创build：
struct Foo { static FooPtr Create() { return FooPtr(new Foo); } protected: Foo() {} }
这比封装typedef更“强”，但却是一个非常常见的模式。
我不是匈牙利命名惯例的忠实粉丝，我通常使用：
typedef boost::shared_ptr<Foo> FooSharedPtr;
足够清晰，但足够短，不会是一个巨大的麻烦。 无论如何，我肯定会指出它是一个特别的共享指针，特别是如果你不是将来唯一使用这种types的指针。
我通常在类中封装typedef 。 原因是我们有一些内存敏感的代码，它可以很容易地在boost::shared_ptr和boost::intrusive_ptr之间切换。因为intrusive_ptr是类需要支持的东西，所以对我来说是有道理的共享指针使用被包装在类中。
当它以_t结尾时很好。
class Bar { public: typedef boost::shared_ptr<Bar> Ptr_t; };
我的第一个回应是问：“为什么input那个？”
回答你的编辑：其实这是一个相当有趣的方法，可以在许多情况下有用。 用它回到你原来的问题，你可能会有：
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... }
我通常不是一个很短的标识符的粉丝，但这是我将使用它们的一种情况。
class Foo { public: typedef std::shared_ptr<Foo> p; };
这使得shared_ptr能够尽可能接近普通的指针而没有混淆的风险。
Foo* myFoo; Foo::p myFoo;
至于破解封装 – 否，在类中定义shared_ptrtypes不会破坏封装，而不是在类之外进行typedefing。 什么意思的“封装”会违反？ 你没有透露任何有关Foo的实现。 你只是定义一个types。 这与Foo *和Foo之间的关系完全类似。 Foo *是某种指向Foo的指针（默认types，正如它发生的那样）。 Foo :: p是另一种指向Foo的指针。 你不打破封装，你只是添加到types系统。
class foo; typedef boost::shared_ptr<foo> foo_p; typedef boost::weak_ptr<foo> foo_wp;
typedef shared_ptr<Foo> sptr_Foo; typedef weak_ptr<Foo> wptr_Foo; typedef unique_ptr<Foo> uptr_Foo;
这是我翻转的惯例之一：
typedef boost::shared_ptr<Foo> FooProxy;
看到boost::shared_ptr是代理模式的一个应用程序。
typedef boost::shared_ptr<MyClass> MyClass$;
怎么样：
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(); }
我用了下面的代码： typedef boost::shared_ptr<Foo> Foo_rcptr_t;
这清楚地表明这是一个计数的ptr。
