C++高質量編程點滴

2019-11-17 05:17:52

字體：大中小

來源：轉載

供稿：網友

　　一、你需要一個函數將一個數組賦值為等差數列，并將會在函數的外部使用它?！　?

　　不合理：　

　　int *GetArray( int n )
　　{
　　 int *p = new int[n];
　　 for ( int i = 0; i < n; i++ )
　　 {
　　　p[i] = i;
　　 }
　　 return p;
　　}　

　　合理：　

　　void GetArray( int *p, int n )
　　{
　　 for ( int i = 0; i < n; i++ )
　　 {
　　 p[i] = i;
　　 }
　　}　
　　解析：　　

　　檢查內存泄露的最好辦法，就是檢查完全配對的申請和釋放，在函數中申請而在外部釋放，將導致代碼的一致性變差，難以維護。而且，你寫的函數不一定是你自己使用的，這樣的函數別人會不知道該怎么適當的使用，假如它是一個DLL的導出函數，并且你在不同的平臺下使用了，便會導致系統崩潰。最好的解決辦法就是在函數調用的外面將內存申請好，函數只對數據進行復制?！　?

　　二、你需要寫一個類來為你治理一個指針，這個類將封裝對指針的申請內存、釋放和其它一些基本操作?！?

　　不合理：　

　　class A
　　{
　　public:
　　 A( void ) {}
　　 ~A( void ) { delete []m_PPTr; }
　　 void Create( int n ){ m_pPtr = new int[n]; }
　　PRivate:
　　 int *m_pPtr;
　　};　
　　合理：　　

　　class A
　　{
　　public:
　　 A( void ) : m_pPtr(0){}
　　 ~A( void ) { Clear(); }
　　 bool Create( int n ){ if ( m_pPtr ) return false; m_pPtr = new int[n]; return ture; }
　　 void Clear( void ) { delete []m_pPtr; m_pPtr = 0; }
　　private:
　　 int *m_pPtr;
　　};
　　解析：　　

　　不合理的代碼就在于當你重復調用Create的時候就會造成內存泄露，解決的辦法就是在new之前判定一下指針是否為0。要能夠有效的執行這個判定，則必須在構造的時候對指針進行初始化，并為這個類添加一個Clear函數來釋放內存。　　
　　
　　三、接上題的Create函數，你現在需要根據傳入的參數做一些比較復雜的算法操作，并對申請的數組賦值。　　

　　不合理：　

　　bool Create(int *a, int n )
　　{
　　 if ( m_pPtr )
　　 return false;
　　 m_pPtr = new int[n];
　　 for ( int i = 0; i < n; i++ )
　　 {
　　 m_pPtr[i] = 3 / a[i];
　　 }
　　 return true;
　　}
　　合理：　　

　　template
　　class auto_array　　
　　{
　　public:
　　 eXPlicit auto_array(_Ty *pPtr=0)throw():m_Ptr(pPtr){}
　　 ~auto_array(){delete[]m_Ptr;}
　　 void reset(_Ty *pPtr=0){if(pPtr!=m_Ptr){delete[]m_Ptr;m_Ptr=pPtr;}}
　　 _Ty* release(void){_Ty *pTemp=m_Ptr;m_Ptr=0;return pTemp;}
　　private:
　　 auto_array(const auto_array&other){}
　　 auto_array& Operator=(const auto_array& other){}
　　 _Ty *m_Ptr;
　　};
　　bool A::Create(int *a, int n )
　　{
　　 if ( m_pPtr )
　　 return false;
　　 auto_array PtrGuard( new int[n] );
　　 for ( int i = 0; i < n; i++ )
　　 {
　　 if ( 0 == a[i] )
　　 {
　　 return false;
　　 }
　　 PtrGuard .get()[i] = 3 / a[i];
　　 }
　　 m_pPtr = PtrGuard.release();
　　 return true;
　　}
　　解析：　　

　　在循環中，當參數數組a中的某一個值為0時，將會產生除0異常，那么，這將會導致你在上面為m_pPtr申請的內存不能合理的釋放。為了解決這個問題，我們寫了一個auto_array作為衛兵來看管企圖逃逸的指針。在auto_array對象PtrGuard析構的時候它會同時刪除附加在它身上的內存指針。我們首先用PtrGuard來進行所有的指針操作，在確定操作完全結束的最后，把指針再賦給真正的變量，并使PtrGuard放棄對該指針的附加，這樣我們就得到了一個最安全的結果。另外需要注重的是，C++的STL庫里本來有一個和auto_array功能非常相似的模版類auto_ptr，但是它只支持單個對象的內存，不支持數組，寫這樣一個auto_array也是不得已而為之。

