(已完成)指標觀念問題...應該吧

baepi

又是小弟我~繼上次問過創建二維動態記憶體~雖然大體已經成功~但是卻發現若是使用class物件~那麼並不會有建構的動作...聽不懂沒關係~畢竟這次跟上次那篇並無太大關係

這次小弟碰到的問題是...先看小弟完成的套件拙作

1. template<class T> T** new_new( int xx , int yy )
   
2. {
   
3.         T **temp = (T**)new T[ ( xx * sizeof(T*) ) + ( xx * yy )  ];        //[ 指標數量 + 大小 ]
   
4.         T *buf = (T *)( temp + xx );        //強制轉為1維陣列 + 略過指標數量
   
5.         temp[ 0 ] = buf;
   
6.         for( int i = 1 ; i < xx ; i++ )
   
7.         {
   
8.                 temp[ i ] = temp[ i - 1 ] + yy ;
   
9.         }
   
10.         return temp;
    
11. }

複製代碼

由此套件創建的二維動態記憶體....class元件會建構了~可是建構的值卻是錯誤的...這是問題1
建構的數量很明顯不對...這是問題2
下面有完整程式碼 + 執行結果~請高手們能給我解答或是提供嘗試的方向

1. #include <iostream>
   
2. using namespace std;
   
3. #define x 3
   
4. #define y 2
   
5. template<class T> T** new_new( int xx , int yy )
   
6. {
   
7.         T **temp = (T**)new T[ ( xx * sizeof(T*) ) + ( xx * yy )  ];        //[ 指標數量 + 大小 ]
   
8.         T *buf = (T *)( temp + xx );        //強制轉為1維陣列 + 略過指標數量
   
9.         temp[ 0 ] = buf;
   
10.         for( int i = 1 ; i < x ; i++ )
    
11.         {
    
12.                 temp[ i ] = temp[ i - 1 ] + yy ;
    
13.         }
    
14.         return temp;
    
15. }
    
16. class test
    
17. {
    
18. public:
    
19.         int a;
    
20.         int b;
    
21.         test();
    
22.         ~test();
    
23. };
    
24. test::test()
    
25. {
    
26.         cout<<"這是建構\n";
    
27.         a = 7 ;
    
28.         b = 8;
    
29. }
    
30. test::~test()
    
31. {
    
32.         cout<<"這是解構\n";
    
33. }
    
34. void main()
    
35. {
    
36. cout<<"固定二維陣列\n";
    
37.         test t[ x ][ y ];
    
38.         for( int i = 0 ; i < x ; i++ )
    
39.         {
    
40.                 for( int j = 0 ; j < y ; j++ )
    
41.                 {
    
42.                         cout << t[ i ][ j ].a << t[ i ][ j ].b << '\t' ;
    
43.                 }
    
44.                 cout<<endl;
    
45.         }
    
46.         cout<<endl;
    
47. 
    
48.         cout<<"動態二維陣列\n";
    
49.         test **tt;
    
50.         tt = new test*[ x ];
    
51.         for( int i = 0 ; i < x ; i++ )
    
52.         {
    
53.                 tt[i] = new test[ y ];
    
54.         }
    
55.         for( int i = 0 ; i < x ; i++ )
    
56.         {
    
57.                 for( int j = 0 ; j < y ; j++ )
    
58.                 {
    
59.                         cout << tt[ i ][ j ].a << tt[ i ][ j ].b << '\t' ;
    
60.                 }
    
61.                 cout<<endl;
    
62.         }
    
63.         cout<<endl;
    
64.         for( int i = 0 ; i < x ; i++ )
    
65.         {
    
66.                 delete [] tt[i];
    
67.         }
    
68.         delete [] tt;
    
69. 
    
70.         cout<<"一次刪除的動態二維陣列\n";
    
71.         test **ttt = new_new< test >( x , y );
    
72.         for( int i = 0 ; i < x ; i++ )
    
73.         {
    
74.                 for( int j = 0 ; j < y ; j++ )
    
75.                 {
    
76.                         cout << ttt[ i ][ j ].a << ttt[ i ][ j ].b << '\t' ;
    
77.                 }
    
78.                 cout<<endl;
    
79.         }
    
80.         cout<<endl;
    
81.         delete [] ttt;
    
82. }

複製代碼

執行結果

1. 固定二維陣列
   
2. 這是建構
   
3. 這是建構
   
4. 這是建構
   
5. 這是建構
   
6. 這是建構
   
7. 這是建構
   
8. 78      78
   
9. 78      78
   
10. 78      78
    
11. 
    
12. 動態二維陣列
    
13. 這是建構
    
14. 這是建構
    
15. 這是建構
    
16. 這是建構
    
17. 這是建構
    
18. 這是建構
    
19. 78      78
    
20. 78      78
    
21. 78      78
    
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. 87      87
    
49. 87      87
    
50. 87      87
    
51. 
    
52. 這是解構
    
53. 這是解構
    
54. 這是解構
    
55. 這是解構
    
56. 這是解構
    
57. 這是解構
    
58. 請按任意鍵繼續 . . .

複製代碼

已知錯誤

1. T **temp = (T**)new T[ ( xx * sizeof(T*) ) + ( xx * yy )  ];        //[ 指標數量 + 大小 ]

複製代碼

但是實在不知怎麼修改....

...

