xiegenwendada
xiegenwendada

C++学习笔记【转】

Debug : 在单独运行时，往往需要编译器提供一些库文件

Release : 可以在没有安装visual c++的computer上正常运行

 

常规设置

1)
在共享DLL中使用MFC : 表示把程序中用到的MFC类库作为动态链接库，这样编译生成器的程序比较小，但是在运行的时候，需要操作系统提供额外的动态库支持。

2)
在静态库中使用MFC : 表示把用到的MFC类的内容作为静态库加到程序中，这样编译产生的程序可以在任何Windwos环境下运行，但是程序的体积比较大。

3)
使用标准Windows库 : 表示不适用MFC类库，仅使用标准的Windows类库。


#define and const
宏的使用是在预处理的时候进行五条件的替换，并没有明确指定这个常量的数据类型、所以带来便利的同时也容易带来问题。
所以出现了const


枚举的使用---------------------------------

  1. enum Weekday  
  2. {  
  3.     mon,  
  4.     tue,  
  5.     wed,  
  6.     thu,  
  7.     fri,  
  8.     sat,  
  9.     sun  
  10. };  


枚举默认的值是0，如果不想用默认，可以直接赋值
枚举定义之后，不能再修改其中某个元素的值


使用位操作符---------------------------------------------------

 
  1.     cout << "use transpose operator :" << endl;  
  2.     int iValue = 1;  
  3. //  iValue = iValue * 4;  
  4.     iValue = iValue << 34; // 34 % 32 = 2左移 因为超过了int的大小空间  
  5.     cout << "iValue value is : " << iValue << endl;  


 

内联函数 :
可以更形象地称为内嵌函数，它是C++对函数的一种特殊修饰。当编译器编译程序时，如果发现某段代码在调用一个内联函数，它就不再去调用该函数，而是将该函数的代码整段插入当前函数调用的位置。这样就省去了函数调用的过程，提高了代码的执行效率。关键字inline


函数重载 :
1)函数重载的意义在于可以根据输入参数的类型或者个数，自动地在多个重载函数中查找与之匹配的重载函数，从而只能地决定采用哪个函数版本。
2)只有相互之间的参数类型或者个数不同，才可以构成合法的重载函数


函数的声明----也称为函数的接口
1)试一试在纯c中使用接口------------------------------------------------
2)尽量在函数中使用断言assert判断函数的有效性
3)函数的功能要做到单一----如果一个函数需要完成多项任务，最好拆分成多个函数


面向对象的知识 :
1)封装
在传统的结构化程序设计思想中，数据和算法是相互分离的。
在面向对象的程序设计思想中，对象就是封装数据和操作这些数据的算法的逻辑实体，也是现实世界中物体在程序中的反映，使用封装有的时候可以很好的保护对象的私有部分

2)继承
从父亲那里得到技能，自己又可以继续学习。比如我现在就站在前人的基础上学习的c++

3)多态
就是指对象在不同情况下具有不同形式的能力。多态机制使具有不同内部结构的对象可以共享相同的外部接口。比如，给别人一幅画，不一定是你自己画的，也可以直接把你老爸的画送出

想想 : 如何在面向对象程序设计思想上，考虑扩展、复用、可维护问题


new :
在new不成功是，不必去判断指针是否为null，因为new不成功时，系统会自动抛出std::bad_alloc异常，new操作永远不会返回null


拷贝构造函数 :
默认也会有拷贝构造函数，当类中含有指针类型的属性时，以拷贝内存形式出现的默认拷贝构造函数只能复制指针属性的值，而不能复制指针属性所指向的内存，在这个情况下需要自定义类的拷贝函数，完成指针属性等需要页数处理的属性的拷贝工作。

p163 拷贝构造函数

 
  1. namespace Zeng  
  2. {  
  3.     class CTest_A  
  4.     {  
  5.     public:  
  6.         CTest_A( int iValue, char* cName )  
  7.         {  
  8.             this->m_iValue = iValue;  
  9.             this->m_pName = new char[ strlen( cName ) + 1 ];  
  10.             strcpy( m_pName, cName );  
  11.         }  
  12.         // 拷贝构造函数  
  13.         CTest_A( const CTest_A& rCG )  
  14.         {  
  15.             this->m_iValue = rCG.m_iValue;  
  16.             this->m_pName = new char[ strlen( rCG.m_pName ) + 1 ];  
  17.             strcpy( m_pName, rCG.m_pName );  
  18.         }  
  19.         void print()  
  20.         {  
  21.             cout << "CTest_G m_iValue value is : " << this->m_iValue << endl;   
  22.             cout << "CTest_G m_pName value is : " << this->m_pName << endl;   
  23.             cout << "CTest_G m_pName address is : " << *this->m_pName << endl;   
  24.         }  
  25.     public:  
  26.         int m_iValue;  
  27.         char* m_pName;  
  28.     }; // 试试拷贝构造函数  
  29. }  
  30.   
  31. int _tmain(int argc, _TCHAR* argv[])  
  32. {  
  33.     Zeng::CTest_A CA( 10, "Zengraoli" );  
  34.     Zeng::CTest_A CA2( 10, "Zengraoli" );  
  35.     Zeng::CTest_A CA3( CG );  
  36.     cout << "CA print" << endl;  
  37.     CA.print();  
  38.   
  39.     cout << "\n";  
  40.     cout << "CA2 print" << endl;  
  41.     CA2.print();  
  42.   
  43.     cout << "\n";  
  44.     cout << "CA3 print" << endl;  
  45.     CA3.print();  
  46.     cout << "class CTest_A size is : " << sizeof( Zeng::CTest_A ) << endl;  
  47.   
  48.     return 0;  
  49. }  


 

P166 操作符重载
函数重载和操作符重载-------------------------------------

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. namespace Zeng  
  6. {  
  7.     class CTest_A  
  8.     {  
  9.     public:  
  10.         CTest_A()  
  11.         {  
  12.         }  
  13.         void print()  
  14.         {  
  15.             cout << "this is CTest_A print()" << endl;  
  16.         }  
  17.     }; // 占1个字节的大小  
  18.   
  19.     class CTest_B : virtual CTest_A  
  20.     {  
  21.     public:  
  22.         CTest_B( int iValue ) : m_iValue( iValue )  
  23.         {  
  24.         }  
  25.         void print()  
  26.         {  
  27.             cout << "m_iValue value is : " << m_iValue << endl;  
  28.         }  
  29.     private:  
  30.         int m_iValue;  
  31.     }; // 占8个字节的大小  
  32.   
  33.     class CTest_C : virtual CTest_A  
  34.     {  
  35.     public:  
  36.         CTest_C()  
  37.         {  
  38.         }  
  39.     }; // 占4个字节的大小  
  40.   
  41.     class CTest_D : virtual CTest_B  
  42.     {  
  43.     public:  
  44.         CTest_D( int iValue ) : CTest_B( iValue )  
  45.         {  
  46.             this->m_iValue = iValue + 89;  
  47.         }  
  48.         void print()  
  49.         {  
  50.             cout << "m_iValue value is : " << this->m_iValue << endl;  
  51.         }  
  52.     private:  
  53.         int m_iValue;  
  54.     }; // 占16个字节的大小  
  55.   
  56.     class CTest_E : public CTest_A  
  57.     {  
  58.     public:  
  59.         CTest_E( int iValue )  
  60.         {  
  61.             this->m_iValue = iValue + 89;  
  62.         }  
  63.         void print()  
  64.         {  
  65.             cout << "this is CTest_E not parameter's print()" << endl;  
  66.         }  
  67.         void print( int iValue )  
  68.         {  
  69.             cout << "this is CTest_E has parameter's print()" << endl;  
  70.         }  
  71. /* 
  72.         int print( int iValue ) 
  73.         { 
  74.             cout << "this is CTest_E has parameter's print()" << endl; 
  75.             return 0; 
  76.         } // c++可以忽略函数的返回值，所以只能靠参数不同来进行函数重载 
  77. */  
  78.     private:  
  79.         int m_iValue;  
  80.     }; // 试试函数重载  
  81.   
  82.     class CTest_F  
  83.     {  
  84.     public:  
  85.         CTest_F( int iValue )  
  86.         {  
  87.             this->m_iValue = iValue;  
  88.         }  
  89.         void print()  
  90.         {  
  91.             cout << "CTest_F m_iValue value is : " << this->m_iValue << endl;   
  92.         }  
  93.         const CTest_F& operator+ ( const CTest_F& rCF )  
  94.         {  
  95.             this->m_iValue += rCF.m_iValue;  
  96.             return *this;  
  97.         }  
  98.         const CTest_F& operator= ( const CTest_F& rCF )  
  99.         {  
  100.             this->m_iValue = rCF.m_iValue;  
  101.             return *this;  
  102.         }  
  103.     public:  
  104.         int m_iValue;  
  105.     }; // 试试操作符重载  
  106. }  
  107.   
  108. int _tmain(int argc, _TCHAR* argv[])  
  109. {  
  110.     Zeng::CTest_A CA;  
  111.     CA.print();  
  112.     cout << "class CTest_A size is : " << sizeof( Zeng::CTest_A ) << endl;  
  113.     cout << "class CTest_B size is : " << sizeof( Zeng::CTest_B ) << endl;  
  114.     cout << "class CTest_C size is : " << sizeof( Zeng::CTest_C ) << endl;  
  115.   
  116.     cout << "\n";  
  117.     Zeng::CTest_D CD( 10 );  
  118.     CD.print();  
  119.     cout << "class CTest_D size is : " << sizeof( Zeng::CTest_D ) << endl;  
  120.   
  121.     cout << "\n";  
  122.     Zeng::CTest_E CE( 10 );  
  123.     CE.print();  
  124.     CE.print(1);  
  125.     cout << "class CTest_E size is : " << sizeof( Zeng::CTest_E ) << endl;  
  126.   
  127.     cout << "\n";  
  128.     Zeng::CTest_F CF( 10 );  
  129.     Zeng::CTest_F CF2( 89 );  
  130.     CF = CF + CF2;  
  131.     cout << "in class CTest_F override add after : " << sizeof( Zeng::CTest_F ) << endl;  
  132.     CF.print();  
  133.     CF = CF2;  
  134.     cout << "in class CTest_F override equal after : " << sizeof( Zeng::CTest_F ) << endl;  
  135.     CF.print();  
  136.     cout << "class CTest_F size is : " << sizeof( Zeng::CTest_F ) << endl;  
  137.   
  138.     return 0;  
  139. }  


 


构造函数私有化的含义---------------------------------------------

 
  1. namespace Rao  
  2. {  
  3.     class CTest  
  4.     {  
  5.     public:  
  6.         static CTest* makeAnObject()  
  7.         {  
  8.              // 程序结束的时候 自动释放  
  9.             static CTest instance;  
  10.             return &instance;  
  11.         }  
  12.         ~CTest()  
  13.         {  
  14.             cout << "CTest Destructor...." << endl;  
  15.         }  
  16.         static int m_nValue;  
  17.     private:  
  18.         CTest()  
  19.         {  
  20.             m_nValue++;  
  21.             cout << "CTest Constructor...." << endl;  
  22.         }  
  23.           
  24.         CTest( const CTest& CopyCTest )  
  25.         {  
  26.             m_nValue++;  
  27.             cout << "CopyCTest Constructor...." << endl;  
  28.         }  
  29.   
  30.         const  CTest& operator= ( const CTest& );  
  31.     };  
  32. }  
  33. main:  
  34.     int Rao::CTest::m_nValue;  
  35.   
  36.     cout << "\n";  
  37.     cout << "use Constructor privatization :" << endl;  
  38.     Rao::CTest* RaoCTest = Rao::CTest::makeAnObject();  
  39.     cout << "m_nValue :" << Rao::CTest::m_nValue << endl;  
  40.     Rao::CTest* RaoCTest2 = Rao::CTest::makeAnObject();  
  41.     cout << "m_nValue :" << Rao::CTest::m_nValue << endl;  
  42.   
  43.     // 调用拷贝构造函数  
  44.     Rao::CTest sg = *Rao::CTest::makeAnObject();  
  45.     cout << "m_nValue :" << Rao::CTest::m_nValue << endl;  


 

类的成员访问控制
public : 公有访问接口
protected : 1)可以供类自身访问的成员 2)可以供下级子类访问的成员
private : 仅供类自身访问的成员


友元函数
简单理解为 : 由于类成员的访问控制机制，很好地实现了数据的隐藏与封装，类的成员变量一般定义为私有成员，成员函数一般定义为公有成员，以此来提供类与外界间的通信接口；但有特殊的情况，比如需要定义某个函数/某个类，这个函数/类不是类CA的一部分，但又需要频繁地访问类CA的隐藏信息，所以C++提供了一个"friend"关键字来完成这个任务。
友元函数和友元类都需要试一试--------------------------------------P172
但需要记住的一点 :
1)友元关系不能被继承。这一点很好理解，我们跟某个类是朋友，并不表示我们跟这个类的儿子(派生类)同样是朋友。
2)友元关系是单向的，不具有交换性。

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. namespace Zeng  
  6. {  
  7.     class CTest_A  
  8.     {  
  9.     public:  
  10.         CTest_A( int iValue )  
  11.         {  
  12.             this->m_iValue = iValue;  
  13.         }  
  14.         void print()  
  15.         {  
  16.             cout << "CTest_A's m_iValue current value is : " << this->m_iValue << endl;  
  17.         }  
  18.         friend void firendFunction( const CTest_A& CA );  
  19.         friend class CTest_B;  
  20.     private:  
  21.         int m_iValue;  
  22.     };  
  23.   
  24.     class CTest_B  
  25.     {  
  26.     public:  
  27.         CTest_B()  
  28.         {  
  29.         }  
  30.         void print( const CTest_A& CA )  
  31.         {  
  32.             cout << "this's firend class CTest_B print : " << CA.m_iValue << endl;  
  33.         }  
  34.     private:  
  35.     }; // 友元类  
  36.   
  37.     void firendFunction( const CTest_A& CA )  
  38.     {  
  39.         cout << "this's firend function print : " << CA.m_iValue << endl;  
  40.     }  
  41. }  
  42.   
  43. int _tmain(int argc, _TCHAR* argv[])  
  44. {  
  45.     Zeng::CTest_A CA( 100 );  
  46.     firendFunction( CA );  
  47.   
  48.     cout << "\n";  
  49.     Zeng::CTest_B CB;  
  50.     CB.print( CA );  
  51.   
  52.     return 0;  
  53. } 

