举例介绍C++高质量编程

下面介绍C++高质量编程。

一、你需要一个函数将一个数组赋值为等差数列，并将会在函数的外部使用它。

不合理：　

 
 
    
  
  
  1. int *GetArray( int n )   
    2.   
  
  2. {   
    3.   
  
  3. int *p = new int[n];   
    4.   
  
  4. for ( int i = 0; i < n; i++ )   
    5.   
  
  5. {   
    6.   
  
  6. 　 p[i] = i;   
    7.   
  
  7. }   
    8.   
  
  8. return p;   
    9.   
  
  9. }　 
    10.

合理：　

 
 
    
  
  
  1. void GetArray( int *p, int n )   
    2.   
  
  2. {   
    3.   
  
  3. for ( int i = 0; i < n; i++ )   
    4.   
  
  4. {   
    5.   
  
  5. p[i] = i;   
    6.   
  
  6. }   
    7.   
  
  7. }  
    8.

解析：

检查内存泄露的***办法，就是检查完全配对的申请和释放，在函数中申请而在外部释放，将导致代码的一致性变差，难以维护。而且，你写的函数不一定是你自己使用的，这样的函数别人会不知道该怎么适当的使用，如果它是一个DLL的导出函数，并且你在不同的平台下使用了，便会导致系统崩溃。***的解决办法就是在函数调用的外面将内存申请好，函数只对数据进行复制。

二、你需要写一个类来为你管理一个指针，这个类将封装对指针的申请内存、释放和其它一些基本操作。　

不合理：　

 
 
    
  
  
  1. class A   
    2.   
  
  2. {   
    3.   
  
  3. public:   
    4.   
  
  4. A( void ) {}   
    5.   
  
  5. ~A( void ) { delete []m_pPtr; }   
    6.   
  
  6. void Create( int n ){ m_pPtr = new int[n]; }   
    7.   
  
  7. private:   
    8.   
  
  8. int *m_pPtr;   
    9.   
  
  9. };　 
    10.

合理：

 
 
    
  
  
  1. class A   
    2.   
  
  2. {   
    3.   
  
  3. public:   
    4.   
  
  4. A( void ) : m_pPtr(0){}   
    5.   
  
  5. ~A( void ) { Clear(); }   
    6.   
  
  6. bool Create( int n ){ if ( m_pPtr ) return false; m_pPtr = new int[n]; return ture; }   
    7.   
  
  7. void Clear( void ) { delete []m_pPtr; m_pPtr = 0; }   
    8.   
  
  8. private:   
    9.   
  
  9. int *m_pPtr;   
    10.   
  
  10. }; 
    11.

解析：

不合理的代码就在于当你重复调用Create的时候就会造成内存泄露，解决的办法就是在new之前判断一下指针是否为0。要能够有效的执行这个判断，则必须在构造的时候对指针进行初始化，并为这个类添加一个Clear函数来释放内存。

三、接上题的Create函数，你现在需要根据传入的参数做一些比较复杂的算法操作，并对申请的数组赋值。

不合理：　

 
 
    
  
  
  1. bool Create(int *a, int n )   
    2.   
  
  2. {   
    3.   
  
  3. if ( m_pPtr )   
    4.   
  
  4. return false;   
    5.   
  
  5. m_pPtr = new int[n];   
    6.   
  
  6. for ( int i = 0; i < n; i++ )   
    7.   
  
  7. {   
    8.   
  
  8. m_pPtr[i] = 3 / a[i];   
    9.   
  
  9. }   
    10.   
  
  10. return true;   
    11.   
  
  11. } 
    12.

