亚洲香蕉网久久综合影视,久久99久久99精品免视看动漫,久久久国产亚洲精品

关于寚w��

rikisand — Sun, 04 Apr 2010 08:00:00 GMT

数据寚w��Q�是指数据所在的内存地址必须是该数据长度的整数倍。处理器可以直接讉K��寚w��的数据，而访问未寚w��的数据会在内部进行一�p�d��的调��_��虽然可以正常处理�Q�但是会降低�q�行速度。例如一个处理器�ȝ��宽度�?4位，那么地址必须�?的倍数�Q�也��是一�ơ取�?个字节。如果我们可以保证所有double地址都�ؓ8的倍数�Q�那么可以用一个存储器操作来读或者写double了，否则我们可能需要执行两�ơ存储器讉K��Q�因为对象可能位于两�?字节存储器块�?/font>

对于�l�构体也是一��L��例如 struct s2{int i;int j;char c;}; 如果我们把这个结构打包成9个字节，只要保证起始地址满��4的对齐要求我们就可以保证i j的对齐，不过如果我们声明了一个数�l�，那么元素地址成�ؓ xd,xd+9,xd+18,xd+27 不满��_��齐了。因此我们呢要分�?2个字节给�q�个�l�构�?/font>

更进一�?�Q?/font>

未对齐的数据会以不同方式�l�cpu带来�ȝ��~

1.如果一个变量被划分��C��个缓存行�Q�那么我们需要访问两个缓存行才可以�?/font>

2.一些simd指��o��L��要求寚w��的指令，对于未对齐的指��o�Q�数据对齐也会媄响这些指令的使用�?/font>

rikisand 2010-04-04 16:00 发表评论

USACO 4.2.2 �W�一道网�l�流····

rikisand — Fri, 26 Mar 2010 05:04:00 GMT

Drainage Ditches
Hal Burch

Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by water for awhile and takes quite a long time to regrow. Thus, Farmer John has built a set of drainage ditches so that Bessie's clover patch is never covered in water. Instead, the water is drained to a nearby stream. Being an ace engineer, Farmer John has also installed regulators at the beginning of each ditch, so he can control at what rate water flows into that ditch.

Farmer John knows not only how many gallons of water each ditch can transport per minute but also the exact layout of the ditches, which feed out of the pond and into each other and stream in a potentially complex network. Note however, that there can be more than one ditch between two intersections.

Given all this information, determine the maximum rate at which water can be transported out of the pond and into the stream. For any given ditch, water flows in only one direction, but there might be a way that water can flow in a circle.

PROGRAM NAME: ditch

INPUT FORMAT

Line 1:
Two space-separated integers, N (0 <= N <= 200) and M (2 <= M <= 200). N is the number of ditches that Farmer John has dug. M is the number of intersections points for those ditches. Intersection 1 is the pond. Intersection point M is the stream.

Line 2..N+1:
Each of N lines contains three integers, S_i, E_i, and C_i. S_i and E_i (1 <= S_i, E_i <= M) designate the intersections between which this ditch flows. Water will flow through this ditch from S_i to E_i. C_i (0 <= C_i <= 10,000,000) is the maximum rate at which water will flow through the ditch.

SAMPLE INPUT (file ditch.in)

OUTPUT FORMAT

One line with a single integer, the maximum rate at which water may emptied from the pond.

SAMPLE OUTPUT (file ditch.out)

最基本的网�l�流

   1:  #include

   2:  #include

   3:  #include<string>

   4:  #include

   5:  #include

   6:  #include

   7:  #include

   8:  #include

   9:  #include

  10:  using namespace std;

  11:  const int MAXN = 220;

  12:  const int infi = 0x7FFFFFFF;

  13:   int capacity[MAXN][MAXN], prenode[MAXN], flow[MAXN];

  14:   queue<int> mq;