抽象一般分为属性抽象和行为抽象两种。前者寻找一类对象共有的属性或者状态变量，后者则寻找这类对象所具有的共同行为特征。在分析新的对象时，应该从属性和行为两个方面进行抽象和概括，提取对象的共有也行。有了抽象，那么就可以提取出来当做接口(虚函数)，可以直接变成类的成员属性和成员函数。


如何在子类中调用从父类继承并且已经被重写的函数？--------------------


  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. namespace Zeng  
  6. {  
  7.     class CTest_A  
  8.     {  
  9.     public:  
  10.         CTest_A( int iValue )  
  11.         {  
  12.             this->m_iValue = iValue;  
  13.         }  
  14.         void print()  
  15.         {  
  16.             cout << "CTest_A's m_iValue current value is : " << this->m_iValue << endl;  
  17.         }  
  18.     private:  
  19.         int m_iValue;  
  20.     };  
  21.   
  22.     class CTest_B : public CTest_A  
  23.     {  
  24.     public:  
  25.         CTest_B( int iValue ) : CTest_A( iValue )  
  26.         {  
  27.             this->m_iValue = iValue;  
  28.         }  
  29.         void print()  
  30.         {  
  31.             cout << "CTest_B's m_iValue current value is : " << this->m_iValue << endl;  
  32.         }  
  33.     private:  
  34.         int m_iValue;  
  35.     }; // virtual CTest_A比普通的public CTest_A多了一个指向父类的指针  
  36. }  
  37.   
  38. int _tmain(int argc, _TCHAR* argv[])  
  39. {  
  40.     Zeng::CTest_A* CB2 = new Zeng::CTest_B( 8 ); // 构造函数的执行顺序是先父类在子类  
  41.     CB2->print(); // 此时调用的是父类的print函数，因为指针时指向CTest_A的，如果在CTest_B的print前面加virtual还调用CTest_B的  
  42.   
  43.     cout << "class CTest_A size is : " << sizeof( Zeng::CTest_A ) << endl;  
  44.     cout << "class CTest_B size is : " << sizeof( Zeng::CTest_B ) << endl;  
  45.   
  46.     return 0;  
  47. }  




this指针 :
比如在类中


  1. class Base  
  2. {  
  3.     public:  
  4.         void SetValue( int nVal )  
  5.         {  
  6.             m_nVal = nVal;  
  7.         }  
  8.     private:  
  9.         int m_nVal;  
  10. }  



SetValue函数中并没有指明m_nVal成员变量到底属于哪一个对象类似的问题...其实编译器隐藏掉了，应该是this->m_nVal = nVal;当然在使用的时候，可以直接在这个变量前面显示的加上去。


但是，this指针在实际开发中的意义却是，用来返回指向对象本身的指针，以实现对象链式引用，或者避免对同一对象进行赋值操作。例如


  1. class Point  
  2. {  
  3.     public:  
  4.         Point( int x, int y ) : m_nX( x ), m_nY( y )  
  5.         {};  
  6.         void operator = (Point& pt)  
  7.         {  
  8.             // 判断传递进来而定参数是否是这个对象本身，是，则不进行赋值操作  
  9.             if( &pt == this )  
  10.             {  
  11.                 m_nX = pt.m_nX;  
  12.                 m_nY = pt.m_nY;  
  13.             }  
  14.         }  
  15.         // 移动点的位置  
  16.         Point& Move( int x, int y )  
  17.         {  
  18.             m_nX += x;  
  19.             m_nY += y;  
  20.             // 返回对象本身，这样可以利用函数返回值进行链式引用  
  21.             return *this;  
  22.         }  
  23.     private:  
  24.         int m_nX;  
  25.         int m_nY;  
  26. };  
  27.   
  28. Point pt1(2, 4);  
  29. Point pt2(0, 0);  
  30. // 自己给自己赋值 试试  
  31. pt1 = pt1;  
  32. // 移动一下，再移动一下 看看什么是返回对象的链式引用------------------------  
  33. pt1.Move( 1, 1 ).Move( 2, 4 );  



指针* :
1)指针加1或者减1，会使指针指向的地址增加或者减少一个对象的数据类型的长度。
2)指针类型的转换
虽然指针类型的转换可能会带来不可预料的麻烦，就行goto语句一样，比如

 
  1. int* pInt;  
  2. float* pFloat = ( float* )pInt;  


这种方法比较直接，但是非常粗鲁，因为他允许你在任何类型之间进行转换，另外这种类型的转换方式在程序语句中很难识别，代码阅读者可能会忽略类型转换的语句。
为了克服这些缺点，C++引入了新的类型转换操作符static_cast来代替上面的类型转换
static_cast<类型说明符>(表达式)
static_cast
指针的类型转换-------------------------------------------------------


  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. namespace Zeng  
  6. {  
  7.     class CTest_A  
  8.     {  
  9.     public:  
  10.         CTest_A()  
  11.         {}  
  12.         virtual void Print()  
  13.         {  
  14.             cout << "this's CTest_A's Print :" << endl;  
  15.         }  
  16.     };  
  17.     class CTest_B : public CTest_A  
  18.     {  
  19.     public:  
  20.         CTest_B()  
  21.         {}  
  22.         void Print()  
  23.         {  
  24.             cout << "this's CTest_B's Print :" << endl;  
  25.         }  
  26.     };  
  27.     class CTest_C  
  28.     {  
  29.     public:  
  30.         CTest_C()  
  31.         {}  
  32.         void Print()  
  33.         {  
  34.             cout << "this's CTest_C's Print :" << endl;  
  35.         }  
  36.     };  
  37.     class CTest_D  
  38.     {  
  39.     public:  
  40.         CTest_D() : m_iNum(14)  
  41.         {  
  42.         }  
  43.         void ConstPrint() const  
  44.         {  
  45.             cout << "ConstPrint print CTest_D m_iNum current value is :" << m_iNum << endl;  
  46.         }  
  47.         void Print()  
  48.         {  
  49.             cout << "Print print CTest_D m_iNum current value is :" << m_iNum << endl;  
  50.         }  
  51.         int m_iNum;  
  52.     }; // 用来测试const_cast转换操作符  
  53. }  
  54.   
  55. int _tmain(int argc, _TCHAR* argv[])  
  56. {  
  57.     cout << "CTest_B convert to CTest_A :" << endl;  
  58.     Zeng::CTest_B* B = new Zeng::CTest_B();  
  59.     Zeng::CTest_A* A = static_cast< Zeng::CTest_A* >( B );  
  60.     A->Print();  
  61.   
  62.   
  63.     cout << "\n";  
  64.     cout << "CTest_A convert to CTest_B :" << endl;  
  65.     Zeng::CTest_A* A2 = new Zeng::CTest_A();  
  66.     Zeng::CTest_B* B2 = static_cast< Zeng::CTest_B* >( A2 );  
  67.     B2->Print();  
  68.   
  69. /* 
  70.     cout << "\n"; 
  71.     cout << "CTest_B convert to CTest_C :" << endl; 
  72.     Zeng::CTest_B* B3 = new Zeng::CTest_B();  
  73.     Zeng::CTest_C* C = static_cast< Zeng::CTest_C* >( B3 ); 
  74.     // the CTest_B has nothing to do with CTest_C, so this convert been an error ! 
  75.     B2->Print(); 
  76. */  
  77.   
  78.     cout << "\n";  
  79.     cout << "CTest_B convert to CTest_C :" << endl;  
  80.     Zeng::CTest_B* B3 = new Zeng::CTest_B();   
  81.     Zeng::CTest_C* C = reinterpret_cast< Zeng::CTest_C* >( B3 );  
  82.     // reinterpret_cast should be convert CTest_B to CTest_C,  
  83.     C->Print();  
  84.   
  85.     cout << "\n";  
  86.     cout << "CTest_A dynamic_cast to CTest_B :" << endl;  
  87.     Zeng::CTest_A* A4 = new Zeng::CTest_A();  
  88.     Zeng::CTest_B* B4 = dynamic_cast< Zeng::CTest_B* >( A4 ); // dynamic_cast要求CTest_B必须要有虚函数  
  89. //  B4->Print(); // 就算是有虚函数，dynamic_cast在处理向下转行的时候，得到的也是NULL  
  90.   
  91.     cout << "\n";  
  92.     cout << "CTest_B dynamic_cast to CTest_A :" << endl;  
  93.     Zeng::CTest_B* A5 = new Zeng::CTest_B();  
  94.     Zeng::CTest_A* B5 = dynamic_cast< Zeng::CTest_A* >( A5 ); // dynamic_cast要求CTest_B必须要有虚函数  
  95.     B5->Print(); // 就算是有虚函数，dynamic_cast在处理向上转行的时候，得到的是和static_cast一样的结果  
  96.   
  97.     int iNum = 14;  
  98.     int* pINum = &iNum;  
  99.     char* pCTest = "a";  
  100. /*  pCTest = reinterpret_cast< int* >( pINum );*/  
  101.     cout << "pINum point value is : " << *pINum << endl;  
  102.     // reinterpret_cast可以在任意指针中转换，即使这两者之间没什么关系  
  103.     pINum = reinterpret_cast< int* >( pCTest );  
  104.     cout << "pINum point value is : " << *pINum << endl;   
  105.   
  106.   
  107.     cout << "\n";  
  108.     const int iNum2 = 14;  
  109.     const int* piNum = &iNum2;  
  110.     int* piValue = const_cast< int* >( piNum );  
  111.     *piValue = 70;  
  112.   
  113.     cout << "use operator const_cast current *piValue value is : " << *piValue << endl;  
  114.     cout << "use operator const_cast current *piNum value is : " << *piNum << endl;  
  115.     cout << "use operator const_cast current iNum value is : " << iNum2 << endl;  
  116.   
  117.     cout << "\n";  
  118.     const Zeng::CTest_D CD;  
  119. //  CD.m_iNum = 70; // error C3892: “CD”: 不能给常量赋值  
  120.     const Zeng::CTest_D* pCD = &CD;  
  121.   
  122.     Zeng::CTest_D* pCD2 = const_cast< Zeng::CTest_D * >( pCD );  
  123.     pCD2->m_iNum = 70;  
  124.     cout << "use const_cast operator as object :" << endl;  
  125.     cout << "pCD2 is not's const point, this point m_iNum value is" << endl;  
  126.     pCD2->Print();  
  127.     cout << "CD is a class object, this object m_iNum value is" << endl;  
  128.     CD.ConstPrint(); // const 对象只能访问class里面带有const的函数  
  129.     cout << "pCD is a const point, this point m_iNum value is" << endl;  
  130.     pCD->ConstPrint();  
  131.   
  132.     return 0;  
  133. }  




二级指针的使用** :
一个例子既可以知道
  1. char* arrMouth[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };  
  2. char** pMouth = arrMouth;  
  3. int nIndex;  
  4. cout << "请输入月份对应的数字 : " << endl;  
  5. cin >> nIndex;  
  6.   
  7. // 之所以是char*是因为每一个月份都是字符串类型的  
  8. char* pCurMonth = *( pMouth + ( nIndex - 1 ) );  
  9. cout << "对应的月份是 : " << pCurMonth << endl;  
  10. cout << "对应的月份是 : " << *pCurMonth << endl;  


指针在函数中的作用 :
1)在函数的参数中使用指针，在传递大数据的时候可以有效减少函数调用的开销


  1. void SumArray( const int* pArray, int nArrayCount, int* nSum )  
  2. {  
  3.     *nSum = 0;  
  4.   
  5.     // 遍历整个数组  
  6.     for (int i = 0; i < nArrayCount; i++)  
  7.     {  
  8.         *nSum += *pArray;  
  9.         pArray++;  
  10.     }  
  11. }  
  12.   
  13. int _tmain(int argc, _TCHAR* argv[])  
  14. {  
  15.     cout << "指针作为函数参数：" << endl;  
  16.     int nArraySum;  
  17.     int iArray[5] = { 1, 2, 3, 4, 5};  
  18.   
  19.     SumArray( iArray, 5, &nArraySum );  
  20.     cout << "运算的和为：" << nArraySum << endl;  
  21.   
  22.     return 0;  
  23. }  

 

2)指针作为函数返回值
当函数的返回值是指针时，这个函数就是指针型函数。指针型函数通常用来获取一些指针变量的值。
在类中返回一个指针类型的成员变量，经常会使用到指针作为函数返回值
  1. char* GetName()  
  2. {  
  3.     return m_pName;  
  4. }  


引用& :
1)引用的本质，就是变量的别名，通俗地讲，就是变量的绰号。对变量的引用进行任何操作，就是对变量本身的操作，就想不管是叫你小名还是叫你的绰号，都是在叫同一个人。


  1. cout << "use reference：" << endl;  
  2. int nIntValue = 99999;  
  3. int& rIntValue = nIntValue;  
  4. cout << "rIntValue：" << rIntValue << endl;  
  5. cout << "rIntValue memory address：" << &rIntValue << endl;  
  6. cout << "nIntValue：" << nIntValue << endl;  
  7. cout << "nIntValue memory address：" << &nIntValue << endl;  
  8.   
  9. rIntValue = 1;  
  10. cout << "modify rIntValue after：" << rIntValue << endl;  
  11. cout << "rIntValue memory address：" << &rIntValue << endl;  
  12. cout << "current nIntValue：" << nIntValue << endl;  
  13. cout << "nIntValue memory address：" << &nIntValue << endl;  
  14.   
  15. nIntValue = 8888;  
  16. cout << "modify nIntValue after：" << nIntValue << endl;  
  17. cout << "nIntValue memory address：" << &nIntValue << endl;  
  18. cout << "current rIntValue：" << rIntValue << endl;  
  19. cout << "rIntValue memory address：" << &rIntValue << endl;  


 

2)在函数参数中使用，传递引用可以直接对这个参数进行修改


  1. void Increase( int& nVal )  
  2. {  
  3.     nVal += 1;  
  4. }  


三种函数参数和返回值的方法 :
1)
传值 是指直接将实际参数的值复制给形参，完成参数的传递
形式简单自然，便于理解，代码可读性高