合理：

 
 
    
  
  
  1. template   
    2.   
  
  2. class auto_array   
    3.   
  
  3. {   
    4.   
  
  4. public:   
    5.   
  
  5. explicit auto_array(_Ty *pPtr=0)throw():m_Ptr(pPtr){}   
    6.   
  
  6. ~auto_array(){delete[]m_Ptr;}   
    7.   
  
  7. void reset(_Ty *pPtr=0){if(pPtr!=m_Ptr){delete[]m_Ptr;m_Ptr=pPtr;}}   
    8.   
  
  8. _Ty* release(void){_Ty *pTemp=m_Ptr;m_Ptr=0;return pTemp;}   
    9.   
  
  9. private:   
    10.   
  
  10. auto_array(const auto_array&other){}   
    11.   
  
  11. auto_array& operator=(const auto_array& other){}   
    12.   
  
  12. _Ty *m_Ptr;   
    13.   
  
  13. };   
    14.   
  
  14. bool A::Create(int *a, int n )   
    15.   
  
  15. {   
    16.   
  
  16. if ( m_pPtr )   
    17.   
  
  17. return false;   
    18.   
  
  18. auto_array PtrGuard( new int[n] );   
    19.   
  
  19. for ( int i = 0; i < n; i++ )   
    20.   
  
  20. {   
    21.   
  
  21. if ( 0 == a[i] )   
    22.   
  
  22. {   
    23.   
  
  23. return false;   
    24.   
  
  24. }   
    25.   
  
  25. PtrGuard .get()[i] = 3 / a[i];   
    26.   
  
  26. }   
    27.   
  
  27. m_pPtr = PtrGuard.release();   
    28.   
  
  28. return true;   
    29.   
  
  29. } 
    30.

解析：

在循环中，当参数数组a中的某一个值为0时，将会产生除0异常，那么，这将会导致你在上面为m_pPtr申请的内存不能合理的释放。为了解决这个问题，我们写了一个auto_array作为卫兵来看守企图逃逸的指针。在auto_array对象PtrGuard析构的时候它会同时删除附加在它身上的内存指针。我们首先用PtrGuard来进行所有的指针操作，在确定操作完全结束的***，把指针再赋给真正的变量，并使PtrGuard放弃对该指针的附加，这样我们就得到了一个最安全的结果。另外需要注意的是，C++的STL库里本来有一个和auto_array功能非常相似的模版类auto_ptr，但是它只支持单个对象的内存，不支持数组，写这样一个auto_array也是不得已而为之。

四、你需要开辟一段内存来存放和管理一个4 x 4的矩阵，并单位化之。

不合理：

 
 
    
  
  
  1. int aMatrix[4][4];   
    2.   
  
  2. for ( int i = 0; i < 4; i++ )   
    3.   
  
  3. {   
    4.   
  
  4. for ( int j = 0; j < 4; j++ )   
    5.   
  
  5. {   
    6.   
  
  6. if ( i == j )   
    7.   
  
  7. {   
    8.   
  
  8. aMatrix[i][j] = 1;   
    9.   
  
  9. }   
    10.   
  
  10. else   
    11.   
  
  11. {   
    12.   
  
  12. aMatrix [i][j] = 0;   
    13.   
  
  13. }   
    14.   
  
  14. }   
    15.   
  
  15. }　 
    16.

合理：

 
 
    
  
  
  1. int aMatrix[4 * 4];   
    2.   
  
  2. for ( int i = 0; i < 4; i++ )   
    3.   
  
  3. {   
    4.   
  
  4. for ( int j = 0; j < 4; j++ )   
    5.   
  
  5. {   
    6.   
  
  6. if ( i == j )　   
    7.   
  
  7. {   
    8.   
  
  8. aMatrix[ i * 4 + j ] = 1;   
    9.   
  
  9. }   
    10.   
  
  10. else   
    11.   
  
  11. {   
    12.   
  
  12. aMatrix [ i * 4 + j ] = 0;   
    13.   
  
  13. }   
    14.   
  
  14. }   
    15.   
  
  15. }　  
    16.

解析：　

在任何时候都要避免使用多维数组，数组维数的增加，相应的程序复杂度将会以几何级数的方式增加，也更加的难于理解。

五、你需要对上面那个矩阵赋值，使它从左上角向右下角按先纵后横的顺序给它赋值

不合理：

 
 
    
  
  
  1. for( int i = 0; i < 4; i++ )   
    2.   
  
  2. {   
    3.   
  
  3. for ( int j = 0; j < 4; j++ )   
    4.   
  
  4. {   
    5.   
  
  5. aMatrix[ j * 4 + i ] = i * 4 + j;   
    6.   
  
  6. }   
    7.   
  
  7. }　  
    8.

合理：

 
 
    
  
  
  1. for( int i = 0; i < 4; i++ )   
    2.   
  
  2. {   
    3.   
  
  3. for ( int j = 0; j < 4; j++ )   
    4.   
  
  4. {   
    5.   
  
  5. aMatrix[i * 4 + j ] = j * 4 + i;   
    6.   
  
  6. }   
    7.   
  
  7. } 
    8.