15:

  16:  int start, end, N;

  17:  void init(){

  18:      freopen("ditch.in","r",stdin);

  19:      //freopen("e:\\usaco\\ditch.in","r",stdin);

  20:      start = 1;

  21:      scanf("%d %d",&N,&end); int c, s, t;

  22:      memset(capacity,0,sizeof(capacity));

  23:      for(int i=0;i  24:      {
  25:          scanf("%d %d %d",&c,&s,&t);
  26:          capacity[c][s] += t; //两个节点间不只有一条�\
  27:      } 
  28:  }
  29:  int bfs(){//��L��增广路径
  30:      while(!mq.empty()) mq.pop(); 
  31:      mq.push(start);  //源节点入�?/span>
  32:      //memset(flow,0,sizeof(flow));
  33:      memset(prenode,-1,sizeof(prenode)); //重置前向节点
  34:      prenode[start] = 0; flow[start]=infi; //源节�Ҏ��量无限大
  35:      while(!mq.empty()){
  36:          int cur = mq.front(); 
  37:          mq.pop();
  38:          if(cur == end) break; //到达汇点�l�束路径 
  39:          for(int i=1;i<=end;i++){ 
  40:              if(prenode[i]==-1 && capacity[cur][i]) //讉K��当前节点所有未讉K��的相邻节点，更新flow
  41:              {
  42:                  prenode[i] = cur;
  43:                  flow[i] = (flow[cur]  44:                  mq.push(i);
  45:              }
  46:          }
  47:      }
  48:      if(prenode[end]==-1)  //如果未找到增�q��\径返�?1
  49:          return -1;
  50:      return flow[end];
  51:  }
  52:  int Edmonds_Karp(){
  53:      int total = 0, pathcapacity;//pathcapacity 路径增加�?/span>
  54:      while((pathcapacity = bfs()) != -1){//可以扑ֈ�增广路径时候进行��@�?/span>
  55:          int cur = end;    //从汇点开始增加逆向节点
  56:          while( cur != start ){
  57:              int t = prenode[cur] ;
  58:              capacity[t][cur] -= pathcapacity;
  59:              capacity[cur][t] += pathcapacity;
  60:              cur = t;
  61:          }
  62:          total += pathcapacity;//max_flow
  63:      }
  64:      return total;
  65:  }
  66:  void output(){
  67:      freopen("ditch.out","w",stdout);
  68:      //freopen("c:\\usaco\\ditch.out","w",stdout);
  69:      cout<  70:  } 
  71:     int main()
  72:  {
  73:      init();  
  74:      output();
  75:      return 0;
  76:  }

标程�Q��用贪心法�Q�寻找一条增�q��\径的时候不断寻找cap最大的�Q�未被访问的节点mloc�Q�然后更新跟mloc盔R��的节点flow�?/font>

及prenode信息.最后当�q�行到end时候，更新路径节点capacity�Q�同时增加max_flow.重复上述�q�程直到找不到增�q��\�?/font>

   1:  #include

   2:  #include <string.h>

3:

   4:  #define MAXI 200

5:

   6:  /* total drain amount between intersection points */

   7:  int drain[MAXI][MAXI];

   8:  int nint; /* number of intersection points */

9:

  10:  int cap[MAXI]; /* amount of flow that can get to each node */

  11:  int vis[MAXI]; /* has this node been visited by Dijkstra's yet? */

  12:  int src[MAXI]; /* the previous node on the path from the source to here */

13:

  14:  int augment(void)

  15:   { /* run a Dijkstra's varient to find maximum augmenting path */

  16:    int lv;

  17:    int mloc, max;

  18:    int t;

19:

  20:    memset(cap, 0, sizeof(cap));

  21:    memset(vis, 0, sizeof(vis));

22:

  23:    cap[0] = 2000000000;

  24:    while (1)

  25:     {

  26:      /* find maximum unvisited node */

  27:      max = 0;

  28:      mloc = -1;

  29:      for (lv = 0; lv < nint; lv++)

  30:        if (!vis[lv] && cap[lv] > max)

  31:         {

  32:          max = cap[lv];

  33:      mloc = lv;

  34:         }

  35:      if (mloc == -1) return 0;

  36:      if (mloc == nint-1) break; /* max is the goal, we're done */

37:

  38:      vis[mloc] = -1; /* mark as visited */

39:

  40:      /* update neighbors, if going through this node improves the

  41:         capacity */

  42:      for (lv = 0; lv < nint; lv++)

  43:        if (drain[mloc][lv] > cap[lv] && max > cap[lv])

  44:         {

  45:          cap[lv] = drain[mloc][lv];

  46:      if (cap[lv] > max) cap[lv] = max;

  47:      src[lv] = mloc;

  48:         }

  49:     }

  50:    max = cap[nint-1];

51:

  52:    /* augment path, starting at end */

  53:    for (lv = nint-1; lv > 0; lv = src[lv])

  54:     {

  55:      t = src[lv];

  56:      drain[t][lv] -= max;

  57:      drain[lv][t] += max;

  58:     }

  59:    return max;

  60:   }

61:

  62:  int main(int argc, char **argv)

  63:   {

  64:    FILE *fout, *fin;

  65:    int lv;

  66:    int num;

  67:    int p1, p2, c;

68:

  69:    if ((fin = fopen("ditch.in", "r")) == NULL)

  70:     {

  71:      perror ("fopen fin");

  72:      exit(1);

  73:     }

  74:    if ((fout = fopen("ditch.out", "w")) == NULL)

  75:     {

  76:      perror ("fopen fout");

  77:      exit(1);

  78:     }

79:

  80:    fscanf (fin, "%d %d", &num, &nint);

  81:    while (num--)

  82:     {

  83:      fscanf (fin, "%d %d %d", &p1, &p2, &c);

  84:      p1--;

  85:      p2--;

  86:      drain[p1][p2] += c; /* note += handles two ditches between same points */

  87:     }

88:

  89:    /* max flow algorithm: augment while you can */

  90:    c = 0;

  91:    while ((p1 = augment()))

  92:      c += p1;

  93:    fprintf (fout, "%d\n", c);

  94:    return 0;

  95:   }

rikisand 2010-03-26 13:04 发表评论

深入探烦C++对象模型��M��W�记 (�?

rikisand — Thu, 25 Mar 2010 13:09:00 GMT

最后一章~~拖了几天�Q�得赶紧��C��了~~

名字�Q?On the cusp of the object model

7.1 Template

Template用的很少�Q�这节中的有些东西比较晦涩，挑一些能理解的记下吧。剩下的�{�用的多了再回头来看�?/font>

Template的具现行�?template instantiation

Template class Point{

public: enum Status{unallocated,normalized};Point(T x=0.0,T y=0.0);

~Point() ; void * operator new(size_t);private:static Point *freelist

static int chunksize; T _x,_y;

};

�~�译器看到这��L��声明�Q�会有什么动作？�Q?/font>

没有。static data 不可�?enum 不可�?�Q�enum虽然�c�d��固定�Q�但他只能和template point class 的某个实体来存取或操作。我们可�?point::Status s;

但是不能 point::status s; 因此我们可能��x��enum抽离��C��个非模板�c�M��避免多重拯��。同样道理，freelist 和chunksize对于�E�序而言也不可用。必��L��指定point::freelist.也就是说静态数据成员是和特定类型的�cȝ��定的而不是泛型的模板�c�R��但是如果定义一个指针不一定会��L��出相应的�c�，因�ؓ一个指针，�q�不一定指向一个class object。编译器不需要知道该class 相应的�Q何member 或者数据或�?/font>

内存布局�Q�所以没有必要具现。但是如果是定义�q�初始化一个引用就真的会具现出一个实体，因�ؓ不存在空引用�?/font>

成员函数�q�不应该被实体化�Q�只有当他被调用的时候才需要被��L��出来�?/font>

template

class mumble{

public: Muble(T t=1024):tt(t){ if(tt!=t)throw ex; }

private: T tt;

};

上面的模板中出现错误有，t=1024 不一定成功，!= 不一定定�?/font>

�q�两个错误只有到��L��操作�l�合具体�c�d��才能��定出来

�~�译器面对一个template声明�Q�在他被一�l�实际参数具��C��前，只能实行以有限地错误��查，只有特定实体定义之后�Q�才会发��C��些与语法无关的但是十分明昄��错误�Q�这是技术上的一大问题�?/font>

Template 的名�U�决议方�?/font>

.h文�g定义

void out(int x){
    cout<<"out_by_class_define_scrope"<}
template
class A{
public:
    void test1(){
        out(m1);
    }
    void test2(){
        out(m2);
    }
private:
    int m1;
    type m2;
};
.cpp文�g定义
void out(double x){
    cout<<"out_by_class_instantiation_scrope"<}

int main(�Q?br>{
    A a;
    a.test1();
    a.test2();

}

按照书中的说法，如果一个函敎ͼ�参数�c�d��和type无关的话�Q�应该取他的scope of template declaration中定义的函数�Q�而反之取在他的instantiation中的那个。事实上在测试中发现

MSVC �?�Q�函数定义的册��是依照类型的�Q�如果有合适的函数比如type是double�Q�此时如果定义处或者具现处有double型的函数定义�Q�那么函数就会决议�ؓ那一个定义的~~~

MEMber function的具现行为：

�~�译器如何确保只有一个vtable产生�Q?一�U�方法是每一个virtual func地址都放在vtable中，如果取得函数地址�Q�则表示virtual func 的定义必然出现在�E�序的某个地点，否则�E�序无法�q�接成功。此外该函数只能有一个实体，否则也是�q�接不成功。那么，��把vtable攑֜�定义了该class的第一个non-inline�Q�nonpure virtual function的文件中吧。。（not so clear�Q?/font>

在实现层面上�Q�template ��g��拒绝全面自动化，以手动方式在个别的object module中完成预先的��L��工作是一�U�有效率的方法�?/font>

7.2异常处理

��Z��l�持执行速度�Q�编译器可以在编译时期徏立�v用于支持的数据结�?/font>

��Z��l�持�E�序大小�Q�编译器可以在执行期建立数据�l�构

c++ eH 主要�׃��个部分构成：

throw语句

catch语句

try语句�Q�这些语句可能触发catch子句起作�?/font>

一个exception 被抛出时候，控制权会从函数调用释攑և�来，�q�寻找一个吻合的catch�Q�如果没有那么默认的处理例程terminate()会被调用�Q�控制权攑ּ�后，堆栈中的每一个函数调用也被推��R��每一个函数被推离堆栈的时候，函数的local class object 的dtor也会被调用�?/font>

在程序不同段里，�׃��声明不同的变量，一个区域可能因为在区域内发生exception的处理方式不同分成多个区�D�c�?/font>

在程序员层面�Q�eh也改变了函数在资源上的管理。例如下面函��C��更含有对一块共享内存的locking和unlocking操作 �Q?/font>

void mumble(void * arena){

Point *p= new point ;

smlock(arena) ;

//�?.如果此时一个exception发生�Q�问题就产生�?/font>

sumunlock(arena);

delete p;

}

从语义上�Ԍ��我们在函数退出堆栈之前，需要unlock�׃�n内存�q�delete p�Q�我们需要这样做�Q?/font>

try{smlock(arena)} catch(�?{

    smunlock(arena); delete p; throw;

}

new不需要放在try�D�里�Q�因为，如果new发生了exception�Q�heap中的内存�q�没有分配，point的ctor没有调用�Q�如果在ctor中exception�Q�那么piont的�Q何构造好的合成物也会自动解构掉，heap也会自动释放掉�?/font>

处理�q�种资源��理问题�Q�徏议：把资源需求封装在一个class object 体内�Q��ƈ由dtor释放资源.

auto_ptr ph (new point); smlock sm(arena);//如果此时exception 没有问题

// 不需要明��的unlock 和delete

// local dtor 会在�q�里被调�?sm.SMlock::~smlock(); ph.auto_ptr::~auto_ptr

Exception handling 的支持：

1.��验发生throw操作的函�?/font>

2.军_��throw是否发生在try区段�?/font>

3.如果是编译器必须把exception type 拿来和catch比较

4.��d��的话控制权交�l�catch

5.如果throw不发生在try�D�|��者没有吻合的�Q�系�l�会摧毁所有active local object b从堆栈把当前函数unwind�?�Q�蟩出到�E�序堆栈的下一个函数去�Q�然后重复上�q�步�?/font>

当一个实际对象在�E�序执行时被抛出�Q�exception object会被产生出来�q��常攑֜�相同形式的exception 数据堆栈中�?/font>

catch(expoint p){

   //do sth

   throw;

}

以及一个exception object �c�d��?exVertex �z��?expoint �Q�这两种�c�d��都吻合，catch会怎么�?/font>

以exception object作�ؓ初��|��像函数参��C��样会有一个local copy�Q�如果p是一个object而不是一个reference �Q�内容被拯��的时候，�q�个object的非expoint部分会被切掉�Q�如果有vptr 会被讑֮�为expoint的vptr�Q�如果被再次丢出呢？丢出p需要再产生另外一个exception 临时对象�Q�丢出原来的异常 �Q�之前的修改�l�统作废。但是如�?catch(expoint& p);怎么样呢�?��M��对这个object的改变都会繁�D�到之后的catch语句怅R�?/font>

c++ �~�译器�ؓ了支持EH付出的代��h��大，某种�E�度是因为执行期的天性以及对底层��g的依赖�?/font>

7.3 RTTI

RTTI是Except handling的一个附属��品，因�ؓ我们需要提供某�U�查询exception objects的方法，用来得到exception的实际类型�?/font>

在向下�{型问题上�Q�如果要保证其安全性，那么必须在执行期�Ҏ��针有所查询�Q�看看它到底指向什么类型的对象。那么我们需要额外的�I�间存储�c�d��信息�Q�通常是一个指针，指某个类型信息节炏V�?/font>

需要额外的旉��以决定执行期的类型�?/font>

冲突发生在：

1.�E�序员大量的使用了多収ͼ��q��要大量的downcast操作

2.�E�序员��用内建的数据�c�d��和非多态，他不需要额外负担带来的便利

那么如何了解�E�序员的需要呢�Q�？ �{�略是一个具有多态性性质的class�Q�也��是��h��内涵�l�承或者声�?virtual func的类需要rtti支持�?/font>

�q�样所有多态类�l�护一个vptr。额外负担降低到�Q�每一个class object多花费一个指针，指针只被讑֮�一�ơ，而且是编译器静态设定�?/font>

down_cast

if(pfct pf = dynamic_cast< pfct >(pt))�?

((type_info*)(pt->vptr[0]))->type_descripter;

Reference --------Pointer

dynamic_cast执行在ptr�?��p�|�q�回0�Q�如果实行在ref上。由于ref不能被赋予null�Q�也��是没有�I�引用。如果我们把一个ref设�ؓ0会引发��时对象��生，然后�?初始化它�Q��ref成�ؓ�q�个临时对象的别名。因此此时失败了会��生一个bad_cast exception�?/font>

typeid的参数可以��引用�Q�对象或者是�c�d��

事实上，type_info 也适用内徏�c�d��Q�这对于eh机制有必�?/font>

例如 int ex_errno; throw ex_errno;

其中int�c�d�� int *ptr; if(typeid(ptr) == typeid(int*));

----------------------全书�W�记到此�l�束 --------------------------------s

rikisand 2010-03-25 21:09 发表评论

重蝲操作�W?(c++primer 4e)

rikisand — Mon, 15 Mar 2010 08:40:00 GMT

1.为啥要重载操作符�Q?/font>

通过重蝲操作�W�，�E�序员可以针对“类”类型的操作数定义不同的操作�W�版本。良好的操作�W�定义可以��class�c�d��的��用想内置�c�d��一��L��观简�z�，使用重定义的操作�W�而不是命名函��C��得程序可以用表达式代替函数调用，使程序编写和阅读更容易~

2.哪些不能重蝲

:: .* . ?: �q�些不能重蝲

3.需要注意的地方�Q?/font>

重蝲必须有一个class�c�d��的操作数�Q�短路求值失去，

重蝲操作�W�和内置操作�W�结合型相同�Q�优先��操作��C��数均相同

不要重蝲一些含有内�|�定义的操作�W?& , && || �q�些

·赋��|��=�Q�下标（【】）调用 �Q�（�Q�）和成员访问操作符必须定义为成�?/font>

·对称的操作符一般定义�ؓ普通非成员函数

++ -- 一般设�|��ؓ成员函数 �Q�因为可能改变对象状�?/font>

4.定义输入输出操作�W?/font>

io操作�W�只能重载�ؓ非成员函敎ͼ�否则做操作符只能是对象成�?用法变成�?object<

输入必须加入文�g�l�束和输入错误的错误处理

istream&
operator>>(istream& in, Sales_item& s)
{
     double price;
     in >> s.isbn >> s.units_sold >> price;
     // check that the inputs succeeded
     if (in)
        s.revenue = s.units_sold * price;
     else
        s = Sales_item(); // input failed: reset object to default state
     return in;
}
如果输入��p�|�Q�调用默认构造函数恢复对象状态�?/font>

5.��术�q�算�W�和关系�q�算�W?/font>

Sales_item& operator -=(const Sales_item& item){
    units_sold-=item.units_sold;
    revenue-=item.revenue;
    return *this;
}
Sales_item operator - (const Sales_item& lhs,const Sales_item& rhs){
    Sales_item res(lhs);
    res+=rhs;
    return res;
}

一般算术运��符讄��为非成员函数�Q�与内置�q�算�W�对应，选择�q�回value 而不是引用。赋��D��符重蝲为成员函敎ͼ��q�用它来实现��术�q�算�W�，�q�样��术�q�算�W�不用friend

相等�q�算�W�和不等�q�算�W�一般成对出玎ͼ�且用一个实现另一�?/font>

关系�q�算�W?== != > < 一般重载成非成员函�?/font>

6.赋值操作符

必须为成员函�?�Q?��P��

=�?= -= 一般都需要返回左操作数的引用

Sales_item& operator = (string is){
isbn = is;
return *this;
}

6.下标操作�W?/font>

必须为类成员函数   �q�回引用使其可以在赋值操作的��L��一�?/font>
一般定义一�U�const �q�回帔R��引用一�U�not const 引用
class Foo { public: int &operator[] (const size_t); const int &operator[] (const size_t) const; // other interface members private: vector data; // other member data and private utility functions };

int& Foo::operator[] (const size_t index)
     {
         return data[index]; // no range checking on index
     }
     const int& Foo::operator[] (const size_t index) const
     {
         return data[index]; // no range checking on index
     }

pari& operator[] (const vector< pair* > ::size_type index){
return *wait_list.at(index);//使用at判断是否��界
}

6.成员讉K��操作�W?/font>

-> 一般要求重载�ؓ成员�q�算�W�，*没有要求 ,但成员比较常见~~~

例子�Q�auto-ptr~~~~

ScreenPtr 的用户将会传递一个指针，该指针指向动态分配的 Screen�Q?tt>ScreenPtr �c�d��拥有该指针，�q�安排在指向基础对象的最后一�?ScreenPtr 消失时删除基��对象。另外，不用�?ScreenPtr �c�d��义默认构造函数。因此，我们知道一�?ScreenPtr 对象��L��指向一�?Screen 对象�Q�不会有未绑定的 ScreenPtr�Q�这一点与内置指针不同。应用程序可以��?ScreenPtr 对象而无��首先测试它是否指向一�?Screen 对象�?/font>

     // private class for use by ScreenPtr only �U�有�c�，
     class ScrPtr {
         friend class ScreenPtr;
         Screen *sp;
         size_t use;
         ScrPtr(Screen *p): sp(p), use(1) { }
         ~ScrPtr() { delete sp; }
     };
        /*
      * smart pointer: Users pass to a pointer to a dynamically allocated Screen, which
      *                   is automatically destroyed when the last ScreenPtr goes away
      */
     class ScreenPtr {
     public:
         // no default constructor: ScreenPtrs must be bound to an object
         ScreenPtr(Screen *p): ptr(new ScrPtr(p)) { }
         // copy members and increment the use count
         ScreenPtr(const ScreenPtr &orig):
            ptr(orig.ptr) { ++ptr->use; }
         ScreenPtr& operator=(const ScreenPtr&);
         // if use count goes to zero, delete the ScrPtr object
         ~ScreenPtr() { if (--ptr->use == 0) delete ptr; }
     private:
         ScrPtr *ptr;    // points to use-counted ScrPtr class
     };
指针支持的基本操作有解引用操作和��头操作。我们的�c�d��以这样定义这些操作：
     class ScreenPtr {
     public:
         // constructor and copy control members as before
         Screen &operator*() { return *ptr->sp; }
         Screen *operator->() { return ptr->sp; }
         const Screen &operator*() const { return *ptr->sp; }
         const Screen *operator->() const { return ptr->sp; }
     private:
         ScrPtr *ptr; // points to use-counted ScrPtr class
     };
解引用操作符是个一元操作符。在�q�个�c�M��Q�解引用操作�W�定义�ؓ成员�Q�因此没有显式�Ş参，该操作符�q�回�?ScreenPtr 所指向�?Screen 的引用�?/font>
��头操作�W�不接受昑ּ�形参。point->action(); �{��h�?nbsp; (point->action)();

可以�q�样使用 ScreenPtr 对象讉K�� Screen 对象的成员：
ScreenPtr p(&myScreen); // copies the underlying Screen p->display(cout);

因�ؓ p 是一�?ScreenPtr 对象�Q?tt>p->display 的含义与�?(p.operator->())->display 求值相同。对 p.operator->() 求值将调用 ScreenPtr �cȝ�� operator->�Q�它�q�回指向 Screen 对象的指针，该指针用于获取�ƈ�q�行 ScreenPtr 所指对象的 display 成员�?/font>
重蝲��头操作�W�必��返回指向类�c�d��的指针，或者返回定义了自己的箭头操作符的类�c�d��对象�?/font>

6.自增自减操作�W?/font>

一般重载�ؓ成员函数�Q��ؓ了与内置�c�d��一��_��前置操作�W�返回运��结果引用，后置操作�W�返回运��前的��|��value not ref �Q��ؓ了区分，后置操作�W�提供了一个实�?�Q?/font>

// prefix: return reference to incremented/decremented object
    CheckedPtr& CheckedPtr::operator++()
    {
        if (curr == end)
            throw out_of_range
                  ("increment past the end of CheckedPtr");
        ++curr;                // advance current state
        return *this;
    }
CheckedPtr CheckedPtr::operator++(int)
     {
         // no check needed here, the call to prefix increment will do the check
         CheckedPtr ret(*this);        // save current value
         ++*this;                      // advance one element, checking the increment 用前�|�实现它�Q�不用判断出界了
         return ret;                   // return saved state
     }
昑ּ�调用�Q?/font>
CheckedPtr parr(ia, ia + size);        // iapoints to an array of ints
parr.operator++(0);                    // call postfix operator++
parr.operator++();                     // call prefix operator++

7 调用操作�W�和函数对象

struct absInt {
       int operator() (int val) {
           return val < 0 ? -val : val;
       }
   };

通过为类�c�d��的对象提供一个实参表而��用调用操作符�Q�所用的方式看�v来像一个函数调用：
     int i = -42;
     absInt absObj; // object that defines function call operator
     unsigned int ui = absObj(i);     // calls absInt::operator(int)
函数调用操作�W�必��d��明�ؓ成员函数。一个类可以定义函数调用操作�W�的多个版本�Q�由形参的数目或�c�d��加以区别�?/font>
定义了调用操作符的类�Q�其对象常称为函数对象，卛_��们是行�ؓ�c�M��函数的对象�?/font>
函数�Q?/font>
     // determine whether a length of a given word is 6 or more
     bool GT6(const string &s)
     {
         return s.size() >= 6;
     }
函数对象�Q?/font>

// determine whether a length of a given word is longer than a stored bound
     class GT_cls {
     public:
         GT_cls(size_t val = 0): bound(val) { }
         bool operator()(const string &s)
                            { return s.size() >= bound; }
     private:
         std::string::size_type bound;
     };
for (size_t i = 0; i != 11; ++i)
     cout << count_if(words.begin(), words.end(), GT(i))
          << " words " << i
          << " characters or longer" << endl;
函数对象的便��h��?/font>
         plus intAdd;         // function object that can add two int values
     negate intNegate;   // function object that can negate an int value
     // uses intAdd::operator(int, int) to add 10 and 20
     int sum = intAdd(10, 20);          // sum = 30
     // uses intNegate::operator(int) to generate -10 as second parameter
     // to intAdd::operator(int, int)
     sum = intAdd(10, intNegate(10));    // sum = 0
函数适配器：
banding器，它通过��一个操作数�l�定到给定��D��将二元函数对象转换��Z��元函数对�?/font>
求反器是一�U�函数适配器，它将谓词函数对象的真值求反。标准库定义了两个求反器�Q?tt>not1 �?not2 分别求反一元二元对�?/tt>

8。实参匹配和转换�Q�俺来看重蝲操作�W�的原因啊，�Q�，�Q?/font> 转换操作�W�是一�U�特�D�的�c�L��员函数。它定义��类�c�d��D�{变�ؓ其他�c�d��值的转换。�{换操作符在类定义体内声明�Q�在保留�?operator 之后跟着转换的目标类型：转换函数采用如下通用形式�Q?/font> operator type(); 转换函数必须是成员函敎ͼ�不能指定�q�回�c�d��Q��ƈ且�Ş参表必须为空�?/font> 虽然转换函数不能指定�q�回�c�d��Q�但是每个�{换函数必��L��式返回一个指定类型的倹{��例如，operator int �q�回一�?int ��|��如果定义 operator Sales_item�Q�它��返回一�?Sales_item 对象�Q�诸如此�c�R�?/font> 转换函数一般不应该改变被�{换的对象。因此，转换操作�W�通常应定义�ؓ const 成员�?/font> 只要存在转换�Q�编译器��在可以使用内置转换的地方自动调用它 In expressions: 在表辑ּ�中： SmallInt si; double dval; si >= dval // si converted to int and then convert to double In conditions: 在条件中�Q?/font> if (si) // si converted to int and then convert to bool When passing arguments to or returning values from a function: ��实参传�l�函数或从函数返回��|�� int calc(int); SmallInt si; int i = calc(si); // convert si to int and call calc As operands to overloaded operators: 作�ؓ重蝲操作�W�的操作敎ͼ� // convert si to int then call opeator<< on the int value cout << si << endl; In an explicit cast: 在显式类型�{换中�Q?/font> int ival; SmallInt si = 3.541; // instruct compiler to cast si to int ival = static_cast(si) + 3; �cȝ��型�{换之后不能再跟另一个类�c�d��转换。如果需要多个类�c�d��转换�Q�则代码��出错。（指的是不能连�l�两个自定义的类型�{换，但是内置�c�d��转换可以的） �q�有一部分是实参匹配和转换 �Q�没旉��?以后再看~~~~ rikisand 2010-03-15 16:40 发表评论

素数�{�法 rikisand — Fri, 12 Mar 2010 06:04:00 GMT #include #include #include "time.h" using namespace std; void sieve(int n){ vector<bool> isprime(n,true); vector<int> prime; int cnt=0; for(int i=2;i<n;i++){ if(isprime[i])cnt++,prime.push_back(i); for(int t=0;t<cnt&&i*prime[t]<n;t++){ isprime[i*prime[t]]=false; if(i%prime[t]==0)break; } } /*for(int i=0;i} void oldseive(int n){ vector<bool> isprime(n,true); vector<int> prime; for(int i=2;i<n;i++){ if(isprime[i]){ prime.push_back(i); for(int j=i*2;j<n;j+=i) isprime[j]=false; } } /*for(int i=0;i} int main(){ clock_t start,end; start = clock(); sieve(2000000); //oldseive(2000000); end = clock(); double time = double(end-start)/CLOCKS_PER_SEC; cout<<endl<< time<<endl; } �U�性筛法sieve 1.546s oldsieve 2.875s 快了��近一�?/p> old sieve �~�陷�Q�合数可能被多次�{�掉�Q�例�?30�?�Q?�Q?�{�掉�?��?然后 �U�性筛法限定了 ��M��一个合数只被它的最��质因数�{�掉一�ơ，怎么做到�q�一点~~ if(i%prime[t]==0) break; 如果此时�{�掉的合��C��到大找到第一个可以整除的质数�Q�那么显然他扑ֈ�了它的最��质因数�Q�此时我们停止搜索质数表�Q�因为后面的质数比当前的prime[t]要大�Q�如果我们用prime[t+n]*i �{�掉了一个合敎ͼ��q�个合数必然可以表述成�ؓ prime[t]*someK *prime[t+n] 也就是说�q�个合数的最��质因数也是prime[t],他应该被 prime[t]�{�掉-->当程序运行到 someK*prime[t+n] 的时候~~~~ over-------------------------------------------------------------------- rikisand 2010-03-12 14:04 发表评论深入探烦C++对象模型��M��W�记 (�? rikisand — Tue, 09 Mar 2010 14:20:00 GMT Function 语义�?/font> ····member 的各�U�调用方式~ 1.非静态成员函敊W?/font> float Point3d::mangitude3d()const{…} 会变�?float Point3d::magnitude(const Point3d* this){…} c++的准则之一�Q�非静态成员函数至��必��d��一般的nonmember function 有相同的效率名称的特�D�处理：�Q�name mangling�Q�一般member名称前面都会加上class名称�Q��Ş成独一无二的命名，class Bar {public �Q�int ival�Q�} 可能变成 ival_3Bar ;3应该是bar的长度了�?/font> �q�样可以防止�l�承体系中两个类定义同样名字的变量~ 如果使用extern “C�?��可以压制nonmember 的mangling 效果 2.虚拟成员函数· 如果normalize 是虚拟函�?他会被翻译成: (*ptr->vptr[1])(ptr); �W�二个ptr是this指针 �c�M��的magnitude 会变�?/font> (*this->vptr[2])(this); 而magnitude是在normalize之后调用的因此此时已�l�确定this指向的是Point3d 因此可以直接调用Point3d::magnitude()更有效率如果用一个对象调用一个虚拟函数应该把它当做正常函数来对待�Q�因为可以确定对象类型直接调用相应的函数卛_��Q�在�q�种情况下，虚拟函数也可以inline 来提高效率了~~~ 3.静态成员函�?/font> class A{ public: static int a; static int geta(){return a;} }; int A::a=33333; int main(){ cout<< ((A*)0)->geta()<} static的主要特征是他没有this 指针�Q�这样导致�?/font> 他不能直接存取其class中的nonstatic members 他不能被声明为const volatile 或者virtual 他不需要经由class object 才被调用虽然大部分情冉|��q�样调用�?/font> 如果取一个static member func 地址则得到的是他在内存中的真正地址�Q�而且得到的是一个函数指针，而不是一个指向class member 函数的指�?/font> ····虚拟成员函数 ��Z��支持virtual func 机制�Q�必��首先能够对多态对象由某种形式的运行期�c�d��判断�Ҏ�� c++中多态表�C�：以一个public blase class 指针或者引�?��d��Z��个derived class object 的意�?/font> 识别出哪个类需要支持多态只要看他是否有��M��的virtual func ~~~单一�l�承 vtable中每一个virtual func�Q�包括pure func�Q�都被指�z�一个固定的索引��|��q�个索引在整个��承体�p�M��保持与特定的virtual function 的关�?/font> 当一个class �l�承自上一个class时�?/font> 1.可以�l�承base class 声明的virtual func �Q�这栯��函数实体的地址会被拯��C��的vtable相对应的slot 中，位置x不变 �q�样调用时�?ptr->func();会翻译成 (*ptr->vtbl[x])func(ptr) ;而不用管ptr 到底是一个base �q�是一个derived 2.他可以��用自��q��函数实体�Q�表�C�Z��自己的函数地址必须攑֜�相应的位�|�x�?,跟上面的例子一�?/font> 3.可以加入新的virtual 函数�Q�这时候vtbl 会变�?/font> ~~~多重�l�承�?/font> 多重�l�承时�?例如 Derived public �?Base1,Base2 Base2 *pbase2 = new Derived; 新的Derived必须调整 Base2 *pbase2 = tmp?tmp+sizeof(Base1):0; 当程序员删除pbase2指向的对象时指针必须再一�ơ调整。上�q�的调整�q�不能在�~�译时期讑֮��Q�因为pbase2指向的对象只有在执行期才能确定�?/font> 同样道理�Q�pbase2 如果要调用函数的话，调用操作会引发必要的指针调整�Q�也必须在执行期调整�?/font> Bjarne采用扩充vtable 每一��记录调整this指针的信息，但浪费，因�ؓ大部分不需要调�?/font> Thunk技术是用一�D�|��~�实现调整this指针以及跛_��virtual func的过�E?/font> 调整this指针的第二个负担是：如果由derved class 调用�Q�或者由�W�二个base class 调用�Q�同一个函数可能在virtual table 对应多个slots pbase1 和derived 的vtable可以合�ƈ�Q�他们用同样的slots 偏移�Q�里面可以放真正的地址�Q�而pbase2 需要调整this指针�Q�其vtabl 相应的地址攄��是相应的thunk地址�?/font> 可以看到”： 1.如果通过指向�W�二个base class 指针调用derived的func ptr 需要调�?/font> 2.如果通过指向derived指针调用从第二个�l�承来的func 需调整 3.如果允许virtual func �q�回�c�d��有所变化�Q�可能base 可能derived�Q�也需要调整this Microsoft 用address point �{�略�Q�即��用来改写别人的函数�Q�期待获得的参数�Q�this�Q�是引入该class 的地址�Q�这��是函数的address class�Q�~~不了啊~~�Q?/font> ~~~虚拟�l�承下的virtual func 即便只有一个base clas 它的布局转换也需要this 指针的调��_��相当复杂~~~ …指向成员函数的指针 double Point::x(); 可以定义指向成员函数的指�?/font> double (Point::* pmf)()=&Point::x; 调用可以 (origin.*pmf)() 或�?ptr->*pmf(); 如果是虚拟函数的指针呢？�Q?/font> Point* ptr= new Point3d; 如果x是一个虚拟函�?/font> (ptr->*pmf)();仍然是Point3d::x()被调用么�Q?/font> �{�案~~是的因�ؓ取得虚拟函数的地址其实取得的是虚拟函数的offset�?/font> 调用会变�?nbsp; (*ptr->vtbl[(int)pmf])(ptr); class A{ public: static int a; static int geta() {return a;} //静态�ƈ不能作�ؓ重蝲条�g int geta(int x){ return a; } int geta( int a)const{} // const成员函数 �Q�可以作为重载条�?br>}; int A::a=33333; int main(){ A a; cout<< ((A*)0)->geta()<geta() int(*p)()= &A::geta; cout<<(*p)()< int (A::* pgeta)(int a) = &A::geta; cout<<(a.*pgeta)(3)<} 输出均�ؓ33333 多重�l�承下呢�Q�？�Q�？ Microsoft提供�?�U�解��x��法：一�U�：单一�l�承的情况（带vcall thunk地址或者函数地址�Q?/font> 2多重�l�承带有faddr 和delta 虚拟�l�承带有四个members �Q�·····具体以后再查吧�Q?/font> ---------- inline members 真正的inline 函数扩展是在调用的那一个点上，�q�回带来参数的求值操作以及暂时性对象的��理形式参数 formal arguments 在inline 期间每一个�Ş式参数都会被相应的实际参数取代，副作用是�Q�不可以只是��单的一一��塞�E�序中出现的每一个�Ş式参敎ͼ�因�ؓ�q�将��D��对于实际参数的多�ơ求值操作，可能产生带来副作用的实际参数�Q�通常�q�需要嵌入实际对象的~~~~ 所以，如果实际参数是常量，那么我们可以直接�l�定�Q�如果不是常量也没有副作用，我们直接代替�Q�否则~~~暂时对象会需要的~· 例如�Q?/font> inline int min(int i,int j) { return i minval = min(val1,val2); minval = min(11,12); minval = min (foo(),bar()+1); �q�会扩展�? minval = val1 minval = 11;( 帔R��? int t1,t2; minval =(t1 = foo()), (t2=bar()+1),t1 如果我们改变函数定义 {int minval = i 如下调用{int minval ; minval = min(val1,val2);} ��Z��l�护局部变量可能会变成�Q?/font> { int m_lv_minval; minval=(__min_lv_minval=val1 一般而言�Q�inline 函数的每一个局部变量都必须攑֜�函数调用的一个封闭区�D�中�Q�拥有一个独一无二的名字，如果inline函数以单一表达式扩展多�ơ，那么每次扩展都需要自��q��一�l�局部变量。如果inline 函数可以以分��ȝ��多个式子被扩展多�ơ，那么只需要一�l�局部变量就可以重复使用�Q�因��Z��们被��闭在自��q��scope中：例如 minval = min(val1,val2) + min(foo(),foo()+1) ; 扩展 int __min_lv_minval_0,__min_lv_minval_1,t1,t2; minval = ((__min_lv_minval_0 = val1 参数带有副作用或者是以一个单一表达式做多重调用�Q�或者是在inline 函数内部有多个局部变�?/font> 都会产生局部变量，要小心对�?/font> --------------------�l�束�U�哦~~~~~~··---------------------- rikisand 2010-03-09 22:20 发表评论深入探烦C++对象模型��M��W�记 (�? rikisand — Sun, 07 Mar 2010 08:39:00 GMT DATA 语义�?/font> �q�段代码输出什么？ #include using namespace std; class A{ public:A(){ac='s';}private:char ac;}; class B:virtual public A{public:B(){a='e';}char a; }; class C:virtual public A{ }; class D:public B,public C { public: D():A(),B(),C(){b=13;} int b; }; int main(){ D d; cout<<"sizeof(A)="< cout<<"sizeof(B)="< cout<<"sizeof(C)="< cout<<"sizeof(D)="< cout< cout<<"address of A's subobject in d"<<(A*)&d< cout<<"address of B's subobject in d"<<(B*)&d< cout<<"address of C's subobject in d"<<(C*)&d< cout<<"address of D's subobject in d"<<(D*)&d< cout< int* p = (int*)(*((int*)&d)); cout<<"address of b's virtual base table="< cout<<"first member in b's virtual base table="<<*p< cout<<"second member in b's virtual base table="<<*(p+1)< cout<<"third member in b's virtual base table="<<*(p+2)< cout< p= (int*)*((int*)((C*)&d)); cout<<"address of c's virtual base class table= "< cout<<"first member in c's virtual base table="<< *p< cout<<"second member in c's virtual base table="<<*(p+1)< cout<<"third member in c's virtual base table="<<*(p+2)< char *pchar= (char*)(&d)+4; //char型加4 注意A中的ac其实是私有变量，B不应该可以访问到的，实际上通过强制转换可以非法触及�?�? cout<<*pchar< cout<<*(pchar+12)< B b; int *pint =(int*)(&b)+1; //int�?1 cout<<*((char*)(pint))< pint = (int*)(&d)+3; cout<<*(pint)<} �l�果是： sizeof(A)=1 sizeof(B)=9 sizeof(C)=5 sizeof(D)=17 address of A's subobject in d0012FF74 address of B's subobject in d0012FF64 address of C's subobject in d0012FF6C address of D's subobject in d0012FF64 address of b's virtual base table=00403350 first member in b's virtual base table=0 second member in b's virtual base table=16 third member in b's virtual base table=0 address of c's virtual base class table= 00403358 first member in c's virtual base table=0 second member in c's virtual base table=8 third member in c's virtual base table=0 e s e 13 1.语言本��n造成的负担：如virtual baseclass 2.寚w��造成的负担（寚w��会单独开题讨论） 3.�~�译器优化处�?A虽然是空�?but ��Z��让A的两个object在内存中得到不同的地址�Q�编译器�l�他加上了一个byte�Q�但是B和C都没有这一个byte呢？�q�是�~�译器做了优化，允许省掉�q�一个byte 看上面的代码”：环境是vs2008 寚w��讄��?字节 A的大��ؓ1 因�ؓ有一个char 没有寚w��因�ؓ不是�l�构型对象，如果A没有�q�个char大小依然�?�?/font> B的大��ؓ9 首先开始是它的virtual base class ptr�Q?个字节的指针�Q�然后是他自��q��member 1个char 此时��Z��保证其对象完整性编译器寚w��?字节处也��是在第九个字节内放入基�cȝ��member �q�样如果我们把A=B B赋给A�Q�传输可以从�?字节开始割出A卛_�� C的大��是5 没什么好解释 D的大��是17首先是B�?字节(4字节vbptr+1字节char member+3字节寚w��)然后是C�?字节vbptr,然后是自��q��member4字节最后是1字节的base class member,可以看到B和C的base class table中的��w��是自�׃��|�与�q�个member的offset �?/font> 不同�~�译器可能结果不同的�Q�因为c++ standard �q�没有强制规�?base class subobjects的顺序等 data member 是程序执行过�E�中的某�U�状态： static data member 是整个class 的状�?/font> non-static data member 是个别class-object 的状�?/font> c++对象��量以空间优化和存取速度的考虑来表现non-static members �Q��ƈ且和c的struct 数据配置的兼�Ҏ��?/font> static data member 攑֜��E�序的一个global data segment 中，不会影响个别的class-object 大小 �Q�在class没有object 时已�l�存在，但是template中有些不�?/font> -----DATA member 的绑�?/font> 始终把nested type 声明攑֜�class 起始处，argument list 中的名称会在�W�一�ơ遇到时候被适当的决议完成，因此extern 和nested type names 之间的非直觉�l�定操作�q�是会发生�?/font> ---- DATA 的存�?/font> Point3d origin,*pt=&origin; origin.x = 0.0; �?pt->x=0.0 ; 有什么区别么�Q�？如果x是静态data member 则完全没有区�?因�ؓ他们都在data segment 中和object无关 ~nonstatic data member--------- 如果point3d不包含虚拟��扉K��么没有差�?/font> 否则我们不能��定pt中必然指向哪一�U�因此不能在�~�译器确定offset需要一些运行时候的计算抉择�Q�而origin则不同一定是某一个类型的所以没有问�?/font> 多��承或者单�l�承都不会带来访问上的媄响，因�ؓ他们都可以向c的结构体那样在编译时期确定各个member的offset。即使是多��承pt指向�W�二个baseclass的data�Q�由于member的位�|�在�~�译时期��已�l�固定了�Q�因此存取member只是一个offset�q�算�Q�像单一�l�承那样��单，不管是指针，reference或者object都一�? 只有virtual base class 会带来一些损耗，因�ؓ他��得对象模型变得复杂了如果我们在一个类中加入了virtual func 会发生什么~~~ 1. 会��生一个virtual table�Q�存放每一个virtual func地址以及rtti支持的type_info 2.class object 内都加入一个vptr�Q�提供执行期的链�?/font> 3.加强ctor 讑֮�vpr初�?/font> 4.加强dtor 消除vptr 从dirived class �?base class 虚拟�l�承�Q?/font> 他必��L��持某�U��Ş式的“shared subobject”��?/font> 那么一个object会分成一个不变局部和一个共享局部的数据�Q�共享局部就是virtual base class subobject�Q�他的位�|�会因�ؓ每次�z��操作发生变化(例如一个virtual base class subobject的位�|�在不同�U�别的��承体�p�M��的位�|�是不确定的�Q�不像多�l�承单��扉K��h��固定的offset)�Q�所以他只能间接存取�Q�因此��生了效率�~�损.(间接是指的是他只能首先读��Z��的指针，然后�Ҏ��指针的内容取��C��) 所以在虚拟�l�承基类中最好不要有data member -------指向DATAmember 的指�?/font> #include using namespace std; class A { public: int a; }; int main(){ int A::* p=&A::a; cout<} 输出 1 因�ؓ��Z��防止&A::a�?int A::*a = 0�Q�一��h��他加�?�? 虚拟�l�承带来的主要冲��L��Q�妨��了优化的有效性，因�ؓ每一层虚拟��扉K��带来了一个额外层�ơ的间接性，在编译器中存�?�c�M��point::x的操作pb.*bx 会被转化�?&pb->vbcPoint+bx 而不是�{换成 &pB +bx 额外的间接性会降低“把所有操作都搬移到缓存器中执行”优化能力，也就是降低了局部性~ rikisand 2010-03-07 16:39 发表评论深入探烦C++对象模型��M��W�记 (�? rikisand — Wed, 03 Mar 2010 14:23:00 GMT 构造函数语义学 --了解�~�译器在构造对象时背着我们�q�了什么勾�?/font> Default Ctor 在需要的时候被构徏出来~ 什么需�? 是编译器需要而不是程序的需�?所以不要期望编译器生成的Ctor会帮我们把我们的成员变量初始化�ؓ零。那是程序的需要，也就是我们程序员的�Q务···�?/font> 例如�Q?/font> class Foo(public:int val;); void foo_bar(){Foo bar; if(bar.val)dosth;} 不要期望�~�译器帮我们初始化它�?。只有global变量会初始化�?�Q�初始化val�q�样的变量需要我们自己写代码的~~ Default Ctor分�ؓtrival�Q�没用的�Q�和non-trival的，下面讨论什么时候编译器需要ctor 也就是有用的ctor�Q�这时候如果我们没有提供一个默认的default ctor 它会帮我们合成一个的~~ 1.带有Default Ctor 的member class object 很好理解�Q�既然内部成员含有default ctor 那么我们创徏新的对象旉��要调用它�Q�而我们�ƈ木有调用它的函数�Q�编译器自然会帮我们提供一个。如果我们提供了default ctor �Q�那么编译器会在我们提供的函数加入调用必��调用的member class 的default ctor。同��L��在每一个ctor里面都将在用户写的代码之前调用需要调用的default ctor -------看例子： class Dopey();class Sneezy{public:Sneezy(int val);Sneezy();};class Bashful{public:BashFul();}; class Snow_white{public: Dopey dopey;Sneezy sneezy;Bashful bashful;private:int muble}; 如果Snow_white没有定义default ctor 那么�~�译器会创徏一个，�q�在其中依照声明��序依次调用dopey sneezy bashful的default ctor 然而如果： Snow_white::Snow_white():sneezy(1024){muble=2045;} �~�译器会扩张�?/font> Snow_white::Snow_white():sneezy(1024){ dopey.Dopey::Dopey(); sneezy.Sneezy::Sneezy(1024); bashful.Bashful::Bashful(); ///////// explicit user code muble = 2048; } 2.�z��自带有Default ctor �?base class 同样道理如果父类有Default ctor 子类当然要调用，�~�译器会为想上面一样�ؓ我们加上 3.含有virtual functions的Class 创徏object 时候需要ctor 来设�|�好vptr 4.带有virtual base class virtual base 实现�Ҏ��各有不同�Q�然而共同点是必��L��virtual base class 在其每一个derived class中的位置能够与执行期准备妥当 X A B C 菱�Ş�l�承 void foo(const A*pa){pa->i=1024;} foo(new A);foo(new C); 知道pa �?i在对象中的位�|��ƈ不是固定的，而是在运行时真正��定pa指向什么对象A�q�是C才能��定的，因此需要设定一个指向基�c�subobject的指针，所以需要ctor工作�?/font> OK: 1.��M��class 如果没有定义Default ctor ��׃��被合成一�?/font> 2.合成出来的Default ctor 会明��设定每一个data member�?/font> 错的很easy了~ ------------------------------------------------------------------------------- 再来�?Copy Ctor�Q?/font> copy ctor 负责用另一个对象初始化一个对�?/font> operator = 负责用另一个对象给一个对象赋�?/font> 直接赋值时�Q�传参时�Q�返回时可能调用Copy ctor Default member initialization~~~ 也就是memberwise 的initialization 他会把每一个data member �Q�内建的或者派生的�Q�从一个object 拯��到另一个object中去如果object允许bitwise的拷贝那么编译器��׃��用生成一个nontrival的default copy ctor 什么时候不可以呢~ 1 内含一个member object 而后者含有copy constructor (声明或者合成的) 2 �l�承一个base class 后者有copy ctor 3 含有virtual func 4 �z��自一个��扉K��Q�其中有virtual base class 1�? 中编译器会把member 或者baseclass copy ctor 调用安插在合成的copy ctor �?/font> 3 中：如果两个同样�c�d��的object赋值时�Q�没有问题因��Z��们的vptr相同但是考虑子类赋值给父类�Q�此时vptr需要更改，那么此时不具有bitwise�Ҏ��，因此需要编译器来加入语句正��更新vptr 4中：每个�~�译器都承诺必须让derived class 中的virtual base class object 在执行期间准备妥当，�l�护位置完整性是�~�译器的责�Q。bitwise copy 有可能会破坏�q�个位置所以编译器需要在自己合成的copy ctor 中作��Z��?/font> 同样问题发生在��承体�p�M��子类向父�c�赋值时�Q�由于对象模型问题，直接bitwise复制可能会导致base class object 的破坏（后面章节会有讨论�Q?/font> -------------------------------------------------------------------------------- �E�序转化语义�? X x0; void foo(){X x1(x0); X x2=x0; X x3=X(x0);} 转化�Q�重写定义，初始化操作会被剥�?nbsp; copy constructor 调用会被安插 void foo(){ X x1;X x2; X x3; x1.X::X(x0); x2.X::X(x0); x3.X::X(x0);} 参数的初始化�Q?/font> 一�U�策略导入暂时的object void foo(X x0);X xx; foo(xx); 转化�Q?/font> X _tmp; _tmp.X::X(x0); foo(_tmp); foo变成 void foo(X& x0); 另一�U�是拯��构徏�Q?/font> 把实际参数直接徏构造应该在的位�|�上�Q�函数返回时局部对象的destructor 会执�?/font> 也就是说把x0建构在foo 的函数执行的地方 �q�回值的初始化： X bar(){ X xx; return xx; } �q�回值如何从局部对象xx拯��而来呢？一�U�方法：1.加上额外参数�Q�类型是class object的reference�Q�这个参数用来放�|�被拯��建构的返回�?�Q�注意拷贝徏构也��是说他被放在应该在的位�|�，也就是说不是局部变量了�Q?/font> 2.return 指��o之前安插一个copy constructor 调用操作 �Q�以便将传回的object 内容当做上述参数的初�?/font> so 上面的程序变成了�Q?/font> void bar(X& _result){ X xx; xx.X::X(); //�~�译器��生的default ctor 调用 _result.X::X(xx);//�~�译器��生的copy ctor 调用 return ; } 现在�~�译器必��{换bar的调用操�?X xx=bar();转换�?X xx; bar(xx); // 注意不用copy ctor了直接操作在xx上了如果�~�译器做了优�?�q�就是named return value 优化而： bar.memfunc();//bar()传回的X 调用成员函数变成�Q?/font> X _tmp; (bar(_tmp),_tmp).memfunc(); 同样道理函数指针 X(*pf)(); 变成 void (*pf)(X&); 使用者的优化: X bar(const T& y,const T& z){ X xx; 通过 y z 计算xx return xx; } �q�种情况下要iuxx被memberwise拯��到编译器产生的_result中，如果定义 ctor来利用yz计算xx则： X bar(const T& y,const T& z){ return X(y,z); } 变成�Q?/font> bar(X& result){ result . X::X(y,z); return; } 无需copy ctor�?/font> �~�译器的优化�Q?/font> 如上所�q�bar中返回了具名数�?named value�Q�因此编译器有可能自�׃��化，�Ҏ��是以result取代named return value bar(X& result){_result.X::X(); 直接处理result �q�不处理变量xx然后复制�l�result �q�样��׃��化了} �q�个优化的激�z�需要class提供一个copy ctor~~~~~~ Copy ctor 要不�? 如果一个class �W�合bitwise的要求那么此时member wise 的拷贝已�l�高效简�z?无需加入�?/font> 但是如果class需要大量的member wise 初始化操作，如用传值方式返回objects�Q�如果是�q�样提供一个copy ctor 可以�Ȁ�z�nRV named return value 优化�Q�这��很合理�?/font> 成员们的初始化过�E�：什么时候必��ȝ��初始化列表： 1.初始化一个reference�?2.初始化一个const member 3.调用父类ctor而且有参数时4调用member class ctor 有参�? 其他情况呢： class word{string name;int cnt;public: name=0;cnt=0;} �~�译器可能这么做: word::word{ name.String::string();调用string的default ctor string tmp=string(0); _name.string::operator=(tmp); tmp.string::~string(); cnt=0; } 昄��name攑ֈ�初始化列表会更有效率 �Q�会变成 name.String::String(0); 而cnt�q�种内徏�c�d��则没有关�p�，放不攑ֈ�初始化列表没有效率上的差�?/font> 初始化列表究竟让�~�译器做了什么？�Q�？�Q?/font> �~�译器会一个个操作list中的式子�Q�以适当�ơ序在ctor内安插初始化操作在�Q何explicit user code 之前�?/font> 注意的地方： list中的�ơ序是按照members声明�ơ序军_��而不是list 中的排列��序军_��?/font> 例如�Q�class x{int i;int j; X(int val):j(val),i(j)} 错了 i先声明则i首先赋予val 然后用未初始化的j赋给i。。�?/font> 可以�q�样X::X(int val):j(val){i=j;} �׃��会安插在explicit code 之前所以没问题会变�?j=val; i=j; 可否用member functions 初始化成员？�Q?/font> �{�案是可以的�Q�因为和objects相关的this指针已经构徏妥当�Q�只是要注意函数调用的member是否已经构徏妥当了即�?/font> ------ - - - ---------- -- --疲惫的结束线- - - - - -- - ----- name return value TEST: ~~~~1 cl /od 不开优化 #include using namespace std; class RVO { public: RVO(){printf("I am in constructor\n");} RVO (const RVO& c_RVO) {printf ("I am in copy constructor\n");} ~RVO(){printf ("I am in destructor\n");} int mem_var; }; RVO MyMethod (int i) { RVO rvo1; rvo1.mem_var = i; return (rvo1); } int main() { RVO rvo;rvo=MyMethod(5); } 输出�Q? I am in constructor //rvo 创徏 I am in constructor // rvo1创徏 I am in copy constructor // rvo1赋值给hiddern I am in destructor // rvo1解构 I am in destructor // hiddern解构 I am in destructor // rvo 解构 A MyMethod (A &_hiddenArg, B &var) { A retVal; retVal.A::A(); // constructor for retVal retVal.member = var.value + bar(var); _hiddenArg.A::A(retVal); // the copy constructor for A return; retVal.A::~A(); // destructor for retVal } A MyMethod(A &_hiddenArg, B &var) { _hiddenArg.A::A(); _hiddenArg.member = var.value + bar(var); Return } ~~~~2 cl /o2 代码同上 output I am in constructor //rvo创徏 I am in constructor //hiddern 创徏 I am in destructor //hiddern 解构 I am in destructor //rvo解构我不明白的是hiddern 怎么传给rvo �Q�我猜可能是�~�译器按照bitwise的复制方式进行的,此时�~�译器�ƈ没有直接建构�l�果于rvo�?/strike> �Q�看看下面的试验�Q?/font> 注：明白了， �l�果直接建构在hiddern�Q�然后通过operator = 传给rvo 。没有copy ctor因�ؓ拯��构造函数是负责初始化的�Q�而operator = 才是用来赋值的. �l�过代码证明是对的，如果重蝲赋��D��符输出变成�Q?/font> I am in constructor //rvo创徏 I am in constructor //hiddern 创徏 I am in operator = //赋值操作~~ I am in destructor //hiddern 解构 I am in destructor //rvo解构 ~~~~3 cl /od #include using namespace std; class RVO { public: RVO(){printf("I am in constructor\n");} RVO (const RVO& c_RVO) {printf ("I am in copy constructor\n");} ~RVO(){printf ("I am in destructor\n");} int mem_var; }; RVO MyMethod (int i) { RVO rvo1; rvo1.mem_var = i; return (rvo1); } void abc(RVO& i){ } int main() { RVO rvo=MyMethod(5); //此时定义和赋值放��C��一个表辑ּ��?br> return 0; } output: I am in constructor // rvo1 创徏注意跟上面的�W�一�U�情况下的hiddern一�?rvo�q�没有调用ctor I am in copy constructor // rvo1 拯��构造给rvo 此时没有hiddern�?直接构徏rvo�?br>I am in destructor // rvo1 析构 I am in destructor // rvo1 解构 ~~~~3 cl /o2 再来~~~~ NRV出马 I am in constructor // rvo构徏�?nbsp; I am in destructor // rvo析构�?/font> 此时 mymethod中的一切都直接反映在rvo�w�上 ok~~~~~4个代码完全一��h��造析构拷贝函��C��数由2-6不等~~~over~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ rikisand 2010-03-03 22:23 发表评论深入探烦C++对象模型��M��W�记 (一) rikisand — Wed, 03 Mar 2010 05:58:00 GMT 寒假基本��M��一遍，现在再读一遍，做下�W�记�?/font> �W�记当做的精��D��有意义�Q�而后回顾可知其意�Q�回其味�Q�方有成�?/font> --------------------------------------------------------------------------------- C语言�Q�数据和操纵数据的方法分开声明,�Ҏ��被写成函数处理外部数�?/font> C++:数据和方法的�l�合��装ADT 更安�?支持�l�承清晰 ��装在空间上的代��P�� 如果仅仅是普通��承则�q�没有什么代��P��因�ؓ每个数据成员直接内涵在每一个class对象中，和c中的struct一��P��而member function如果不是inline的则只会产生一个实体，而inline会在每一个��用的模块产生一个函数实�?/font> c++在空间和存取效率的代价主要由virtual带来�Q?/font> virtual function 机制�Q?vtable vptr 执行期绑�?/font> virtual class 机制�Q?/font> �q�有多重�l�承下的额外负担�Q�子�c��{换成�W�二个父�cȝ��时候） ---------------------------------------------------------------------- c++对象模型�Q�也��是我们怎么在内存中安排各个数据成员以及成员函数 1.��单对象模型~ 对象由各个slot�l�成�Q�每一个slot包含指针�Q�指向各个成�?/font> 2.表格驱动模型~ 对象含有两个指针�Q�一个指向成员数据表�Q�另一个指向成员函数表 3.c++实际对象模型~ 非静态数据被攑֜�对象内，而静态数据成员放在对象外�Q�显然啊�Q�他属于�c�）�Q�成员函�?/font> 不管静态或者非静态都攑֜�对象外面 Virtual functions �Q�每个class产生一堆指向vitrualfunctions的指针，攑֜�vtables中，每个对象含有vptr 指向vtable vptr的设定，重置均有class的ctor�Q�dtor�Q�copy assignment �q�算�W�自动完�?/font> 优点�Q�空间和存储效率 �~�点�Q�如果对象模型的nonstatic data members 有所修改�Q�也��是对象内部布局有所更改�Q�那么��用该对象的应用程序需要重新编�? 虚拟�l�承�Q�不��基�c�被�z��了多��次�Q�永�q�只有一个实体（菱�Ş�l�承最下面对象中只有一个顶部类实体�Q?/font> �l�承的实玎ͼ�一�U�可以用basetable 在basetable中指向一个baseclass的地址�Q�但�q�会随着�l�承深度��来��深变得�?/font> 现在采用的方法之后记录~~~ �Q�P 书中的程序：对象模型对程序的影响�Q?/font> X foobar(){ X xx; X *px = new X; xx.foo(); px->foo(); //foo是一个virtual function delete px; return xx; } //调用�?X _result; // foobar(_result); void foobar(X& _result){ _result.X::X();//构造result px = _new(sizeof(X)); if(px!=0) px->X::X; foo(&_result);//使用result取代xx但是不激�z�virtual机制 (*px->vtbl[2])(px);//使用virtual机制扩展px->foo(); if(px!=0){ (*px->vtbl[1])(px);//使用virtual调用destructor delete px; } //不用使用named return statement return ; } ------------------------------------------------------------------------------------ 关键词带来的�ȝ��~~ struct �?class 在C++中可以�؜用，�q�不是由于��用哪一个决定其�Ҏ��，只是�l��h的感觉不同�Ş了class更像是c++中��承的代名�?struct更像C中的数据�?/font> 如果需要向C函数传递数据集合可以��用struct以保证对象模型的支持使用struct完全可以声明各种class的特�?/font> 对象的差�?/font> 1.�E�序模型procedural model 同c一�?/font> 2.抽象数据�c�d��模型 ADT object-base 抽象指的是一族表辑ּ��Q�public接口�Q�的提供�Q�具体计��方法未�?/font> 3.面向对象 oo 有一些彼此相关的模型通过一个抽象的baseclass用以提供公共接口��装��h�� OO中程序员可能需要处理一个未知实体，在执行点之前无法��定�Q�这是由pointers和reference实现的而在ADT中程序员处理的是一个拥有固定单一�c�d��的实体，�~�译时期��已�l�确定了~ c++中的多态：1.把derived class的指针�{化成一个基�cȝ��指针 2virtualfunctions 3.dynamic_cast 和typeid�q�算�W?/font> 多态主要是�l�由一个共同的接口来媄响类型的��装�Q�这个接口通常被放�|�在抽象的baseclass中，�q�个�׃�n接口是以virtual functions机制来引发的�Q�可以在执行期间�Ҏ��object的真正类型解析出到底是哪一个函数实体被调用�?/font> 我们的代码可以避免由于增加某一个特定的derived 实体而改变，只需要新的derivedclass重写�q�样的接口便可�?/font> //��试指针引用的多�?br>#include using namespace std; struct Point{ public: Point(float x=0.):_x(x){} float x(){return _x;} void x(float xval){_x=xval;} virtual void out(){ cout<<"I am a Point"< } protected: float _x; }; struct Point2d:public Point{ public: Point2d(float x=0.,float y=0.):Point(x),_y(y){} float y(){return _y;} void y(float yval){_y=yval;} virtual void out(){ cout<<"I am a Point2d"< } protected: float _y; }; int main(){ Point pt; Point2d pt2; Point* ptr; Point2d* ptr2; pt.out(); pt2.out(); pt=pt2;pt.out(); ptr=&pt2; ptr->out(); (*ptr).out(); Point& ptref=pt2; ptref.out(); } output: I am a Point I am a Point2d I am a Point I am a Point2d I am a Point2d I am a Point2d 指针和引用可以实现多态，因�ؓ指针和引用的赋值只是改变其指向的范��_��q�没有触及对象模型的改变�Q�因此可以��生多态的效果。而value的赋值操作会��D��对象模型的切�Ԍ��从而真实的改变了对象的内部模型与类型，失去了多态的效果。oo 不支持对对象的直接处�?/font> 指针的类型：不同的指针从内存角度来看没什么不同，只是占据了一个word的空��_��但是指针的类型会告诉�~�译器如何解释某个特定地址中的内存内容以及大小 OB设计也就是ADT设计比OO讄��更有效率因�ؓ其所有函数引发操作均在编译器��定OO需要一些运行时��定�Q�对象构��v来不需要设�|�virtual机制比OO紧凑因�ؓ无需支持virtual机制从而没有额外负�?/font> 但是OB相对来说�Ҏ��较��~~ rikisand 2010-03-03 13:58 发表评论 More Effective C++ (1) rikisand — Mon, 18 Jan 2010 06:16:00 GMT �W�四�?nbsp; 效率 ······条款16 ��C��80-20准则大约20%的代码��用了80%的资源，�E�序的整体性能是由该程序的一��部分代码所军_��的~ 可行的办法是使用�E�序分析器（profiler�Q�来扑ֈ��D��性能瓉��的拿20%的程序~ 而且要针寚w��成瓉��的资源来使用相应的分析器~ ······条款17 考虑使用延迟计算延迟计算�Q?也就是说知道�E�序要求�l�出�l�果的时候才�q�行�q�算~ 很好理解�Q�和操作�pȝ��中的cow copy on write 一个原理~ 四个使用场景�Q?/font> ~1~ 引用计数 �Q?/font> 　　class String{…}; String s1 = “hello”; String s2 = s1 ; //call string Copy ctor 通常情况下，s2赋值后会有一个hello的拷贝，者通常需要��用new操作�W�分配内存，之后strcpys1 的数据给他，但如果下面的操作如下的话�Q?/font> cout << s1 ; cout << s1 + s2; �q�种情况下如果只增加s1的引用计敎ͼ�而s2只是�׃�ns1的值就可以了。只有在需要对s2�q�行修改或者s1�q�行修改�Ӟ��才需要真正拷贝给s2一个副本，引用计数的实现在29条款 ~2~区分��d��操作如： String s = “homer’s all”; cout<< s[3]; s[3] = ‘x’; 在进行读操作�Ӟ��使用引用计数是开销很小的，然而写操作必须生成新的拯��。通过条款30的代理类我们可以把判断读写操作推�q�到我们能够军_��哪个是正��操作的时�?/font> ~3~延迟��d�� 假设�E�序使用了包含许多数据成员的大对象，�q�些对象必须在每�ơ程序运行的时候保留下来，因此存进了数据库。某些时候从database中取出所有数据是没有必要的，比如他只讉K��该对象中的一个数据成员。此�Ӟ��应该对对象进行处理，只有对象内部某一个特定的数据成员被访问的时候才把他取出来。类��g��os中的按需换页~ class LargeObject{ LargeObject(ObjectID id); const string& field1() const; int field2() const; double field3() const; const string& field4() const; private: ObjectID id; mutable string* field1value; mutable int * fieldValue; }; LargeObject::LargeObject(ObjectID id):oid(id),fieldValue(0),…{} const string& LargeObject::field1()const{ if(fieldValue == 0){ //read the data for field 1 from database and make field1 point to it } return *field1Value; } 实施lazy fetching ��M��成员函数都需要初始化�I�指针以指向有效数据。但是const成员函数中，试图修改数据�~�译器会报错。所以声明字�D�|��针�ؓ mutable �Q�表�C�Z�Q何函数都可以修改,即便在const成员函数中也可以~ 条款28中的��指针可以让这一�Ҏ��更灵�z?/font> ~3~延迟表达式求�?/font> 数��D��领域，也在使用延迟计算。例�?/font> matrix m1(1000,1000); matrix m2(1000,1000); matrix m3 = m1 + m2; 如果此时计算出m3的话�q�算量非�怹�大~ 但是如果此时�E�序为： m3 = m4*m1; 那么刚才的计��就没必要了如果cout<< m3[4]; 我们只需要计��m3[4]��可以了�Q�其他的值等到确实需要他们的时候才予以计算~如果�q�气够好的话永远不需要计��~ �ȝ��Q��g�q�计��只有当软�g在某�U�程度下可以被避免时候才有意义~只有延迟计算得到的好处大于设计它与实现它��p��的精力时才有意义~ ·······条款18�Q?分期摊还预期的计��开销提前计算~ over-eager evaluation 在系�l�要求你做某些事情之前就做了他~ 例如�Q�大量数据的集合 template class DataCollection}{ public: NumericalType min() const; NumericalType max() const; NumericalType avg() const; }; 使用提前计算�Q�我们随时跟�t�目前集合的最大最��^均��|��q�样 min max avg被调用时候，我们可以不用计算立刻�q�回正确的数值~~ 提前计算的思想便是�Q�如果预计某个计��会被频�J�调用，你可以通过设计你的数据�l�构以更高效的办法处理请求，�q�样可以降低每次��h��的��^均开销~ 最��单的做法�?�~�存已经计算�q��ƈ且很可能不需要重新计��的那些值~ 例如在数据库中存有很多办公室的电话号码，�E�序在每�ơ查询电话时先查询本地的�~�存如果没找到再去访问数据库�Q��ƈ且更新缓存，�q�样使用�~�存�q�_��讉K��旉��要大大减��?/font> 预处理也是一�U�策略�?/font> 例如设计动态数�l�的时候，当烦引下标大于已有最大范围时候，需要new出新的空��_��如果甌��两倍于索引的大��的话就可以避免频繁的申��h��作~~~ ········条款 19 �Q?了解临时对象的来�?/font> 如果一个对象被创徏�Q�不是在堆上�Q�没有名字，那么�q�个对象��是临时对象�?/font> 通常产生于： ��Z��使函数调用能够成功而进行的隐式转换�Q�或者函数返回对象是�q�行的隐式�{换。由于构造和析构他们带来的开销可以�l�你的程序带来显著的影响�Q�因此有必要了解他们~ ~1首先考虑��Z��函数调用能通过产生的��时对象的情况传给某个函数的对象的�c�d��和这个函数所�l�定的参数类型不一致的情况下会出现�q�种情况�?/font> 例如�Q?/font> size_t count(const string& str,char ch); 函数定义��str中ch的数�?/font> char buffer[100]; cout< 传入的是一个char数组�Q�此时编译器会调用str的构造函敎ͼ�利用buffer来创��Z��个��时对象�?/font> 在调用完countChar语句后这个��时对象就被自动销毁了~ 仅当传值或者const引用的时候才会发生这��L��c�d��转换~当传递一个非帔R��引用的时候，不会发生�?/font> void uppercasify(string& str); //change all chars in str to upper case; 在这个例子中使用char数组��׃��会成功~ 因�ؓ�E�序作者声明非帔R��引用也就是想让对引用的修改反映在他引用的对象�w�上�Q�但是如果此时生成了临时对象�Q�那么这些修改只是作用在临时对象�w�上�Q�也��׃��是作者的本意了。所以c++��止非常量引用��生��时对象�?/font> ~2 函数�q�回对象时候会产生临时对象例如�Q?const Number operator + ( const Number& lhs,const Number& rhs); �q�个函数�q�回一个��时对象，因�ؓ他没有名字，只是函数的返回倹{�?/font> 条款20�?�Q�会介绍让编译器对已�l�超出生存周期的临时对象�q�行优化 ········条款20�Q?协助�~�译器实现返回��g��?/font> �q�回��g��化：�q�回带有参数的构造函数�?/font> cosnt Rational operator * (cosnt Rational& lhs,const Rational& rhs){ return Rational(lhs.numerator()*rhs.numerator(),lhs.denomiator()*rhs.denominator()}; c++允许�~�译器针对超出生命周期的临时对象�q�行优化。因此如果调用Rational c=a*b�Q?/font> c++允许�~�译器消除operator*内部的��时变量以及operator*�q�回的��时变量，�~�译器可以把return表达式所定义的返回对象构造在分配�l�c的内存上。如果这样做的话那么调用operator*所产生的��时对象所带来的开销��是0~ 我们可以把operator 声明为内联函数而去除调用构造函数带来的开销~ #include #include #include "time.h" using namespace std; char buffer[100]; class number{ public: const friend number operator * (const number& rhs,const number lhs); number(){} number(int b):a(b){} number(const number& rhs){ a = rhs.a; } int a; }; const number operator*(const number& rhs,const number lhs){ number res; res.a = rhs.a * lhs.a; return res; /*return number(rhs.a*lhs.a);*/ } //CLOCKS_PER_SEC int main() { clock_t start = clock(); number A(5);number B(6); for(int i=0;i<100000000;i++) number C = A*B; clock_t end = clock(); cout<} 通过上面的程序运�?如果没有�q�回��g��?�q�行旉�� 15.9s 优化后是 10.1s �q�是很显著的�?快了33% �Q�如果这�U�情况出现在�E�序的热点处~效果��很好了 ·········条款21 �Q?通过函数重蝲避免隐式�c�d��转换例子�Q?/font> class upint{ public: upint(); upint(int value); }; cosnt upint operator+(const upint&lhs,const upint&rhs); upint up1,up2; upint up3 = up1+up2; upi3 = up1 +10; upi4 = 10+ upi2; �q�些语句也可以通过�Q�因为创��Z��临时对象�Q�通过带有int的构造函��C�生了临时的upint对象�Q�如果我们不愿意��些��时对象的产生与析构付��Z��P��我们需要做什么：我们声明 cosnt upint operator+(cosnt upint&lhs,int rhs); cosnt upint operator+(int lhs,const upint& rhs); ��可以去除��时对象��生了~ 但是如果我们写了 const upint operator+(int lhs,int rhs); // 错了~ c++规定�Q�每一个被重蝲的运��符必须臛_��有一个参数属于用戯��定义�c�d��Q�int�q�不是自定义�c�d��所以上面的不对�?/font> 同样的如果希望string char* 作�ؓ参数的函敎ͼ�都有理由�q�行重蝲而避免隐形类型�{换（仅仅在有必要的时候，也就是说他们可以对程序效率�v到很大帮助的时候~�Q?/font> ··········条款�Q?考虑使用 op = 来取�?单独�?op�q�算�W?/font> class Rational{ public: Rational& operator+=(const Rational& rhs); Rational& operator-=(const Rational& rhs); } const Rational operator+(cosnt Rational& lhs,const Rational & rhs){ return Rational(lhs)+=rhs; } 利用+= -=来实�? -可以保证�q�算�W�的赋值�Ş式与单独使用�q�算�W�之间存在正常的关系�?/font> Rational a,b,c,d,result; result = a+ b+c+d; // 可能要用�?个��时对�?/font> result +=a;result+=b;result+=c; //没有临时对象前者书写维护都更容易，而且一般来说效率不存在问题�Q�但是特�D�情况下后者效率更高更可取注意�Q?/font> 如果+的实现是�q�样的： const T operator+ (constT& lhs,const T&rhs){ T result(lhs); return result += rhs; } �q�个模版中包含有名字对象result�Q�这个对象有名字意味着�q�回��g��化不可用~~~~~~~~· ·······条款23 �Q?考虑使用其他�{��h的程序库 ��L��Q?/font> 提供�c�M��功能的程序库通常在性能问题上采取不同的权衡措施�Q�比如iostream和stdio�Q�所以通过分析�E�序扑ֈ�软�g瓉��之后�Q�可以考虑是否通过替换�E�序库来消除瓉��~~~~ ······条款24 : 理解虚函敎ͼ�多重�l�承�Q�虚基类以及 RTTI 带来的开销虚函数表�Q�vtabs 指向虚函数表的指�?vptrs �E�序中每个声明了或者��承了的虚函数的类都具有自��q��虚函数表。表中的各个��就是指向虚函数具体实现的指针�?/font> class c1{ c1(); virtual ~c1(); virtual void f1(); virtual int f2(char c)const; virtual void f3(const string& s); }; c1 的虚函数表包括： c1::~c1 c1::f1 c1::f2 c1::f3 class c2:public c1{ c2(); virtual ~c2(); virtual void f1(); virtual void f5(char *str); }; 它的虚函数表入口指向的是那些由c1声明但是c2没有重定义的虚函数指针： c2::~c2 c2::f1 c1::f2 c1::f3 c2::f5 所以开销上：必须为包含虚函数的类腑և�额外的空间来存放虚函数表。一个类的虚函数表的大小取决于它的虚函数的个敎ͼ�虽然每一个类只要有一个虚函数表，但是如果有很多类或者每个类��h��很多个虚函数�Q�虚函数表也会占据很大的�I�间�Q�这也是mfc没有采用虚函数实现消息机制的一个原因�?/font> �׃��每一个类只需要一个vtbl的拷贝，把它攑֜�哪里是一个问题：一�U�：为每一个需要vtbl的目标文件生成拷贝，然后�q�接时取出重复拷�?/font> 或者：更常见的是采用试探性算法决定哪一个目标文件应该包含类的vtbl。试探：一个类的vtbl通常产生在包含该�cȝ��一个非内联�Q�非�U�虚函数定义的目标文仉��。所以上面c1�cȝ��vtbl��放在c1::~c1 定义的目标文仉��。如果所有虚函数都声明�ؓ内联�Q�试探性算法就会失败，在每一个目标文件就会有vtbl。所以一般忽略虚函数的inline指��o�?/font> 如果一个类��h��虚函敎ͼ�那么�q�个�cȝ��每一个对象都会具有指向这个虚函数表的指针�Q�这是一个隐藏数据成员vptr~被编译器加在某一个位�|��?/font> 此处�W�二个开销�Q�你必须在每一个对象中存放一个额外的指针~ 如果对象很小�q�个开销��十分显著~~因�ؓ比例大~ 此时 void makeCall(c1* pc1){ pc1->f1(); } ��译�?(*pc1->vptr[i])(pc1); �Ҏ��vptr扑ֈ�vtbl �q�很��单，在vtbl扑ֈ�调用函数对应的函数指针，�q�个步骤也很��单，因�ؓ�~�译器�ؓ虚函数表里的每一个函数设�|�了唯一的烦�?/font> 然后调用指针所指向的函数~ �q�样看来�Q�调用虚函数与普通函数调用的效率相差无几�Q�只多出几个指��o�?/font> 虚函数真正的开销与内联函数有关~�Q�在实际应用中，虚函��C��应该被内联，因�ؓ内联意味着在编译时�ȝ��被调用函数的函数体来代替被调用函数。但是虚函数意味着�q�行时刻军_��调用哪个一函数�Q�so~~~虚函��C��出的�W�三个代价啊�Q�~不能内联�Q�通过对象调用虚函数的时候，�q�些虚函数可以内联，但是大多数虚函数通过指针或者以用来调用的）�?/font> ~多重�l�承的情�?/font> 多重�l�承一般要求虚基类。没有虚基类�Q�如果一个派生类��h��多个通向基类的��承�\径，基类的数据成员会被复制到每一个��承类对象里，�l�承�c�M��基类间的每一条�\径都有一个拷贝�?/font> 有了虚基�c�，通常使用指向虚基�cȝ��指针作�ؓ避免重复的手�D�，�q�样需要在对象内部嵌入一个或者多个指针~也带来了一定的开销~ 例如菱�Ş�l�承 �Q? class A{}; class B:virtual public A{}; class C:virtual public A{}; class D:public B,public C{}; �q�里A是一个虚基类�Q�因为B和C虚拟�l�承了他�?/font> 对象 D 的布局�Q?/font> B data vptr pointer to virtual base class C data vptr pointer to virtual base class D data members A data members vptr 上面四个�c�，只有三个vptr�Q�因为B和D可以�׃�n一个vptr �Q��ؓ啥？�Q?/font> 现在我们已经看到虚函数如何��对象变得更大�Q�以及�ؓ何不能把它内联了~ 下面我们看看RTTI的开销 runtime type identifycation 所需要的开销通过rtti我们可以知道对象和类的有关信息，所以肯定在某个地方存储了这些供我们查询的信息，�q�些信息被存储在type_info �c�d��的对象里�Q�你可以通过typeid�q�算�W�访问一个类的type_info对象�?/font> 每个�c�M��仅需要一个RTTI的拷贝，规范上只保证提供哪些臛_��有一个虚函数的对象的准确的动态类型信息~ why�Q�和虚函数有啥关�p�~ 因�ؓrtti设计在vtbl�?/font> vtbl的下�?包含指向type_info对象的指针。所以��用这�U�实现方法，消费的空间是vtbl中占用一个额外的单元再加上存储type_info对象所需要的�I�间�?/font> ------------------------�|�恶的结束线 OVER~------------------------------------------ rikisand 2010-01-18 14:16 发表评论 rikisand — Sun, 17 Jan 2010 11:36:00 GMT 解决��目的问题，意识到断�a�的重要性。如果一个程序在某处遇到了非法的��|��那么最好的情况便是在此��d��下报错，最坏的情况便是�E�序不吭不响的执行着~~直到你发��C��执行的方式极��异，此时�Q�你要花九牛二虎之力才能扑ֈ�错误所在之处~~~~ 学习一下断�a�吧： ·······什么是断言在某处判断某一个表辑ּ�的��gؓ真或者假�Q�如果假则输出错误消息�ƈ停止�E�序的执行~ assert是宏�Q�而不是函敎ͼ�只在debug版本中有效，因此无需在release版本删除�?/font> ·······哪几�U�断�a� MFC ASSERT void foo(char* p,int size) { ASSERT(p != 0); // 验证�~�冲区指�?br>ASSERT((size >= 100); // ��认�~�冲区大��至��ؓ100字节 // foo 函数的其它计��过�E?br>} 如果没有定义_DEBUG预处理符�Q�则该语句不会真正生成代码。Visual C++会在调试模式�~�译时自动定义_DEBUG�Q�而在发行模式下，该预处理�W�是不存在的。如果定义了_DEBUG�Q�则上述两个断言生成的代码类如： //ASSERT(p != 0); do { if(!(p != 0) && AfxAssertFailedLine(__FILE__, __LINE__)) AfxDebugBreak(); } while(0); //ASSERT((size >= 100); do { if(!(size >= 100) && AfxAssertFailedLine(__FILE__,__LINE__)) AfxDebugBreak(); }while(0); ASSERT_KINDOF(classname,pObject); ASSERT_KINDOF(CDocument,pDocument); ��验pObject指向的对象是classname�cȝ��一个对象或者其�z��cȝ��对象 ASSERT_VALID(pObject); pObject 必须是一个派生于CObject�cȝ��c�d��象，会调用其重写的AssertValid函数 �Q�例�?/font> 如果使用应用向导或类向导生成��Z��MFC的类�Q�通常会得到AssertValid()的骨�Ӟ��最好改写这些骨架代码以增加最基本的完整性检查。下面是一个典型的例子�Q�类Sample从CObject�l�承�Q�假定它含有职员名字及其薪水�Q? class Sample : public CObject { protected: CString m_Name; // 职员名字 double m_Salary; // 薪水 public: Sample(LPCTSTR name,double salary) : m_Name(name), m_Salary(salary) {} #ifdef _DEBUG virtual void AssertValid() const; #endif }; #ifdef _DEBUG void Sample::AssertValid() const { CObject::AssertValid(); // 验证基类 ASSERT(!m_Name.IsEmpty()); // 验证职员名字 ASSERT(m_Salary > 0); // 验证薪水 } #endif CRT assertion _ASSERT �?nbsp; _ASSERTE 后一个会在出错时同时打印出条件判断句 ANSI assert() 注意�Q�assert用于��非法的输入�Q�但是合法的输入�q�不一定是正确的，例如�Q?/font> int pB = (int*)malloc(sizeof(int)*1000); assert(pB!=NULL) //错误的��用assert 他会在release版本失效~也就是说assert不应该对�E�序产生副作�?/font> 正确的做法： int pB = (int*) malloc(sizeof(int)*1000); if(pB == NULL) { //错误处理 } else{ } 另一个例子： void draw(){ CFigure* pF = getCF(); assert(pf!=NULL); if(pf == NULL){} else{ } } 此处�Q�对于getCF来说�q�回��gؓNULL是非法的�Q�如果他的返回值可能�ؓnull��没必要加上assert语句�?/font> 而下面的if语句则是��Z��防止release版本出现null指针的情��c�? VERIFY() �׃��ASSERT仅在�E�序的调试版起作用，��试表达式��L��被动的。也��是��_��它们不能包含赋倹{��增量、减量等真正改变数据的操作。但有时候我们需要验证一个主动表辑ּ��Q�比如赋��D��句。这时可以��用VERIFY代替ASSERT。下面是一个例子： void foo(char* p,int size) { char* q; // 指针的副�?br>VERIFY(q = p); // 拯��指针�q�执行验�?br>ASSERT((size >= 100); // ��保�~�冲区大��至��ؓ100字节 // 执行 foo 的其它操�?br>} 在调试模式下ASSERT和VERIFY是相同的。但在release模式下，VERIFY能够�l�箋对表辑ּ�求��|��但不再进行断�a��验）�Q�而ASSERT语句在效果上��如同已�l�删除了一栗��? ��管在MFC源代码中可以扑ֈ�一些应用VERIFY的例子，但ASSERT用得更�ؓ普遍。一些程序员��L��完全避免使用VERIFY�Q�因��Z��们已�l�习惯于使用被动断言。请��C��Q�如果在ASSERT语句中��用了��d��表达式，�~�译器不会发��Z�Q何警告。在发行模式下编译时该表辑ּ�会被直接删除�Q�从而导致程序运行的错误。由于发行版�E�序不含调试信息�Q�这�U�类型的错误是很难找到原因的�? rikisand 2010-01-17 19:36 发表评论 c++ RTTI (1) rikisand — Sun, 03 Jan 2010 09:59:00 GMT ��目中遇��C�� RTTI 先学一部分 c++ primer内容 �q�行时类型识别： �E�序可以使用基类的指�?/font>或者引用来��索这些指针或引用所指对象的实际�z��c�d�� 标准库提供了两个操作�W�： 1. typeid 他可以返回指针或者引用所指向对象的实际类�?/font> 2. dynamic_cast ��基�cȝ��型的指针或引用安全的转�ؓ�z��cȝ��指针或者引�?nbsp; 对于不带虚函数的�c�d��~�译时期执行�Q�否则在�q�行期间执行使用时机�Q?/font> 基类指针调用�z��c�L��员函数的话，一般应使用虚函敎ͼ��q�样�~�译器会�Ҏ��对象的实际类型来选择正确的函数。但是某些情况下无法使用虚函敎ͼ�那么�?/font> 时如果需要��用基�c�L��针调用派生类成员函数侉K��要��用RTTI强制转换�Q�而且必须��查�{换是否成�?/font>�?/font> (一) Dynamic_cast dynamic_cast 如果转换到指针失败则�q�回 0 如果转换到引用类型失败则抛出 bad_cast 异常 �Ҏ��针操作： if(Derived *derivedPtr = dynamic_cast (basePtr)){ //basePtr point to a derived object; }else{ //basePtr point to a base object; } �?if 语句中进行检�?1.条�g代码内部知道 derivedPtr 的类�?2.不可能在��试代码和��用代码中加入代码�Q�也��是说不会在没有��试前就使用derivedPtr 3.如果��p�|外部不会使用未绑定的指针derivedPtr 对引用操作：因�ؓ不存在空引用所以�{换失败抛出异�?/font> void f(const Base& b){ try{ const Derived &d = dynamic_cast (b); }catch(bad_cast){ } } (�? typeid typeid(e) e是�Q意的表达式或者类型名 Base *bp; Derived *dp; //compare type at run time of two objects if(typeid(*bp)==typeid(*dp)){ //bp dp point to objects of the same type } if(typeid(*bp)==typeid(Derived)){ //bp actually point to a Derived } 注意typeid ��试的是 *bp 对象 //test always fails: The type of bp if pointer to Base if(typeid(bp)==typeid(Derived)){ } Base* ��永�q�和Derived�c�d��不同只有typeid 的操作数是带虚函数的�cȝ��对象的时候，才返回动态类型信息，��试指针�q�回指针的静态的�Q�编译时�c�d�� Q�三 �Q�type_info �c?/p> 作�ؓtypeid的返回�?提供 t1==t2 t1!=t2 t.name() 的操�?/p> 作�ؓ应用例子�Q�可以实��C��个类型敏感的相等操作�W?/p> friend bool operator == (const base& lhs, const base& rhs){ return typeid(lhs)==typeid(rhs) && lhs.equal(rhs); } �q�样可以处理基类子类混合的相�{�判断了 rikisand 2010-01-03 17:59 发表评论 TC-Practice-Record rikisand — Sat, 26 Dec 2009 09:28:00 GMT tchs-1 none 1000pt DFS 利用�q�入的方向划分四个边 tchs-2 250pt 直接��就�?我写�?�?500pt 暴力可以�q�，但是判断时候不能用stringstream 用算术判�?也可以用构造法 1000pt 每一位有三种可能�?/p> 不用�Q�保持不动，变化�Q�分别递归计算value�q�更新结果即可，�׃��递归深度最多只�?3层所以不会tle 另外也可以写出基��Cؓ3的��@环来遍历每一�U�情况具体看代码 for(i=0,A[0]++;A[i]>2;i++){ A[i]=0;A[i+1]++; } tchs-3 1000pt 要想使乘�U�最大，需要更多的3卛_�� 500pt 又看错题�?~~~ft 要注意题目一定要看清�?/p> tchs-4 500pt 模拟题，好难�?音乐的~ 可以都乘�?6 用整数来计算 ��点会很烦~ �q�种题思�\要清�?一步一步来 tchs-5 250pt ��单题�Q�注意��用double 可以�?.0*int��׃��用double()了还�?int(h+1e-9); 500pt ��单题�Q�把所有word提取出来然后排序�Q�再依次插入标点卛_��Q�注意有些小技�?/p> Code Snippet string wordSort(string s) { vector<string> SA,SB; string A="",B=""; for(int i=0;i<s.size();i++) if(s[i]>='A'&&s[i]<='Z'||(s[i]<='z'&&s[i]>='a')){ if(B!=""){ SB.push_back(B);B=""; } A+=s[i]; } else{ if(A!=""){ SA.push_back(A);A=""; } B+=s[i]; } if(A!="")SA.push_back(A);if(B!="")SB.push_back(B); sort(SA.begin(),SA.end());string res=""; int i=0; for(; i<SA.size()&&i<SB.size();i++) if(s[0]>='A'&&s[0]<='Z'||(s[0]<='z'&&s[0]>='a')) res=res+SA[i]+SB[i]; else res=res+SB[i]+SA[i]; for(;i<SA.size();i++)res+=SA[i]; for(;i<SB.size();i++)res+=SB[i]; return res; } 思�\要清晎ͼ�两个轮替记录卛_�� 1000pt 昄��的BFS 利用队列只是题意不太好理解，最好把判断写成��函敎ͼ��ȝ��序会看�v来比较清晎ͼ�不容易出错~ 一步一步来 rikisand 2009-12-26 17:28 发表评论 ALGORITHM IN C (1) rikisand — Wed, 11 Nov 2009 12:18:00 GMT Steps to developing a usable algorithm. • Define the problem. • Find an algorithm to solve it. • Fast enough? • If not, figure out why. • Find a way to address the problem. • Iterate until satisfied. 主要内容 FIND-UNION ALGORITHM ��是利用�q�查集来考察�q�通性的��法。条件N个节点，M对节点，输入每一对节�Ҏ��候，如果已经�q�通，则忽略，否则输出接点�q�更�? 主要介绍三种��法�Q�第一�U�，QUCK-FIND 利用数组记录每一个联通子图，同一个联通子囄��节点数组变量是相同的。因此每��d��一对就需要遍历N个数�l�变量考察是否需要更斎ͼ�最坏时间MN�Q�实际上每个子图为高度�ؓ2的树;�W�二�U�，QUICK-UNION 联通子��N��要union�?仅仅需要将两个root union 因此每个联通子��N��度变高，所有find root 会消耗一定时��_��当然无需遍历N�?�Q�最坏时��_��也就是每�ơ均需要从叶子节点��d��溯求根（�q�里书中丑־�例子好像有问题）也是MN�Q�第三种也就�?QUICK WEIGHT UNION �q�种�Ҏ��在两个子树合�q�的时候，不是��单的指定合�ƈ�{�略�Q�而是�l�过判断的，把size��（相应高度也小�Q�的合�ƈ到size大的里面�Q�实际上很容易理解就是尽量减��树的高度来�q�求quick-find的效率； �q�而作者写道�\径压�~�，也是�q�种思想。或者实��Cؓ全部压羃�Q�也��是说在�q�行union操作的时候，所有check的节炚w��直接链接到union后的新root下面�Q�或者half union �Q�容易实��C��性能好）每次check时候，如果没有停止loop��单的�?id[i]=id[id[i]];卛_��辑ֈ�减少到根距离的效果�? half union 的主要代码： int i,j; for(i=p;id[i]!=i;i=id[i]) id[i]=id[id[i]]; for(j=p;id[j]!=j;j=id[j]) id[j]=id[id[j]]; if(i==j)continue; if(size[i]>size[j]) id[j]=i,size[i]+=size[j]; else id[i]=j,size[j]+=size[i]; �W�一�ơ用windows live writer 试试效果哦~~ rikisand 2009-11-11 20:18 发表评论

亚洲香蕉网久久综合影视,久久99久久99精品免视看动漫,久久久国产亚洲精品

关于寚w��

USACO 4.2.2 �W�一道网�l�流····

PROGRAM NAME: ditch

INPUT FORMAT

SAMPLE INPUT (file ditch.in)

OUTPUT FORMAT

SAMPLE OUTPUT (file ditch.out)

深入探烦C++对象模型��M���W�记 (�?

重蝲操作�W?(c++primer 4e)

素数�{�法

深入探烦C++对象模型��M���W�记 (�?

深入探烦C++对象模型��M���W�记 (�?

深入探烦C++对象模型��M���W�记 (�?

深入探烦C++对象模型��M���W�记 (一)

More Effective C++ (1)

c++ RTTI (1)

TC-Practice-Record

ALGORITHM IN C (1)

深入探烦C++对象模型��M��W�记 (�?

深入探烦C++对象模型��M��W�记 (�?

深入探烦C++对象模型��M��W�记 (�?

深入探烦C++对象模型��M��W�记 (�?

深入探烦C++对象模型��M��W�记 (一)