2)
传指针 是指将需要传递的数据的指针作为参数进行传递
效率高，可以同时传入传出参数

3)
传引用 将需要传递的数据的引用作为参数进行传递
效率高，可以同时传入传出参数，形式自然


异常处理
异常的使用，会降低程序的性能，但是，如果使用得当，有时也可以提高程序的性能。比如，如果函数的参数是指针，则需要在函数入口处对这个指针的有效性进行检查。


  1. double Divede( int a, int b )  
  2. {  
  3.     if ( 0 == b )  
  4.     {  
  5.         throw "除数不能为 0 ";  
  6.     }  
  7.     return ( double )a / b;  
  8. }  
  9.   
  10.     cout << "use exception deal : " << endl;  
  11.     try  
  12.     {  
  13.         Divede( 2, 0 );  
  14.         cout << "throw a exception : " << endl;  
  15.     }  
  16.     catch ( char* pMsg )  
  17.     {  
  18.         cout << "catch a exception : " << pMsg << endl;  
  19.     }  
  20.     catch (...)  
  21.     {  
  22.         cout << "catch a exception : " << endl;  
  23.     }  
  24.   
  25.     cout << "is this appcation exit ? : " << endl;  


名字空间namespace :
主要在多人同时开发时候使用，避免冲突


  1. namespace Zeng  
  2. {  
  3.     class CTest  
  4.     {  
  5.     public:  
  6.         void Print()  
  7.         {  
  8.             cout << "this is namespace Zeng's Print" << endl;  
  9.         }  
  10.     };  
  11. }  
  12.   
  13.     cout << "use namespace Zeng ? : " << endl;  
  14.     Zeng::CTest CZengText;  
  15.     CZengText.Print();  


自定义类型的使用typedef :
后代前，以后使用byte就相当于使用了unsigned char
  1. typedef unsigned char byte;  


宏的使用#define
1)简单的使用
#define MAXSIZE 100
2)宏直接分配数组
  1. #define myInitArray(ArrayName, ArraySize, InitValue) byte ArrayName[ArraySize + 1] = InitValue  

 

3)宏中定义函数


  1. #ifndef SAFE_DELETE  
  2. #define SAFE_DELETE( p )        {           \  
  3.             if( NULL != p )             \  
  4.             {                           \  
  5.                 delete p; p = NULL;     \  
  6.                 cout << "safe delete..." << endl; \  
  7.             } }  
  8. #endif  
  9.   
  10. #ifndef SAFE_DELETE_ARRAY  
  11. #define SAFE_DELETE_ARRAY( p )      {           \  
  12.     if( NULL != p )             \  
  13. {                           \  
  14.     delete[] p; p = NULL;       \  
  15.     cout << "safe delete[]..." << endl; \  
  16. } }  
  17. #endif  
  18.   
  19.   
  20.     Zeng::CTest* CZengText2 = new Zeng::CTest;  
  21.     SAFE_DELETE( CZengText2 );  



用const保护数据
1)const定义常量


  1. const int number = 1;   // 声明一个整形常量并复制为1  
  2. const int* pNumber; // 声明一个常量型指针，指针所指向的变量的值不能改变，也就是一个常量  
  3. int const* pNumber; // 声明一个常量整型指针，意义同上  
  4. int* const pNumber = &number;       // 声明一个整型常量指针，指针不能修改  
  5. const int* const pNumber = &number;// 声明一个常量整型常量指针，指针和指针所指向的变量值都不能改变  
  6. const int& number = number; // 声明一个常量整型引用  


2)根据const实在*的位置判断 :
const在*左边，则表示const修饰的是int，这个指针指向的int变量的值不能修改，而指针本身的值是可变的；
如果const在*的右边，则表示const修饰的是指针，这个指针的值不能在声明后修改，所以在声明这样的指针时必须赋初值，而这个指针所指向的int变量的值是可变的。

3)在函数参数中加入const
表示这只是一个传入参数，在整个函数内部不能被修改。

4)修饰类成员函数
在声明类的成员函数时，如果在末尾加上const修饰，则表示在这个成员函数内不得改变该对象的任何数据。这种模式常用来表示"对象数据制度"的访问模式。
  1. namespace Zeng  
  2. {  
  3.     class CTest  
  4.     {  
  5.     public:  
  6.         void Print() const  
  7.         {  
  8.             m_nValue = 1;  
  9.             cout << "this is namespace Zeng's Print" << endl;  
  10.         }  
  11.     private:  
  12.         int m_nValue;  
  13.     };  
  14. }  

// 提示error : error C2166: 左值指定 const 对象

STL:
算法(algorithm)+容器(container)+迭代器(iterator) = STL

容器(container)
主要含有deque(双端队列)、queue(队列)、stack(堆栈容器)、vector(动态数组容器)、map multimap unordered_map unorderd_multimap(映射容器 由{键, 值}对组成)、set multiset unordered_set

unordered_multiset(集合容器)、algorithm(通用算法, 包括比较、交换、查找、排序等)、functional(模板类)、string(字符串类)、regex(正则表达式)、memory(定义了跟内存操作相关的组件, 例如智能指针等)

vector相对于数组来说，他可以合理利用空间，让程序有更大的可扩展性


函数模板
1)当编译器发现一个函数模板的调用后，将根据实参的实际数据类型来确认是否匹配函数模板中对应的形参，然后生成一个重载函数。根据参数类型的不同，一个函数模板可以随时变成各种不同的重载

函数，从而实集类型的处理。

2)比如max函数---------------------能够比较int、float、string
temple<typename 标识符>
返回值类型 函数名(形参表)
{
    //函数体
}


类模板
1)类模板的声明
temple<typename 标识符>
class 类名
{
    //类的定义
}

2)定义一个用于比较两个数的类模板compare


  1. #include "stdafx.h"  
  2. #include<vector>  
  3. #include<string>  
  4. #include<iostream>  
  5. #include<algorithm>  
  6. using namespace std;  
  7.   
  8. template <typename T>  
  9. T compare( const T a, const T b)  
  10. {  
  11.     return ( a > b ? a : b );  
  12. }  
  13. template <>  
  14. string compare( const string a, const string b)  
  15. {  
  16.     return ( a.size() > b.size() ? a : b );  
  17. }  
  18.   
  19. int main()  
  20. {  
  21.     const int ii = 10;  
  22.     const int ij = 20;  
  23.     cout << "return the max value is :  " << compare<int>( ii, ij ) << endl;  
  24.   
  25.     const float fi = 0.7f;  
  26.     const float fj = 1.2f;  
  27.     cout << "return the max value is :  " << compare<float>( fi, fj ) << endl;  
  28.   
  29.     const string strN = "aaaaaaaaaaa";  
  30.     const string strM = "zengraoli";  
  31.     cout << "return the max value is :  " << compare<string>( strN, strM ) << endl;  
  32.   
  33.     return 0;  
  34. }  


模板的实例化
1)隐式实例化
常用方式，实例化为
compare<int> intcompare(2, 3)

2)显示实例化
在声明时，直接在template关键字后接函数的声明，且函数标识符后接模板参数
比如：
template int compare<int> intcompare( int, int );

用模板使用通用算法-------------------------------------------------------------------------
actioncontainer 有一个撤销和恢复的通用功能


  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. template<typename T>  
  6. class CActionContainer  
  7. {  
  8. public:  
  9.     CActionContainer()  
  10.         : m_nRedoPos( 0 ), m_nUndoPos( 0 )  
  11.     {  
  12.     }  
  13.     void add( T value );  
  14.     T redo();  
  15.     T undo();  
  16. private:  
  17.     int m_nRedoPos;  
  18.     int m_nUndoPos;  
  19.     // Container size  
  20.     const static int ActionContainerSize = 5;  
  21.     // record array  
  22.     T m_RedoAction[ ActionContainerSize ];  
  23.     T m_UndoAction[ ActionContainerSize ];  
  24. };  
  25. template<typename T>  
  26. void CActionContainer<T>::add( T value )  
  27. {  
  28.     // if the container is full, adjust the pos of the container to add  
  29.     if ( m_nUndoPos > ActionContainerSize )  
  30.     {  
  31.         m_nUndoPos = m_nUndoPos - 1;  
  32.         for ( int i = 0; i < ActionContainerSize; i++ )  
  33.         {  
  34.             m_UndoAction[i] = m_UndoAction[ i + 1];  
  35.         }  
  36.     }  
  37.     m_UndoAction[ m_nUndoPos++ ] = value;  
  38. }  
  39.   
  40. // undo operator  
  41. template <typename T>  
  42. T CActionContainer<T>::undo()  
  43. {  
  44.     // copy the revocation action to restore of the array  
  45.     m_RedoAction[ m_nRedoPos++ ] = m_UndoAction[ --m_nUndoPos ];  
  46.     return m_UndoAction[ m_nUndoPos ];  
  47. }  
  48.   
  49. // redo operaor  
  50. template <typename T>  
  51. T CActionContainer<T>::redo()  
  52. {  
  53.     // copy recovery action to the revocation of the array  
  54.     m_UndoAction[ m_nUndoPos++ ] = m_RedoAction[ --m_nRedoPos ];  
  55.     return m_RedoAction[ m_nRedoPos ];  
  56. }  
  57.   
  58. int _tmain(int argc, _TCHAR* argv[])  
  59. {  
  60.     CActionContainer<int> intaction;  
  61.     intaction.add( 1 );  
  62.     intaction.add( 2 );  
  63.     intaction.add( 3 );  
  64.     intaction.add( 4 );  
  65.     intaction.add( 5 );  
  66.       
  67.     int iUndo = intaction.undo();  
  68.     cout << "pass undo current value is : " << iUndo << endl;  
  69.     iUndo = intaction.undo();  
  70.     cout << "second pass undo current value is : " << iUndo << endl;  
  71.   
  72.     int iRedo = intaction.redo();  
  73.     cout << "pass redo current value is : " << iRedo << endl;  
  74.     iRedo = intaction.redo();  
  75.     cout << "second pass redo current value is : " << iRedo << endl;  
  76.   
  77.     return 0;  
  78. }  


泛型编程
1)
通过使用模板，可以使程序具有更好的代码重用性。泛型编程就是一种大量使用模板来实现更好的代码重用性的编程方式

2)
泛型编程的代表作品STL是一种高效、泛型、可交互操作的软件组件。其中算法是泛型的，不与任何特定的数据结构或对象类型联系在一起。

STL容器
1)
顺序容器
deque(双端队列)、list(线性表)、vector(动态数组容器)
基于这三种基本的顺序容器又可以构造出一些专门的容器，用于比较特殊的数据结构，包括heap(堆)、stack(栈)、queue(队列)、priority queue(优先队列)

2)
关联容器
所容纳的对象时有{键、值}对组成

3)
操作容器中的数据元素

接受用户输入并将数据保存到容器中
在开始位置插入一个数据
删除容器中的前三个数据
清空容器中的所有数据
  1. #include "stdafx.h"  
  2. #include<vector>  
  3. #include<string>  
  4. #include<iostream>  
  5. #include<algorithm>  
  6. using namespace std;  
  7.   
  8. void vecDisplay( const float fValue )  
  9. {  
  10.     cout << "current value is : " << fValue << endl;  
  11. }  
  12.   
  13. int _tmain(int argc, _TCHAR* argv[])  
  14. {  
  15.     vector<float> vecScore;  
  16.     float fi = 0.0f;  
  17.     for ( int i = 0; i < 5; i++ )  
  18.     {  
  19.         cin >> fi;  
  20.         vecScore.push_back(fi);  
  21.     }  
  22.     cout << "input the value : " << endl;  
  23.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  24.   
  25.     const float fj = 0.02f;  
  26.     vecScore.insert( vecScore.begin(), fj );  
  27.     cout << "\n";  
  28.     cout << "in the begin insert a number 0.02 : " << endl;  
  29.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  30.   
  31.     vecScore.erase( vecScore.begin() );  
  32.     vecScore.erase( vecScore.begin() );  
  33.     vecScore.erase( vecScore.begin() );  
  34.     cout << "\n";  
  35.     cout << "delete vec in the before three number : " << endl;  
  36.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  37.   
  38.     vecScore.clear();  
  39.     cout << "\n";  
  40.     cout << "clear vec : " << endl;  
  41.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  42.     return 0;  
  43. }  


STL迭代器
1)
容器和算法结合起来的黏合剂
和指针的区别，迭代器不一定具有地址值

2)
按照使用的目的不同，各个容器都提供了多种类型的迭代器。比如只读迭代器，前移迭代器等。跟指针类似迭代器前面加上*运算符能够获取这个迭代器所指向的数据；可以使用++或者--来将迭代器向

前或者向后移动一个位置，让它指向容器中的其他位置的数据元素。如果迭代器到达容器中的最后一个元素的后面，则迭代器编程past_the_end值，使用past_the_end值的迭代器来访问数据元素是非法

的，就好像使用NULL值的指针一样。

3)遍历容器


  1. #include "stdafx.h"  
  2. #include<vector>  
  3. #include<string>  
  4. #include<iostream>  
  5. #include<algorithm>  
  6. using namespace std;  
  7.   
  8. int main()  
  9. {  
  10.     vector<int> vecScore;  
  11.     vecScore.push_back( 50 );  
  12.     vecScore.push_back( 60 );  
  13.     vecScore.push_back( 70 );  
  14.     vecScore.push_back( 80 );  
  15.     vecScore.push_back( 90 );  
  16.   
  17.     vector<int>::iterator it;  
  18.     for ( it = vecScore.begin(); it != vecScore.end(); it++ )  
  19.     {  
  20.         cout << "print current value : " << ( *it ) << endl;  
  21.     }  
  22.   
  23.     return 0;  
  24. }  

