Discussion :

[Iradrille]

Hello,

Typedefs internes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Foo {
public:
   using Ptr = std::shared_ptr<Foo>;
   using WkPtr = std::weak_ptr<Foo>;
};

Typedefs externes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class Foo;
using FooPtr = std::shared_ptr<Foo>;
using FooWkPtr = std::weak_ptr<Foo>;

J'avais commencé par utiliser des typedefs internes, qui me semblaient plus propres.
Puis je me suis rapidement retrouvé dans un cas d'interdépendances

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class A {
   std::vector<B::Ptr> vec;
};
class B {
   A::WkPtr a;
};

Donc 2 solutions :
- ne pas utiliser le typedef dans un des cas (ce qui me plais pas trop)
- utiliser des typedefs externes (ce qui me plais pas trop non plus, mais sur le coup ça semblait la meilleure solution)

J'ai donc utilisé des typedefs externes partout (ce qui permet pas mal de déclarations anticipées du coup )

Et puis aujourd'hui, je me retrouve avec le problème inverse

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
template <class T>
struct Foo {
   // pourrait être
   // static typename T::Ptr create(sfg::Desktop& d) {
   // avec des typedefs internes
   static std::shared_ptr<T> create(sfg::Desktop& d) {
       auto obj = std::make_shared<T>(d);
       obj->setUp();
       return obj;
   }
};

Ce qui relance le débat...

C'est impossible de pouvoir utiliser des typedefs partout ?
Je suppose que du coup les typedefs internes sont une meilleure solution ?

[Kalith]

Une troisième solution serait d'utiliser une classe de trait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template<typename T>
struct pointer_traits {
    using Ptr = std::shared_ptr<T>;
    using WkPtr = std::weak_ptr<T>;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class B;
 
template<>
struct pointer_traits<B> {
    // ça n'a pas forcément de sens, mais juste pour l'exemple
    using Ptr = std::unique_ptr<B>;
    using WkPtr = B*; 
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class A {
   std::vector<pointer_traits<B>::Ptr> vec;
};
class B {
   pointer_traits<A>::WkPtr a;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
template <class T>
struct Foo {
   static typename pointer_traits<T>::Ptr create(sfg::Desktop& d) {
       auto obj = std::make_shared<T>(d);
       obj->setUp();
       return obj;
   }
};

[Arzar]

Si le but est vraiment d'avoir à éviter de taper quelques caractères en plus à chaque shared_ptr (ce qui tendrait à indiquer une utilisation probablement abusive de shared_ptr mais bon... ) peut être qu'un alias de template suffit ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
template <typename T>
using Ptr = std::shared_ptr<T>;

Ce qui donne le code suivant, qui n'est pas trop mal finalement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
template <class T>
struct Foo {
   static Ptr<T> create(int t) {
      auto obj = std::make_shared<T>(t);
      return obj;
   }
};

Ou peut être un mélange des deux, pour les type fixes, sans template la convention serait d'avoir un typedef avec un Ptr accolé au bout, comme FooPtr, histoire d’éviter d’encombrer le code avec trop de chevron et pour le reste se rabattre sur une utilisation de Ptr<T>.

[Iradrille]

Si le but est vraiment d'avoir à éviter de taper quelques caractères en plus à chaque shared_ptr (ce qui tendrait à indiquer une utilisation probablement abusive de shared_ptr mais bon... )

Le but n'est pas d'économiser quelques caractères, mais d'avoir le même type, nommé de la même façon partout.
(Tu me diras que dans ce cas j'ai juste à ne pas utiliser de typedefs, donc oui il y a aussi le but de donner un nom significatif, et si possible moins long à ces shared_ptr)

@Kalith : pile ce qu'il me faut, merci !