Подтвердить что ты не робот

Какая ваша конвенция для typedef'ing shared_ptr?

Я перехожу между соглашениями об именах для typedef'ing шаблона boost:: shared_ptr. Например:

typedef boost::shared_ptr<Foo> FooPtr;

Прежде чем приступать к соглашению, я хотел бы посмотреть, что другие используют. Какова ваша конвенция?

EDIT:

Для тех, кто вложен в typedef внутри Foo, разве вас не беспокоит, что Foo теперь "осознает", как он будет передаваться? Кажется, он разрушает инкапсуляцию. Как насчет этого:

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

Ты бы не сделал этого сейчас, не так ли?: -)

4b9b3361

ОТВЕТЫ

Ответ 1

Я бы тоже добавил некоторые варианты этого старого вопроса, хотя они могут быть весьма противоречивыми...

Как и ответ OldPeculier Мне нравятся короткие имена типов, которые как можно ближе напоминают стандартные указатели.

В проекте, который использовал 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 в стандартах и ​​реализациях компилятора, у меня возникнет соблазн попробовать следующий синтаксис, предполагая, что эти звездные символы будут рассматриваться как регулярная часть идентификатора типа. Конечно, это практично, если для всех задействованных разработчиков есть удобный способ ввода текста:

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_ä.)

Ответ 2

Ответ: не делайте этого. Это удобно для вас и для кого-то еще. Скажите, что вы имеете в виду.

Ответ 3

Мои предпочтения:

class Foo
{
public:

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

Проблема только с FooPtr заключается в том, что у вас могут быть разные типы указателей (например, weak_ptr s). Я также не очень люблю сокращения, но это совсем другое дело.

Ответ 4

Лично в коде, за который я отвечаю, вы обычно видите FooPtr typedef'd в той же области пространства имен, что и Foo, а Foo будет содержать типизированный "SmartPtr" typedef для того же типа, что и FooPtr. Имея FooPtr, вы можете легко использовать негласное ручное использование. наличие вложенного typedef для "SmartPtr" или некоторого "четного" допускает простое общее использование в шаблонах, макросах и т.д., не зная этого фактического типа интеллектуального указателя.

Кроме того, я бы предложил добавить к этому вопросу "субъективный" тег.

Ответ 5

Я использовал как внешний, так и инкапсулированный typedef, но в итоге оказался первым,

typedef boost::shared_ptr<Foo> FooPtr;

исключительно потому, что в комбинированных выражениях это выглядит более чистое, чем Foo::Ptr.

Не беспокоит ли вас, что Foo теперь "осознает", как он будет передаваться?

Достаточно часто эти классы создаются только с помощью метода factory:

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

   protected:
     Foo() {}
}

Такой "более сильный", чем инкапсулирование typedef, но очень общий шаблон.

Ответ 6

Я не большой поклонник венгерских соглашений об именах, я обычно использую:

typedef boost::shared_ptr<Foo> FooSharedPtr;

Достаточно подробный, чтобы быть ясным, но достаточно коротким, чтобы не быть большой проблемой. В любом случае, я бы определенно указал на него, в частности, на общий указатель, особенно если вы не единственный, кто будет использовать этот тип в будущем.

Ответ 7

Я обычно инкапсулирую typedef внутри класса. Причина в том, что у нас есть некоторый код, чувствительный к памяти, и он позволяет легко переключаться между boost::shared_ptr и boost::intrusive_ptr Поскольку intrusive_ptr - это то, что должен поддерживать класс, имеет смысл, чтобы я знал, какой общий разделитель для использования будет обернут в классе.

Ответ 8

Мой первый ответ - спросить: "Почему 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...
}

Ответ 9

Я вообще не поклонник очень коротких идентификаторов, но это один случай, когда я их буду использовать.

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

Это позволяет shared_ptr как можно ближе напоминать обычные указатели без риска путаницы.

Foo* myFoo;
Foo::p myFoo;

А что касается разрыва инкапсуляции - нет, то typedefing тип shared_ptr внутри класса не нарушает инкапсуляцию не более, чем набирает ее вне класса. Какое значение "инкапсуляции" было бы нарушено? Вы не раскрываете ничего о реализации Foo. Вы просто определяете тип. Это совершенно аналогично взаимосвязи между Foo * и Foo. Foo * - это определенный тип указателя на Foo (по умолчанию, как это бывает). Foo:: p - это еще один вид указателя на Foo. Вы не нарушаете инкапсуляцию, вы просто добавляете систему типов.

Ответ 10

class foo;

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

Ответ 11

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

Ответ 12

Хорошо, когда заканчивается _t.

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

Ответ 13

Это была одна из конвенций, которые я переворачивал до:

typedef boost::shared_ptr<Foo> FooProxy;

... видя, что boost::shared_ptr является приложением шаблона Proxy.

Ответ 14

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

Ответ 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();
}

Ответ 16

Я использовал следующее: typedef boost::shared_ptr<Foo> Foo_rcptr_t;

Это ясно указывает, что это refpounted ptr.