4)一般使用
a、对于对象，一般存放该对象的指针
b、小心清理容器中保存的对象指针，如果容器中保存的是对象，那么在容器析构的时候容器会自动清理这些对象。但是，如果存放对象指针，那么在容器析构的时候，首先要释放这些指针所指向的对象。

  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "string"  
  4. #include "algorithm"  
  5. #include "iostream"  
  6. using namespace std;  
  7.   
  8. class CStudent  
  9. {  
  10. public:  
  11.     CStudent( int iHeight ) : m_nHeight( iHeight )  
  12.     {  
  13.   
  14.     }  
  15.     int GetHeight() const  
  16.     {  
  17.         return m_nHeight;  
  18.     }  
  19. private:  
  20.     int m_nHeight;  
  21. };  
  22.   
  23. void vecDisplay( CStudent* pSt )  
  24. {  
  25.     cout << "current value is : " << pSt->GetHeight() << endl;  
  26. }  
  27.   
  28. int _tmain(int argc, _TCHAR* argv[])  
  29. {  
  30.     vector<CStudent *> vecStudent;  
  31.     CStudent* CTest_A = new CStudent( 165 );  
  32.     CStudent* CTest_B = new CStudent( 175 );  
  33.     CStudent* CTest_C = new CStudent( 185 );  
  34.     vecStudent.push_back( CTest_A );  
  35.     vecStudent.push_back( CTest_B );  
  36.     vecStudent.push_back( CTest_C );  
  37.   
  38.     cout << "Init vector : " << endl;  
  39.     for_each( vecStudent.begin(), vecStudent.end(), vecDisplay );  
  40.   
  41.     vector<CStudent *>::iterator it;  
  42.     for ( it = vecStudent.begin(); it != vecStudent.end(); it++ )  
  43.     {  
  44.         if ( NULL != ( *it ))  
  45.         {  
  46.             delete ( *it );  
  47.         }  
  48.         ( *it ) = NULL;  
  49.     }  
  50.     cout << "clear this point vector" << endl;  
  51.     vecStudent.clear();  
  52.   
  53.     return 0;  
  54. }  

c、如果需要将某个对象保存到容器中，实际上STL会重新生成一个此对象的拷贝，然后将这个拷贝保存在容器中，源对象不再使用。所以，当要保存的对象中含有指针类型成员变量时，要为容器中的对

象实现拷贝构造函数和赋值操作符。
--------------------------------------------------------------

  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "string"  
  4. #include "algorithm"  
  5. #include "iostream"  
  6. using namespace std;  
  7.   
  8. class CStudent  
  9. {  
  10. public:  
  11.     CStudent( const char* strName, const int iHeight)  
  12.     {  
  13.         m_nHeight = iHeight;  
  14.         m_strName = new char[ strlen( strName + 1 ) ];  
  15.         strcpy( m_strName, strName );  
  16.     }  
  17.     CStudent( const CStudent& st )  
  18.     {  
  19.         m_nHeight = st.m_nHeight;  
  20.         m_strName = new char[ strlen( st.m_strName ) ];  
  21.         strcpy( m_strName, st.m_strName );  
  22.     }  
  23.     CStudent& operator= ( const CStudent& st )  
  24.     {  
  25.         // to prevent self assignment  
  26.         if ( this == &st )  
  27.         {  
  28.             return *this;  
  29.         }  
  30.         m_nHeight = st.m_nHeight;  
  31.         m_strName = new char[ strlen( st.m_strName ) ];  
  32.         strcpy( m_strName, st.m_strName );  
  33.         return *this;  
  34.     }  
  35.     ~CStudent()  
  36.     {  
  37.         if ( NULL != m_strName )  
  38.         {  
  39.             delete[] m_strName;  
  40.             m_strName = NULL;  
  41.         }  
  42.     }  
  43.     char* GetName() const  
  44.     {  
  45.         return m_strName;  
  46.     }  
  47.     int GetHeight() const  
  48.     {  
  49.         return m_nHeight;  
  50.     }  
  51. private:  
  52.     int m_nHeight;  
  53.     char* m_strName;  
  54. };  
  55.   
  56. void vecDisplay( const CStudent st )  
  57. {  
  58.     cout << "the student name is : " << st.GetName()<< endl;  
  59. }  
  60.   
  61. int _tmain(int argc, _TCHAR* argv[])  
  62. {  
  63.     // Init  
  64.     vector<CStudent> vecStudent;  
  65.     CStudent Test_A( "zengraoli1", 155 );  
  66.     CStudent Test_B( "zengraoli2", 165 );  
  67.     CStudent Test_C( "zengraoli3", 175 );  
  68.   
  69.     Test_A = Test_B; // Test_A已经构造过了，所以这时进入的事重载的=操作符  
  70.     CStudent Test_D = Test_C; // Test_D没构造过，所以这时进入拷贝构造函数  
  71.   
  72.     vecStudent.push_back(Test_A);  
  73.     vecStudent.push_back(Test_B);  
  74.     vecStudent.push_back(Test_C);  
  75.   
  76.     cout << "output vector element : " << endl;  
  77.     for_each( vecStudent.begin(), vecStudent.end(), vecDisplay );  
  78.   
  79.     return 0;  
  80. }  

d、删除一个容器中大于某个数
删除的时候要注意：
    如在for循环中加上it++，那么删除的时候会后移一个。可以不再for中写it++，而在else部分写
    删除一个数的时候，不能仅仅是vecStudent.erase( it );必须要it = vecStudent.erase( it );记录，这是因为STL里的所有容器类中的erase实现都会返回一个迭代器，这个迭代器指向"当前删除

元素的后续元素，或者是end()"
--------------------------------------------------------------

  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "string"  
  4. #include "algorithm"  
  5. #include "iostream"  
  6. using namespace std;  
  7.   
  8. class CStudent  
  9. {  
  10. public:  
  11.     CStudent( int iHeight ) : m_nHeight( iHeight )  
  12.     {  
  13.   
  14.     }  
  15.     int GetHeight() const  
  16.     {  
  17.         return m_nHeight;  
  18.     }  
  19. private:  
  20.     int m_nHeight;  
  21. };  
  22.   
  23. void vecDisplay( CStudent* pSt )  
  24. {  
  25.     cout << "current value is : " << pSt->GetHeight() << endl;  
  26. }  
  27.   
  28. int _tmain(int argc, _TCHAR* argv[])  
  29. {  
  30.     vector<CStudent *> vecStudent;  
  31.     CStudent* CTest_A = new CStudent( 165 );  
  32.     CStudent* CTest_B = new CStudent( 175 );  
  33.     CStudent* CTest_C = new CStudent( 185 );  
  34.     vecStudent.push_back( CTest_A );  
  35.     vecStudent.push_back( CTest_B );  
  36.     vecStudent.push_back( CTest_C );  
  37.   
  38.     cout << "Init vector : " << endl;  
  39.     for_each( vecStudent.begin(), vecStudent.end(), vecDisplay );  
  40.   
  41.   
  42.     vector<CStudent *>::iterator it;  
  43.     for ( it = vecStudent.begin(); it != vecStudent.end(); )  
  44.     {  
  45.         if ( ( *it )->GetHeight() < 180 )  
  46.         {  
  47.             delete ( *it );  
  48.             ( *it ) = NULL;  
  49.             it = vecStudent.erase( it );  
  50.         }  
  51.         else  
  52.         {  
  53.             it++;  
  54.         }  
  55.     }  
  56.     cout << "\n";  
  57.     cout << "delete smaller then 180 : " << endl;  
  58.     for_each( vecStudent.begin(), vecStudent.end(), vecDisplay );  
  59.     return 0;  
  60. } 
怎样选择STL容器类型
vector : 需要保存大量数据的时候
map : 用来实现查找表，或者用来存储稀疏数组或稀疏矩阵
list : 频繁地对序列的中部进行插入和删除操作
deque : 当大部分插入和删除发生在序列的头部或尾部时
array : 固定长度的数组


STL算法
1)用for_each()算法遍历容器中的数据元素

for_each()的参数分别是开始位置、结束位置、处理函数

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. void vecDisplay( const int iValue )   
  8. {  
  9.     cout << "current value add 10 : " << iValue + 10 << endl;  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     vector<int> vecSalary;  
  15.     vecSalary.push_back( 10 );  
  16.     vecSalary.push_back( 20 );  
  17.     vecSalary.push_back( 30 );  
  18.     vecSalary.push_back( 40 );  
  19.     vecSalary.push_back( 50 );  
  20.   
  21.     cout << "display the value：" << endl;  
  22.     for_each( vecSalary.begin(), vecSalary.end(), vecDisplay );  
  23.   
  24.   
  25.     return 0;  
  26. }  

2)用find算法实现线性查找-----判断容器中是否存在特定的数据

find()的参数分别是开始位置、结束位置、要查找的数据

 
  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "algorithm"  
  4. #include "string"  
  5. #include "iostream"  
  6. using namespace std;  
  7.   
  8. int _tmain(int argc, _TCHAR* argv[])  
  9. {  
  10.   
  11.     vector<string> vecStudentName;  
  12.     vecStudentName.push_back( "zengraoli" );  
  13.     vecStudentName.push_back( "125308501" );  
  14.     vecStudentName.push_back( "test" );  
  15.     vecStudentName.push_back( "find" );  
  16.   
  17.     const string strFindName = "125308501";  
  18.     vector<string>::iterator it = find( vecStudentName.begin(), vecStudentName.end(), strFindName );  
  19.     if (vecStudentName.end() != it)  
  20.     {  
  21.         cout << "vecStudentName is exist this string 125308501 !" << endl;  
  22.     }  
  23.     it = find( vecStudentName.begin(), vecStudentName.end(), "125308502" );  
  24.     if ( vecStudentName.end() == it )  
  25.     {  
  26.         cout << "vecStudentName isn't exist this string 125308502 !" << endl;  
  27.     }  
  28.   
  29.   
  30.     return 0;  
  31. }  

3)用find_if()算法实现线性查找-----判断容器中是否存在指定范围的数据

find_if()的参数分别是开始位置、结束位置、所定义的要查找的条件(以bool(int)函数来表示)


 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "algorithm"  
  5. #include "vector"  
  6.   
  7. #define FIND_VALUE_TERMS 6  
  8.   
  9. bool isPass( int n )  
  10. {  
  11.     return n >= FIND_VALUE_TERMS;  
  12. }  
  13.   
  14. void vecDisplay( int iValue )  
  15. {  
  16.     cout << "current container value is : " << iValue << endl;  
  17. }  
  18.   
  19. int _tmain(int argc, _TCHAR* argv[])  
  20. {  
  21.     vector<int> vecScores;  
  22.     for ( int i = 1; i <= 10; i++ )  
  23.     {  
  24.         vecScores.push_back( i );  
  25.     }  
  26.   
  27.     vector< int >::iterator it = vecScores.begin();  
  28.     do   
  29.     {  
  30.         it = find_if( it, vecScores.end(), isPass );  
  31.         if (it != vecScores.end())  
  32.         {  
  33.             cout << "meet the conditions : " << ( *it ) << endl;  
  34.             it++; // this iterator point next  
  35.         }  
  36.         else  
  37.         {  
  38.             break;  
  39.         }  
  40.     } while (true);  
  41.   
  42.     return 0;  
  43. }  

4)用remove()实现移除、replace()实现替换
 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "algorithm"  
  5. #include "vector"  
  6.   
  7. #define FIND_VALUE_TERMS 6  
  8.   
  9. void vecDisplay( int iValue )  
  10. {  
  11.     cout << "current container value is : " << iValue << endl;  
  12. }  
  13.   
  14. int _tmain(int argc, _TCHAR* argv[])  
  15. {  
  16.     vector<int> vecScores;  
  17.     for ( int i = 1; i <= 10; i++ )  
  18.     {  
  19.         vecScores.push_back( i );  
  20.     //  vecScores.push_back( 9 );  
  21.     }  
  22.   
  23.     cout << "used function remove" << endl;  
  24.     const int removeValue = 8;  
  25.     remove( vecScores.begin(), vecScores.end(), removeValue );  
  26.     for_each( vecScores.begin(), vecScores.end(), vecDisplay );  
  27.   
  28.     cout << "\n";  
  29.     cout << "used function replace" << endl;  
  30.     const int replaceValue = 9;  
  31.     const int newValue = 999;  
  32.     replace( vecScores.begin(), vecScores.end(),replaceValue, newValue );  
  33.     for_each( vecScores.begin(), vecScores.end(), vecDisplay );  
  34.   
  35.     return 0;  
  36. }  

5)复制容器元素 : copy()

有时需要将一个容器中的元素复制到另一个容器中区，来完成数据的备份或者进行其他处理。
vector<float>::iterator lastPos在使用的时候，指向的是某个具体的数据而不是该数据的pos。
 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. void vecDisplay( const int iValue )   
  8. {  
  9.     cout << "current container value is: " << iValue << endl;  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     vector<float> vecScoreFirst;  
  15.     vector<float> vecScoreSecond;  
  16.     vector<float> vecScore;  
  17.   
  18.     for ( int i = 0; i < 10; i++ )  
  19.     {  
  20.         vecScoreFirst.push_back( 60.0f + i );  
  21.     }  
  22.     cout << "vecScoreFirst current value：" << endl;  
  23.     for_each( vecScoreFirst.begin(), vecScoreFirst.end(), vecDisplay );  
  24.   
  25.     for ( int i = 0; i < 10; i++ )  
  26.     {  
  27.         vecScoreSecond.push_back( 80.0f + i );  
  28.     }  
  29.     cout << "\n" << endl;  
  30.     cout << "vecScoreSecond current value：" << endl;  
  31.     for_each( vecScoreSecond.begin(), vecScoreSecond.end(), vecDisplay );  
  32.   
  33.   
  34.     vecScore.resize( vecScoreFirst.size() + vecScoreSecond.size() ); // resize vecScore  
  35.     vector< float >::iterator lastPos = copy( vecScoreFirst.begin(), vecScoreFirst.end(), vecScore.begin() );  
  36.     copy( vecScoreSecond.begin(), vecScoreSecond.end(), lastPos );  
  37.   
  38.     cout << "\n" << endl;  
  39.     cout << "vecScore current value：" << endl;  
  40.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  41.   
  42.     return 0;  
  43. }  

