久久人人爽人人爽爽久久,亚洲第一精品在线,欧美日韩免费一区二区三区

1个短��的实例�Q�显�C�构建和中序遍历2叉查找树

Wed, 13 May 2009 09:21:00 GMT

  1#include "stdafx.h"
  2#include <iostream>
  3using namespace std;
  4
  5template <typename T>
  6class BinarySearchTree
  7{
  8 friend  ostream& operator<<(ostream& , BinarySearchTree<T>& );
  9public:
10 BinarySearchTree();
11 void insert(const T );
12 void midvisit()
13 {
14
15  midvisit(root);
16 }
17
18protected:
19
20private:
21 class TNode
22 {
23  friend class BinarySearchTree;
24 public:
25  TNode(T a)
26   :data(a),
27   left(NULL),
28   right(NULL)
29  {
30
31  }
32 protected:
33 private:
34  T data;
35  TNode* left;
36  TNode* right;
37 };
38 void insert(const T ,TNode*&);
39 void midvisit(TNode* x)
40 {
41  if (x==NULL)
42  {
43   return;
44  }
45  midvisit(x->left);
46  cout<<x->data;
47  midvisit(x->right);
48
49 }
50TNode* root;
51
52
53};
54template<typename T2>
55ostream& operator<<(ostream& os, BinarySearchTree<T2>& a)
56{
57
58
59}
60template<typename T>
61BinarySearchTree<T>::BinarySearchTree()
62{
63
64root=NULL;
65}
66template<typename T>
67void BinarySearchTree<T>::insert(const T a,TNode*& t)
68{
69    if (t==NULL)
70    {
71  t=new TNode(a);
72  return;
73    }
74 if (a>t->data)
75 {
76  insert(a,t->right);
77 }
78 else
79  insert(a,t->left);
80
81
82}
83template<typename T>
84void BinarySearchTree<T>::insert(const T a)
85{
86 insert(a,root);
87
88
89
90
91}
92int _tmain(int argc, _TCHAR* argv[])
93{
94 BinarySearchTree<int > a;
95 for (int i=0;i<10;++i)
96 {
97  a.insert(i);
98 }
99 cout<<"insert data"<<endl;
100    a.midvisit();
101 return 0;
102}
103

黄大�?/a> 2009-05-13 17:21 发表评论

Tue, 12 Jun 2007 08:09:00 GMT

1int (* backarry(int (* arrayname )[3]) ) [3]
2{
3 return arrayname;
4
5};

呵呵�Q�是有点古�?

再来�?br>

1int (*  backarry(int (* arrayname )[3]) )  [3]
2{
3
4    return arrayname;
5
6};
7int (&  backarry(int (& arrayname)[3]))[3]
8{
9    for (int i=0;i<3;++i)
10    {
11        cout<<i;
12    }
13    return arrayname;
14};
15int main()
16{
17int array[3]={1,2,3};
18backarry(array);//会调用哪个呢�Q�？
19}

黄大�?/a> 2007-06-12 16:09 发表评论

Thu, 22 Mar 2007 01:56:00 GMT

1 #pragma once
2
3 class component
4 {
5 public :
6     component(void);
7   virtual void printsefl() = 0    ;
8 public :
9     virtual ~component(void);
10 };
11
12 class concreatecom : public component
13 {
14 public :
15     concreatecom(char * );
16   virtual void printsefl()   ;
17   virtual ~concreatecom(void);
18 protected:
19 private :
20 char * _psz_text;
21 };
22
23 class decorator: public component
24 {
25 public :
26      decorator(component & );
27   virtual void printsefl()     ;
28   virtual ~decorator();
29 protected:
30
31 private :
32    component & _pcomponent;
33 };
34 class  headdeco: public decorator
35 {
36 public :
37        headdeco(component & , int );
38    virtual void printsefl()   ;
39    virtual ~headdeco();
40 protected:
41     virtual void printhead()  ;
42 private :
43 int _i_head;
44 };
45
46 class enddeco: public decorator
47 {
48 public :
49       enddeco(component & ,char * );
50     virtual void printsefl() ;
51     virtual  ~enddeco();
52 protected:
53       virtual void printend() ;
54 private :
55 char * _pch_end;
56 };

1 #include " StdAfx.h "
2 #include < iostream >
3 #include " component.h "
4 using namespace std;
5
6 component::component(void)
7 {
8 }
9
10 component::~component(void)
11 {
12 }
13
14 void concreatecom::printsefl()
15 {
16    cout << endl;
17    cout << _psz_text ;
18    cout << endl;
19 }
20 concreatecom::concreatecom(char * psz)
21 {
22       _psz_text = psz;
23 }
24 decorator::decorator(component & a):
25    _pcomponent(a)
26 {
27
28 }
29 concreatecom::~concreatecom()
30 {
31
32 }
33 void decorator::printsefl()
34 {
35 _pcomponent.printsefl();
36
37 }
38
39 decorator::~decorator()
40 {
41
42 }
43
44 headdeco::headdeco(component & refcom, int i):
45   decorator(refcom)
46 ,_i_head(i)
47 {
48
49 }
50 void headdeco::printsefl()
51 {
52    printhead();
53    decorator::printsefl();
54
55 }
56 void headdeco::printhead()
57 {
58     cout << endl;
59    cout << _i_head;
60    cout << endl;
61 }
62 headdeco::~headdeco()
63 {
64
65 }
66
67 enddeco::enddeco(component & refcom,char * pch)
68 :decorator(refcom)
69 ,_pch_end(pch)
70 {
71
72 }
73 void enddeco::printsefl()
74 {
75     decorator::printsefl();
76     printend();
77 }
78 void enddeco::printend()
79 {
80     cout << endl;
81     cout << _pch_end;
82     cout << endl;
83 }
84 enddeco::~enddeco()
85 {
86
87 }

1 // decorator.cpp : 定义控制台应用程序的入口炏V�?br /> 2 //
3
4 #include " stdafx.h "
5 #include < iostream >
6 #include " component.h "
7 using namespace std;
8
9 void printmodel(component & pcom )
10 {
11     pcom.printsefl();
12 }
13 int _tmain( int argc, _TCHAR * argv[])
14 {
15
16     printmodel(headdeco(headdeco(enddeco(concreatecom( " 正文输出中。。。�?/span> " ), " 黄大�?/span> " ), 2 ), 1 ));
17     return 0 ;
18 }
19

�q�个decorator 模式例子让初学�?更能加深多态威力的体会�?decorator 模式比子�cȝ��zȝ��体会
要注意的问题是：对象链��L��?concreatecomponent 对象处结束�?br />
///此处是client 使用对象的入口点�Q�仅仅得��C�� 1�?decorator 的派生类对象�Q�client 什么都不知�?br />printmodel(headdeco(headdeco(enddeco(concreatecom("正文输出中。。。�?),"黄大�?),2),1));
///

在vc2005 下通过

黄大�?/a> 2007-03-22 09:56 发表评论

STL container

Mon, 18 Sep 2006 02:43:00 GMT

Containers in STL can be divided into three categories:
1.sequence containers,
2.associative containers,
3.container adapters.

1.Sequence Containers

Sequence containers maintain the original ordering of inserted elements. This allows you to specify where to insert the element in the container.

The deque (double-ended queue) container allows for fast insertions and deletions at the beginning and end of the container. You can also randomly access any element quickly.

The list container allows for fast insertions and deletions anywhere in the container, but you cannot randomly access an element in the container.

The vector container behaves like an array, but will automatically grow as required.

For more information on the sequence containers, consult the following table:

Sequence Container	Native STL
deque	deque Class
ilist	Not Applicable
list	list Class
vector	vector Class

2.Associative Containers

The defining characteristic of associative containers is that elements are inserted in a pre-defined order, such as sorted ascending.

The associative containers can be grouped into two subsets: maps and sets. A map, sometimes referred to as a dictionary, consists of a key/value pair. The key is used to order the sequence, and the value is somehow associated with that key. For example, a map might contain keys representing every unique word in a text and values representing the number of times that word appears in the text. A set is simply an ascending container of unique elements.

Both map and set only allow one instance of a key or element to be inserted into the container. If multiple instances of elements are required, use multimap or multiset.

Both maps and sets support bidirectional iterators. For more information on iterators, see Iterators.

While not officially part of the STL standard, hash_map and hash_set are commonly used to improve searching times. These containers store their elements as a hash table, with each table entry containing a bidirectional linked list of elements. To ensure the fastest search times, make sure that the hashing algorithm for your elements returns evenly distributed hash values.

For more information on the associative containers, consult the following table:

Associative Container	Native STL
hash_map	hash_map Class
hash_multimap	hash_multimap Class
hash_multiset	hash_multiset Class
hash_set	hash_set Class
map	map Class
multimap	multimap Class
multiset	multiset Class
set	set Class

3.Container Adapters

The container adapters are simply variations of the above containers. The container adapters do not support iterators.

The priority_queue container organized such that the element with the highest value is always first in the queue.

The queue container follows FIFO (first in, first out) semantics. The first element inserted (pushed) into the queue is the first to be removed (popped).

The stack container follows LIFO (last in, first out) semantics. The last element to be inserted (pushed) on the stack is the first element to be removed (popped).

Since container adapters do not support iterators, they cannot be used with the STL algorithms. For more information on algorithms, see Algorithms.

For more information on the container adapters, consult the following table:

Container Adapter	Native STL
priority_queue	priority_queue Class
queue	queue Class
stack	stack Class

Requirements for Container Elements

Elements inserted into an STL container can be of any object type that supplies a public copy constructor, a public
                                      public 拯��构�?�Q�public 析构 ,public 赋值操作符   elem& operator =( elem const &)
destructor, and a public assignment operator. The destructor may not throw an exception. Furthermore, associative
                                                                       析构不能抛出异常
