c++的三大特性

Operator Overloading

下面的代码是一段运算符重载代码：

1. class CVeryLong 
2.   {
3.   public:
4.       // default contructor inits member variables to zero
6.       CVeryLong(){ m_lHigh = m_lLow = 0; } 
7.       // initialization constructor sets member variables to a value
9.       CVeryLong( long lHigh, long lLow ){ m_lHigh = lHigh; m_lLow = lLow; } 
10.       virtual ~CVeryLong(){}; // destructor
12.       void SetHighValue( long lValue ){ m_lHigh = lValue; }
13.       long GetHighValue(){ return m_lHigh; }
14.       void SetLowValue( long lValue ){ m_lLow = lValue; }
15.       long GetLowValue(){ return m_lLow; }
16.       BOOL operator < ( CVeryLong& refValue )    // less than operator
18.       {
19.           if ( m_lHigh < refValue.GetHighValue()) return TRUE;
20.           else if ( m_lHigh > refValue.GetHighValue()) return FALSE;
21.           else if ( m_lLow < refValue.GetLowValue()) return TRUE;
22.           else return FALSE; // >=
24.       }
25.       BOOL operator > ( CVeryLong& refValue )    // greater than operator
27.       {
28.           if ( m_lHigh > refValue.GetHighValue()) return TRUE;
29.           else if ( m_lHigh < refValue.GetHighValue()) return FALSE;
30.           else if ( m_lLow > refValue.GetLowValue()) return TRUE;
31.           else return FALSE; // <=
33.       }
34.       BOOL operator == ( CVeryLong& refValue ) // equivalence operator
36.       {
37.           return m_lHigh == refValue.GetHighValue() 
38.                    && m_lLow == refValue.GetLowValue();
39.       }
41.   private:
42.       long m_lLow;
43.       long m_lHigh;
44.   };

CVeryLong 类有两个long私有变量，能够显示一个64位整型数。在这个类中，我们重载了小于号(<),大于号(>),等于号（=）,使得64位整数类可以进行比较运算。显然，这个类是不完整的，因为还有很多数学运算符没重载。下面的代码简单使用我们的新类：

1. {
2.    CString csText;
4.    CVeryLong vl1( 1, 2 ), vl2( 1, 3 ), vl3;
5.    
6.    cout << "vl1 is (1, 2)" << endl;
7.    cout << "vl2 is (1, 3)" << endl;
8.    cout << "vl3 is (1, 2)" << endl;
9.        
10.    csText = "vl1 < vl2 is ";
11.    csText += vl1 < vl2 ? "true" : "false";
12.    cout << (LPCTSTR)csText << endl;
14.    csText = "vl1 > vl2 is ";
15.    csText += vl1 > vl2 ? "true" : "false";
16.    cout << (LPCTSTR)csText << endl;
18.    csText = "vl1 = = vl2 is ";
19.    csText += vl1 == vl2 ? "true" : "false";
20.    cout << (LPCTSTR)csText << endl;
22.    csText = "vl1 < vl3 is ";
23.    csText += vl1 < vl3 ? "true" : "false";
24.    cout << (LPCTSTR)csText << endl;
26.    csText = "vl1 > vl3 is ";
27.    csText += vl1 > vl3 ? "true" : "false";
28.    cout << (LPCTSTR)csText << endl;
30.    csText = "vl1 = = vl3 is ";
31.    csText += vl1 == vl3 ? "true" : "false";
32.    cout << (LPCTSTR)csText << endl;
33. }

 

运行结果：

1.        vl1 is (1, 2)
2.        vl2 is (1, 3)
3.        vl3 is (1, 2)
4.        vl1 < vl2 is true
5.        vl1 > vl2 is false
6.        vl1 == vl2 is false
7.        vl1 < vl3 is false
8.        vl1 > vl3 is false
9.        vl1 == vl3 is true

在这里，我们告诉编译器当它看到<,>,或=作用在我们的新类中该做什么，在别的语言中可以定义成员函数来做同样的事。

Exceptions