6)复制容器元素 : copy_backward()
从后向前覆盖
 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. void vecDisplay( const int iValue )   
  8. {  
  9.     cout << "current container value is: " << iValue << endl;  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     vector<float> vecScoreFirst;  
  15.     vector<float> vecScoreSecond;  
  16.     vector<float> vecScore;  
  17.   
  18.     for ( int i = 0; i < 10; i++ )  
  19.     {  
  20.         vecScoreFirst.push_back( 60.0f + i );  
  21.     }  
  22.     cout << "vecScoreFirst current value：" << endl;  
  23.     for_each( vecScoreFirst.begin(), vecScoreFirst.end(), vecDisplay );  
  24.   
  25.     for ( int i = 0; i < 10; i++ )  
  26.     {  
  27.         vecScoreSecond.push_back( 80.0f + i );  
  28.     }  
  29.     cout << "\n" << endl;  
  30.     cout << "vecScoreSecond current value：" << endl;  
  31.     for_each( vecScoreSecond.begin(), vecScoreSecond.end(), vecDisplay );  
  32.   
  33.     cout << "\n" << endl;  
  34.     vecScore.resize( vecScoreFirst.size() + vecScoreSecond.size() ); // resize vecScore  
  35.     cout << "vecScore size is : " << vecScore.size() << endl;  
  36.   
  37.     copy( vecScoreFirst.begin(), vecScoreFirst.end(), vecScore.begin() );  
  38.     copy_backward( vecScoreSecond.begin(), vecScoreSecond.end(), vecScore.end() );  
  39.   
  40.     cout << "\n" << endl;  
  41.     cout << "vecScore current value：" << endl;  
  42.     for_each( vecScore.begin(), vecScore.end(), vecDisplay );  
  43.   
  44.     return 0;  
  45. }  


7)合并容器元素 : merge()
类似copy的用法
 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. void vecDisplay( const int iValue )   
  8. {  
  9.     cout << "current container value is: " << iValue << endl;  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     vector<float> vecScoreFirst;  
  15.     vector<float> vecScoreSecond;  
  16.     vector<float> vecResutl;  
  17.   
  18.     for ( int i = 0; i < 10; i++ )  
  19.     {  
  20.         vecScoreFirst.push_back( 60.0f + i );  
  21.     }  
  22.     cout << "vecScoreFirst current value：" << endl;  
  23.     for_each( vecScoreFirst.begin(), vecScoreFirst.end(), vecDisplay );  
  24.   
  25.     for ( int i = 0; i < 10; i++ )  
  26.     {  
  27.         vecScoreSecond.push_back( 60.0f + i );  
  28.     }  
  29.     cout << "\n" << endl;  
  30.     cout << "vecScoreSecond current value：" << endl;  
  31.     for_each( vecScoreSecond.begin(), vecScoreSecond.end(), vecDisplay );  
  32.   
  33.   
  34.     // used merge the two container must to pass through sort, otherwise error  
  35.     vecResutl.resize( vecScoreFirst.size() + vecScoreSecond.size() );  
  36.     merge( vecScoreFirst.begin(), vecScoreFirst.end(), vecScoreSecond.begin(), vecScoreSecond.end(), vecResutl.begin() );  
  37.   
  38.     cout << "\n" << endl;  
  39.     cout << "vecScore current value：" << endl;  
  40.     for_each( vecResutl.begin(), vecResutl.end(), vecDisplay );  
  41.   
  42.     return 0;  
  43. }  

8)set_union()
合并之后去掉两个容器中重复的部分

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. void vecDisplay( const int iValue )   
  8. {  
  9.     cout << "current container value is: " << iValue << endl;  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     vector<float> vecScoreFirst;  
  15.     vector<float> vecScoreSecond;  
  16.     vector<float> vecResutl;  
  17.   
  18.     for ( int i = 0; i < 10; i++ )  
  19.     {  
  20.         vecScoreFirst.push_back( 60.0f + i );  
  21.     }  
  22.     cout << "vecScoreFirst current value：" << endl;  
  23.     for_each( vecScoreFirst.begin(), vecScoreFirst.end(), vecDisplay );  
  24.   
  25.     for ( int i = 0; i < 10; i++ )  
  26.     {  
  27.         vecScoreSecond.push_back( 60.0f + i );  
  28.     }  
  29.     cout << "\n" << endl;  
  30.     cout << "vecScoreSecond current value：" << endl;  
  31.     for_each( vecScoreSecond.begin(), vecScoreSecond.end(), vecDisplay );  
  32.   
  33.   
  34.     // used merge the two container must to pass through sort, otherwise error  
  35.     vecResutl.resize( vecScoreFirst.size() + vecScoreSecond.size() );  
  36.     set_union( vecScoreFirst.begin(), vecScoreFirst.end(), vecScoreSecond.begin(), vecScoreSecond.end(), vecResutl.begin() );  
  37.   
  38.     cout << "\n" << endl;  
  39.     cout << "vecScore current value：" << endl;  
  40.     for_each( vecResutl.begin(), vecResutl.end(), vecDisplay );  
  41.   
  42.     return 0;  
  43. }  

9)transform()
在进行元素的复制时，同时对元素进行某些操作
transform有两种使用方式，分别对应的func参数不同

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4. #include "vector"  
  5. #include "algorithm"  
  6.   
  7. #define ADD_VALUE 10  
  8.   
  9. // used transform the first form  
  10. int firstAddFunc( int iValue )  
  11. {  
  12.     return iValue + ADD_VALUE;  
  13. }  
  14.   
  15. // used transform the first form  
  16. int secondAddFunc( int iLeftValue, int iRightValue )  
  17. {  
  18.     return iLeftValue + iRightValue;  
  19. }  
  20.   
  21. void vecDisplay( int iValue )  
  22. {  
  23.     cout << "current container value is: " << iValue << endl;  
  24. }  
  25.   
  26. int _tmain(int argc, _TCHAR* argv[])  
  27. {  
  28.     vector<float> vecScoreFirst;  
  29.     vector<float> vecScoreSecond;  
  30.     vector<float> vecResutl;  
  31.   
  32.     for ( int i = 0; i < 10; i++ )  
  33.     {  
  34.         vecScoreFirst.push_back( 60.0f + i );  
  35.     }  
  36.     cout << "vecScoreFirst current value：" << endl;  
  37.     for_each( vecScoreFirst.begin(), vecScoreFirst.end(), vecDisplay );  
  38.   
  39.     for ( int i = 0; i < 10; i++ )  
  40.     {  
  41.         vecScoreSecond.push_back( 80.0f + i );  
  42.     }  
  43.     cout << "\n" << endl;  
  44.     cout << "vecScoreSecond current value：" << endl;  
  45.     for_each( vecScoreSecond.begin(), vecScoreSecond.end(), vecDisplay );  
  46.   
  47.     // used transform the first form  
  48.     vecResutl.resize( vecScoreFirst.size() );  
  49.     transform( vecScoreFirst.begin(), vecScoreFirst.end(), vecResutl.begin(), firstAddFunc );  
  50.     cout << "\n" << endl;  
  51.     cout << "transform the first form vecScore current value：" << endl;  
  52.     for_each( vecResutl.begin(), vecResutl.end(), vecDisplay );  
  53.   
  54.     // used transform the second form  
  55.     vecResutl.clear();  
  56.     vecResutl.resize( vecScoreFirst.size() );  
  57.     transform( vecScoreFirst.begin(), vecScoreFirst.end(), vecScoreSecond.begin(), vecResutl.begin(), secondAddFunc );  
  58.     cout << "\n" << endl;  
  59.     cout << "transform the second form vecScore current value：" << endl;  
  60.     for_each( vecResutl.begin(), vecResutl.end(), vecDisplay );  
  61.   
  62.     return 0;  
  63. }  

10)sort()、reverse()
排序和翻转算法

 
  1. #include "stdafx.h"  
  2. #include "string"  
  3. #include "iostream"  
  4. using namespace std;  
  5. #include "vector"  
  6. #include "algorithm"  
  7.   
  8. void vecDisplay( const string iValue )   
  9. {  
  10.     cout << "current container value is: " << iValue << endl;  
  11. }  
  12.   
  13. int _tmain(int argc, _TCHAR* argv[])  
  14. {  
  15.     vector<string> vecStudentName;  
  16.     vector<string>::iterator it;  
  17.     vecStudentName.push_back( "zeng" );  
  18.     vecStudentName.push_back( "zengraoli" );  
  19.     vecStudentName.push_back( "zengRaoli" );  
  20.     vecStudentName.push_back( "test" );  
  21.     vecStudentName.push_back( "125308501" );  
  22.     vecStudentName.push_back( "zengRaoli2" );  
  23.     vecStudentName.push_back( "1zeng" );  
  24.   
  25.     cout << "vecStudentName current value：" << endl;  
  26.     for( it = vecStudentName.begin(); it != vecStudentName.end(); it++ )  
  27.     {  
  28.         cout << "vecScore current value：" << ( *it ) << endl;  
  29.     }  
  30.   
  31.     // used sort algorithm  
  32.     sort( vecStudentName.begin(), vecStudentName.end() );  
  33.     cout << "\n" << endl;  
  34.     cout << "pass sort vecStudentName current value：" << endl;  
  35.     for_each( vecStudentName.begin(), vecStudentName.end(), vecDisplay );  
  36.   
  37.     // used reverse algorithm  
  38.     reverse( vecStudentName.begin(), vecStudentName.end() );  
  39.     cout << "\n" << endl;  
  40.     cout << "pass reverse vecStudentName current value：" << endl;  
  41.     for_each( vecStudentName.begin(), vecStudentName.end(), vecDisplay );  
  42.   
  43.     return 0;  
  44. }  


更改对基本数据类型的sort算法：

 
  1. #include "stdafx.h"  
  2. #include "string"  
  3. #include "vector"  
  4. #include "algorithm"  
  5. #include "assert.h"  
  6. #include "iostream"  
  7. using namespace std;  
  8.   
  9. void vecDisplay( const int iValue )  
  10. {  
  11.     cout << "current value is " << iValue << endl;  
  12. }  
  13.   
  14. // my sort algorithm  
  15. bool defineSort( const int iLeftValue, const int iRightValue )  
  16. {  
  17.     return ( iLeftValue > iRightValue );  
  18. }  
  19.   
  20. int _tmain(int argc, _TCHAR* argv[])  
  21. {  
  22.     vector<int> vecIValue;  
  23.     vecIValue.push_back( 9 );  
  24.     vecIValue.push_back( 1 );  
  25.     vecIValue.push_back( 3 );  
  26.     vecIValue.push_back( 5 );  
  27.     vecIValue.push_back( 8 );  
  28.     vecIValue.push_back( 7 );  
  29.     vecIValue.push_back( 2 );  
  30.   
  31. /* 
  32.     sort( vecIValue.begin(), vecIValue.end() ); 
  33.     cout << "pass sort : " << endl; 
  34.     for_each( vecIValue.begin(), vecIValue.end(), vecDisplay ); 
  35. */  
  36.       
  37.     sort( vecIValue.begin(), vecIValue.end(), defineSort );  
  38.     cout << "pass sort : " << endl;  
  39.     for_each( vecIValue.begin(), vecIValue.end(), vecDisplay );  
  40.   
  41.   
  42.     return 0;  
  43. }  

针对于自定义类型的sort算法
需要重写 < 号，暂时类里面不带有指针变量，否则还要重写拷贝构造

 
  1. #include "stdafx.h"  
  2. #include "string"  
  3. #include "vector"  
  4. #include "algorithm"  
  5. #include "assert.h"  
  6. #include "iostream"  
  7. using namespace std;  
  8.   
  9. namespace Zeng  
  10. {  
  11.     class CTest_Rectang  
  12.     {  
  13.     public:  
  14.         CTest_Rectang( int iLong, int iWidth, int iHeight )  
  15.             : m_iLong( iLong ), m_iWidth( iWidth ), m_iHeight( iHeight )  
  16.         {  
  17.         }  
  18.         bool operator < ( const CTest_Rectang& rCTest_Rectang )  
  19.         {  
  20.             assert( rCTest_Rectang.m_iLong );  
  21.             if ( rCTest_Rectang.m_iLong > this->m_iLong )  
  22.             {  
  23.                 return true;  
  24.             }  
  25.             return false;  
  26.         }  
  27.         friend void vecDisplay( const CTest_Rectang& rCTest_Rectang );  
  28.     private:  
  29.         int m_iLong;  
  30.         int m_iWidth;  
  31.         int m_iHeight;  
  32.     };  
  33.     void vecDisplay( const Zeng::CTest_Rectang& rCTest_Rectang )   
  34.     {  
  35.         cout << "current container Zeng::CTest_Rectang m_iLong is: " << rCTest_Rectang.m_iLong << endl;  
  36.     }  
  37. }  
  38.   
  39. int _tmain(int argc, _TCHAR* argv[])  
  40. {  
  41.     vector<Zeng::CTest_Rectang> vecCTestRectang;  
  42.     for ( int i = 0; i < 8; i++ )  
  43.     {  
  44.         vecCTestRectang.push_back( Zeng::CTest_Rectang( 14 + i, 14, 14 ) );  
  45.     }  
  46.   
  47.     // used sort algorithm  
  48.     sort( vecCTestRectang.begin(), vecCTestRectang.end() );  
  49.     cout << "\n" << endl;  
  50.     cout << "pass sort vecStudentName current value：" << endl;  
  51.     for_each( vecCTestRectang.begin(), vecCTestRectang.end(), Zeng::vecDisplay );  
  52.   
  53.     // used reverse algorithm  
  54.     reverse( vecCTestRectang.begin(), vecCTestRectang.end() );  
  55.     cout << "\n" << endl;  
  56.     cout << "pass reverse vecStudentName current value：" << endl;  
  57.     for_each( vecCTestRectang.begin(), vecCTestRectang.end(), Zeng::vecDisplay );  
  58.   
  59.     return 0;  
  60. }  

11)min_element()、max_element()
取最大最小值算法，容器需要经过sort排序
找到后输出后面的全部值

 
  1. #include "stdafx.h"  
  2. #include "string"  
  3. #include "vector"  
  4. #include "algorithm"  
  5. #include "assert.h"  
  6. #include "iostream"  
  7. using namespace std;  
  8.   
  9. void vecDisplay( const int iValue )  
  10. {  
  11.     cout << "current value is " << iValue << endl;  
  12. }  
  13.   
  14. // my sort algorithm  
  15. bool defineSort( const int iLeftValue, const int iRightValue )  
  16. {  
  17.     return ( iLeftValue > iRightValue );  
  18. }  
  19.   
  20. int _tmain(int argc, _TCHAR* argv[])  
  21. {  
  22.     vector<int> vecIValue;  
  23.     vecIValue.push_back( 7 );  
  24.     vecIValue.push_back( 8 );  
  25.     vecIValue.push_back( 3 );  
  26.     vecIValue.push_back( 1 );  
  27.     vecIValue.push_back( 9 );  
  28.     vecIValue.push_back( 5 );  
  29.     vecIValue.push_back( 2 );  
  30.   
  31.     vector<int>::iterator it;  
  32.     it = max_element( vecIValue.begin(), vecIValue.end() );  
  33.     for ( ; it != vecIValue.end(); it++ )  
  34.     {  
  35.         cout << "max_element current value is : " << ( *it ) << endl;  
  36.     }  
  37.   
  38.     cout << "\n" << endl;  
  39.     it = min_element( vecIValue.begin(), vecIValue.end() );  
  40.     for ( ; it != vecIValue.end(); it++ )  
  41.     {  
  42.         cout << "min_element current value is : " << ( *it ) << endl;  
  43.     }  
  44.   
  45.     return 0;  
  46. }  