解析：

尽量保证顺序的访问数组的每一个元素。由于Windows内存的管理模式，内存是分页管理的。顺序访问数组可以基本保证页面不会来回切换，从而减少了页失效的数量，提高了程序的整体性能。这种性能的提升对于大的数组尤为明显。

六、你需要用3个float值来表示一个三维的点，并要写一个函数对一个三维点的数组进行计算赋值。　

不合理：

 
 
    
  
  
  1. void foo( float *pPoints[3] )   
    2.   
  
  2. {   
    3.   
  
  3. float aPoint[3] = { 1.0f, 2.0f, 3.0f };   
    4.   
  
  4. int nCount = (int)_msize( pPoints );   
    5.   
  
  5. for ( int i = 0; i < nCount; i++ )   
    6.   
  
  6. {   
    7.   
  
  7. pPoints[i][0] = aPoint[0];   
    8.   
  
  8. pPoints[i][1] = aPoint[1];   
    9.   
  
  9. pPoints[i][2] = aPoint[2];   
    10.   
  
  10. }   
    11.   
  
  11. } 
    12.

合理：

 
 
    
  
  
  1. struct POINT3   
    2.   
  
  2. {   
    3.   
  
  3. float x, y, z;   
    4.   
  
  4. };   
    5.   
  
  5. void foo( POINT3 *pPoints, int nCount )   
    6.   
  
  6. {   
    7.   
  
  7. POINT3 Pt = { 1.0f, 2.0f, 3.0f };   
    8.   
  
  8. for ( int i = 0; i < nCount; i++ )   
    9.   
  
  9. {   
    10.   
  
  10. pPoints[i] = Pt;  
    11.   
  
  11. }   
    12.   
  
  12. } 
    13.

解析：

一，不要使用_msize对数组的大小进行测定，_msize只能对使用malloc或calloc申请的内存进行大小测定，对于其它的如new或一些API，将会导致程序的崩溃。在设计此类需要传入数组的函数时，别忘了把数组的元素数量也做为参数一并传入，哪怕它是固定的，这将是一个良好的习惯。

二，对于float[3]这种类型，尽量避免直接使用它，***的办法就是用struct对其进行简单的封装，在复制的时候直接使用“=”就可以进行准确的按位赋值了。

七、你有一个函数的定义，在这个函数中会new一个比较大的对象Data，并在计算后将它删除。但这个函数将被频繁调用。

不合理：

 
 
    
  
  
  1. void foo( void )   
    2.   
  
  2. {   
    3.   
  
  3. Data *p = new Data;   
    4.   
  
  4. CalcData( p );   
    5.   
  
  5. delete p;   
    6.   
  
  6. }  
    7.

合理：

 
 
    
  
  
  1. char Buf[sizeof(DATA)];   
    2.   
  
  2. void foo( void )   
    3.   
  
  3. {   
    4.   
  
  4. Data *p = new(Buf) Data;   
    5.   
  
  5. CalcData( p );   
    6.   
  
  6. }  
    7.

解析：

new(buf) type;是定位的new语法，它不会真正的分配内存，而是简单的在指定的已分配的内存起点上划分出一段与类型大小匹配的空间，并直接在这段内存上对该类型进行构造对象，并返回对象的指针。由于它没有真正的分配内存空间，因此它的效率是非常高的，在类似于上述例程中，频繁申请和释放一个大对象的操作，定位的new可以带来很大的效率提升。

希望通过以上内容的介绍，能够给你带来帮助。

网页题目：举例介绍C++高质量编程
网站链接：http://www.shufengxianlan.com/qtweb/news32/391232.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

分类信息网

成都商城网站开发　　 　网站空间　　 　成都网站制作　　 　成都免费网站建设　　 　西信中心　　 　资阳服务器托管　　 　南充主机托管　　 　广汉长尔科技　　 　成都谷歌SEO　　 　成都网站建设　　 　成都小程序开发　　 　腾讯云香港空间　　 　眉山托管服务器　　 　犀浦雨棚定制　　 　免备案虚拟主机　　 　郫县明安消防器材　　 　成都水电改造　　 　护栏打桩机　　 　网站域名　　 　简阳服务器托管