containers such as set and map must have a public comparison operator defined, which is operator< by default. Some
                             兌��容器除此�?�q�应由有比较操作�W?br />                  operations on containers might also require a public default constructor and a public equivalence operator.

以下是�?各容�?�q�代器类型输��Z��?br />

1#include <vector>
2#include <list>
3#include <deque>
4#include <set>
5#include <map>
6using namespace std;
7template <typename inputitrator >
8void predict(inputitrator  a)
9{   iterator_traits<inputitrator>::iterato_category  b;
10
11   cout<< endl<< "  "<<typeid(b).name();
12}
13
14
15main()
16
17{
18  vector<int> a;
19  deque<int> b;
20  list<int> c;
21  set<int> d;
22  map<int> e;
23
24   predict(a.begin());
25   predict(b.begin());
26   predict(c.begin());
27    predict(d.begin());
28     predict(e.begin());
29
30}

output iterator
   -> forward iterator
   -> bidirectional iterator
   -> random-access iterator

input iterator
   -> forward iterator
   -> bidirectional iterator
   -> random-access iterator

黄大�?/a> 2006-09-18 10:43 发表评论

MFC �?命��o消息传�?�Q�原创）

Thu, 27 Jul 2006 03:27:00 GMT

                        先对对于mfc中的命��o消息路由的机制原理作个简单的�ȝ��Q?br />      CCmdTarget �?模板 �Q�提供： CCmdTarget::OnCmdMsg() �q�个函数 �?其派生类的消息结构数�l�（它是静态的�Q�做搜烦 �q�向上（基类�Q�的�l�构数组做搜索�ƈ调用相应的成员函数�?br />   �z��c�M��?
DECLARE_MESSAGE_MAP()
BEGIN_MESSAGE_MAP(本类, 基类)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
END_MESSAGE_MAP()
加入链表

        AfxWndProc �Q�只有发向窗口才会被调用�Q�，此函�?��用HWND �?mfc库的全局变量�?br />扑ֈ�句柄映射表，转�ؓ CWnd �?�Q�最�l��?�z��cȝ��对OnCmdMsg()的重�?来实�?不同的�\�?br />
     以上原理
           做�ؓ一个例子，��给��Z��C�Z��Q?br />

1class CMan : public CCmdTarget
2{
3    DECLARE_DYNAMIC(CMan)
4
5public:
6    CMan();
7    virtual ~CMan();
8
9protected:
10    DECLARE_MESSAGE_MAP()
11public:
12    afx_msg void OnAppAbout();
13    virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo);
14    int m_id;
15    CString m_name;
16};////////////自定义的c++�c?br />17
18
19////////////////重蝲 onCmdMsg�Q�（m_man为CMainFram的成员）
20BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
21{
22    // TODO: 在此��d��专用代码�?或调用基�c?/span>
23          if (m_man.OnCmdMsg(nID, nCode, pExtra, pHandlerInfo ))
24          {
25              return true;
26
27          }else
28    return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
29}
30//////////////�l�CMan 加个命��o响应
31BEGIN_MESSAGE_MAP(CMan, CCmdTarget)
32    ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
33END_MESSAGE_MAP()
34
35
36
37// CMan 消息处理�E�序
38
39void CMan::OnAppAbout()
40{
41    // TODO: 在此��d��命��o处理�E�序代码
42    CString str;
43    str.Format("%d ",m_id);
44    str+=m_name;
45    AfxMessageBox(str);
46}
47///////////
48
49�q�行后就会发玊W�此命��o��由CMan::onAppAbout() 来�?br />50响应

黄大�?/a> 2006-07-27 11:27 发表评论

聚合

Wed, 05 Jul 2006 03:45:00 GMT

            重用的另一�U�方�?br />      a 聚合 b
    b 要有必要的支持才能实玎ͼ�具体�q�程如：
     a, cocreateinstance,指定自己的IUnknown ,�q�必��d��iid,ppv中指定是 IID__IUnknown ,IUnknown*�Q�被聚合的com�cȝ�� 非委托IUnknown�Q?br />此时被聚合类在类厂（createinstance �?接收 a�?IUnknown �q�在 b 的成员中赋好��|��支持下，被创�?br />的com�c?被创建�?br />      b �?2�l?IUnknown 接口�Q�委托（聚合�Q?和 �?非委托（正常�Q?br />    在a 中获�?IUnknown接口�Q�b的）�Q�请�?其他接口�?( a�?客户发出的对b 的接口请�?转到 a 获取
IUnknown 接口调用 queryinterface ),全部使用 b 对象的�?委托接口来判断�?是把接口��h�� 转到
非委�?�q�是外部 a 的IUnknown

黄大�?/a> 2006-07-05 11:45 发表评论

Tue, 04 Jul 2006 08:20:00 GMT

摘要: 1 #pragma once 2 static const GUID CLSID_mydiv = 3 { ... 阅读全文

黄大�?/a> 2006-07-04 16:20 发表评论

Run time type Information

Tue, 04 Jul 2006 02:23:00 GMT