函数指针
1)
根据函数指针所指向函数的不同，需要根据函数的具体声明来定义一个函数指针，其语法格式如下：
    函数返回值类型标识符 ( 指针变量名 )( 形参列表 );
由于"()"的优先级高于"*"，所以指针变量名外的括号必不可少。形参列表表示指针变量指向的函数所带的参数列表。
2)
例如有一个函数
void PrintPass( int iLeft, int iRightValue );
如果要声明一个函数指针
void ( *pFunc )( int iLeft, int iRightValue );
省略形参后
void ( *pFunc )( int, int );
如果要定义多个同一类型的指针，还可以使用typedef关键字定义一种新的函数之着呢的数据类型，用这种新的数据类型来定义函数指针，例如
// 定义一种新的函数指针的数据类型
typedef bool ( *pFunc )( int, int );
// 使用新的数据类型定义函数指针
pFunc pMax;
// 直接指向函数
pMax = Max;

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. typedef bool ( *pFunc )( int, int );  
  6.   
  7. bool Max( const int iLeftValue, const int iRightValue )  
  8. {  
  9.     return ( iLeftValue > iRightValue );  
  10. }  
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     pFunc pMax;  
  15.     pMax = Max;  
  16.     cout << "pMax( 5, 6 ) this return bool value is : " << pMax( 5, 6 ) << endl;  
  17.     cout << "pMax( 6, 5 ) this return bool value is : " << pMax( 6, 5 ) << endl;  
  18.   
  19.     return 0;  
  20. }  

3)
可以在声明的时候不使用typedef直接用auto作为函数指针的数据类型来声明一个函数指针，
auto pMax = Max; // 只能在vs2010上面才使用有效

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. int Max( const int iLeftValue, const int iRightValue )  
  6. {  
  7.     return ( iLeftValue > iRightValue );  
  8. }  
  9.   
  10. int _tmain(int argc, _TCHAR* argv[])  
  11. {  
  12.     auto pMaxSendcont = Max;  
  13.     cout << "pMaxSendcont( 5, 6 ) this return bool value is : " << pMaxSendcont( 5, 6 ) << endl;  
  14.     cout << "pMaxSendcont( 6, 5 ) this return bool value is : " << pMaxSendcont( 6, 5 ) << endl;  
  15.     return 0;  
  16. }  

用函数指针实现回调函数
1)
回调函数就是一个通过函数指针调用的函数。如果吧函数的指针(地址)作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，就说这事回调函数。回调函数不是由该函数的实现方直接

调用，而是特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
2)
回调函数实现的机制是：
a、定义一个回调函数
b、提供函数实现的一方在初始化的时候，将回调函数的函数指针注册给调用者
c、当特定的事件或条件发生的时候，调用者使用函数指针调用回调函数对事件进行处理
3)为什么要使用回调函数
因为可以把调用者与被调用者分开，所以调用者不关心谁是被调用者。它只需知道存在一个具有特定原型和限制条件的被调用函数

 
  1. #include "stdafx.h"  
  2. #include "iostream"  
  3. using namespace std;  
  4.   
  5. typedef bool ( *PMAXFUNC )( int, int );  
  6.   
  7. void PrintMessage( int iLeftValue, int iRightValue, PMAXFUNC pMax )  
  8. {  
  9.     cout << "Print Header :" << endl;  
  10.     cout << "====================================================" << endl;  
  11.     cout << "pMax LeftValue is : " << iLeftValue << endl;  
  12.     cout << "pMax RightValue is : " << iRightValue << endl;  
  13.     cout << "pMax function return is : " << pMax( iLeftValue, iRightValue ) << endl;  
  14.     cout << "====================================================" << endl;  
  15.     cout << "Print ender :" << endl;  
  16. }  
  17.   
  18. bool Max( const int iLeftValue, const int iRightValue )  
  19. {  
  20.     return ( iLeftValue > iRightValue );  
  21. }  
  22.   
  23. int _tmain(int argc, _TCHAR* argv[])  
  24. {  
  25.     PMAXFUNC pMax = Max;  
  26.     PrintMessage( 5, 6, pMax );  
  27.   
  28.     return 0;  
  29. }  

4)将函数指针应用到STL算法中
ptr_fun()函数将一个普通函数指针转换为一个函数对象
bind1st()函数将整个函数对象的第一个参数绑定为nStandardHeigth

a、在count_if()算法中实现规则和统计标准的完全自定义：

 
  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "string"  
  4. #include "algorithm"  
  5. #include "functional"  
  6. #include "iostream"  
  7. using namespace std;  
  8.   
  9. #define STANDARHEIGHT   165  
  10. #define STUDENTNUM      5  
  11.   
  12. class CStudent  
  13. {  
  14. public:  
  15.     CStudent( int iHeight ) : m_iHeight( iHeight )  
  16.     {  
  17.     }  
  18.     int GetHeight() const  
  19.     {  
  20.         return m_iHeight;  
  21.     }  
  22. private:  
  23.     int m_iHeight;  
  24. };  
  25.   
  26. bool countHeight( int iHeight, const CStudent st)  
  27. {  
  28.     return st.GetHeight() > iHeight;  
  29. }  
  30.   
  31. int _tmain(int argc, _TCHAR* argv[])  
  32. {  
  33.     vector<CStudent> vecStudent;  
  34.     for (int i = 0; i < STUDENTNUM; i++)  
  35.     {  
  36.         vecStudent.push_back( CStudent( STANDARHEIGHT - 10 + i * 10 ) );  
  37.     }  
  38.   
  39.     const int nStandarHeight = STANDARHEIGHT;  
  40.     int iCount = count_if( vecStudent.begin(), vecStudent.end(), bind1st( ptr_fun( countHeight ), nStandarHeight ) );  
  41.   
  42.     cout << "the student height greater than Standar Number is : " << iCount << endl;  
  43.   
  44.     return 0;  
  45. }  

    bind1st()函数将整个函数对象的第一个参数绑定为nStandardHeigth，而函数对象的第二个参数就是iron国企中的CStudent对象作为参数调用countHeight()这个重新定义的统计规则函数，以实现

统计规则和统计标准的完全自定义。

b、在算法中使用指向某个类的成员函数的函数指针

 
  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "string"  
  4. #include "algorithm"  
  5. #include "functional"  
  6. #include "iostream"  
  7. using namespace std;  
  8.   
  9. class CStudent  
  10. {  
  11. public:  
  12.     CStudent( string strName )  
  13.     {  
  14.         m_strName = strName;  
  15.     }  
  16.     bool isNamed( string strName )  
  17.     {  
  18.         return strName == m_strName;  
  19.     }  
  20. private:  
  21.     string m_strName;  
  22. };  
  23.   
  24.   
  25. int _tmain(int argc, _TCHAR* argv[])  
  26. {  
  27.     vector<CStudent> vecStudent;  
  28.     vecStudent.push_back( CStudent( "zengraoli1" ) );  
  29.     vecStudent.push_back( CStudent( "zengraoli2" ) );  
  30.     vecStudent.push_back( CStudent( "zengraoli3" ) );  
  31.       
  32.     string strFindName = "zengraoli2";  
  33.     vector<CStudent>::iterator it = find_if( vecStudent.begin(), vecStudent.end(),  
  34.                                              bind2nd( mem_fun_ref( &CStudent::isNamed ), strFindName ) );  
  35.     if ( it != vecStudent.end() )  
  36.     {  
  37.         cout << "找到了对应的vecStudent!" << endl;  
  38.     }  
  39.   
  40.     return 0;  
  41. }  

    在这段代码中，&CStudent::isNamed去的成员函数isNamed()的地址，也就是获得了指向这个成员函数的函数指针；然后使用mem_fun_ref()函数将这个函数指针构造成一个函数对象，如果容器中保存的是指向对象的指针，就应该使用mem_fun_ref()函数来完成这一任务。
    因为这个成员函数需要一个蚕食，所以更进一步的，使用bind2nd()函数绑定其第二个参数strFindName来作为查找条件。因为这是一个类的成员函数指针，所以容器中的对象会作为默认隐含的第一个参数。

=====================================================================
函数指针配合STL算法的应用，将STL算法的通用性发挥到了极致。


函数对象
1)所谓函数对象，就是定义了函数调用操作符(function-call operator)，即operator()的普通类的对象。在重载的函数调用操作符中，可以实现函数的所有功能。同事，因为类具有属性，可以将每次

函数调用的状态数据保存到他的属性中，这样函数对象就不会像函数指针那样失忆了，从而可以应用在更广的范围内。
2)定义一个模板函数对象
------------------------------------------------------

 
  1. template <typename T>  
  2. class myMax  
  3. {  
  4.     T operator()(T a, T b)  
  5.     {  
  6.         return ( a > b ? a : b );  
  7.     }  
  8. };  

3)在STL中使用函数对象
------------------------------------------------------

 
  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "algorithm"  
  4. #include "iostream"  
  5. using namespace std;  
  6.   
  7. namespace Zeng  
  8. {  
  9.     class CStudent  
  10.     {  
  11.     public:  
  12.         CStudent( int nHeight ) : m_nHieght( nHeight )   
  13.         {  
  14.         }  
  15.         int GetHeight()  
  16.         {  
  17.             return m_nHieght;  
  18.         }  
  19.     private:  
  20.         int m_nHieght;  
  21.     };  
  22.   
  23.     class CAverageHeight  
  24.     {  
  25.     public:  
  26.         CAverageHeight() : m_nCount( 0 ), m_nTotalHeight( 0 )  
  27.         {  
  28.         }  
  29.         void operator ()( CStudent st )  
  30.         {  
  31.             m_nTotalHeight += st.GetHeight();  
  32.             m_nCount++;  
  33.         }  
  34.         int GetCount()  
  35.         {  
  36.             return m_nCount;  
  37.         }  
  38.         int GetTotalHeight()  
  39.         {  
  40.             return m_nTotalHeight;  
  41.         }  
  42.         float GetAverageHeight()  
  43.         {  
  44.             if ( 0 != m_nCount )  
  45.             {  
  46.                 return static_cast<float>( GetTotalHeight() / GetCount() );  
  47.             }  
  48.             return 0;  
  49.         }  
  50.     private:  
  51.         int m_nCount;  
  52.         int m_nTotalHeight;  
  53.     };  
  54. }  
  55.   
  56.   
  57. int _tmain(int argc, _TCHAR* argv[])  
  58. {  
  59.     vector<Zeng::CStudent> vecStudent;  
  60.     vecStudent.push_back( Zeng::CStudent( 155 ) );  
  61.     vecStudent.push_back( Zeng::CStudent( 165 ) );  
  62.     vecStudent.push_back( Zeng::CStudent( 175 ) );  
  63.     vecStudent.push_back( Zeng::CStudent( 185 ) );  
  64.     vecStudent.push_back( Zeng::CStudent( 195 ) );  
  65.   
  66.     // use function object  
  67.     Zeng::CAverageHeight ah;  
  68.     // use function object in the stl algorithm  
  69.     ah = for_each( vecStudent.begin(), vecStudent.end(), ah);  
  70.     cout << "average height is : " << ah.GetAverageHeight() << endl;  
  71.     cout << "the student count is : " << ah.GetCount() << endl;  
  72.   
  73.     return 0;  
  74. }  

说明：在这里创建了一个函数对象ah并将它应用到for_each()算法中，for_each()算法会以容器中的每个Student对象为参数来对这个函数对象的"()"操作符进行调用。这时，函数对象自然就会将每个

Student对象的身高累加到它自己的m_nTotalHeight属性上，同事它还会记录已经统计过的对象数目。最后，for_each()算法会将完成统计后的函数对象作为结果返回，而这时的函数对象ah已经是一个保存了统计结果的函数对象了。通过函数对象提供的接口函数，可以轻松地获得统计结果并进行输出。

还可以这么用：

 
  1. #include "stdafx.h"  
  2. #include "vector"  
  3. #include "algorithm"  
  4. #include "iostream"  
  5. using namespace std;  
  6.   
  7. namespace Zeng  
  8. {  
  9.     class CStudent  
  10.     {  
  11.     public:  
  12.         CStudent( int nHeight ) : m_nHieght( nHeight )   
  13.         {  
  14.         }  
  15.         int GetHeight()  
  16.         {  
  17.             return m_nHieght;  
  18.         }  
  19.     private:  
  20.         int m_nHieght;  
  21.     };  
  22.   
  23.     class CAverageHeight  
  24.     {  
  25.     public:  
  26.         CAverageHeight() : m_nCount( 0 ), m_nTotalHeight( 0 )  
  27.         {  
  28.         }  
  29.         void operator ()( CStudent st )  
  30.         {  
  31.             m_nTotalHeight += st.GetHeight();  
  32.             m_nCount++;  
  33.         }  
  34.         operator float()  
  35.         {  
  36.             return GetAverageHeight();  
  37.         }  
  38.         operator int()  
  39.         {  
  40.             return GetCount();  
  41.         }  
  42.         int GetCount()  
  43.         {  
  44.             return m_nCount;  
  45.         }  
  46.         int GetTotalHeight()  
  47.         {  
  48.             return m_nTotalHeight;  
  49.         }  
  50.         float GetAverageHeight()  
  51.         {  
  52.             if ( 0 != m_nCount )  
  53.             {  
  54.                 return static_cast<float>( GetTotalHeight() / GetCount() );  
  55.             }  
  56.             return 0;  
  57.         }  
  58.     private:  
  59.         int m_nCount;  
  60.         int m_nTotalHeight;  
  61.     };  
  62. }  
  63.   
  64.   
  65. int _tmain(int argc, _TCHAR* argv[])  
  66. {  
  67.     vector<Zeng::CStudent> vecStudent;  
  68.     vecStudent.push_back( Zeng::CStudent( 155 ) );  
  69.     vecStudent.push_back( Zeng::CStudent( 165 ) );  
  70.     vecStudent.push_back( Zeng::CStudent( 175 ) );  
  71.     vecStudent.push_back( Zeng::CStudent( 185 ) );  
  72.     vecStudent.push_back( Zeng::CStudent( 195 ) );  
  73.   
  74.     // use function object  
  75.     float fAverHeight = for_each( vecStudent.begin(), vecStudent.end(), Zeng::CAverageHeight() );  
  76.     cout << "average height is : " << fAverHeight << endl;  
  77.     int iCount = for_each( vecStudent.begin(), vecStudent.end(), Zeng::CAverageHeight() );  
  78.     cout << "average height is : " << iCount << endl;  
  79.     return 0;  
  80. } 

