Quel est votre convention pour typedef avec shared_ptr?

J'aimerais aussi ajouter quelques options à cette vieille question, même s'ils peuvent être très controversée...

Similaire à OldPeculier réponse j'aime le type court de noms qui ressemblent à la norme pointeurs aussi étroitement que possible.

Dans un projet utilisé shared_pointer presque partout, j'ai utilisé

typedef boost::shared_ptr<Foo> Foo_;

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

J'ai profité de trois choses:

1. Que le caractère de soulignement en quelque sorte de ressemble à un opérateur, mais est la plupart du temps traités comme une lettre, de sorte qu'il peut être une partie d'un identifiant (et je ne vois pas de règle interdisant à la fin de l'identifiant).
2. Que j'ai seulement besoin de venir avec un typedef.
3. Je préfère Foo* myFoo1; sur Foo *myFoo1; pour plusieurs raisons, et il correspond bien avec Foo_ myFoo2.

En cas de besoin de typedefs pour les différents types de pointeurs intelligents, j'irais pour

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;

Avec l'augmentation de la prise en charge d'Unicode dans les normes et le compilateur implémentations, je serais tenté d'essayer la syntaxe suivante, en supposant que ces caractères étoiles serait considéré comme une partie régulière de l'identificateur de type. Bien sûr, ce n'est pratique que si toutes les parties impliquées, les développeurs ont pratique d'une méthode de saisie de texte pour cette:

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;

(Un test rapide a indiqué que ce n'est pas réellement le travail, au moins avec mon environnement de construction. Mais la même chose est vraie pour Foo_ä.)

Ma préférence:

class Foo
{
public:

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

Le problème avec juste FooPtr est que vous pouvez avoir différents types de pointeurs (par exemple, weak_ptrs). Je n'ai pas beaucoup de soins pour les abréviations, mais c'est tout à fait autre chose.

J'ai utilisé à la fois l'extérieur et encapsulé typedef, mais a terminé avec la première,

typedef boost::shared_ptr<Foo> FooPtr; 

uniquement parce que dans le combiné d'expressions, cela paraît plus propre que Foo::Ptr.

N'est-ce pas vous déranger que Foo est maintenant conscient de la façon dont il sera passé autour?

Assez souvent, ces classes sont réalisable grâce à une méthode de fabrique seulement:

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

   protected:
     Foo() {}
}

Qui est une sorte de "plus fort" que l'encapsulation de la définition de type, encore un schéma très commun.

Je suis généralement pas un fan de très courte identifiants, mais c'est un cas où je vais les utiliser.

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

Cela permet shared_ptr pour ressembler à l'ordinaire pointeurs d'aussi près que possible sans risque de confusion.

Foo* myFoo;
Foo::p myFoo;

Et comme pour briser l'encapsulation—non, typedefing le shared_ptr type au sein de la classe de ne pas briser l'encapsulation, pas plus que typedefing à l'extérieur de la classe. Quelle est la signification de "l'encapsulation" serait-il violent? Vous n'êtes pas rien révéler sur la mise en œuvre de Foo. Vous êtes simplement à la définition d'un type. Ce qui est parfaitement analogue à la relation entre les Foo* et Foo. Foo* est un certain type de pointeur de Foo (la valeur par défaut, car il arrive). Foo::p est un autre type de pointeur à Toto. Vous n'êtes pas briser l'encapsulation, vous êtes juste en ajoutant le type de système.

Mon premier réflexe est de demander, "Pourquoi typedef qui?"

En réponse à votre edit: en Fait c'est plutôt une approche intéressante qui pourrait être utile dans de nombreuses situations. L'aide afin de revenir à votre première question que vous pourriez avoir:

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

C'est agréable quand elle se termine avec _t.

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

class foo;

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

Comment sur:

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

Permettant ensuite tout Shared classe à avoir leur propre Ptr objet, comme dans:

class myClass : public Shared<myClass>
{
};

int main()
{
    myClass::Ptr object;
    //...
    object->foo();
}