一 dynamic_cast < type-id > ( expression )
type-id :必须是指针或者引�?br /> expression:必须是指针或者一个左�?br />基本上是用来�?子对象间的�{�?br />1.基本的用�?br />

class B { ... };
class C : public B { ... };
class D : public C { ... };

void f(D* pd)
{
   C* pc = dynamic_cast(pd);   // ok: C is a direct base class
                                 // pc points to C subobject of pd 

   B* pb = dynamic_cast(pd);   // ok: B is an indirect base class
                                 // pb points to B subobject of pd 
   ...
}

This type of conversion is called an "upcast" because it moves a pointer up a class hierarchy, from a derived class to a class it is derived from. An upcast is an implicit conversion.

If type-id is void*, a run-time check is made to determine the actual type of expression. The result is a pointer to the complete object pointed to by expression. For example:

class A { ... };

class B { ... };

void f()
{
   A* pa = new A;
   B* pb = new B;
   void* pv = dynamic_cast(pa);
   // pv now points to an object of type A
   ...
   pv = dynamic_cast(pb);
   // pv now points to an object of type B
}

If type-id is not void*, a run-time check is made to see if the object pointed to by expression can be converted to the type pointed to by type-id.

If the type of expression is a base class of the type of type-id, a run-time check is made to see if expression actually points to a complete object of the type of type-id. If this is true, the result is a pointer to a complete object of the type of type-id. For example:

class B { ... };
class D : public B { ... };

void f()
{
   B* pb = new D;                     // unclear but ok
   B* pb2 = new B;

   D* pd = dynamic_cast(pb);      // ok: pb actually points to a D
   ...
   D* pd2 = dynamic_cast(pb2);   // pb2 points to a B not a D
                                    // cast was bad so pd2 == NULL
   ...
}

This type of conversion is called a "downcast" because it moves a pointer down a class hierarchy, from a given class to a class derived from it.
��结�Q?br /> a 实际指向对象和 �?b 目标对象, b 是a �?基类�Q�子对象�Q�，或者是2�?同��转换才成�?br />否则目标为NULL;也就是说不能向下�?br />

2 多重非虚的��承模�?br />

Class Hierarchy Showing Multiple Inheritance

A pointer to an object of type D can be safely cast to B or C. However, if D is cast to point to an A object, which instance of A would result? This would result in an ambiguous casting error. To get around this problem, you can perform two unambiguous casts. For example:

void f()
{
   D* pd = new D;
   A* pa = dynamic_cast(pd);      // error: ambiguous
   B* pb = dynamic_cast(pd);      // first cast to B
   A* pa2 = dynamic_cast(pb);   // ok: unambiguous
}

Further ambiguities can be introduced when you use virtual base classes. Consider the class hierarchy shown in the following figure.

也就是说�?意性下会失�?br />3.子对象间的�{�?br />

Class Hierarchy Showing Duplicate Base Classes

    //pd 指向 e 对象
void f(D* pd)
{
   E* pe = dynamic_cast(pd);
   B* pb = pe;      // upcast, implicit conversion
   A* pa = pb;      // upcast, implicit conversion
}

//pd 指向 e 对象
void f(D* pd)
{
   B* pb = dynamic_cast(pd);      // cross cast
   A* pa = pb;                  // upcast, implicit conversion
}

也就是�?所�?cross cast

二�?typeid( type-id )     typeid( expression )
   此操作符�q�回个�?const type_info &
            expression 必须指向一个多态类型（带虚函数    �Q�，�q�且要解引用

#include
#include

class Base {
public:
virtual void vvfunc() {}
};

class Derived : public Base {};

using namespace std;
int main()
{
   Derived* pd = new Derived;
   Base* pb = pd;
   cout << typeid( pb ).name() << endl;   //prints "class Base *"
   cout << typeid( *pb ).name() << endl;   //prints "class Derived"
   cout << typeid( pd ).name() << endl;   //prints "class Derived *"
   cout << typeid( *pd ).name() << endl;   //prints "class Derived"
   delete pd;
}
// compile with: /GR /EHsc

在模版中使用
template < typename T > T max( T arg1, T arg2 ) {
   cout << typeid( T ).name() << "s compared." << endl;
   return ( arg1 > arg2 ? arg1 : arg2 );
}

黄大�?/a> 2006-07-04 10:23 发表评论

Fri, 30 Jun 2006 09:23:00 GMT

摘要: // {7B55D765-68A6-404e-99E2-CA9ABC389A27} static const GUID IID_IUnknown9 = { 0x7b55d765 ... 阅读全文

黄大�?/a> 2006-06-30 17:23 发表评论

MFC�?windows object �?C++ object

Fri, 30 Jun 2006 03:33:00 GMT

The Problem

Windows objects are normally represented by HANDLEs. The MFC classes wrap Windows object handles with C++ objects. The handle wrapping functions of the MFC class library provide a way to find the C++ object that is wrapping the Windows object with a particular handle. There are times when a Windows object does not have a C++ wrapper object, however, and at these times a temporary object is created to act as the C++ wrapper.

mfc 映射�?windows object ---->c++ wrapper
以下使用 mfc 的函�?如：fromhandle, getdlgitem,都会�q�回temporary �?pemanent c++ wrapper object
注意�Q?br /> 零时�?对象会被在空闲时(OnIdle()函数)被删除，不能存下在下�ơ消息处理中使用
The default OnIdle processing in CWinThread automatically calls DeleteTempMap for each class that supports temporary handle maps
////////////////////////////////////////////////////////////
The Windows objects that use handle maps are:

HWND (CWnd and CWnd-derived classes)
HDC (CDC and CDC-derived classes)
HMENU (CMenu)
HPEN (CGdiObject)
HBRUSH (CGdiObject)
HFONT (CGdiObject)
HBITMAP (CGdiObject)
HPALETTE (CGdiObject)
HRGN (CGdiObject)
HIMAGELIST (CImageList)
SOCKET (CSocket)

///////////////////////////////////////////////

Given a handle to any of these objects, you can find the MFC object that wraps the handle by calling the static member function FromHandle. For example, given an HWND called hWnd:

CWnd::FromHandle(hWnd)

will return a pointer to the CWnd that wraps the hWnd. If that hWnd does not have a specific wrapper object, then a temporary CWnd is created to wrap the hWnd. This makes it possible to get a valid C++ object from any handle.

Once you have a wrapper object, you can get to its handle through a public member variable. In the case of a CWnd, m_hWnd contains the HWND for that object.

Attaching Handles to MFC Objects

Given a newly created handle-wrapper object and a handle to a Windows object, you can associate the two by calling Attach. For example:

CWnd myWnd;
myWnd.Attach(hWnd);
  ////mywnd 析构时会调用 destroywindow ,�q�同 hwnd 一起销�?br />

This makes an entry in the permanent map associating myWnd and hWnd.
Calling CWnd::FromHandle(hWnd) will now return a pointer to myWnd.
When myWnd is deleted, the destructor will automatically destroy the hWnd by calling the Windows DestroyWindow function. If this is not desired, the hWnd must be detached from myWnd before the myWnd object is destroyed (normally when leaving the scope at which myWnd was defined). The Detach member function does this.

myWnd.Detach();

More About Temporary Objects

Temporary objects are created whenever FromHandle is given a handle that does not already have a wrapper object. These temporary objects are detached from their handle and deleted by the DeleteTempMap functions. The default OnIdle processing in CWinThread automatically calls DeleteTempMap for each class that supports temporary handle maps. This means that you cannot assume a pointer to a temporary object will be valid past the point of exit from the function where the pointer was obtained, as the temporary object will be deleted during the Windows message-loop idle time.

很重�?
在多�U�程中传�?c++ wrapper object 是无效的(无论�?temporary �q�是 permanent)
只能传�?windows handle, 换句话就是说�Q?�U�程只能讉K�� 自己创徏的c++ wrapper object

Wrapper Objects and Multiple Threads

Both temporary and permanent objects are maintained on a per-thread basis. That is, one thread cannot access another threads C++ wrapper objects, regardless of whether it is temporary or permanent. As stated above, temporary objects are deleted when the thread which that temporary object belongs enters OnIdle.

To pass these objects from one thread to another, always send them as their native HANDLE type. Passing a C++ wrapper object from one thread to another will often result in unexpected results.

黄大�?/a> 2006-06-30 11:33 发表评论

Fri, 02 Jun 2006 07:43:00 GMT

1.容器
   ��序: vector(�c�M��动态增长数�l�） deque �Q�双端队列） list�Q�双头指针）
   兌��:set multiset(有重复） map   multiset�Q�有重复�Q?�Q�自动排序（内部2叉树�Q?br /> �Ҏ��预定义容器：stack, queue ,prority queue
2.�q�代�?br />      每种容器都提供了自己的�P代器�Q�相同的操作界面�Q�不同的内部实现�Q?br />   *,->,==,!=,++,--共同操作
     随机iterator : 支持 >�Q?lt;:如：vector, deque,string
    双向iterator:不支�?gt;,<:
   �Ҏ��预定义：
插入�q�代�?br />          insert iterator:引�v自动增长�Q�非覆盖
             back_inserter(container)
             front_inserter(container)
           inserter(container,pos)//调用 container.insert()//每种容器都具有insert()//兌��容器唯一
��P代器
             istream_iterator
             ostream_iterator
逆向�q�代�?br />容器中元素应满��Q?br />     有拷贝构造，赋��D��符�Q�析构能销�?br />   ��序�Q�默认构造应该可�?br />   兌��Q�必��L��排序准则
容器中是 ��g��是引�?br />
通用操作�Q?br />   containertype c;
ct c(c1);
ct   c(begin,end);
c.~ct();
c.size(), c.max_size(),c.empty(),c1==c2;c1c.inert(pos,elem);c.erase(begin,end),c.clear(),c.get_allocator

     3.vector
    动态增长数�l?在队��插入，删除效率�?br />注意动态增长时 �q�代器失�?内部可能要重配置
除了clear(),vector 不会自动�~�小
vector 的�P代器 ��是元素的native指针,�q�箋存储�Q��P代器是个random
�I�判�?br />       a.begin==a.end

4.list
   �q�代器是个双向的�Q�非�q�箋存储�Q�而且是个环状链表在尾端是个未初始化节�?br />�I�判�?br />   a.begin==a.end;
clear remove unique(把相同元素移出，留一�? insert
只能使用成员函数 sort�Q�不能��用算�?sort(他只接受random iterator)
5 .deque
动态增长的双端队列 �Q�但内部机制和vector 不一�?�Q�若�q�连�l�存储的集合
��法复杂度高�Q�如排序时可��?其复制到 vector中，�?��插�?删除效率高�?�Q?br />提供随机�q�代�?br />6.stack (container adapter)
先进后出�Q�不供�P代器�Q?不提供走访功�?br />7.queue(container adapter)
  先进先出�Q�不提供�q�代器，不提供走访功�?br />8.heap 辅助
   其内部�ؓ一个完�?叉树�Q�插入时自动排序�Q�一般�ؓmax_heap
   左右无序�Q�某节点 i, 父节点 i/2,左子节点 2i�Q�右子节�?2i+1�Q?br />

template inline   void make_heap(      RandomAccessIterator First,      RandomAccessIterator Last   )template inline   void sort_heap(      RandomAccessIterator First,      RandomAccessIterator Last   )template inline   void push_heap(      RandomAccessIterator First,      RandomAccessIterator Last   )template inline   void pop_heap(      RandomAccessIterator First,      RandomAccessIterator Last   )

             9.set,兌��容器 �Q�底层以rb-tree 实现�Q�其�q�代器�ؓ个const iterator
   不能用�P代器来改�?元素��|��~�省下以递增排序

黄大�?/a> 2006-06-02 15:43 发表评论

STL 乱学一�Q�原创）

Wed, 31 May 2006 08:53:00 GMT

摘要: 1 template < typename T1,typename T2 > 2 class mypair : public pair < T1,T2 > ... 阅读全文

黄大�?/a> 2006-05-31 16:53 发表评论

Wed, 31 May 2006 05:36:00 GMT

我在上篇中“盘点”了TCPL和D&E以及入门教程、高效和健壮�~�程、模板和泛型�~�程�{�方面共十几本C++好书。冬��L��来，让我们��l�C++书籍�_�ֽ�之旅J

标准库�?

当我�q�在研究院工作时�Q�与同院另外两家研究所合作开发过一个大型水利枢�U�调度集成项目。我们三家��Y件系�l�之间都要相互通信。在调试通讯模块�Ӟ��l�心的客��P��一名好学的�pȝ��理员）发现对于同一通信规约的解释代码，我的不超�q?0行，而对方的则超�q�了150行且很难看懂。这位系�l�管理员很纳��P��我说大家�~�程风格和习惯不一��P��我��用了标准库，而他使用了传�l�C�~�程风格以及他所习惯的另外一些技术。�?

别误会！我绝无贬低这位合作伙伴的意思。事实上�Q�我寚w��些真正有着深厚的C�~�程功力的程序员常常怀有钦佩之心。毕竟，C++能有今天的成功在很大�E�度上缘于它深深地植根于C。作��Z��名C++�E�序员，倘若不熟悉C++中的C�Q�我往往会认��Z��的基本功是不扎实的，他的技术底气是不��的。�?

不过话又说回来，C++是一�U�多范型�Q�paradigm�Q�编�E�语�a��Q�具体采用哪�U�编�E�风��|��专业�E�序员应该知道视具体情况而定。作��Z��名经帔R��要在现场做即兴开发的��目负责人，��Z��短��^快地解决当务之急，我习惯尽量采用现有的库（和组�Ӟ��。效率（以及强健性）久经验证的C++标准库已�l�摆在那儿了�Q�何乐而不用呢�Q��?

Nicolai M. Josuttis, The C++ Standard Library: A Tutorial and Reference
《C++标准�E�序库：自修教程与参考手册》，华中�U�技大学出版�C?

�q�是一本百�U�全书式的C++标准库著作，是一本需要一再查阅的参考大全。它在完备性、细致性以及精��性方面都是无与��u比的。本书详�l�介�l�了每一标准库组件的规格和用法，内容�늛�包括��和本地化在内的整个标准库而不仅仅是STL。正如本书副标题所�C�，它首先适合作�ؓ教程阅读�Q�尔后又可用作参考手册�?

��显易懂的写作风��g��得这本书非常易读。如果你希望学习标准库的用法�q�尽可能地发挥其潜能�Q�那你必��L��有这本书。正如网�l�上所�a��Q�这本书不仅仅应该摆在你的书��׃��Q�更应该攑ֈ�你的电脑桌上。我向每一位职业C++�E�序员强烈推荐�?

Angelika Langer, Klaus Kreft, Standard C++ IOStreams and Locales: Advanced Programmer's Guide and Reference
《标准C++输入输出��与本地化》，人民邮电出版�C?

C++标准库由STL、流和本地化三部分构成。关于STL的书市面上已�l�有不少�Q�但�|�见��和本地化方面的专著。本书是�q�两个领域中最优秀的一本，�q�今为止没有��M��一本书比这一本更全面详尽地讨��Z��和本地化。如果你不满��于停留在“会用”流库的层面�Q�千万不要错�q�它�?

2001�q�夏天，我草草翻阅过�q�本书的中文版，从内容到包装都给我留下了比较深刻的印�?�?不过负面的居多一些�?003�q�秋天，无意中得知某�|�络书店正以��低��h��甩卖�q�本书的中译本，情不自禁�Q�一阵唏嘘�?

Scott Meyers, Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library
《Effective STL�Q�媄印版�Q�》，中国电力出版�C?

��d��Scott 的《Effective C++》和《More Effective C++》的中译本之后，我一直期待这本书的中文版。我从潘爱民先生的个��Z��上了解刎ͼ�他和他的合作伙伴��g��早已完成了这本书的翻译工作，可惜至今市面上仍不得见。幸�q�的是，我们可以看到它的原版�?

本书是��用STL的程序员必读之作。在�q�本书中�Q�Scott向我们讲�q�STL容器和算法的工作机制以及如何以最��x��式��用它们。和Scott的其他作品一��P��q�本书的写作风格清晰、精��，��h��极佳的可��L��。看�q�这本书以后�Q�我想你也许会和我以及其他C++�E�序员一样��生这��L��x��Q�Scott什么时候会写出一本“More Effective STL”？

关于STL�Q�我�q�提醒你留心Matthew H. Austern的《Generic Programming and the STL: Using and Extending the C++ Standard Template Library》（《泛型编�E�与STL》，中国电力出版�C�）。这本书散发着��厚的学院气息。Andrew Koenig和Barbara Moo在《Accelerated C++: Practical Programming by Example》一书末��N��重推荐另外两本进阶好书（除了他们自己的《Ruminations on C++》外�Q�，其中一本是TCPL�Q�另外一本就是本书！

�|�络�~�程

在网�l�编�E�时代，C++应该扮演着怎样的角�Ԍ��让ACE�Q�Adaptive Communications Environment�Q�来告诉你�?

Douglas C. Schmidt, Stephen D. Huston, C++ Network Programming, Volume 1: Mastering Complexity with ACE and Patterns
Douglas C. Schmidt, Stephen D. Huston, C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks
《C++�|�络�~�程�Q�卷1�Q�运用ACE和模式消除复杂性》，华中�U�技大学出版�C?
《C++�|�络�~�程�Q�卷2�Q�基�?ACE 和框架的�pȝ��化复用》，电子工业出版�C?

采用C++�q�行企业�U�网�l�编�E�，目前ACE�Q�以及这两本书）是一个值得考虑的选择。ACE是一个面向对象、跨�q�_��、开放源码的�|�络�~�程框架�Q�目标在于构建高性能�|�络应用和中间�g。Douglas是ACE的创始�h�Q�Stephen则已为ACE提供了数�q�的技术支持和��N��服务�Q�两位都是ACE�C��Q�是的，ACE的媄响和实际应用的程度已�l��Ş成了一个社��）的专家�?

ACE�q�不单单被大学和研究所�q�捧�Q�它已经被成功地应用于世界上成千上万个商业应用中。在电信、宇航、医药和财经领域的网�l�系�l�中�Q�ACE已经�q��l�发挥着重要的作用。如果你准备开发高性能通讯�pȝ��Q�你应该考虑考虑�q�一汇集世界��尖专家智慧的成果�?

除了使用C++面向对象设计技术和模板�{�高�U�语�a��Ҏ��外�Q�ACE�q�运用了大量的模式。《C++�|�络�~�程》卷1和卷2�q�不仅仅教你关于ACE的方斚w��面，它还会教�l�你模式和通用框架设计�{�高�U�技术等。所以，作�ؓ一名中、高�U�C++�E�序员，即��你很��进行正儿八�l�的C++�|�络�E�序设计�Q�阅读这两本书同样可以从中受益�?

是的�Q��ƈ非所有网�l�应用都要��用Web服务器（以及其他应用服务器）和重量��l��g模型�Q�换个思�\�Q�它们或�怹�可以从轻量��的ACE�l��g中获益�?

杂项

以下�q�几本书之所以被列入“杂��”单元，只是因�ؓ我没有考虑出更合适的归类�Ҏ��Q�它们和上面的书�c�一��P��值得一诅R�?

Bruce Eckel, Thinking in C++, Volume 1: Introduction to Standard C++ (2nd Edition)
Bruce Eckel, Thinking in C++, Volume 2: Practical Programming (Second Edition)
《C++�~�程思想�Q�第2版）�W?��P��标准C++导引》，机械工业出版�C?
《C++�~�程思想�Q�英文版 �W?版）》，机械工业出版�C?

《Thinking in C++》的�W?版于1996�q�荣获“��Y件研发”杂志评选的图书震撼大奖。最新推出的�W?版对内容�q�行了大�q�改写和调整�Q�以反映C++标准化带来的影响以及�q�几�q�面向对象领域最新研�I�和实践成果。“输入输入流”、“多重��扎쀝、“异常处理”和“运行时�c�d��识别”等高��主题�q�同C++标准化以后增加的一些内容则被放入第二卷中。Bruce是一名经验丰富的C++讲师和顾问，其培训和写作�l�验都是世界一��水准，他的作品比那些“玩��”的技术�h员写的东西更能吸引读者。事实上�Q�在同类图书中，对于大多数读者而言�Q�这本书的可��L��要��过TCPL和《C++ Primer》。顺带一提，讉K��作者的站点�Q�你可以先睹�W�二��L��风采�?

Andrew Koenig, Barbara E. Moo, Ruminations on C++: A Decade of Programming Insight and Experience
《C++沉思录》，人民邮电出版�C?

Andrew是世界上屈指可数的C++专家。这是一本关于C++�~�程思想和程序设计技术而非语言�l�节的著作。如果你已经��h��一定的基础�Q�这本书��教你在�q�行C++�~�程时应该怎样思考，应该如何表达解决�Ҏ��。整本书技术表��N��彻�Q�文字通俗易懂。Bjarne�q�样评�h�q�本书：本书遍布“C++是什么、C++能够做什么”的真知��D��?

Stanley B. Lippman, Inside The C++ Object Model
《深度探索C++对象模型》，华中�U�技大学出版�C?
《深度探索C++对象模型�Q�媄印版�Q�》，中国电力出版�C?

从编译器的角度观察C++可以使你知其然�ƈ知其所以然。本书探讨了大量的C++面向对象�E�序设计的底层运作机�Ӟ��包括构造函数、函数、��时对象、��ѝ��虚拟、模板的实例化、异常处理、运行期�c�d��识别�{�，另外�q�介�l�了一些在实现C++对象模型�q�程中做出的权衡折衷。喜�Ƣ刨栚w��底的C++�E�序员不要错�q�这本书�?

Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns: Elements of Reusable Object-Oriented software
《设计模式：可复用面向对象��Y件的基础》，机械工业出版�C?
《设计模式：可复用面向对象��Y件的基础�Q�英文版�Q�》，机械工业出版�C?

设计可复用的面向对象的��Y�Ӟ��你需要掌握设计模式。本书�ƈ非专为C++�E�序员而写�Q�但它采用了C++�Q�以及Smalltalk�Q�作��Z��要示例语�a��Q�C++�E�序员尤其易于从中受益。四位作者都是国际公认的面向对象软�g领域专家�Q�他们将面向对象软�g的设计经验作��计模式详�l�记录下来。这本书影响是如此深�q�，以至于四位作者以及本书都被昵�U�CؓGoF�Q�Gang of Four�Q�。本书学院气息浓厚，行文风格严�}��z�，虽然它不如某些讲解模式的书籍易读�Q�但真正要精准地理解设计模式�Q�本书是�l�极权威。学习设计模式，�q�本书需要一而再、再而三的咀嚹{��顺带一句：请将设计模式化作开拓思维的钥匙，切莫成�ؓ��闭思维的枷锁�?

�q�有一些C++好书值得一读，恕此处无法一一列出。例如John Lakos的著作《Large-Scale C++ Software Design》（《大规模C++�E�序设计》，中国电力出版�C�）和侯捷先生的《STL 源码剖析》（华中�U�技大学出版�C�）�{��?

《STL 源码剖析》是一本很有特色的书，但我认�ؓ它还可以更好。我个�h期待侯捷先生自第一版发行以来经�q�对模板技术的沉淀和再思考之后，再写一本剖析得更深入、更透彻�q�且更全面的“第二版”。遗憄��是，侯捷先生在完成《C++ Templates: The Complete Guide》一书的��译后似乎决定暂时告别模�ѝ��泛型编�E�和STL领域�?

2004�q?�?1日补充：我目前最常查阅的两本参考书是《C++标准�E�序库》和《STL源码剖析》。当然了�Q�这与我�q�内的写作计划有很大的关�p�R�?

使用C++成功开发大规模软�g�pȝ��Q�不仅需要很好地理解大多数C++书籍中讲�q�的逻辑设计问题�Q�更需要掌握《大规模C++�E�序设计》中讲述的物理设计技术。当�Ӟ��q�本书的��有点过时了�Q�不�q�，如果你的�_�֊�和金钱都比较宽�Ԓ�Q�买一本看看�ƈ无坏处�?

��x��Q�我��x��必要声明一下，有一些（好）书没有得到推荐，主要原因如下�Q?

    * 以上�q�些书已�l��够多、��够好了�?
    * 我不会推荐通过正常渠道很难购买到的书籍 �?不管是中文版�q�是英文版�?
    * 作（译）者名气大��不影响我的推荐。我们是在看书，不是看�h�?
    * 我不会推荐我从来没有看过的书。我臛_��要看�q�其中的某个版本�Q�包括电子��Q�。这个“看”，一般指“认真阅诠Z��，不过有一些也只能��是“浏览”�?

�l�语

作�ؓ一名普通技术写译者，我深知技术创作和��译的艰辛（和快乐）�Q��ƈ多多��少了解一些有��x��术书�c�创作、翻译、制作、出版以及市场推介背后的�l�节。今天，我不会再对一本看上去差强人意的图书信口开沟뀂罗列同一本书的各�U�版本的用意只在于�ؓ你多提供一些信息，让你多一�U�选择�?

在本文成文的后期�Q�我�l�Bjarne写了一��信�Q�请教如果他来写�q�篇文章会怎么写。他�l�了我简明扼要的��。在肯定以上列出的绝大部分图书都是世界顶��水�q�的C++著作的同�Ӟ��Bjarne提醒我别忘了向专家��E�序员推荐《The C++ Standard : Incorporating Technical Corrigendum No. 1》。这本书�?C++标准规范的“图书版”，Bjarne亲自��Z��作序�?

Bjarne�q�友好地提醒我，在我的推荐列表中没有哪一本有助于C++�E�序员进行Windows�~�程 �?�q�正是我的本意。在�q�篇文章中，我只推荐、点评��^��C��立的C++著作�Q�网�l�编�E�除外） �?和操作系�l�无养I��和集成开发环境无养I��我甚臛_��惛_��们和�~�译器也无关。你可以�Ҏ��业务开发需要，选读自己喜爱的领域相关的C++书籍�?

说到“系�l�无兟뀁��^��C��立”，我不由得惌��v了“抽象层”的概念。开发实际应用的C++�E�序员通常工作于特定操作系�l�、特定开发环境和特定业务领域之中�Q�而对标准C++和C++标准库扎实而深�ȝ��把握�Q�无疑是你得以在不同的操作系�l�、不同的开发环境以及不同的业务领域之间�U�|��驰骋的“抽象”本钱。�?

黄大�?/a> 2006-05-31 13:36 发表评论

Wed, 31 May 2006 05:35:00 GMT

C++是一门广泛用于工业��Y件研发的大型语言。它自��n的复杂性和解决现实问题的能力，使其极具学术研究价值和工业价倹{��和C语言一��P��C++已经在许多重要的领域大获成功�?

然而，一个不可否认的现实是，在低阶程序设计领域，C++挤压着C同时也在承受着C的强烈反弹，而在高阶�E�序设计领域�Q�Java和C#正在不断蚕食着C++的地盘。也许C++与C合�ؓ一体永�q�都是一个梦惻I��也许Java和C#的狂潮终��迫使C++回归本位 �?回到它有着�Ҏ��性优势的开发领域：低��pȝ��E�序设计、高�U�大规模高性能应用设计、嵌入式�E�序设计以及数值科学计��等。果真如此，我认��未尝不是一件好事�?

C++吸引如此之多的智力投入，以至于这个领域的优秀作品�Q�包括重量��的��Y件��品、程序库以及书籍�{�，��C��胜数。文题“C++�E�序设计之四书五�l�”一个不太严格的含义是：C++�E�序设计之四�?�?五经。是的，在本文（及其下篇�Q�中�Q�我��分门别�c�L��?0多本C++好书�Q�你可以�Ҏ��自己的需要选读�?

TCPL和D&E

TCPL和D&E分别是《The C++ Programming Language》和《The Design and Evolution of C++》的��U�ͼ�均出自Bjarne Stroustrup之手。我��它们单列出来，首先是因为Bjarne是C++语言的创��，然后是因为比“首先”那个原因更重要的原因：�q�两本书是C++领域毋庸�|�疑的杰作。说它们是C++语言圣经�Q��ƈ不�ؓ�q��?

Bjarne Stroustrup, The C++ Programming Language (Special 3rd Edition)
《C++�E�序设计语言�Q�特别版�Q�》，机械工业出版�C?
《C++�E�序设计语言�Q�特别版�Q�（英文影印版）》，高等教育出版�C?

�q�今为止�Q�TCPL是除了C++标准文献之外最权威的C++参考手册。和大多��C�h的看法不大一��P��我认为Bjarne的文字语�a��q�不逊色于他所创徏的程序语�a��Q�至��我喜欢�q�种学院气息��厚的作品。本书对C++语言的描�q�轮廓鲜明、直截了当。它从C++语言创徏者的角度来观察C++�Q�这是�Q何别的作者和书籍做不到的 �?没有��M��人比Bjarne自己更清楚该怎么来��用C++�?

�q�是一本严肃的著作�Q�以中、高�U�C++开发�h员�ؓ目标读者。如果你是一名有�l�验的C++�E�序员，需要了解更加本质的C++知识�Q�本书正是�ؓ你而写。它不是那种让你看了会不断窃喜的��书�Q�需要用心体会，反复咀嚹{��在阅读�q�程中，��L��别留心Bjarne先生��了什么，又对什么一语带�q�。我个�h比较喜欢�q�本书的�W�四部分“��用C++做设计”，�q�样的内容在�c�M��的程序设计语�a�书籍中很隄��?�?我甚臌��为Bjarne应该��这部分独立出来单独写一本书�?

Bjarne Stroustrup, The Design and Evolution of C++
《C++语言的设计和演化》，机械工业出版�C?
《C++语言的设计和演化�Q�英文版�Q�》，机械工业出版�C?

D&E是一本关于C++语言设计原理、设计决�{�和设计哲学的专著。它清晰地回�{�了C++��Z��么会成�ؓ今天�q�个样子而没有变成另外一�U�语�a�。作为C++语言的创��，Bjarne淋漓��致地展�C�Z��他独到而深�ȝ��见解。除了广受赞誉的语言�Ҏ��外�Q�Bjarne没有回避那些引�v争议的甚臌��拒绝的C++�Ҏ��，他一一�l�出了逻辑严密、��o��Z��服的解释。内�Ҏ��盖C++的史前时代、带�cȝ��C、C++的设计规则、标准化、库、内存管理、多重��ѝ��模板等�Q�对包括异常机制、运行时�c�d��信息和名字空间在内的重要的新�Ҏ��都分别�q�行了深入探讨。每一名C++�E�序员都应该可以从Bjarne的阐释中加深�Ҏ��中这门语�a�的认识�?

需要再�ơ提醒的是，�q�两本书知识��羃�Q�信息量极大�Q�请不要错过Bjarne每一句看似�O不经意的话�?

入门教程

学习��M��一门语�a�都需要一个从入门到精通、从新手到高手��@序渐�q�的�q�程。不�q�，对于一个所谓的新手而言�Q�究竟是一个完完全全的新手�Q�还是一个熟悉某�U�别的语�a�的“新手”，甚至是在某种语言�E�序设计领域已经颇有建树的高手，很难一概而论�Q�不同的C++新手需要不同的入门书籍�?

Andrew Koenig, Barbara E. Moo, Accelerated C++: Practical Programming by Example
《Accelerated C++中文版》，中国电力出版�C?

和市面上大多数C++教程不同�Q�本书不是从“C++中的C”开始讲解，而是始于地道的C++�Ҏ��。从一开始就使用标准库来写程序，随着讲述的逐渐深入�Q�又一一解释�q�些标准库组件所依赖的基��概念。另外，和其他C++教材不同的是�Q�这本书以实例拉动语�a�和标准库的讲解，对后两者的讲解是�ؓ了给实例�E�序提供支持�Q�而不是像�l�大多数C++教材那样�Q�例子只是用作演�C��a��Ҏ��和标准库用法的辅助工具�?

作者在C++领域的编�E�实��c��教育培训以及技术写作方面都是世界一��水准。我喜欢�q�种大量使用标准库和C++语言原生�Ҏ��的清新的写作风根{��在�q�本教材面前�Q�几乎迄今�ؓ止的所有C++教材都黯然失色或昑־��q�时。尽��这本教材也许对于国内的高校教育来说有些前卫�Q�不�q�我仍然极力向我的同行们推荐。顺带一提，在Bjarne和我最�q�的一��通信里，他这栯��h��书：对于有经验的�E�序员学习C++而言�Q�这本书可能是世界上最好的一本�?

Stanley B.Lippman, Josee Lajoie, C++ Primer (3rd Edition)
《C++ Primer (3RD)中文版》，中国电力出版�C?

�q�本书的名字多少有点让�h误解。尽��作者声�U�这本书是�ؓC++新手而写�Q�但无论是它的厚度还是讲解的深度都暴露了��g��q��如此。也许说它是一本“从入门到精通”的C++教程会更合适一些。我个�h认�ؓ它�ƈ不适合完全不懂C++的初学�?�?在阅读这本书之前�Q�你臛_��应该先有那么一点C或C++的背景知识，或者至��要��h��一些其他语�a�的编�E�经验�?

��管�q�本书省略了一些高�U�C++�Ҏ��的讨论�Q�但仍然可以�U�得上是�q�今为止最全面的C++学习教程。事实上�Q�如果一名C++初学者能够扎扎实实地��d��本书�q�对照《C++ Primer Answer Book》完成全部习题的话，他的水��^肯定可以�q�入职业C++�E�序员的行列。我个�h认�ؓ�Q�即使你已经拥有了TCPL�Q�这本书依然有拥有的价��|��因�ؓ在许多方面它比TCPL来得更详�l�、更易懂�?

Stanley B. Lippman, Essential C++
《Essential C++中文版》，华中�U�技大学出版�C?
《Essential C++�Q�媄印版�Q�》，中国电力出版�C?

可以不太严格地认��本书是《C++ Primer》的�_��版。本书一一讲述了C++中最具代表性的主题�Q�包括过�E�式�~�程、泛型编�E�、基于对象编�E�、面向对象编�E�、模板编�E�以及异常处理等。Stanley��门槛调低到“具有其他语�a��E�序设计�l�验”的C++新手所能接受的最基本的层�ơ，使他们能够迅速开始��用C++�~�程而又免于阅读《C++ Primer》那��L��大部头。它以实例引导学习，力图使读者在最短的旉��内把握C++的精�_�V�?

也许换一个�h来概�q�C++�~�程范型�Q�paradigm�Q�的�Ҏ��面面需要好几百��|��能说清楚�Q�但�q�本��书不可思议地做��C��q�一炏V��我个�h非常喜欢�q�种满是技术、简明扼要�ƈ且“有话好好说”的书。这本书同样��h��一个明昄��风格�Q�所有程序例子全部采用标准库�l��g�Q�让��目一新�?

以上三本书都不是��Z��完完全全的编�E�新手而写。完全的C++�~�程新手可以阅读Francis Glassborow的新书（��未出版�Q�：《A Beginners Introduction to Computer Programming : You Can Do It!》。这也是Bjarne的推荐。Francis Glassborow是ACCU��d��Q�多�q�来他对几乎每一本C++�l�典名著评头��Q�他自己的这一本自然会引�vC++�C��的极大兴��?

高效、健壮编�E?

两年前我在负责一个省�U�电力调度系�l�项目时�~�写了一个网关程序，它从SCADA�pȝ��获取电力实时信息。通讯接口采用了不常用的数据库直连方式�Q�这个网关程序一端连接SQL Server 6.5�Q�另一端连接Oralce 8.1.6�Q�。由于实时测点近万，每次��全部取��h��新或插入一遍显然是低效的。我在网关程序里��Z��一个内存库�Q�获取到的数据首先在其中�q�行比较�Q�然后决定是否更新物理数据库�Q�同时还做了别的更复杂的事情……）�Q�从而在效率和资源占用两斚w��辑ֈ�了预期效果�?

�q�个�E�序一直运行得很好�Q�但在离开现场之后的某一天，�pȝ��理员打来电话，说大概因为网�l�故障等原因�Q�有时这个网关程序会崩溃�?�?它自己崩掉也��qŞ了，问题是它�q�会把Windows 2000 Advanced Server搞成“蓝屏”！坦白地说�Q�我�q�从来没看过哪个非蓄意的�E�序有这个“能耐”。由于当时正忙于另外一个大��目�Q�无法去现场调试�Q�最后只有凭�l�验对内存库代码��心��翼地封装以异常处理代码�Q�同时也做了一些别的修改……）。这��P��虽然没有��d��解决问题�Q�但�E�序�l�究不再��d��那么隄��了�?

在这儿讲�q�么一�D�花�i�有什么意思呢�Q�当初�ؓ那个可怕的bug朝思暮��x��我可不认��是一个“花�i�”）�Q�我惌��的是�Q�对于�Q何��Y件而言�Q�离开强健�Q�效率也��无从谈赗��而对于C++�E�序员来��_��也许�~�写一个高效的�E�序�q�不难，但要�~�写一个需�? �?24��时持箋�q�行的服务端软�g��׃��是那么容易了�Q�需要考虑许多因素�Q�有时这些因素甚臌��q�超出C++语言和开发工��L��本��n。作��Z��名开发实际项目��Y件的�E�序员，�q��非得自己��钉子才能积累经验，只要我们��_��虚心�Q�别人的�l�验往往都是我们很好的借鉴。鉴于此�Q�我推荐以下几本书供你选读�Q�它们可以让你从强健和效率两斚w��受益�Q�当然了�Q�它们涵盖的内容�q�不限于异常处理J�Q��?

Scott Meyers, Effective C++: 50 Specific Ways to Improve Your Programs and Design (2nd Edition)
Scott Meyers, More Effective C++: 35 New Ways to Improve Your Programs and Designs
《Effective C++中文版》，华中�U�技大学出版�C?
《More Effective C++中文版》，中国电力出版�C?
《Effective C++�Q�媄印版�Q�》，中国电力出版�C?

如果说《Effective C++》主要讨论C++中一些相对基��的概念和技巧的话，那么《More Effective C++》则着重探讨了包括异常处理在内的一�p�d��高��技术。与前者相比，后者具有两大主要区别：其一�Q�它包含很多时新的标准C++的内容；�W�二�Q�它讨论的主题們֐�于“战略化”而非“战术化”，�q�且讨论得更深入、更��d��。尤其是对虚析构函数、智能指针、引用计��C��及代理类�Q�proxy classe�Q�等技术和模式��的深入程度，让�h很难惌��是出��C��q�样的一本小书之中�?

游刃有余的技术，高超的写作技巧，Scott无疑是世界上最优秀的C++技术作家之一。在��z�、清晰、易�ȝ��斚w��Q�这两本书都卓尔不群。��M��Q�Scott提供的这85个可以改善编�E�技术和设计思维的方法，都是中、高�U�C++�E�序员必备的技能。我强烈推荐�q�两本书�Q�实际上�q�有一本，�E�后��׃��看到�Q��?

Herb Sutter, Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions
Herb Sutter, More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions
《Exceptional C++中文版》，中国电力出版�C?
《More Exceptional C++中文版》，华中�U�技大学出版�C?

你自认�ؓ是一名C++语言专家吗？��M��读ISO C++标准委员会秘书长的这两本书再回答。在�q�两本书中，Herb采用了“问�{�”的方式指导你学习C++语言�Ҏ��。对于每一个专题，Herb首先合理地设惛_��你的疑问和困惑，接着又猜��出你十有八九是错误的解�{�，然后�l�你以指点�ƈ提出最佌��x��案，最后还归纳��决类似问题的普适性原则�?

�q�两本书是典型的��q��C++语言�l�节的著作，很薄�Q�但内容密集�Q�远�q�超�q�Scott的那两本书，读�v来很费脑�{?�?我个��为它们要比Scott的书难懂得多。若要研习这薄薄的两本书所包含的知识，臛_��需要花�Ҏ��月的旉��Q�（在Scott的荐序中�Q�他坦陈不止一�ơ陷入GotW问题的陷阱，你应该知道这意味着什么）对于语言�l�节的深�I�有什么好处呢�Q�尽��在大多数情况下�Q�我们不必关心C++代码�q�后的动作，然而当我们不得不关心时�Q�这两本书可以�ؓ我们提供很好的线索，因�ؓ它们揭示了C++语言中微妙而又臛_��重要的东�ѝ�?

Stephen C. Dewhurst, C++ Gotchas: Avoiding Common Problems in Coding and Design
《C++�E�序设计陷阱》，中国青年出版�C?

Stephen的理论素��d��实践�l�验注定�q�是一本值得一�ȝ��好书。Stephen曄��是贝��实验室中第一批C++使用者。他已经使用C++成功解决了包括编译器、证�怺�易、电子商务以及嵌入式�pȝ��{�领域中的问题。本书汇集了作者来自开发一�U�的99条编�E�真知灼见，�z�悉它们�Q�你可以避免几乎所有常见的C++设计和编�E�问题�?

我甚臌��为，对于C++�~�程菜鸟而言�Q�阅读这本书会比阅读Scott和Herb的书更能��L��而立竿见影地获得更大的提高。我个�h很喜�Ƣ这本书的写作风�?�?Stephen的许多观点看似极端却无可辩驳。当然了�Q�这�U�自信（以及冷幽默）来自于作者深厚的技术素养，而非自大的偏执�?

除了上面推荐的书�c�外�Q�Dov Bulka�?David Mayhew合著的《Efficient C++: Performance Programming Techniques》（《提高C++性能的编�E�技术》，清华大学出版�C�）也值得一看。这本超薄小书聚焦于高性能C++应用�E�序开发。两位作者都是IBM软�g专家�Q�都工作于对性能要求极高的系�l�构建领域，本书是他们的�l�验之谈。也有�h不喜�Ƣ这本书�Q�因为它�׃��不少的篇�q�讲�q�和C++无关的东西，我却恰恰因�ؓ�q�一点而对�q�本书��生好感，正是�q�些东西让我开阔了眼界�?

模板和泛型编�E?

模板和基于模板的泛型�~�程无疑是当今发展最�z�跃的C++�E�序设计技术。模板的�W�一个革命性的应用是STL�Q�它��模板技术在泛型容器和算法领域的�q�用展现得淋漓尽��_��而Boost、Loki�{�现代程序库则将模板技术的潜能不断发挥到极致。在模板和泛型编�E�领域，我推荐以下两本重量��著作�Q?

David Vandevoorde, Nicolai M. Josuttis, C++ Templates: The Complete Guide
《C++ Templates全览�Q�繁体版�Q�》，台湾��峰资讯股䆾有限公司
《C++ Templates全览�Q�简体版�Q�》，人民邮电出版�C?

有一�U�老套的赞��一本书的手法，大致是“没有看�q�这本书�Q�你��怎么怎么地”，�q�里面往往夸张的成分居多。不�q�，倘若说“没有看�q�《C++ Templates: The Complete Guide》，你就不可能精通C++模板�~�程”，那么�q�个论断对于世界上绝大多数C++�E�序员来说是成立的�?

�q�本书填补了C++模板书籍领域由来已久的空白。此前，上有《Modern C++ Design》这��L��专注于模杉K��U�编�E�技术和泛型模式的著作，下有《The C++ Standard Library》这��L��针对特定模板框架和组件的使用指南。然而，假如�Ҏ��板机制缺乏深入的理解�Q�你��很�䏀�上下”自如。鉴于此�Q�我向每一位��望透彻理解C++模板技术的朋友推荐�q�本书�?

�q�本书在内地、台湑֐�有一个译本，但出自不同的译者之手。当你看到这��文章时�Q�两个译本应该都已经上市�Q�对于读者来说当然也��多了一�U�选择。侯捷先生个人网站上开放了�J�体译本大部分章节，不妨先睹为快�?

Andrei Alexandrescu, Modern C++ Design: Generic Programming and Design Patterns Applied
《C++设计新思维�Q�泛型编�E�与设计模式之应用》，华中�U�技大学出版�C?
《C++设计新思维�Q�媄印版�Q�》，中国电力出版�C?

你自认�ؓ是C++模板�~�程高手吗？��L��q�这本书再回�{�J �q�是一本出自天才之手��o人敬畏的��C��。泛型模式，无限延��你的视野�Q��以挑战�Q何一名C++�E�序员的思维极限�?

�q�本书共分�ؓ两大部分�Q�第一部分讨论�?Loki�E�序库采用的基础技术以及一些高�U�语�a��Ҏ��，包括��Z��{�略的类设计、模板局部特化、编译期断言、Typelist以及��型对象分配技术等。第二部分则着重介�l�了Loki中的重要�l��g和泛型模式技术，包括泛化仿函敎ͼ�Generalization Functor�Q�、单�Ӟ��Singleton�Q�、智能指针、对象工厂（Object Factory�Q�、抽象工厂（Abstract Factory�Q�、访问者（Visitor�Q�以及多�Ҏ��Q�Multimethods�Q�等。每一�U�技术都让�h大开眼界�Q�叹��止�?

在C++的学习方面，�q�犹不及往往成了不求甚解的借口。然而，面向对象�q��C++的全部，模板和泛型编�E�亦占半壁江山。对于“严肃”的C++�E�序员而言�Q�及时跟�q�这��Ҏ��l�例证的成功技术，不失为明��Z��举�?

�l�语

�q�些著作是如此大名鼎鼎，也许�Ҏ��不缺我一个推荐。然而，�U늄�C++�E�序员队伍的发展壮大速度不像其他更时髦的语言那样�q�速，��C�h�q��L��多于旧�h出。除了热忱地�Ƣ迎��C�h�Q�我个�h认�ؓ��C��对C++书籍�q�行“盘点”的时候了�Q��ƈ且希望这��L��“盘点”有益于感兴��的读者。请保持耐心和宽厚。在下篇中，我将�l�箋介绍标准库、网�l�编�E�以及其他方面的C++好书。有好书�怼��Q�这个冬天不会冷

黄大�?/a> 2006-05-31 13:35 发表评论

C++ STL��?转蝲)

Wed, 31 May 2006 02:01:00 GMT

C++ STL��?/td>
原创�Q?a >怒火之袍	2002�q?0�?8�?

一、STL��?/h3>
STL�Q�Standard Template Library�Q�标准模板库)是惠普实验室开发的一�p�d��软�g的统�U�。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。现在虽说它主要出现在C++中，但在被引入C++之前该技术就已经存在了很长的一�D�|��间�?/p>
STL的代码从�q�义上讲分�ؓ三类�Q�algorithm�Q�算法）、container�Q�容器）和iterator�Q��P代器�Q�，几乎所有的代码都采用了模板�c�d��模版函数的方式，�q�相比于传统的由函数和类�l�成的库来说提供了更好的代码重用��Z��。在C++标准中，STL被组�l��ؓ下面�?3个头文�g�Q?lt;algorithm>�?lt;deque>�?lt;functional>�?lt;iterator>�?lt;vector>�?lt;list>�?lt;map>�?lt;memory>�?lt;numeric>�?lt;queue>�?lt;set>�?lt;stack>�?lt;utility>。以下笔者就��单介�l�一下STL各个部分的主要特炏V�?/p>

二、算�?/h3>
大家都能取得的一个共识是函数库对数据�c�d��的选择对其可重用性�v着臛_��重要的作用。�D例来��_��一个求�Ҏ��的函敎ͼ�在��用��Q�Ҏ��作�ؓ其参数类型的情况下的可重用性肯定比使用整型作�ؓ它的参数�c�L��要高。而C++通过模板的机制允许推�q�对某些�c�d��的选择�Q�直到真正想使用模板或者说�Ҏ��板进行特化的时候，STL��利用了�q�一�Ҏ��供了相当多的有用��法。它是在一个有效的框架中完成这些算法的——你可以��所有的�c�d��划分为少数的几类�Q�然后就可以在模版的参数中��用一�U�类型替换掉同一�U�类中的其他�c�d��?/p>
STL提供了大�U?00个实现算法的模版函数�Q�比如算法for_each��ؓ指定序列中的每一个元素调用指定的函数�Q�stable_sort以你所指定的规则对序列�q�行�E�_��性排序等�{�。这样一来，只要我们熟悉了STL之后�Q�许多代码可以被大大的化��Q�只需要通过调用一两个��法模板�Q�就可以完成所需要的功能�q�大大地提升效率�?/p>
��法部分主要由头文�g�Q?lt;numeric>�?lt;functional>�l�成�?lt;algorithm>是所有STL头文件中最大的一个（��管它很好理解）�Q�它是由一大堆模版函数�l�成的，可以认�ؓ每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修攏V��移除、反转、排序、合�q�等�{��?lt;numeric>体积很小�Q�只包括几个在序列上面进行简单数学运��的模板函数�Q�包括加法和乘法在序列上的一些操作�?lt;functional>中则定义了一些模板类�Q�用以声明函数对象�?/p>

三、容�?/h3>
在实际的开发过�E�中�Q�数据结构本�w�的重要性不会逊于操作于数据结构的��法的重要性，当程序中存在着�Ҏ��间要求很高的部分�Ӟ��数据�l�构的选择��显得更加重要�?/p>
�l�典的数据结构数量有限，但是我们常常重复着一些�ؓ了实现向量、链表等�l�构而编写的代码�Q�这些代码都十分�怼��Q�只是�ؓ了适应不同数据的变化而在�l�节上有所出入。STL容器��׃ؓ我们提供了这��L��方便�Q�它允许我们重复利用已有的实现构造自��q��特定�c�d��下的数据�l�构�Q�通过讄��一些模版类�Q�STL容器�Ҏ��常用的数据结构提供了支持�Q�这些模板的参数允许我们指定容器中元素的数据�c�d��Q�可以将我们许多重复而乏味的工作��化�?/p>
容器部分主要由头文�g,,,,,�?lt;queue>�l�成。对于常用的一些容器和容器适配器（可以看作由其它容器实现的容器�Q�，可以通过下表�ȝ��一下它们和相应头文件的对应关系�?/p>

数据�l�构描述实现头文�?/font>

向量(vector) �q�箋存储的元�?/td>

列表(list) ��p��点组成的双向链表�Q�每个结点包含着一个元�?/td>

双队�?deque) �q�箋存储的指向不同元素的指针所�l�成的数�l?/td>

集合(set) ��p��点组成的�U�黑树，每个节点都包含着一个元素，节点之间以某�U�作用于元素对的谓词排列�Q�没有两个不同的元素能够拥有相同的次�?/td>

多重集合(multiset) 允许存在两个�ơ序相等的元素的集合

�?stack) 后进先出的值的排列

队列(queue) 先进先出的执的排�?/td>

优先队列(priority_queue) 元素的次序是�׃��用于所存储的值对上的某种谓词军_��的的一�U�队�?/td>

映射(map) 由{键，值}对组成的集合�Q�以某种作用于键对上的谓词排�?/td>

多重映射(multimap) 允许键对有相�{�的�ơ序的映��?/td>

四、�P代器

下面要说的�P代器从作用上来说是最基本的部分，可是理解��h��比前两者都要费力一些（臛_��W�者是�q�样�Q�。��Y件设计有一个基本原则，所有的问题都可以通过引进一个间接层来简化，�q�种��化在STL中就是用�q�代器来完成的。概括来��_��q�代器在STL中用来将��法和容器联�p��v来，��L��一�U�黏和剂的作用。几乎STL提供的所有算法都是通过�q�代器存取元素序列进行工作的�Q�每一个容器都定义了其本��n所专有的�P代器�Q�用以存取容器中的元素�?/p>

�q�代器部分主要由头文�?lt;utility>,�?lt;memory>�l�成�?lt;utility>是一个很��的头文�Ӟ��它包括了贯穿使用在STL中的几个模板的声明，中提供了�q�代器��用的许多�Ҏ��Q�而对�?lt;memory>的描�q�则十分的困难，它以不同��d��的方式�ؓ容器中的元素分配存储�I�间�Q�同时也为某些算法执行期间��生的临时对象提供机制,中的主要部分是模板类allocator�Q�它负责产生所有容器中的默认分配器�?/p>

五、对初学者学习STL的一点徏�?/h3>
对于之前不太了解STL的读者来��_��上面的文字只是十分概括地描述了一下STL的框�Ӟ��Ҏ��理解STL的机制乃至��用STL所起到的帮助微乎甚微，�q�不光是因�ؓ深入STL需要对C++的高�U�应用有比较全面的了解，更因为STL的三个部分算法、容器和�q�代器三部分是互相牵制或者说是紧密结合的。从概念上讲最基础的部分是�q�代器，可是直接学习�q�代器会遇到许多抽象枯燥和繁琐的�l�节�Q�然而不真正理解�q�代器又是无法直接进入另两部分的学习的（臛_��对剖析源码来说是�q�样�Q�。可以说�Q�适应STL处理问题的方法是需要花费一定的旉��的，但是以此��Z��P��STL取得了一�U�十分可�늚�独立性，它通过�q�代器能在尽可能��地知道某种数据�l�构的情况下完成对这一�l�构的运��，所以下军_��ȝ��STL的朋友们千万不要被一时的困难��d��。其实STL�q�用的模式相对统一�Q�只要适应了它�Q�从一个STL工具到另一个工��P��都不会有什么大的变化�?/p>
对于STL的��用，也普遍存在着两种观点。第一�U�认为STL的最大作用在于充当经典的数据�l�构和算法教材，因�ؓ它的源代码涉及了许多具体实现斚w��的问题。第二种则认为STL的初衷乃是�ؓ了简化设计，避免重复力_��Q�提高编�E�效率，因此应该是“应用至上”的�Q�对于源代码则不必深�I�。笔者则认�ؓ分析源代码和应用�q�不矛盾�Q�通过分析源代码也能提高我们对其应用的理解�Q�当然根据具体的目的也可以有不同的侧重�?/p>
最后要说的是，STL是ANSI/ISO C++标准的一部分�Q�所以对于一个可以有多种C++实现的过�E�，首先考虑的应该是STL提供的模板（高效且可�U�L��性好�Q�，其次才是各个厂商各自相应的库�Q�高效但可移植性不好）以及自己�ȝ��写代码（可移植性好但低效）�?/p>

黄大�?/a> 2006-05-31 10:01 发表评论

Sat, 27 May 2006 09:55:00 GMT

                              �q�几天看了下模板 �Q�以下是个�h的些心得�Q�高手见�W�了
1.�c�L���?实例 对象定义 引�v 实例�?br />                            指针�Q�引�?不会引�v实例�?br />�c�非型参敊W?只能�?整�Ş�Q�枚举，外联�l�，且应��Z��个常量编译时���应���定
                    ���点型，�cȝ��型，。。。都不可�?br />2.class templates 的成员函�?在调用和取地址时实例化�Q�在�c�d��例化时不会自动实例化
3.class templates 的友元申�?br />    a.非模版类�?br />          friend class man;
          friend void f(void);
           friend void man::f(void);
   b.一对一的模版友�?br />             friend class man;
             friend void f( man);
             friend void man::f();
    c.一对多的模版友�?br />          template 
               friend class man;
           template 
              friend void  f( T);
           template 
              friend void man::f();
4.�c�L��版的静态成�?
      �q�不在模版定义时实例化，在类模版实例化时实例化，对应1个类�?br />template 
int man::size=10;
而成员函数应�?br />  template 
   void man::f(void)
{
..........................................
}
5.成员模版 可以是普通类�?模版�c?br />如：
class woman                                             
{
public:
 template 
  class man
 {
 public:
  print(T a)
  {
   cout<    
  }

};
template
  void print(T2 a)
{
  cout< };
protected:
private:
};
                         1个好的例�?br />                           template    class A
                                {      public:
                                                      template
                                                      A&    operator =(const A & );
                               }
                               如此则A 的对�?可以用其他型的对象赋��g��
     在��用时才实例化
                                        但是其定义比较骇�?br />                         template
                                     template
                                     A& A::operator=(const A& a)
                                   { ...........................}

6.�c�L��版的特化
      特化1个类模板�Q�所有成员必��ȝ��化包括静态类数据成员(vc),但友元模板（1�Q?�Q�可�?br />不特化，当作一个显�C�实参的函数模板处理卛_��Q?�?特化1个模�?成员函数

         模板成员函数特化是定义必��d��现在实现文�g�Q�cpp)�?br />       语法�?br />    void man::f(void)
{
............................
}

�cȝ��?br /> template <>
class man
{
       ......//中所有类型参��C��int 替代
};

  man::man()
{
......
}

void man::f(void)
{
}
注意 �c�L��员中
   static const 有序�c�d��可以在体内初始化static const int a=10;
                        仅仅static 必须在体�?br />                                                               static int a;
                                                              int woman::a=10;
   �?特化
   template
   int man::size=10;
   特化
   int man::size=10;
7偏特�?br />   �c�L��板有1个以上模版参敎ͼ��c�d��参数�Q�非�c�d��参数�Q?br />              某些模版参数被实际的型和值取代（注意�?取代 �Q�不是增加，减少�Q?br />      如：

//////////////////头文�?br />       template
class wc
{
public:
wc()
{
  cout<<"\n int T1,T2, int";
}
protected:
private:
};
template
class wc
{
public:
wc()
{
  cout<<"\n in T *, T ,size";
}
protected:
private:
};
template
class wc
{
public:
wc()
{
  cout<<"\n in T* ,float,size";
}
protected:
private:
};
template
class wc
{
public:
wc()
{
  cout<<"\n in T* ,float,80";
}
protected:
private:
};
///////头文�?br />//////main()
wc wc1;
wc wc2;
wc wc3;
wcwc4;
///////main() ,在vc 7 上通过
//////main()

8.预设模板参数(只有在类模板中才指定 �Q? . 明确指定 a   ,直接定义�?man<> kkk;2. a )
template
class man
{
..........
}

写到�q�里�H�然惛_��
                  class A {
                            virtual void   print();
                              };
                  class B:public A {
                                          virtual void print();
                                          };
B b;
                 A *a =&b;
                a->print();//调用 B的，此时 print()中的this 指针是 B * const,使用B 的接口�?

9.双重模板参数�Q�很有用�Q?br />                template >
class baby
{
public:
baby ()
{
   cout<<"\n in baby";
}
protected:
private:
};//�c�d��参数可以�?�cȝ��?br />
baby > b; //ok
////////////////////////
template class TT>//可以省略�?template   class  TT>
class son
{
public:
   TT * a;
     son()
  {
           a=0;
   cout<<"\n in son";
  }
protected:
private:
};
   son b;//则就含有�?man * a;
TT 是模板占位符��P��是一个带1个类型参数的�c�L��板，如果其有默认模板参数则忽略掉
所以 GG若带默认的模�?应该如下
            template > class GG>
class son
{
}

/////////   �c�L��板类型参�?同时�q�可以是 �c�L��?br />
10. 字符串常量在模板中的注意事项

           char * a="hi ,friend ";///"hi, friend" 文字帔R�� ?const char [10] �c�d�� 左��D�{换到 const char *
限定转换�?char *,
                template       ostream& operator <<(ostream & os, const T & b)�Q?/注意只有const 才能接受临时变量

             cout<<"hi,friend";
              cout<<"bad";
/////2个不同的模板实例
   typeid(变量).name();///直接打印出变量类�?br />写到�q�，闲扯下：
    栈区�Q�堆区，全局�Q�静态）区，文字帔R��Q�代码区�Q?个大区，�q�个是我听说�?br />////////////////////////////////////////////////
11.模板的编译模�?br />     在实例化点必��能扑ֈ�定义//原则
                           只能使用包含模式了，
a..h. cpp 在�?h最后一行包含进 cpp
b. 全部在h �?cpp

                     分离模式,目前支持的export 关键字i的编译器很少�Q�vc.net 不支持）

12.
函数指针�c�d��也能做模板类型参�?br />

bool minn( int a, int b)
{
      return a < b;
}

template < typename T1,typename T2 >
     const T1 &   mymin( const T1 & t1, const T1 & t2, T2 t3 )
{
      return t3(t1,t2) ? t1:t2;
}
void main()
{
cout << mymin( 2 , 3 ,minn);
}

13.
模板参数可以是个�c�L��板 �?
template
class a
{
};
a< vector >;

template class con >
void add(con,con)
{
cout<<"ok";
}

add(a,b)//�Ҏ��在于需要推�?vc 7 可以从�?�c�L��板中推导出参数类�?/p>

template class con >
class ggoo
{
public:
con a;
con b;

protected:
private:
};

ggoo kk;//b, con 的模板参数可以�Q�?br />

黄大�?/a> 2006-05-27 17:55 发表评论

Sat, 27 May 2006 07:31:00 GMT

      template
T f(T a1,T a2)
{
.........................
}

昄��实参
f(1,2);
昄��实例�?br />template int f(int ,int);�Q�申明）
昄��特化
template <> int f (int,int)�Q�定义）
{

      ...........
}
强制从模版中挑�?br />
f<>(2,3);

在函数调用，取函数地址�?实参推演�Q�左��|��限定�Q�基�c�）
int (* p)(int ,int)=&f;     int(*p) (int ,int )=& f
f(2,3);                             f(2,3);
1.�~�译模版�Ӟ��~�译器检�?br />2.实例化时�Q�在实例化点再编译）�Q�编译器��?br />
函数模版只能出现在模版定义中
函数模版实例可以出现在模版定义和非定义中
//////////////////////
1.非模版函��C��先��?br />2.候�?--〉可行实例化�Q�有特化否〈）�Q�有非模版否�Q?-〉选中
3.依赖模版参数的在实例点解析，不依赖的在模版定义时解析

黄大�?/a> 2006-05-27 15:31 发表评论

const �?引用

Sat, 27 May 2006 06:21:00 GMT

   int & != int
   ////引用是一�U�类�?br />   const int ==int
///const 修饰在非引用 �?指针情况下�?不改变类�?br />   const int & != int &
   const int *   !=int *   ////只有 const �c�d�� 指针能接�?const �c�d�� 地址
  非引用类�?必须�_��匚w��
   float i=2.22f;
   int & p= i;///error
const int & p=i;//ok,零时对象,也就是说其可以接�?个右值或不匹配类�?br />   特别需要注�?非const引用必需是个�_��匚w��的左�?br />如�?
   const int a=100;
   const int * & p=& a//error,& a�?const int * , 但其地址是个叛_�?只有 const 才能接受��x��
   const int * const & p= &a//ok;不是对“const”的引用不能�l�定到非 lvalue
int a=10;
int *& b=&a///错误
int *const & b=&a;//ok
�?char * a="good";//"good" 是const char [5]�c�d��---->const char* 但�?�?a是char* ;�q�个是编译器的例�?br />
引用�Q�没有指针语法的指针�Q�非const引用只能接受左�?br />指针的引用相当于一个指针的指针�Q�常用于函数参数中来改变指针本��n的��|��外部同时也改变）
�?br />       void f(int *&p)
{
p=new int [5];//外部也改变了
}
             void f(int **p)
{
*p=new int [5];//外部也改�?br />}
                void f(int * p)
{
p=new int [5];//外部不改�?br />}
非const 指针都可以给void *;
void *p =(int) 0x3444;

黄大�?/a> 2006-05-27 14:21 发表评论