[已解决]一上午都没有找出来的小错误（悬赏20鱼币）

爱学习520

做一个冒泡排序，比较结构体里面数据的大小，请问这个为什么错了，我测试过int、double、char这些都没有问题，这个比较结构体哪里错了，为什么不正确排序，如图：
正确答案应该是：
1 1
2 2
3 3

1. #include<iostream>
   
2. using namespace std;
   
3. 
   
4. class Text
   
5. {
   
6.         public:
   
7.                 int x;
   
8.             int y;       
   
9.         Text(){        }
   
10.             
    
11.         Text(int x,int y)
    
12.         {
    
13.                 this->x=x;
    
14.                 this->y=y;
    
15.         }
    
16.         bool operator>(Text& text)
    
17.         {
    
18.                 return this->x > text.x&&this->y > text.y;
    
19.         }
    
20.         void print()
    
21.         {
    
22.                 cout<<x<<"  "<<y<<endl;
    
23.         }
    
24. };
    
25. //冒泡排序
    
26. template<class T>
    
27. void sort(T arr,int length)
    
28. {
    
29.         int i,j;
    
30.         Text* temp;
    
31.        
    
32.         for(i=0;i<length-1;i++)
    
33.             for(j=i+1;j<length;j++)
    
34.             if(arr[i]>arr[j])
    
35.             {
    
36.                     temp=arr[j];
    
37.                     arr[j]=arr[i];
    
38.                     arr[i]=temp;                   
    
39.                 }                                   
    
40. }
    
41. main()
    
42. {
    
43.         int i;
    
44.         Text a(2,2),b(3,3),c(1,1);        
    
45.         Text* arr[3]={&a,&b,&c};       
    
46.         sort(arr,3);
    
47.        
    
48.         arr[0]->print();
    
49.         arr[1]->print();
    
50.         arr[2]->print();
    
51. 
    
52. 
    
53.    
    
54. 
    
55. 
    
56. }

复制代码

最佳答案

月排行榜 / 总排行榜

xieglt

2020-8-7 11:10:33

看错了，是你的重载 〉调用写错了。
把
if(arr[i]>arr[j])
改写成
if(*arr[i]>*arr[j])

跳转到最佳答案楼层

xieglt

为什么要用指针？指针交换乱了。

重载=操作符比较好

#include<iostream>
using namespace std;

class Text
{
        public:
                int x;
            int y;        
        Text(){        }

            
        Text(int x,int y)
        {
                        this->x=x;
                        this->y=y;
        }

                //重载 =
                Text & operator = (const Text & t)
                {
                        x = t.x;
                        y = t.y;
                        return * this;
                }

        bool operator>(Text& text)
        {
                        return this->x > text.x&&this->y > text.y;
        }
        void print()
        {
                        cout<<x<<"  "<<y<<endl;
        }
};
//冒泡排序
template<class T>
void sort(T arr,int length)
{
        int i,j;
        //
        Text temp;
       
        for(i=0;i<length-1;i++)
                for(j=i+1;j<length;j++)
            if(arr[i]>arr[j])
            {
                                temp=arr[j];
                                arr[j]=arr[i];
                                arr[i]=temp;                    
                        }                                    
}
void main()
{
        int i=0;
        Text a(2,2),b(3,3),c(1,1);         
        Text arr[3]={a,b,c};        
        sort(arr,3);
       
        arr[0].print();
        arr[1].print();
        arr[2].print();
}

爱学习520

xieglt 发表于 2020-8-7 10:47
为什么要用指针？指针交换乱了。

重载=操作符比较好

但是我哪个哪里错了呢，求指导

xieglt

错在比较大小后的交换
交换的是指针，不是X，Y的值
3个指针变来变去，乱套了，自己跟踪调试一下。

xieglt

看错了，是你的重载 〉调用写错了。
把
if(arr[i]>arr[j])
改写成
if(*arr[i]>*arr[j])

xieglt

两个指针比较是他们的地址在比，而没有调用重载>函数。

xieglt

所以建议不要随便用指针，很不优雅。

sunrise085

五楼说得对！

爱学习520

xieglt 发表于 2020-8-7 11:10
看错了，是你的重载 〉调用写错了。
把
if(arr>arr[j])

非常感谢，20鱼币已经通过给你四个帖子分别支持了5鱼币，表示感谢

aironeng

学习