你可能感兴趣的:(C++学习笔记【转】)

  • Linux C++ 编程死锁详解 PM简读馆 Linux嵌入式驱动开发开发语言c++linux
    作者简介：程序员转项目管理领域优质创作者个人邮箱：[[email protected]]PMP资料导航：PM菜鸟（查阅PMP大纲考点）座右铭：上善若水，水善利万物而不争。绿泡泡：PM简读馆（包含更多PM常用免费资料）目录概要一、死锁的四个必要条件二、常见死锁场景三、代码解释1、资源申请顺序不一致问题描述解决方案2.优先级倒置问题描述解决方案3.线程间循环等待问题描述解决方案4.锁嵌套（LockNe
  • 英伟达的ptx是什么？ptx在接近汇编语言的层级运行？ AI-AIGC-7744423 人工智能
    PTX（ParallelThreadeXecution）是英伟达CUDA架构中的一种中间表示形式（IR）语言。以下是关于它的介绍以及它与汇编语言层级关系的说明：PTX介绍•性质与作用：PTX是一种类似于汇编语言的指令集架构，但它更像是一种抽象的、面向并行计算的中间语言。它是CUDA编程模型中，主机代码与实际在GPU上执行的机器码之间的桥梁。开发者编写的CUDAC/C++等高级语言代码，在编译过程中
  • 转USDT手续费太贵？我教你！ Trx能量租赁闪兑 比特币智能合约能源物联网
    什么是TRX能量闪租？还不明白就来看看1.当我们在波场转u的时候，是需要矿工费那么这个矿工费可以理解为能量和带宽2.能量和TRX是两个概念，不要混淆3.转账的时候首先是需要消耗能量和带宽，当我们能量不足转账所需时，就会燃烧相应的TRX作为能量。对方账户有u需要65000的能量=13.7TRX，对方账户没有u或者交易所地址需要131000的能量=27.3TRX4.为了节省一定的trx.能量可以找我们
  • C# 通过 CLR 调用 C++ 代码无法命中断点问题解决 qzy0621 C++调试c++c#
    C#通过CLR调用C++代码无法命中断点问题解决一、启用混合模式调试二、C++项目配置核查三、确保生成配置一致四、确认编译器配置符号路径设置，在VS调试时查看模块窗口强制附加调试器（备选方案）常见陷阱排查表C#通过CLR调用C++代码无法命中断点问题解决以下是解决C#通过CLR调用C++代码时无法命中断点的综合解决方案，结合了调试配置优化、符号加载及常见陷阱排查：一、启用混合模式调试在C#项目的属
  • c语言utc时间转换北京时间_STM32开发 -- UTC、UNIX时间戳、北京时间之间的转换 weixin_39628180 c语言utc时间转换北京时间
    我碰到的问题，GPS上UTC时间转北京时间和STM32上UNIX时间戳转北京时间。这部分之前讲RTC和GPS的时候有涉及到一部分。具体的RTC如何得到UNIX时间戳，和GNRMC如何解析得到UTC时间可以参看一下。参看：STM32开发–RTC详解参看：STM32开发–GPS模块开发详解扩展：C语言再学习–时间函数这里主要看三者转换方法：一、UTC时间转换为北京时间参看:UTC时间转换为北京时间时间
  • C++并发编程实战 lijiaxin2333 C++c++
    文章目录第一章:你好,C++并发世界什么是并发并发的途径为什么使用并发什么时候不使用并发C++新标准中的并发支持开始入门:你好,并发世界第一章:你好,C++并发世界至C++11开始,C++标准支持多线程程序.什么是并发人可以一边唱歌一边跳舞,计算机呢?单处理器计算机每秒可以切换任务许多次,做一点A任务再做一点B任务,然AB任务看起来是并行发生.这就是任务切换.任务切换可以被看做并发.多处理器计算机
  • C++ 并发编程实战 学习笔记 myc13381 c++笔记
    C++并发编程学习笔记目录一.基本接口二.初步了解多线程三.线程所属权管理四.线程间共享数据五.同步并发操作六.C++内存模型和原子类型操作七.基于锁的并发数据结构设计八.无锁数据结构九.并发代码设计十.高级线程管理十一.并行算法十二.参考资料基本接口std::thread常用成员函数构造和析构函数//默认构造函数，创建一个线程，什么也不做thread()noexcept;//初始化构造函数，创建
  • C++ 重载运算符和重载函数 阳光向日葵向阳 c++开发语言
    C++允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。C++中的函数重载在同一个作
  • 一文讲通锁标记对象std::adopt_lock盲点 郭涤生 c/c++#并发线程c++并发编程
    一文讲通锁标记对象std::adopt_lock盲点1.核心概念2.代码详解1.单个锁2.多重锁(可以用来预防死锁)3.条件变量的互斥控制4.复杂示例:多生产者-多消费者模型(超纲了，可不看，哈哈哈哈)3.小结1.核心概念在C++中，std::adopt_lock是一个锁标记对象[^1]，用于配合锁对象（如std::lock_guard、std::unique_lock或std::shared_l
  • 多线程程序的测试和调试_第11章_《C++并发编程实战》笔记 郭涤生 #并发线程c/c++c++笔记并发编程
    多线程程序的测试和调试1.并发相关Bug的核心类型1.1数据竞争（DataRace）1.2死锁（Deadlock）1.3活锁（Livelock）2.定位并发Bug的技巧3.代码优化与修复示例3.1修复数据竞争（使用原子操作）3.2避免死锁（统一锁顺序）4.总结5.多选题目及答案6.设计题目7.设计题目参考答案1.并发相关Bug的核心类型1.1数据竞争（DataRace）定义：多线程同时访问共享数据
  • 设计无锁的并发数据结构_第七章_《C++并发编程实战》笔记 郭涤生 #并发线程c/c++数据结构c++
    设计无锁的并发数据结构1.核心概念与难点1.1无锁（Lock-Free）条件1.2原子操作的重要性1.3内存顺序（MemoryOrder）1.4ABA问题2.代码解析：无锁栈的实现（简化）3.多选题目4.设计题目5.多选题答案6.设计题参考答案1.核心概念与难点1.1无锁（Lock-Free）条件定义：一种并发算法的实现方式，保证无限执行进程中至少有一个线程能推进操作（系统整体进步）。关键特性：无
  • 并发设计_第八章_《C++并发编程实战》笔记 郭涤生 #并发线程c/c++c++并发编程
    并发设计1.线程间工作划分（工作窃取）2.性能优化（伪共享与缓存行对齐）3.设计并发数据结构（无锁队列）4.多选题目5.多选题目答案4.设计题目5.设计题目参考答案1.线程间工作划分（工作窃取）概念：使用工作窃取（WorkStealing）策略平衡负载。空闲线程从其他线程的任务队列尾部“偷”任务执行，减少闲置线程。代码示例：线程池实现工作窃取队列#include#include#include#i
  • C++内存模型和原子操作_第五章_《C++并发编程实战》笔记 郭涤生 c/c++#并发线程c++并发编程
    C++内存模型和原子操作1.原子操作与无锁编程2.内存顺序核心概念示例代码3.原子操作的应用：自旋锁核心概念示例代码4.无锁数据结构：无锁栈核心概念示例代码5.多选题目5.多选答案7.设计题目7.设计题目示例答案1.原子操作与无锁编程核心概念原子操作：是不可分割的操作，在执行过程中不会被其他线程中断。C++标准库在头文件中提供了一系列原子类型，如std::atomic、std::atomic等。原
  • C C++ 为什么称为Native代码、虚拟机 TO_ZRG c++开发语言
    CC++为什么称为Native代码，为什么要快1.直接编译为机器码无需中间层：C/C++代码通过编译器（如GCC、Clang）直接编译为CPU可执行的机器码（二进制指令），运行时无需虚拟机（如JVM）或解释器（如Python解释器）的介入。减少运行时开销：相比Java、C#等需要运行时环境（JIT编译）的语言，C/C++的执行路径更短，避免了中间层的性能损耗。2.底层硬件访问能力直接操作硬件：C/
  • 用C++代码利用std::filesystem库写入一个文件路径到数据库中 新兴AI民工 C++编程实战大杂烩c++数据库filesystem转移字符处理
    使用C++代码写数据库不是什么麻烦事，但是和成熟的JAVA体系不一样，C++没有那么多成熟的数据库操作，比如mybatis等等。而且C++一般来说也不会用于写业务软件，不会用比较重的三方库。所以有时用C++代码来直接操作数据库，碰到的一个问题是：在一张数据库表中定义了一个字段：filePathvarchar2(100)需求是将一个形如：c:\test\test.log这样的文件名写入到该字段。本来
  • 【C++】 命令空间 不具名命名空间 具名命名空间 十年一梦实验室 c++开发语言
    在C++中，命名空间（Namespace）是一种用于组织代码、避免命名冲突的机制。通过将代码封装在命名空间中，可以确保不同模块或库中的同名实体不会发生冲突。C++中的命名空间分为具名命名空间（NamedNamespace）和不具名命名空间（UnnamedNamespace）。1.具名命名空间（NamedNamespace）具名命名空间是显式命名的命名空间，用于将代码封装在一个特定的作用域内。1.1
  • 【c++】内联函数 十年一梦实验室 c++
    内联函数详解内联函数（InlineFunction）是C++中的一种重要特性，它通过将函数体的代码直接插入到调用点，从而减少传统函数调用的开销。本文将详细介绍内联函数的定义、用途、实现机制、注意事项以及适用场景，帮助你全面理解这一特性。1.内联函数的定义内联函数是一种特殊的函数，通过在函数定义前添加inline关键字，建议编译器在调用该函数时将其函数体直接嵌入到调用处，而不是执行传统的函数调用流程
  • 鸿蒙(HarmonyOS)应用开发实战——数据库版本升级案例 CTrup 移动开发鸿蒙开发HarmonyOSharmonyos数据库华为鸿蒙开发装饰器模式ArkUI前端
    往期推文全新看点学鸿蒙开发的优劣势，你清楚吗？建议你了解一下！鸿蒙（HarmonyOS）北向开发知识点记录~鸿蒙（OpenHarmony）南向开发保姆级知识点汇总~鸿蒙应用开发与鸿蒙系统开发哪个更有前景？嵌入式开发适不适合做鸿蒙南向开发？看完这篇你就了解了~对于大前端开发来说，转鸿蒙开发究竟是福还是祸？鸿蒙岗位需求突增！移动端、PC端、IoT到底该怎么选？记录一场鸿蒙开发岗位面试经历~持续更新中…
  • 使用C++实现链表数据结构 向着开发进攻 c语言数据结构c++链表
    使用C++实现链表数据结构在计算机科学中，链表是最基础且常用的数据结构之一，它属于线性数据结构。链表相比于数组，它能动态地管理内存，具有更高的插入和删除效率，特别是在频繁需要增删操作的场景下。本文将通过C++编程语言实现单链表的数据结构。我们将实现以下功能：链表的插入:在链表头、尾部插入节点。链表的删除:删除指定位置的节点。链表的遍历:打印链表的所有元素。链表的搜索:根据值查找节点。一、链表的基本
  • RecyclerView学习笔记(1) ChildHelper.Bucket 奋斗小小鸟cy Androidandroid数据结构
    简介toString方法set方法get方法clear方法countOnesBefore方法reset方法insert方法remove方法总结简介RecyclerView中的ChildHelper.Bucket是一个工具类，实现了类似List的数据结构，从而达到减少内存占用的目的。Bucket是一个链表结构，有两个字段：mData用于存储当前信息，next指向下一个数据publicstaticcl
  • C++常用设计模式详解 TT编程 C++编程c++设计模式开发语言面试
    前言：本文详细解释几种常用的C++设计模式，都是平时项目中用的比较多的。本文针对每种设计模式都给出了示例，让你跟着代码彻底搞懂设计模式。Tips：如果是准备面试，不需要知道所有的设计模式，要深入理解下面几种常用即可，因为面试官会先问你了解哪些设计模式，然后从你了解的里面挑一个深问，而且很有可能还会让你手撕出来。而且，最好提前准备一下自己的项目中哪里用到了你说的设计模式，面试官也可能会问。文章目录C
  • android 根目录 写文件路径,android app文件目录结构 weixin_39593498 android根目录写文件路径
    转：https://blog.csdn.net/luoguopeng/article/details/72832567androidapp目录:SDCard/Android/data/你的应用的包名/原来，只要把文件写在这里的话，可以不用动态申请权限，只要在manifest里面声明权限就ok了；应用程序在运行的过程中如果需要向手机上保存数据，一般是把数据保存在SDcard中的。大部分应用是直接在S
  • Java线程协作式中断机制 超人汪小建(seaboat) 线程协作式中断机制jvm
    跟着作者的65节课彻底搞懂Java并发原理专栏，一步步彻底搞懂Java并发原理。作者简介：笔名seaboat，擅长工程算法、人工智能算法、自然语言处理、计算机视觉、架构、分布式、高并发、大数据和搜索引擎等方面的技术，大多数编程语言都会使用，但更擅长Java、Python和C++。平时喜欢看书写作、运动、画画。崇尚技术自由，崇尚思想自由。出版书籍：《Tomcat内核设计剖析》、《图解数据结构与算法》
  • Python,C++开发全球咖啡豆生产区状态实时显示APP Geeker-2025 pythonc++
    开发一个全球咖啡豆主产区状况实时显示App，旨在为用户提供全球咖啡豆主产区的实时信息，包括产量、价格、天气、气候条件、物流信息等。以下是App的核心功能设计和实现思路：---###核心功能设计1.**咖啡豆主产区数据展示**：-提供全球主要咖啡豆产区的基本信息（如国家、地区、产量、主要品种等）。-支持按国家或地区筛选产区。2.**实时产量与价格**：-提供咖啡豆的实时产量数据和市场价格。-支持查看
  • Android开发：如何在应用中显示应用名称 t0_54program 编程问题解决手册android个人开发
    在Android开发中，应用程序的用户界面（UI）设计是一个关键环节。许多新手开发者在使用AndroidStudio和Java语言创建应用时，可能会遇到一些常见的UI问题。比如，如何在应用的顶部显示应用名称（即标题栏或工具栏）。本文将详细讲解如何在Android应用中正确显示应用名称，并通过一个实际的实例来展示解决方案。问题描述假设你正在开发一个简单的Android应用，该应用可以将公斤（kg）转
  • RxSwift 学习笔记第二篇之Observables 我叫柱子哥 #RxSwiftrxswiftObservableSwift
    目录前言一、什么是Observables二、创建Observable的几种方式1.just1.含义2.实用场景2.of1.含义3.from4.create5.interval三、订阅Observable四、取消订阅（DisposeBag）五、常见操作符六、总结前言这篇博客主要介绍Observables的用法。一、什么是ObservablesObservables是Rx的核心。在Rx中我们看到“Ob
  • 华为工程师带你实战C++：专业深度全面完整 6v6-博客 华为c++java
    华为工程师带你实战C++：专业深度全面完整本课程以实战为主，课上全部代码均为边讲边手敲，学完此套课程，可以达到一个C++中高级开发者的水平。既适合于刚刚入门有一定的语言基础的人，也适合于有一定的开发经验的人。课程大纲第1章：C++基础与提高1-1C++学习开山篇1-2C到C++类型安全增强1-3Cout格式输出，函数重载初步1-4函数重载原理1-5C++运算符重载初步1-6C++函数默认参数1-7
  • c++ 嵌套类（Nested Class）、局部类（Local Class） JANGHIGH C++c++开发语言
    c++嵌套类（NestedClass）、局部类（LocalClass）一、嵌套类（NestedClass）典型场景示例：链表实现中的嵌套类二、局部类（LocalClass）典型场景示例：函数内部的策略类三、关键区别与注意事项注意事项四、总结C++中的嵌套类（NestedClass）和局部类（LocalClass）是两种特殊的类定义方式，用于优化代码组织和封装性。以下是详细说明和示例：一、嵌套类（N
  • c++ 嵌套名字空间和匿名名字空间 JANGHIGH C++c++开发语言
    c++嵌套名字空间和匿名名字空间一、嵌套名字空间（NestedNamespaces）核心特性示例二、匿名名字空间（AnonymousNamespace）核心特性示例三、关键区别与注意事项注意事项四、总结一、嵌套名字空间（NestedNamespaces）核心特性多层作用域：名字空间可以多层嵌套，形成逻辑上的层次结构。分散定义：同一个名字空间可以在程序的不同位置多次定义（编译器会合并内容）。C++1
  • STL之vector类的模拟实现 C-SDN花园GGbond 玩转c++c++开发语言
    博客主页：C-SDN花园GGbond⏩文章专栏：玩转c++目录1.vector的成员变量2.vector的成员函数2.1.vector的迭代器2.2.vector的初始化与销毁2.2.1.构造函数与拷贝构造2.2.2.赋值重载与析构函数2.3.vector的容量操作2.3.1.有效长度与容量大小2.3.2.容量操作2.4.vector的访问操作2.5.vector的修改操作2.5.1.常见的修改操
  • ViewController添加button按钮解析。（翻译） 张亚雄 c
    <div class="it610-blog-content-contain" style="font-size: 14px"></div>//  ViewController.m //  Reservation software // //  Created by 张亚雄 on 15/6/2.
  • mongoDB 简单的增删改查 开窍的石头 mongodb
       在上一篇文章中我们已经讲了mongodb怎么安装和数据库/表的创建。在这里我们讲mongoDB的数据库操作       在mongo中对于不存在的表当你用db.表名 他会自动统计 下边用到的user是表明，db代表的是数据库       添加(insert):
  • log4j配置 0624chenhong log4j
    1) 新建java项目 2) 导入jar包，项目右击，properties—java build path—libraries—Add External jar，加入log4j.jar包。 3) 新建一个类com.hand.Log4jTest package com.hand; import org.apache.log4j.Logger; public class
  • 多点触摸(图片缩放为例) 不懂事的小屁孩 多点触摸
    多点触摸的事件跟单点是大同小异的，上个图片缩放的代码，供大家参考一下 import android.app.Activity; import android.os.Bundle; import android.view.MotionEvent; import android.view.View; import android.view.View.OnTouchListener
  • 有关浏览器窗口宽度高度几个值的解析 换个号韩国红果果 JavaScripthtml
    1 元素的 offsetWidth 包括border padding  content  整体的宽度。 clientWidth  只包括内容区 padding 不包括border。 clientLeft =  offsetWidth -clientWidth  即这个元素border的值 offsetLeft  若无已定位的包裹元素
  • 数据库产品巡礼：IBM DB2概览 蓝儿唯美 db2
    IBM DB2是一个支持了NoSQL功能的关系数据库管理系统，其包含了对XML，图像存储和Java脚本对象表示（JSON）的支持。DB2可被各种类型的企 业使用，它提供了一个数据平台，同时支持事务和分析操作，通过提供持续的数据流来保持事务工作流和分析操作的高效性。 DB2支持的操作系统 DB2可应用于以下三个主要的平台:   工作站，DB2可在Linus、Unix、Windo
  • java笔记5 a-john java
    控制执行流程： 1，true和false    利用条件表达式的真或假来决定执行路径。例：（a==b）。它利用条件操作符“==”来判断a值是否等于b值，返回true或false。java不允许我们将一个数字作为布尔值使用，虽然这在C和C++里是允许的。如果想在布尔测试中使用一个非布尔值，那么首先必须用一个条件表达式将其转化成布尔值，例如if(a!=0)。 2，if-els
  • Web开发常用手册汇总 aijuans PHP
    一门技术，如果没有好的参考手册指导,很难普及大众。这其实就是为什么很多技术，非常好，却得不到普遍运用的原因。 正如我们学习一门技术，过程大概是这个样子： ①我们日常工作中，遇到了问题，困难。寻找解决方案，即寻找新的技术； ②为什么要学习这门技术？这门技术是不是很好的解决了我们遇到的难题，困惑。这个问题，非常重要，我们不是为了学习技术而学习技术，而是为了更好的处理我们遇到的问题，才需要学习新的
  • 今天帮助人解决的一个sql问题 asialee sql
                今天有个人问了一个问题，如下： type     AD      value          A  
  • 意图对象传递数据 百合不是茶 android意图IntentBundle对象数据的传递
    学习意图将数据传递给目标活动; 初学者需要好好研究的       1,将下面的代码添加到main.xml中    <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http:/
  • oracle查询锁表解锁语句 bijian1013 oracleobjectsessionkill
    一.查询锁定的表 如下语句，都可以查询锁定的表 语句一： select a.sid, a.serial#, p.spid, c.object_name, b.session_id, b.oracle_username, b.os_user_name from v$process p, v$s
  • mac osx 10.10 下安装 mysql 5.6 二进制文件［tar.gz］ 征客丶 mysqlosx
    场景：在 mac osx 10.10 下安装 mysql 5.6 的二进制文件。 环境：mac osx 10.10、mysql 5.6 的二进制文件 步骤：[所有目录请从根“/”目录开始取，以免层级弄错导致找不到目录] 1、下载 mysql 5.6 的二进制文件，下载目录下面称之为 mysql5.6SourceDir； 下载地址：http://dev.mysql.com/downl
  • 分布式系统与框架 bit1129 分布式
    RPC框架 Dubbo 什么是Dubbo   Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。其核心部分包含:    远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。    集群容错: 提供基于接
  • 那些令人蛋痛的专业术语 白糖_ springWebSSOIOC
    spring 【控制反转(IOC)/依赖注入(DI)】： 由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。 简单的说：对象的创建又容器(比如spring容器)来执行，程序里不直接new对象。 Web 【单点登录(SSO)】：SSO的定义是在多个应用系统中，用户
  • 《给大忙人看的java8》摘抄 braveCS java8
    函数式接口：只包含一个抽象方法的接口 lambda表达式：是一段可以传递的代码       你最好将一个lambda表达式想象成一个函数，而不是一个对象，并记住它可以被转换为一个函数式接口。 事实上，函数式接口的转换是你在Java中使用lambda表达式能做的唯一一件事。   方法引用：又是要传递给其他代码的操作已经有实现的方法了，这时可以使
  • 编程之美-计算字符串的相似度 bylijinnan java算法编程之美
    public class StringDistance { /** * 编程之美 计算字符串的相似度 * 我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为： * 1.修改一个字符（如把“a”替换为“b”）; * 2.增加一个字符（如把“abdd”变为“aebdd”）; * 3.删除一个字符（如把“travelling”变为“trav
  • 上传、下载压缩图片 chengxuyuancsdn 下载
    /** * * @param uploadImage --本地路径(tomacat路径) * @param serverDir --服务器路径 * @param imageType --文件或图片类型 * 此方法可以上传文件或图片.txt,.jpg,.gif等 */ public void upload(String uploadImage,Str
  • bellman-ford(贝尔曼-福特)算法 comsci 算法F#
    Bellman-Ford算法(根据发明者 Richard Bellman 和 Lester Ford 命名)是求解单源最短路径问题的一种算法。单源点的最短路径问题是指：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore zu 也为这个算法的发展做出了贡献。 与迪科
  • oracle ASM中ASM_POWER_LIMIT参数 daizj ASMoracleASM_POWER_LIMIT磁盘平衡
    ASM_POWER_LIMIT 该初始化参数用于指定ASM例程平衡磁盘所用的最大权值，其数值范围为0~11，默认值为1。该初始化参数是动态参数，可以使用ALTER  SESSION或ALTER  SYSTEM命令进行修改。示例如下： SQL>ALTER  SESSION  SET   Asm_power_limit=2;
  • 高级排序:快速排序 dieslrae 快速排序
    public void quickSort(int[] array){ this.quickSort(array, 0, array.length - 1); } public void quickSort(int[] array,int left,int right){ if(right - left <= 0
  • C语言学习六指针_何谓变量的地址 一个指针变量到底占几个字节 dcj3sjt126com C语言
    # include <stdio.h> int main(void) { /* 1、一个变量的地址只用第一个字节表示 2、虽然他只使用了第一个字节表示，但是他本身指针变量类型就可以确定出他指向的指针变量占几个字节了 3、他都只存了第一个字节地址，为什么只需要存一个字节的地址，却占了4个字节，虽然只有一个字节， 但是这些字节比较多，所以编号就比较大，
  • phpize使用方法 dcj3sjt126com PHP
    phpize是用来扩展php扩展模块的，通过phpize可以建立php的外挂模块,下面介绍一个它的使用方法,需要的朋友可以参考下 安装（fastcgi模式）的时候，常常有这样一句命令： 代码如下: /usr/local/webserver/php/bin/phpize   一、phpize是干嘛的？ phpize是什么？ phpize是用来扩展php扩展模块的，通过phpi
  • Java虚拟机学习 - 对象引用强度 shuizhaosi888 JAVA虚拟机
    本文原文链接：http://blog.csdn.net/java2000_wl/article/details/8090276 转载请注明出处！ 无论是通过计数算法判断对象的引用数量，还是通过根搜索算法判断对象引用链是否可达，判定对象是否存活都与“引用”相关。 引用主要分为 ：强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Wea
  • .NET Framework 3.5 Service Pack 1（完整软件包）下载地址 happyqing .net下载framework
      Microsoft .NET Framework 3.5 Service Pack 1（完整软件包）  http://www.microsoft.com/zh-cn/download/details.aspx?id=25150 Microsoft .NET Framework 3.5 Service Pack 1 是一个累积更新，包含很多基于 .NET Framewo
  • JAVA定时器的使用 jingjing0907 javatimer线程定时器
    1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。 对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。 privatejava.util.Timer timer; timer = newTimer(true); timer.schedule( newjava.util.TimerTask() { public void run()
  • Webbench 流浪鱼 webbench
    首页下载地址 http://home.tiscali.cz/~cz210552/webbench.html Webbench是知名的网站压力测试工具，它是由Lionbridge公司（http://www.lionbridge.com）开发。 Webbench能测试处在相同硬件上，不同服务的性能以及不同硬件上同一个服务的运行状况。webbench的标准测试可以向我们展示服务器的两项内容：每秒钟相
  • 第11章 动画效果（中） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • windows下制作bat启动脚本. sanyecao2314 javacmd脚本bat
    java -classpath C:\dwjj\commons-dbcp.jar;C:\dwjj\commons-pool.jar;C:\dwjj\log4j-1.2.16.jar;C:\dwjj\poi-3.9-20121203.jar;C:\dwjj\sqljdbc4.jar;C:\dwjj\voucherimp.jar com.citsamex.core.startup.MainStart
  • Java进行RSA加解密的例子 tomcat_oracle java
    加密是保证数据安全的手段之一。加密是将纯文本数据转换为难以理解的密文；解密是将密文转换回纯文本。 　　数据的加解密属于密码学的范畴。通常，加密和解密都需要使用一些秘密信息，这些秘密信息叫做密钥，将纯文本转为密文或者转回的时候都要用到这些密钥。 　　对称加密指的是发送者和接收者共用同一个密钥的加解密方法。 　　非对称加密(又称公钥加密)指的是需要一个私有密钥一个公开密钥，两个不同的密钥的
  • Android_ViewStub 阿尔萨斯 ViewStub
    public final class ViewStub extends View java.lang.Object android.view.View android.view.ViewStub 类摘要： ViewStub 是一个隐藏的，不占用内存空间的视图对象，它可以在运行时延迟加载布局资源文件。当 ViewSt
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他