C++ 运算符重载（C+；+；）有些奇怪 ###MyClass.h### #ifndef_MyClass #定义我的类 #包括 使用名称空间std； 类MyClass { 公众： MyClass（常量字符串名称、常量字符串文本）； 无效显示（ostream&out）常数； MyClass和运算符=（常量MyClass和m）； int比较（constmyclass和right）const； 私人： 字符串\u名称； 字符串-文本； }; 布尔运算符getLChild（））； } 其他的 { 如果（ptr->getRChild（）==0） ptr->setRChild（新节点（项目））； 其他的 插入（项目，ptr->getRChild（））； } } void BST:：析构函数（const Node*r） { 如果（r！=0） { 析构函数（r->getLChild（））； 析构函数（r->getRChild（））； 删除r； } } BST:：~BST（） { 析构函数（根）； } ###main.cpp### #包括 #包括“MyClass.h” #包括“BST.h” 使用名称空间std； void main（） { MyClass*mc1=新的MyClass（“树”，“这是一棵树”）； MyClass*mc2=新的MyClass（“书”，“这是一本书”）； MyClass*mc3=新的MyClass（“动物园”，“这是动物园”）； BST*树=新的BST（）； 树->插入（mc1）； 树->插入（mc2）； 树->插入（mc3）； cout

这里您只是比较指针，即内存地址：

###MyClass.h###

    #ifndef _MyClass
    #define _MyClass
    #include <string>
    using namespace std;


    class MyClass
    {
    public:
        MyClass(const string name, const string text);
        void display(ostream & out) const;

        MyClass & operator = (const MyClass & m);
        int compare(const MyClass & right) const;

    private:
        string _name;
        string _text;
    };

    bool operator < (const MyClass & left, const MyClass & right);
    ostream & operator << (ostream & out, const MyClass & mc);
    #endif

###Node.h###

    #include <string>
    #include "MyClass.h"
    using namespace std;
    typedef MyClass * DataType; 

    class Node
    {
    private:
        DataType item; // data
        Node * lchild; // left child pointer
        Node * rchild; // right child pointer

    public:
        Node(DataType Item);
        DataType getItem() const;
        void setItem(const DataType  & data);
        Node* getLChild() const;
        void setLChild(Node * p);
        Node* getRChild() const;
        void setRChild(Node * p);
        virtual ~Node();
    };

###BST.h###

    #include "Node.h"
    using namespace std;

    class BST
    {
    private:
            Node * root; 
            bool Search(const DataType item, Node * r) const; 
            void Insert (DataType item, Node * ptr);
            void Destructor(const Node * r);

    public:
        BST();
        bool IsEmpty() const;
        void Insert(const DataType item);
        bool Search(const DataType item) const;
        virtual ~BST();
    };

###MyClass.cpp###

    #include <iostream>
    #include "MyClass.h"
    using namespace std;

    MyClass::MyClass(const string name, const string text)
    {
        _name = name;
        _text = text;
    }

    void MyClass::display(ostream & out) const
    {
        out << "Name: " << _name << endl;
        out << "Text: " << _text << endl;
    }

    MyClass & MyClass::operator = (const MyClass & m)  
    {  
        if (this == & m)
            return *this;

        _name = m._name;
        _text = m._text;

        return *this; 
    }

    int MyClass::compare(const MyClass & right) const
    {
        return _name.compare(right._name);
    }

    bool operator < (const MyClass & left, const MyClass & right)  
    {  
        return left.compare(right) > 0;
    }

    ostream & operator << (ostream & out, const MyClass & mc)
    {
        mc.display(out);
        return out;
    }

###Node.cpp###

    #include "Node.h"

    Node::Node(DataType Item):item(Item)
    {
        lchild = 0;
        rchild = 0;
    }

    DataType Node::getItem() const
    {
        DataType anItem = item; 
        return anItem;
    }

    void Node::setItem( const DataType & data)
    {
        item = data;
    }

    Node* Node::getLChild() const
    {
        Node * p = lchild;
        return p;
    }

    void Node::setLChild(Node * p)
    {
        lchild = p;
    }

    Node* Node::getRChild() const
    {
        Node * p = rchild;
        return p;
    }

    void Node::setRChild(Node * p)
    {
        rchild = p;
    }

    Node::~Node()
    {
    }

###BST.cpp###

    #include <iostream>
    #include "BST.h"
    using namespace std;

    bool BST::Search(const DataType item) const
    {
        return Search(item, root);
    }

    bool BST::Search(const DataType item, Node * r) const
    {
        if(r != 0)
        {
            if (item == r->getItem())
                return true;
            else
            {
                if (item < r->getItem())
                    return Search(item, r->getLChild());
                else
                    return Search(item, r->getRChild());
            }
        }
        else
            return false;
    }

    BST::BST()
    {
        root = 0;
    }

    bool BST::IsEmpty() const
    {
        return (root == 0);
    }

    void BST::Insert(const DataType item)
    {
        if(root == 0)
            root = new Node(item);
        else
            Insert(item, root);
    }

    void BST::Insert(DataType item, Node * ptr)
    {
        if (item < ptr->getItem())
        {
            if (ptr->getLChild() == 0)
                ptr->setLChild(new Node(item));
            else 
                Insert(item, ptr->getLChild());
        }
        else 
        {
            if (ptr->getRChild() == 0)
                ptr->setRChild(new Node(item));
            else 
                Insert(item, ptr->getRChild());
        }
    } 

    void BST::Destructor(const Node * r)
    {
        if(r!=0)
        {
            Destructor( r->getLChild());
            Destructor( r->getRChild());
            delete r;
        }
    }

    BST::~BST()
    {
        Destructor(root);
    }

###main.cpp###

    #include <iostream>
    #include "MyClass.h"
    #include "BST.h"
    using namespace std;

    void main()
    {
        MyClass * mc1 = new MyClass("Tree","This is a tree");
        MyClass * mc2 = new MyClass("Book","This is a book");
            MyClass * mc3 = new MyClass("Zoo","This is a zoo");

        BST * tree = new BST();
        tree->Insert(mc1);
        tree->Insert(mc2);
        tree->Insert(mc3);

        cout << boolalpha << ("Book" < "Tree") << endl;
        cout << (mc2 < mc1) << endl;

        cout << (tree->Search(new MyClass("Book",""))) << endl;
    }

---

等等。我甚至会更进一步说，如果您确实确定需要并且有充分的理由不在堆栈上自动分配，那么您应该只使用

new

动态分配对象。如果您确实必须使用动态分配的指针，请看一看。

这里您只是在比较指针，即内存地址：

###MyClass.h###

    #ifndef _MyClass
    #define _MyClass
    #include <string>
    using namespace std;


    class MyClass
    {
    public:
        MyClass(const string name, const string text);
        void display(ostream & out) const;

        MyClass & operator = (const MyClass & m);
        int compare(const MyClass & right) const;

    private:
        string _name;
        string _text;
    };

    bool operator < (const MyClass & left, const MyClass & right);
    ostream & operator << (ostream & out, const MyClass & mc);
    #endif

###Node.h###

    #include <string>
    #include "MyClass.h"
    using namespace std;
    typedef MyClass * DataType; 

    class Node
    {
    private:
        DataType item; // data
        Node * lchild; // left child pointer
        Node * rchild; // right child pointer

    public:
        Node(DataType Item);
        DataType getItem() const;
        void setItem(const DataType  & data);
        Node* getLChild() const;
        void setLChild(Node * p);
        Node* getRChild() const;
        void setRChild(Node * p);
        virtual ~Node();
    };

###BST.h###

    #include "Node.h"
    using namespace std;

    class BST
    {
    private:
            Node * root; 
            bool Search(const DataType item, Node * r) const; 
            void Insert (DataType item, Node * ptr);
            void Destructor(const Node * r);

    public:
        BST();
        bool IsEmpty() const;
        void Insert(const DataType item);
        bool Search(const DataType item) const;
        virtual ~BST();
    };

