Savoir si 2 objets sont comparables

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Salut à tous,

je suis en train d'essayer d'implémenter un arbre binaire en C++ avec la POO mais je me heurte à un problème. Mon implémentation utilisant des templates pour être "universelle" il me faut savoir si le type passé en paramètre est comparable avec les opérateur < et > pour mettre le nœud au bon endroit.

Voici mon code pour l'instant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*

  Implementation of binary search tree in cpp template

 */


#ifndef __BST_HPP__
#define __BST_HPP__


#include <memory>


template<class T_data>
class Bst
{
    T_data d_data;
    std::auto_ptr<Bst<T_data>> d_left;
    std::auto_ptr<Bst<T_data>> d_right;

public:
    Bst(T_data data)
        :
        d_data(data),
        d_left(nullptr),
        d_right(nullptr)
    {
    }

    //! Copy constructor
    Bst(const Bst &other)
        :
        d_data(other.data())
    {
        
    }

    //! Move constructor
    Bst(Bst &&other) noexcept;

    ~Bst() noexcept = default;

    //! Copy assignment operator
    Bst& operator=(const Bst &other);

    //! Move assignment operator
    Bst& operator=(Bst &&other) noexcept;

    

    T_data const &data() const
    {
        return d_data;
    }

};


#endif // __BST_HPP__

Ma question est donc comment savoir si 2 objet sont comparable ou non.

Je vous remercie d'avance de votre aide :)

« La Nature est un livre écrit en langage mathématique », Galilée

+0 -0

Cette réponse a aidé l'auteur du sujet

Salut,

En fait, tu cherches l'équivalent de ce qu'on peut faire en Java par exemple avec public class Bst<T extends Comparable>. La bonne nouvelle c'est que tu n'as pas besoin de ça.

Tu peux utiliser les opérateurs de comparaison directement et, si ton type T_data ne les implémente pas, tu auras une erreur lors de la compilation.

+2 -0

Cette réponse a aidé l'auteur du sujet

Lu'!

Sur un BST, ce sera std::unique_ptr. Comme l'ont dit les autres, à l'instanciation de ton template le typage est effectué, si l'opérateur n'existe pas une erreur sera indiquée par le compilateur.

A l'avenir, il y aura les concepts pour nous aider (C++20 ?).

First : Always RTFM - "Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

+0 -0
Auteur du sujet

Tu peux utiliser std::enable_if en combinaison avec les type traits de comparaison de Boost.TypeTraits.

Praetonus

Ok merci :)

Au passage, std::auto_ptr est déprécié depuis C++11 et sera supprimé dans C++17. Utilise std::unique_ptr ou std::shared_ptr selon tes besoins.

Praetonus

Dac, en tout cas vivement 2017

Et sinon merci à tous pour vos réponses :)

Edit:

Comme l'ont dit les autres, à l'instanciation de ton template le typage est effectué, si l'opérateur n'existe pas une erreur sera indiquée par le compilateur.

Ksass`Peuk

Du coup je met rien ?

A l'avenir, il y aura les concepts pour nous aider (C++20 ?).

Ksass`Peuk

Vivement 2020 :D

Édité par LudoBike

« La Nature est un livre écrit en langage mathématique », Galilée

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte