在Ubuntu下运行会段错误,Win下可以正常运行,为什么?

janusle

以下是我数据结构课程中的一个作业.我在Ubuntu下用g++编译后,运行会显示"段错误",但是在Win下用g++编译后,运行没有提示.我不知道我哪里出问题了.用gdb调试,程序似乎是在其中的一个FilterDown函数中中断的.但是我看不出问题.诸位帮忙看看.

1. 
   
2. #include<iostream>
   
3. using namespace std;
   
4. 
   
5. 
   
6. class heap{
   
7. public:
   
8.   heap(int size = 10):maxsize(size) , currentsize(0) { heapArray = new int[10]; }
   
9.   heap(int a[] , int size);  //通过一个数组构建一个堆.
   
10.   ~heap(){delete [] heapArray;}
    
11.   int getTop(){return heapArray[0];}
    
12.   bool deletetop();  //删除堆顶
    
13.   bool insert(int data); //插入一个元素
    
14.   bool isempty() const{ return currentsize == 0; }
    
15.   bool isfull() const{ return currentsize == maxsize; }
    
16.   int sizeofheap() { return currentsize; }
    
17.   void setempty(){ currentsize = 0 ;}
    
18.   
    
19. 
    
20. private:
    
21.   int *heapArray;
    
22.   int currentsize;
    
23.   int maxsize;
    
24.   void FilterDown(int p); //向下调整函数
    
25.   void FilterUp(int p );  //想上调整函数
    
26. 
    
27. 
    
28. 
    
29. };
    
30. 
    
31. bool heap::deletetop()
    
32. {
    
33. if ( currentsize == 0 )
    
34.   return false;         
    
35. heapArray[0] = heapArray[currentsize-1];
    
36. currentsize--;
    
37. FilterDown(0);
    
38. return true;
    
39. 
    
40. }
    
41. 
    
42. bool heap::insert(int data)
    
43. {
    
44. if ( currentsize == maxsize )
    
45.   return false;
    
46. 
    
47. heapArray[currentsize] = data;
    
48. FilterUp(currentsize);
    
49. currentsize++;
    
50. return true;
    
51. }
    
52. 
    
53. void heap::FilterUp(int p)
    
54. {
    
55. int temp;
    
56. int i = p;
    
57. int j = (i - 1) / 2;
    
58. while( j >= 0 )
    
59.   {
    
60.     if ( heapArray[i] < heapArray[j] )
    
61.      {
    
62.        temp = heapArray[i];
    
63.        heapArray[i] = heapArray[j];
    
64.        heapArray[j] = temp;
    
65.      }
    
66.     else
    
67.      break;
    
68. 
    
69.     i = j;
    
70.     j = (j - 1) / 2;
    
71.   }
    
72. }
    
73. 
    
74. heap::heap(int a[] , int size)
    
75. {
    
76.   maxsize = size + 10;
    
77.   heapArray = new int[maxsize];
    
78.   heapArray = a;
    
79.   currentsize = size;
    
80.   int i = (currentsize - 2) / 2;
    
81.   while(i >= 0)
    
82.    {
    
83.      FilterDown(i--);
    
84.    }
    
85. }
    
86. 
    
87. 
    
88. 
    
89. void heap::FilterDown(int p)
    
90. {
    
91.   int i = p;
    
92.   int j = i * 2 + 1;
    
93.   int temp;
    
94.   while ( j < currentsize )
    
95.    {
    
96.       
    
97.      if ( ( (j + 1) < currentsize ) && ( heapArray[j] > heapArray[j+1] ) )
    
98.        j++;
    
99.    
    
100.      if ( heapArray[i] > heapArray[j] )
     
101.       {
     
102.         temp = heapArray[i];
     
103.         heapArray[i] = heapArray[j];
     
104.         heapArray[j] = temp;
     
105.       }  
     
106.      else
     
107.       break;
     
108. 
     
109.      i = j;
     
110.      j = j * 2 + 1;
     
111. 
     
112.    }     
     
113. 
     
114. 
     
115. 
     
116. }
     
117. 
     
118. int main()
     
119. {
     
120.   int a[] = {80 , 57 , 99 , 35 , 23 , 11 , 74 , 29 , 62 , 16};
     
121.   heap b(a , 10);
     
122.   b.insert(14);
     
123.   b.deletetop();
     
124. 
     
125. }
     

复制代码

cjaizss

自己学着拿gdb调

cjaizss

不过最后好心的我还是帮你看了一下。
错误居然发生在bool heap::insert(int data)里的
heapArray[currentsize] = data;
watch heapArray,发现，居然是这句修改了heapArray的值
很绯疑所思是吗？
哦，原来heapArray本来指着main里的a数组，a的长度是10；
currentsize 也是10，哦，越界。
而且正好heapArray[current]存的就是heapArray这个变量。
教训啊，这个故事告诉我们越界访问的后果是多么的严重

janusle

谢谢，谢谢。我不应该直接指向那个数组，应该复制一下。呵呵

指针看来是很危险的东西！

[ 本帖最后由 janusle 于 2006-12-23 14:12 编辑 ]

ssffzz1

Windows的检测机制没有linux的严格.

galaxywar

原帖由 ssffzz1 于 2006-12-23 13:47 发表
Windows的检测机制没有linux的严格.

不是这个原因. 越界访问未必一定会core dump, 如果你访问的地址对当前进程是有效而且可读的就不会有事(对于读来说), 具有一定偶然性. 这个版里以前有篇贴子是关于malloc实现,还有sbrk()和brk()的讨论, 可以看一下.

据我碰到过的一些跨平台的程序, 明明有越界访问,  在Unix下就是比在Windows下容易重现的多. 我估计是windows下内存分配机制有所不同,到底有什么不同, 我也不清楚.