　　四、你需要開辟一段內存來存放和治理一個4 x 4的矩陣，并單位化之。

　　不合理：

　　int aMatrix[4][4];
　　for ( int i = 0; i < 4; i++ )
　　{
　　 for ( int j = 0; j < 4; j++ )
　　 {
　　 if ( i == j )
　　 {
　　 aMatrix[i][j] = 1;
　　 }
　　 else
　　 {
　　 aMatrix [i][j] = 0;
　　 }
　　 }
　　}　
　　合理：

　　int aMatrix[4 * 4];
　　for ( int i = 0; i < 4; i++ )
　　{
　　 for ( int j = 0; j < 4; j++ )
　　 {
　　 if ( i == j )　
　　 {
　　 aMatrix[ i * 4 + j ] = 1;
　　 }
　　 else
　　 {
　　 aMatrix [ i * 4 + j ] = 0;
　　 }
　　 }
　　}　　
　　解析：　

　　在任何時候都要避免使用多維數組，數組維數的增加，相應的程序復雜度將會以幾何級數的方式增加，也更加的難于理解?！　?

　　五、你需要對上面那個矩陣賦值，使它從左上角向右下角按先縱后橫的順序給它賦值

　　不合理：

　　for( int i = 0; i < 4; i++ )
　　{
　　 for ( int j = 0; j < 4; j++ )
　　 {
　　 aMatrix[ j * 4 + i ] = i * 4 + j;
　　 }
　　}　　
　　合理：

　　for( int i = 0; i < 4; i++ )
　　{
　　 for ( int j = 0; j < 4; j++ )
　　 {
　　 aMatrix[i * 4 + j ] = j * 4 + i;
　　 }
　　}
　　解析：　　

　　盡量保證順序的訪問數組的每一個元素。由于Windows內存的治理模式，內存是分頁治理的。順序訪問數組可以基本保證頁面不會往返切換，從而減少了頁失效的數量，提高了程序的整體性能。這種性能的提升對于大的數組尤為明顯?！　?

　　六、你需要用3個float值來表示一個三維的點，并要寫一個函數對一個三維點的數組進行計算賦值?！?

　　不合理：

　　void foo( float *pPoints[3] )
　　{
　　 float aPoint[3] = { 1.0f, 2.0f, 3.0f };
　　 int nCount = (int)_msize( pPoints );
　　 for ( int i = 0; i < nCount; i++ )
　　 {
　　 pPoints[i][0] = aPoint[0];
　　 pPoints[i][1] = aPoint[1];
　　 pPoints[i][2] = aPoint[2];
　　 }
　　}
　　合理：

　　strUCt POINT3
　　{
　　 float x, y, z;
　　};
　　void foo( POINT3 *pPoints, int nCount )
　　{
　　 POINT3 Pt = { 1.0f, 2.0f, 3.0f };
　　 for ( int i = 0; i < nCount; i++ )
　　 {
　　 pPoints[i] = Pt;

　　 }
　　}
　　解析：　　

　　有兩點，一，不要使用_msize對數組的大小進行測定，_msize只能對使用malloc或calloc申請的內存進行大小測定，對于其它的如new或一些API，將會導致程序的崩潰。在設計此類需要傳入數組的函數時，別忘了把數組的元素數量也做為參數一并傳入，哪怕它是固定的，這將是一個良好的習慣。二，對于float[3]這種類型，盡量避免直接使用它，最好的辦法就是用struct對其進行簡單的封裝，在復制的時候直接使用“=”就可以進行準確的按位賦值了。

　　七、你有一個函數的定義，在這個函數中會new一個比較大的對象Data，并在計算后將它刪除。但這個函數將被頻繁調用?！　?

　　不合理：　　

　　void foo( void )
　　{
　　 Data *p = new Data;
　　 CalcData( p );
　　 delete p;
　　}　　
　　合理：

　　char Buf[sizeof(DATA)];
　　void foo( void )
　　{
　　 Data *p = new(Buf) Data;
　　 CalcData( p );
　　}　
　　解析：　　

　　new(buf) type;是定位的new語法，它不會真正的分配內存，而是簡單的在指定的已分配的內存起點上劃分出一段與類型大小匹配的空間，并直接在這段內存上對該類型進行構造對象，并返回對象的指針。由于它沒有真正的分配內存空間，因此它的效率是非常高的，在類似于上述例程中，頻繁申請和釋放一個大對象的操作，定位的new可以帶來很大的效率提升。

上一篇：利用C++模板編寫的序列化框架

下一篇：C語言初學者的困惑--如何由dos向windows轉變