3. ist dieser header schön?

ist dieser header schön?

  • O

    schöner code is ja doch sehr wichtig wie ich gemerkt hab, und darum wollte ich euch mal fragen, wie ihr folgenden header auf einer skala von 1-10 bwertet(1 is flop 10 is top).
    wieso ich das nich selber bewertung kann, sondern euch damit nerve? nun, ich hab da en bissl "rumgehackt"(naja eigentlich wars eher ein ausprobieren,was alles möglich ist), und weis jetzt nicht, ob ich schon über eine "schmerzgrenze" hinaus bin....

    hier is der header:

    #ifndef group_map_h
#define group_map_h
#include <cmath>//only for pow
#include <map>//only for pair
#include "traits.h"//for iterator traits
namespace utility{
    template<class KeyType,class Type,class keyCompare>
    class node{
        private:
            //the Key/Value pair in each node
            mutable Type value;
            const KeyType key;

            node* left;
            node* right;
            node* parent;
        public:
            //ctor
            node(const KeyType Key,const node* Parent):key(Key),left(0),right(0),parent(Parent){}
            node():left(0),right(0),parent(0){}

            //get methods
            const Type& getValue()const;
            const KeyType& getKey()const;
            node* getLeft()const;
            node* getRight()const;
            node* getParent()const;

            //set methods
            void setValue(const Type Value);
            void setLeft(const node* value);
            void setRight(const node* value);
            void setParent(const node* Parent);

            //methods for finding begin() and end()
            node* maxNode();
            node* minNode();

            //the return type of this function is the return type of keyCompare
            bool operator<(node* Operand);
    };

    //workaround for template template type
    template<class Type,class Allocator,template<class,class> class Container>
    class containerType{
        public:
            typedef Container<Type,Allocator> container;
    };

    template<class KeyType,class Type,template<class,class> class Container,class Allocator,class keyCompare>
    class tree{
        private:
            //internal typedefs
            typedef containerType<Type,Allocator,Container>::container container;
            typedef node<KeyType,container,keyCompare> node;
            typedef std::pair<KeyType,Type> value_type;
            typedef unsigned int size_type;

            //nested iterator
            template<class Type,class ContainerType,class Traits>
            class treeIterator;

            node* root;
            unsigned char planeCount;
            unsigned int maxElement;
            unsigned int ElementCount;

            //private Methods
            std::pair<unsigned char,node*> getParentNode(KeyType Key);
            node* createNode(node* Parent,KeyType Key,Type Value);

        public:
            //iterator typedefs
            typedef treeIterator<Type,container,traits<Type> > iterator;
            typedef treeIterator<Type,container,constTraits<Type> > const_iterator;
            typedef treeIterator<Type,container,reverseTraits<Type> > reverse_iterator;
            typedef treeIterator<Type,container,constReverseTraits<Type> > const_reverse_iterator;

            typedef container::iterator member_iterator;
            typedef container::const_iterator const_member_iterator;

            //iterator methods
            tree():root(new node()){}

            iterator end();
            const_iterator end()const;

            reverse_iterator rend();
            const_reverse_iterator rend()const;

            iterator begin();
            const_iterator begin()const;

            reverse_iterator rbegin();
            const_reverse_iterator rbegin()const;

            std::pair<member_iterator,member_iterator> equal_range(const KeyType& Key);
            std::pair<const_member_iterator,const_member_iterator> equal_range(const KeyType& Key)const;

            //method for clearing the whole tree
            void clear();

            //test whether tree is empty
            bool empty()const;

            //methods for deleting single value/key pairs
            size_type erase(const KeyType Key);
            void erase(iterator Iterator);
            void erase(member_iterator Iterator);
            void erase(iterator First,iterator Second);
            void erase(member_iterator First,member_iterator Second);

            //methods for counting elements
            size_type count(const KeyType Key);
            size_type size();
            size_type max_size();

            //method for finding single values by Key
            iterator find(const KeyType Key);
            const_iterator find(const KeyType Key)const;

            //methods for insert elements
            iterator insert(const value_type& Object);
            template<class InputIterator>
            void insert(InputIterator First,InputIterator Last);

    };

    //Iterator of Tree
    template<class KeyType,class Type,template<class,class> class Container,class Allocator,class keyCompare>
    template<class Type,class ContainerType,class Traits>
    class tree<KeyType,Type,Container,Allocator,keyCompare>::treeIterator{
        public:
            //public iterator Interface
            typedef Traits::value_type value_type;
            typedef int difference_type;
            typedef Traits::pointer pointer;
            typedef Traits::reference reference;
            typedef std::bidirectional_iterator_tag iterator_category;