异常需要有语言的支持，否则将很难被复制。Windows NT 提供Structured Exception Handing(SEH)的复杂功能，这种由操作系统提供的功能和C++提供的异常是同一种类型。其他语言可以获得SEH带来的好处，而C++的轻便机制使得它能够在所有的操作系统中工作的像SEH一样好。

异常处理正如名字所暗示：有处理异常情况的能力，不会增加正常情况的负担。下面的代码是异常处理。

1. DWORD dwStart = ::GetTickCount(); // used for timing in mSec
3. const int x = 1000000;
4. const int xEnd = -x;
5. int y = x;
6. int z;
7. while ( y > xEnd )
8. {
9.     try
10.     {
11.         while ( y > xEnd )
12.             z = x / y--; // divide protected by exception
14.     }
15.     catch (...)
16.     {
17.         cout << "Divide by zero" << endl; // trapped out of inner loop
19.         y--; // continue via outer loop
21.     }
22. }
24. DWORD dwStop = ::GetTickCount();
25. DWORD dwDiff = dwStop - dwStart;
26. CString csMessage;
27. csMessage.Format( "mSec = %d", dwDiff );
28. cout << (LPCTSTR)csMessage << endl;

输出：

Divide by zero
mSec = 491

内层循环不需要检查是否除0，当发生除0时，把它当成一个异常来处理了。对比没有异常时上面的代码应该写成：

  
  

   
   
while ( y > xEnd )
{    
    if ( x != 0 ) // has to execute for every iteration 
    {
        z = x / y--;
    }
    else
    {
        cout << "Attempted divide by zero" << endl;
    }
}
  
  

Templates

Function Templates

通过函数模板，可以指定一类函数基于相同的代码，但是不同的类型或是类却有不同的功能。下面是一个模板函数，

返回两个数中的最大值。

  
  
template <class T> T& Max( T& a, T& b ) 
{
    if ( a >  b ) return a; else return b;
}

通过这种方式，可以避免 MaxFloat, MaxInt, MaxShort, MaxChar等函数的实现。如果调用Max时，使用float，

编译器将会进行编译。由于可以重载运算符，Max函数就不在局限于基本类型。上面的CVeryLong类也能够适用。

Class Templates

     
     
template<class KEY, class ARG_KEY, class DATA, class ARG_DATA>
class CTree 
{
private:
    typedef enum
    {   balLeft = -1,
        balEven,
        balRight,
    } BALANCE;
    class CNode;
    typedef CNode* PNODE;
    class CNode // container to hold the data and hide the balancing details 
    {
    public:
        CNode( ARG_KEY key, ARG_DATA data );
        // additional members not shown 
    private:
        KEY m_key;
        DATA m_data;
        BALANCE m_Bal; // -1..1 current balance data for this node 
        PNODE m_pLeft;
        PNODE m_pRight;
    };
    CTree(){ m_pRoot = 0; m_nSize = 0; m_bHeightChange = false; }
    virtual ~CTree();
    bool GetFirst( ARG_KEY key, ARG_DATA data );
    bool GetLast( ARG_KEY key, ARG_DATA data );
    bool GetNext( ARG_KEY key, ARG_DATA data );
    bool GetPrev( ARG_KEY key, ARG_DATA data );
    bool Add( ARG_KEY key, ARG_DATA data );
    ARG_DATA operator[]( ARG_KEY key );
    bool Delete( ARG_KEY key );
    // additional members not shown 
private:
    CNode* m_pRoot;
    bool m_bHeightChange;
    int m_nSize;
};

上面的类通过指定不同类型，将产生新的类，这些类所具有的操作是相同的。

让我们来看下，模板的声明：

template<class KEY, class ARG_KEY, class DATA, class ARG_DATA>
class CTree

在声明中有四个参数，指定键的类型，键的传递方式，数据类型，数据的传递方式

CTree<CString, const char*, CVeryLong,CVeryLong&> treeVeryLong;
CTree<CString, const char*, float,float> treeFloat; 
CTree<long, long, CString, constchar*> treeString; 
CTree<CVeryLong,   CVeryLong,CList<int, int>, <int,int>&> treeList;
第一个例子是一棵以CVeryLong为数据，CString为键的树，键的传递方式是 const char* ,数据的传递
方式是通过引用。
类模板提供了强大的代码重用机制。