###MyClass.cpp###

    #include <iostream>
    #include "MyClass.h"
    using namespace std;

    MyClass::MyClass(const string name, const string text)
    {
        _name = name;
        _text = text;
    }

    void MyClass::display(ostream & out) const
    {
        out << "Name: " << _name << endl;
        out << "Text: " << _text << endl;
    }

    MyClass & MyClass::operator = (const MyClass & m)  
    {  
        if (this == & m)
            return *this;

        _name = m._name;
        _text = m._text;

        return *this; 
    }

    int MyClass::compare(const MyClass & right) const
    {
        return _name.compare(right._name);
    }

    bool operator < (const MyClass & left, const MyClass & right)  
    {  
        return left.compare(right) > 0;
    }

    ostream & operator << (ostream & out, const MyClass & mc)
    {
        mc.display(out);
        return out;
    }

###Node.cpp###

    #include "Node.h"

    Node::Node(DataType Item):item(Item)
    {
        lchild = 0;
        rchild = 0;
    }

    DataType Node::getItem() const
    {
        DataType anItem = item; 
        return anItem;
    }

    void Node::setItem( const DataType & data)
    {
        item = data;
    }

    Node* Node::getLChild() const
    {
        Node * p = lchild;
        return p;
    }

    void Node::setLChild(Node * p)
    {
        lchild = p;
    }

    Node* Node::getRChild() const
    {
        Node * p = rchild;
        return p;
    }

    void Node::setRChild(Node * p)
    {
        rchild = p;
    }

    Node::~Node()
    {
    }

###BST.cpp###

    #include <iostream>
    #include "BST.h"
    using namespace std;

    bool BST::Search(const DataType item) const
    {
        return Search(item, root);
    }

    bool BST::Search(const DataType item, Node * r) const
    {
        if(r != 0)
        {
            if (item == r->getItem())
                return true;
            else
            {
                if (item < r->getItem())
                    return Search(item, r->getLChild());
                else
                    return Search(item, r->getRChild());
            }
        }
        else
            return false;
    }

    BST::BST()
    {
        root = 0;
    }

    bool BST::IsEmpty() const
    {
        return (root == 0);
    }

    void BST::Insert(const DataType item)
    {
        if(root == 0)
            root = new Node(item);
        else
            Insert(item, root);
    }

    void BST::Insert(DataType item, Node * ptr)
    {
        if (item < ptr->getItem())
        {
            if (ptr->getLChild() == 0)
                ptr->setLChild(new Node(item));
            else 
                Insert(item, ptr->getLChild());
        }
        else 
        {
            if (ptr->getRChild() == 0)
                ptr->setRChild(new Node(item));
            else 
                Insert(item, ptr->getRChild());
        }
    } 

    void BST::Destructor(const Node * r)
    {
        if(r!=0)
        {
            Destructor( r->getLChild());
            Destructor( r->getRChild());
            delete r;
        }
    }

    BST::~BST()
    {
        Destructor(root);
    }

###main.cpp###

    #include <iostream>
    #include "MyClass.h"
    #include "BST.h"
    using namespace std;

    void main()
    {
        MyClass * mc1 = new MyClass("Tree","This is a tree");
        MyClass * mc2 = new MyClass("Book","This is a book");
            MyClass * mc3 = new MyClass("Zoo","This is a zoo");

        BST * tree = new BST();
        tree->Insert(mc1);
        tree->Insert(mc2);
        tree->Insert(mc3);

        cout << boolalpha << ("Book" < "Tree") << endl;
        cout << (mc2 < mc1) << endl;

        cout << (tree->Search(new MyClass("Book",""))) << endl;
    }

---

等等。我甚至想进一步说，如果您确实确定需要并且有充分的理由不在堆栈上自动分配对象，那么您应该只使用

new

动态分配对象。如果您确实必须使用动态分配的指针，请看一看。

void main（）

不好：。也没有理由让所有对象都成为指针。只需在堆栈上分配它们。

void main（）

不好：。也没有理由让所有对象都成为指针。只需在堆栈上分配它们即可。@downvoter，您愿意评论吗？如果此答案有问题，我宁愿修复它。@downvoter，您愿意评论吗？如果此答案有问题，我宁愿修复它。

cout << ((*mc2) < (*mc1)) << endl;

MyClass mc1("Tree","This is a tree");