        private:
            //here are some private member missing
            node* position;

            //this member contains the key/iterator data for the current position, and its updated via the operators
            //++() ++(int) --() --(int),the operators *() and ->() return references or pointers to it
            //its allowed to change the iterator, but its not allowed to change Key
            std::pair<const KeyType,ContainerType::iterator> currentData;
        public:
            //ctor
            treeIterator(){};
            treeIterator(node* Position){}

            //operators
            treeIterator& operator=(treeIterator Operand);
            bool operator==(treeIterator Operand);
            bool operator!=(treeIterator Operand);

            std::pair<const KeyType,ContainerType::iterator>& operator*();
            std::pair<const KeyType,ContainerType::iterator>* operator->();

            //these iterator
            treeIterator& operator++();
            treeIterator  operator++(int);
            treeIterator& operator--();
            treeIterator  operator--(int);
    };

}
#define TreeIterator
#include "Iterator.cpp"//iterator implementation
#undef TreeIterator
#include "GroupMap.cpp"//tree implementation
#endif
    0
  • ?

    #include <map>//only for pair
    was ist mit <utility>

    0
  • ?

    Wirklich sehr leserlich, doch. Topp 👍 👍

    Mal im ernst: Kein Wunder das C++ immer unbedeutender wird wenn man sowas lesen muss. Die Maschinen werden immer schnell und dann soll sich der Mensch noch mit so kryptischem Mist abgeben? Ne, danke...

    PS: Is halt ein typischer C++ Header -> sprich: Hässlich
    Oder wolltest du nur ein bißchen angeben wie toll du coden kannst?

    0
  • R
     

    using std::pair;

    so was doch bitte nicht im Header!

    Und ein paar Leerzeilen zwischen durch lockert, dass alles ein bisschen auf und man kann es gleich schneller lesen.

    Und ich würde ein paar mehr Kommentare streuen (und Doxygen oä. benutzen :)) und die public/private Bereiche durchgängig ordnen, wenn es möglich ist, da ein ständiges hin und her zwischen public und private das lesen doch erschwert

    (und ich würde nicht .h als C++ Header nehmen, sondern .hpp oder .hxx oder .hh)

    0
  • I

    kingruedi schrieb:

    using std::pair;

    so was doch bitte nicht im Header!

    Öhm, warum eigentlich nicht? Vielleicht wege folgender Problematik?
    foo.h:
    /* ... /
    using std::pair;
    /    ..*/

    foo.c:
    #include "foo.h"
    /../
    using bar::pair;

    int main() {
    pair *p; // Jeder denkt, dass jetzt hier bar::pair genommen wird aber in
    // Wirklichkeit gibt es jetzt einen Fehler, da nicht klar ist,
    // ob pair aus bar oder foo gemeint ist.

    /../
    }

    Sollte man dann in Headern immer explizit den Namensraum ansprechen und nie
    using bla::blub oder using namespace bla benutzen?

    0
  • H

    interpreter schrieb:

    kingruedi schrieb:

    using std::pair;

    so was doch bitte nicht im Header!

    Öhm, warum eigentlich nicht?

    Lies: http://www.gotw.ca/gotw/053.htm
    Beachte bitte besonders den Abschnitt über using-Deklarationen. Das die problematischer sind als using-Direktiven ist für viele Leute nämlich nicht intuitiv verständlich.

    Sollte man dann in Headern immer explizit den Namensraum ansprechen und nie
    using bla::blub oder using namespace bla benutzen?

    Genauso ist es.

    0
  • ?

    0
  • Z

    naja, und da werd ich angemeckert weil mein code unleserlich ist ^^

    alles dicht an dicht gepackt und der wechsel zwischen public und private ist net sehr schön. hier und da eine leerzeile kann schon wunder bewirken (:

    0
  • O

    ein vernichtendes Urteil Oo
    das winzige worüber ihr nicht gemeckert habt, war diese schweinierei:

    template<class KeyType,class Type,template<class,class> class Container,class Allocator,class keyCompare>
    template<class Type,class ContainerType,class Traits>
    class tree<KeyType,Type,Container,Allocator,keyCompare>::treeIterator{

    😃

    mom ich edite oben gleich

    so ist geedited

    im iterator konnte ih das erste public nicht wegkriegen, da gehts nicht anders, da ich die typen definieren muss, bevor ich sie benutzen kann, und die typen müssen halt public sein.

    Oder wolltest du nur ein bißchen angeben wie toll du coden kannst?

    ich kann nicht gut coden, wieso sollte ich damit angeben?

    0
Anmelden zum Antworten