瀏覽完整內容，請先 註冊 或 登入會員

kiwis

kiwis 發表於 2016-11-28 03:43 PM

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

我猜你是想要”只 new 一次，也只 delete 一次，但是想用二維陣列的方式操作”吧？

如果是的話，也不是不 ...

>kaworucloud
...

瀏覽完整內容，請先 註冊 或 登入會員

baepi

kilean 發表於 2016-11-29 02:34 PM

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

其實，我不太明白你的用意。
用多少就配置多少記憶體，new 了卻不用，只是為了避開錯誤，不是正確的作法。
...

...

瀏覽完整內容，請先 註冊 或 登入會員

kilean

其實，我不太明白你的用意。
用多少就配置多少記憶體，new 了卻不用，只是為了避開錯誤，不是正確的作法。
靜態動態一維二維陣列對記憶體的使用上你可能要去了解。
包含過去的我在內，很多人對這方面觀念很弱，真的不好解釋。
試著解釋給其他同事聽，也是解釋了很久。

基本上：
1. 我不建議在function 或method 內new 東西然後 return 出來。
...

瀏覽完整內容，請先 註冊 或 登入會員

baepi 發表於 2016-11-28 10:17 AM

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

感謝還是有人給予回覆...其實我測試到現在已經半放棄了
delete要幾次跟幾維本質上是不太有直接關係的~是 ...

一般的二維陣列用法因為涉及兩個 [], (兩層的指標)
...

瀏覽完整內容，請先 註冊 或 登入會員

kiwis

補一下實際操作，不知道為何程式碼沒辦法貼，所以請看附檔 : p

kiwis

我猜你是想要”只 new 一次，也只 delete 一次，但是想用二維陣列的方式操作”吧？

如果是的話，也不是不行這樣做，只是有點複雜。
重點是要實作一個一維陣列的template。

1. template<class T>
   
2. class T2DArray
   
3. {
   
4. public:
   
5.         T2DArray(int new_x, int new_y):
   
6.           p_array(0),
   
7.           x(new_x),
   
8.           y(new_y)
   
9.         {
   
10.                 p_array = new T[ x*y ];
    
11.         };
    
12. 
    
13.         ~T2DArray()
    
14.         {
    
15.                 if(p_array)
    
16.                         delete [] p_array;
    
17.         };
    
18. 
    
19.         class TArray
    
20.         {
    
21.         public:
    
22.                 TArray(T* array, int new_length):
    
23.                   length(new_length),
    
24.                   p_array(array)
    
25.                 {
    
26.                 }
    
27. 
    
28.                 T& operator[](int index)
    
29.                 {
    
30.                         if(index >= length || 0 > index)
    
31.                                 throw std::invalid_argument( "invalid index.\n" );
    
32.                         else
    
33.                                 return (p_array[index]);
    
34.                 };
    
35. 
    
36.         private:
    
37.                 T* p_array;
    
38.                 int length;
    
39. 
    
40.         };
    
41. 
    
42.         TArray operator[](int index)
    
43.         {
    
44.                 if(index >= x || 0 > index)
    
45.                         throw std::invalid_argument( "invalid index.\n" );
    
46.                 else
    
47.                         return TArray(p_array+(y * index) ,y);
    
48.         };
    
49. 
    
50. 
    
51. private:
    
52.         T2DArray(const T2DArray&);                           // copy constructor
    
53.         T2DArray& operator=(const T2DArray&);        // assign operator
    
54.         T* p_array;
    
55.         int x;
    
56.         int y;
    
57. 
    
58. };

複製代碼

T2DArray[ index ] 會傳回一個 TArray，
TArray[ index ] 會傳回記憶體上真正的數字，

不過是一個感覺上危險到不行的東西，
隨時會來個 Array Out Of Bound 的例外...

個人並不推薦這種用法。...

瀏覽完整內容，請先 註冊 或 登入會員

baepi

inunu 發表於 2016-11-28 03:27 AM

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

1. 把你 動態二維陣列 裡的做法整個代進去就對了

2. delete[] 本來就需要兩個層次, 否則就不是二維 ...

感謝還是有人給予回覆...其實我測試到現在已經半放棄了
...

瀏覽完整內容，請先 註冊 或 登入會員

cockroachrun

c++ 下沒辦法只有一次new . 因為 class 要construct . 也要 destruct
但又因為你要求的是兩個不同的class ( T*  跟 T 是不一樣的東西) 所以.. 沒有辦法做到.

1. 把你 動態二維陣列 裡的做法整個代進去就對了

2. delete[] 本來就需要兩個層次, 否則就不是二維

cockroachrun

建構的數量當然不對啊
因為你寫的是
new T[ ( xx * sizeof(T*) ) + ( xx * yy )  ];
這是產生 class T 共 xx*sizeof(T*) + (xx*yy) 個
假設是在32bit 的pc windows OS 下 sizeof(T*) 為4
所以你一共產生了 xx*4 + xx*yy 個T 物件. 被建構的次數也是 xx*4 + xx*yy 次

怎麼改.. 分兩次new
一次 temp= new T*[xx];
temp[0] = new T[xx*yy];   之後的程式碼就一樣..

johnwanz

new_new 第一行, 為何要
new T[ ( xx * sizeof(T*) ) + ( xx * yy )  ];

real data 只有xx*yy不是嗎?