亚洲一级Av无码毛片久久精品,国内精品伊人久久久久,色综合久久久久综合99

Void and void pointer

zml_cnnk — Sun, 22 Nov 2009 08:14:00 GMT

1.概述

　　许多初学者对C/C++语言中的void及void指针�c�d��不甚理解�Q�因此在使用上出��C��一些错误。本文将对void关键字的深刻含义�q�行解说�Q��ƈ详述void及void指针�c�d��的��用方法与技巧�?br>
　　2.void的含�?/strong>

　　void的字面意思是“无类�?#8221;�Q�void *则�ؓ“无类型指�?#8221;�Q�void *可以指向��M��c�d��的数据�?br>
　　void几乎只有“注释”和限制程序的作用�Q�因��Z��来没有�h会定义一个void变量�Q�让我们试着来定义：

void a;

　　�q�行语句�~�译时会出错�Q�提�C?#8220;illegal use of type 'void'”。不�q�，即��void a的编译不会出错，它也没有��M��实际意义�?br>
　　void真正发挥的作用在于：

　　�Q?�Q�对函数�q�回的限定；

　　�Q?�Q�对函数参数的限定�?br>
　　我们��在�W�三节对以上二点�q�行具体说明�?br>
　　众所周知�Q�如果指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋��|��如果p1和p2指向不同的数据类型，则必��M��用强制类型�{换运��符把赋��D��符双��的指针类型�{换�ؓ左边指针的类型�?

　　例如�Q?br>

float *p1;
int *p2;
p1 = p2;

　　其中p1 = p2语句会编译出错，提示“'=' : cannot convert from 'int *' to 'float *'”�Q�必��L��为：

p1 = (float *)p2;

　　而void *则不同，��M��c�d��的指针都可以直接赋值给它，无需�q�行强制�c�d��转换�Q?

void *p1;
int *p2;
p1 = p2;

　　但这�q�不意味着�Q�void *也可以无需强制�c�d��转换地赋�l�其它类型的指针。因�?#8220;无类�?#8221;可以包容“有类�?#8221;�Q��?#8220;有类�?#8221;则不能包�?#8220;无类�?#8221;。道理很��单，我们可以�?#8220;男�h和女人都是�h”�Q�但不能�?#8220;人是男�h”或�?#8220;人是女�h”。下面的语句�~�译出错�Q?br>

void *p1;
int *p2;
p2 = p1;

　　提示“'=' : cannot convert from 'void *' to 'int *'”�?br>
3.void的��?br>
　　下面�l�出void关键字的使用规则�Q?br>
　　规则一如果函数没有�q�回��|��那么应声明�ؓvoid�c�d��

　　在C语言中，凡不加返回值类型限定的函数�Q�就会被�~�译器作��回整型值处理。但是许多程序员却误以�ؓ其�ؓvoid�c�d��。例如：

add ( int a, int b )
{
return a + b;
}
int main(int argc, char* argv[])
{
printf ( "2 + 3 = %d", add ( 2, 3) );
}

　　�E�序�q�行的结果�ؓ输出�Q?br>
　　2 + 3 = 5

　　�q�说明不加返回��D��明的函数的确为int函数�?br>
　　林锐博士《高质量C/C++�~�程》中提到�Q?#8220;C++语言有很严格的类型安全检查，不允�怸��q�情况（指函��C��加类型声明）发生”。可是编译器�q�不一定这么认定，譬如在Visual C++6.0中上�q�add函数的编译无错也无警告且�q�行正确�Q�所以不能寄希望于编译器会做严格的类型检查�?br>
　　因此�Q��ؓ了避免�؜乱，我们在编写C/C++�E�序�Ӟ��对于��M��函数都必��M��个不漏地指定其类型。如果函数没有返回��|��一定要声明为void�c�d��。这既是�E�序良好可读性的需要，也是�~�程规范性的要求。另外，加上void�c�d��声明后，也可以发挥代码的“自注�?#8221;作用。代码的“自注�?#8221;即代码能自己注释自己�?br>
　　规则二如果函数无参数�Q�那么应声明其参��Cؓvoid

　　在C++语言中声明一个这��L��函数�Q?br>

int function(void)
{
return 1;
}

　　则进行下面的调用是不合法的：

function(2);

　　因�ؓ在C++中，函数参数为void的意思是�q�个函数不接受�Q何参数�?br>
　　我们在Turbo C 2.0中编译：

#include "stdio.h"
fun()
{
return 1;
}
main()
{
printf("%d",fun(2));
getchar();
}

　　�~�译正确且输�?�Q�这说明�Q�在C语言中，可以�l�无参数的函��C��送�Q意类型的参数�Q�但是在C++�~�译器中�~�译同样的代码则会出错。在C++中，不能向无参数的函��C��送�Q何参敎ͼ�出错提示“'fun' : function does not take 1 parameters”�?br>
　　所以，无论在C�q�是C++中，若函��C��接受��M��参数�Q�一定要指明参数为void�?br>
　　规则三小心��用void指针�c�d��

　　按照ANSI(American National Standards Institute)标准�Q�不能对void指针�q�行��法操作�Q�即下列操作都是不合法的�Q?br>

void * pvoid;
pvoid++; //ANSI�Q�错�?br>pvoid += 1; //ANSI�Q�错�?br>//ANSI标准之所以这栯��定，是因为它坚持�Q�进行算法操作的指针必须是确定知道其指向数据�c�d��大小的�?br>//例如�Q?br>int *pint;
pint++; //ANSI�Q�正��?/td>

　　pint++的结果是使其增大sizeof(int)�?br>
　　但是大名鼎鼎的GNU(GNU's Not Unix的羃�?则不�q�么认定�Q�它指定void *的算法操作与char *一致�?br>
　　因此下列语句在GNU�~�译器中皆正��：

pvoid++; //GNU�Q�正��?br>pvoid += 1; //GNU�Q�正��?/td>

　　pvoid++的执行结果是其增大了1�?br>
　　在实际的�E�序设计中，��合ANSI标准�Q��ƈ提高�E�序的可�U�L��性，我们可以�q�样�~�写实现同样功能的代码：

void * pvoid;
(char *)pvoid++; //ANSI�Q�正��；GNU�Q�正��?br>(char *)pvoid += 1; //ANSI�Q�错误；GNU�Q�正��?/td>

　　GNU和ANSI�q�有一些区别，��M��而言�Q�GNU较ANSI�?#8220;开�?#8221;�Q�提供了�Ҏ(gu��)��多语法的支持。但是我们在真实设计�Ӟ��q�是应该��可能地�q�合ANSI标准�?br>
　　规则四如果函数的参数可以是�Q意类型指针，那么应声明其参数为void *

　　典型的如内存操作函数memcpy和memset的函数原型分别�ؓ�Q?br>

void * memcpy(void *dest, const void *src, size_t len);
void * memset ( void * buffer, int c, size_t num );

　　�q�样�Q��Q何类型的指针都可以传入memcpy和memset中，�q�也真实��C��C��内存操作函数的意义，因�ؓ它操作的对象仅仅是一片内存，而不��片内存是什么类型。如果memcpy和memset的参数类型不是void *�Q�而是char *�Q�那才叫真的奇怪了�Q�这��L��memcpy和memset明显不是一�?#8220;�U��a的，��q��低�񔭑�味�?#8221;函数�Q?br>
　　下面的代码执行正��：

//�C�Z��Q�memset接受��L��c�d��指针
int intarray[100];
memset ( intarray, 0, 100*sizeof(int) ); //��intarray�?
//�C�Z��Q�memcpy接受��L��c�d��指针
int intarray1[100], intarray2[100];
memcpy ( intarray1, intarray2, 100*sizeof(int) ); //��intarray2拯��l�intarray1

　　有趣的是�Q�memcpy和memset函数�q�回的也是void *�c�d��Q�标准库函数的编写者是多么地富有学问啊�Q?br>
　　规则�?void不能代表一个真实的变量

　　下面代码都企图让void代表一个真实的变量�Q�因此都是错误的代码�Q?br>

void a; //错误
function(void a); //错误

　　void体现了一�U�抽象，�q�个世界上的变量都是“有类�?#8221;的，譬如一个�h不是男�h��是女�h�Q�还有�h妖？�Q��?br>
　　void的出现只是�ؓ了一�U�抽象的需要，如果你正��地理解了面向对象中“抽象基类”的概念，也很�Ҏ(gu��)��理解void数据�c�d��。正如不能给抽象基类定义一个实例，我们也不能定义一个void�Q�让我们�c�L��的称void�?#8220;抽象数据�c�d��”�Q�变量�?br>
　　4.�ȝ��

　　��小的void蕴藏着很丰富的设计哲学�Q�作��Z��名程序设计�h员，寚w��题进行深一个层�ơ的思考必然��我们受益匪浅

zml_cnnk 2009-11-22 16:14 发表评论

Type Attribute aligned

zml_cnnk — Sun, 22 Nov 2009 06:28:00 GMT

Type attribute aligned allows you to specify the alignment of a structure, class, union, or enumeration. The syntax and considerations for specifying alignment factor are the same as for variable attribute aligned. Like variable attribute aligned, type attribute aligned can only increase alignment. Type attribute packed is used to decrease alignment.
If the attribute appears immediately after the class, struct, union, or enumeration token or immediately after the closing right curly brace, it applies to the type identifier. It can also be specified on a typedef declaration. In a variable declaration, such as
class A {} a;

the placement of the type attribute can be confusing.
In the following definitions, the attribute applies to A:
struct __attribute__((__aligned__(8))) A {}; struct A {} __attribute__((__aligned__(8))) ; struct __attribute__((__aligned__(8))) A {} a; struct A {} __attribute__((__aligned__(8))) a; typedef struct __attribute__((__aligned__(8))) A {} a; typedef struct A {} __attribute__((__aligned__(8))) a;

In the following definitions, the attribute applies to a:
__attribute__((__aligned__(8))) struct A {} a; struct A {} const __attribute__((__aligned__(8))) a; __attribute__((__aligned__(8))) typedef struct A {} a; typedef __attribute__((__aligned__(8))) struct A {} a; typedef struct A {} const __attribute__((__aligned__(8))) a; typedef struct A {} a __attribute__((__aligned__(8)));

zml_cnnk 2009-11-22 14:28 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:28:00 GMT

虚函数是C++中用于实现多�?polymorphism)的机制。核心理念就是通过基类讉K��z��c�d��义的函数。假设我们有下面的类层次�Q?br>class A
{
public:
    virtual void foo() { cout << "A::foo() is called" << endl;}
};
class B: public A
{
public:
    virtual void foo() { cout << "B::foo() is called" << endl;}
};

那么�Q�在使用的时候，我们可以�Q?br>A * a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B�?

�q�个例子是虚函数的一个典型应用，通过�q�个例子�Q�也�怽��对虚函数有了一些概��c��它虚就虚在所�?#8220;推迟联编”或�?#8220;动态联�~?#8221;上，一个类函数的调用�ƈ不是在编译时刻被��定的，而是在运行时刻被��定的。由于编写代码的时候�ƈ不能��定被调用的是基�cȝ��函数�q�是哪个�z��cȝ��函数�Q�所以被成�ؓ“�?#8221;函数�?/p>
虚函数只能借助于指针或者引用来辑ֈ�多态的效果�Q�如果是下面�q�样的代码，则虽然是虚函敎ͼ�但它不是多态的�Q?br>class A
{
public:
    virtual void foo();
};
class B: public A
{
    virtual void foo();
};
void bar()
{
    A a;
    a.foo(); // A::foo()被调�?br>}

1.1 多�?/strong>

在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍焉��对上面的�c�d��ơ，但是使用的方法变的复杂了一些：
void bar(A *a)
{
    a->foo(); // 被调用的是A::foo() �q�是B::foo()�Q?br>}

因�ؓfoo()是个虚函敎ͼ�所以在bar�q�个函数中，只根据这�D�代码，无从��定�q�里被调用的是A::foo()�q�是B::foo()�Q�但是可以肯定的��_��如果a指向的是A�cȝ��实例�Q�则A::foo()被调用，如果a指向的是B�cȝ��实例�Q�则B::foo()被调用�?/p>
�q�种同一代码可以产生不同效果的特点，被称�?#8220;多�?#8221;�?/p>

1.2 多态有什么用�Q?/strong>
　　多态这么神奇，但是能用来做什么呢�Q�这个命题我难以用一两句话概括，一般的C++教程�Q�或者其它面向对象语�a�的教�E�）都用一个画囄��例子来展�C�多态的用途，我就不再重复�q�个例子了，如果你不知道�q�个例子�Q�随便找本书应该都有介绍。我试图从一个抽象的角度描述一下，回头再结合那个画囄��例子�Q�也�怽��更�Ҏ(gu��)��理解�?/p>
在面向对象的�~�程中，首先会针�Ҏ(gu��)��据进行抽象（��定基类�Q�和�l�承�Q�确定派生类�Q�，构成�c�d��ơ。这个类层次的��用者在使用它们的时候，如果仍然在需要基�cȝ��时候写针对基类的代码，在需要派生类的时候写针对�z��cȝ��代码�Q�就�{�于�c�d��ơ完全暴露在使用者面前。如果这个类层次有�Q何的改变�Q�增加了新类�Q�，都需要��用�?#8220;知道”�Q�针�Ҏ(gu��)��c�d��代码�Q�。这样就增加了类层次与其使用者之间的耦合�Q�有人把�q�种情况列�ؓ�E�序中的“bad smell”之一�?/p>
多态可以�ɽE�序员脱��这�U�窘境。再回头看看1.1中的例子�Q�bar()作�ؓA-B�q�个�c�d��ơ的使用者，它�ƈ不知道这个类层次中有多少个类�Q�每个类都叫什么，但是一样可以很好的工作�Q�当有一个C�c�M��A�c�L��生出来后�Q�bar()也不需�?#8220;知道”�Q�修改）。这完全归功于多�?-�~�译器针对虚函数产生了可以在�q�行时刻��定被调用函数的代码�?/p>

1.3 如何“动态联�~?/strong>”
　　�~�译器是如何针对虚函��C�生可以再�q�行时刻��定被调用函数的代码呢？也就是说�Q�虚函数实际上是如何被编译器处理的呢�Q�Lippman在深度探索C++对象模型[1]中的不同章节讲到了几�U�方式，�q�里�?#8220;标准�?#8221;方式��单介�l�一下�?/p>
我所说的“标准”方式�Q�也��是所谓的“VTABLE”机制。编译器发现一个类中有被声明�ؓvirtual的函敎ͼ��׃��为其搞一个虚函数表，也就�?VTABLE。VTABLE实际上是一个函数指针的数组�Q�每个虚函数占用�q�个数组的一个slot。一个类只有一个VTABLE�Q�不��它有多��个实例。派生类有自��q��VTABLE�Q�但是派生类的VTABLE与基�cȝ��VTABLE有相同的函数排列��序�Q�同名的虚函数被攑֜�两个数组的相同位�|�上。在创徏�c�d��例的时候，�~�译器还会在每个实例的内存布局中增加一个vptr字段�Q�该字段指向本类的VTABLE。通过�q�些手段�Q�编译器在看��C��个虚函数调用的时候，��׃��这个调用改写，针对1.1中的例子�Q?br>void bar(A * a)
{
    a->foo();
}
会被改写为：
void bar(A * a)
{
    (a->vptr[1])();
}

因�ؓ�z��c�d��基类的foo()函数��h��相同的VTABLE索引�Q�而他们的vptr又指向不同的VTABLE�Q�因此通过�q�样的方法可以在�q�行时刻军_��调用哪个foo()函数�?/p>
虽然实际情况�q�非�q�么��单，但是基本原理大致如此�?/p>

1.4 overload�?/strong>override

虚函数��L��在派生类中被改写�Q�这�U�改写被�U�Cؓ“override”。我�l�常��h��“overload”�?#8220;override”�q�两个单词。但是随着各类C++的书��来��多�Q�后来的�E�序员也�怸�会再犯我犯过的错误了。但是我打算澄清一下：

override是指�z��c�重写基�cȝ��虚函敎ͼ��p��我们前面B�c�M��重写了A�c�M��的foo()函数。重写的函数必须有一致的参数表和�q�回��|��C++标准允许�q�回��g��同的情况�Q�这个我会在“语法”部分��单介�l�，但是很少�~�译器支持这个feature�Q�。这个单词好象一直没有什么合适的中文词汇来对应，有�h译�ؓ“覆盖”�Q�还贴切一些�?br>overload�U�定成俗的被��译�?#8220;重蝲”。是指编写一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型��C��为参敎ͼ�也可以接受��Q�Ҏ(gu��)��作�ؓ参数�?/p>

�?/strong>. 虚函数的语法
　　虚函数的标志�?#8220;virtual”关键字�?/p>

2.1 使用virtual关键�?/strong>

考虑下面的类层次�Q?br>class A
{
public:
    virtual void foo();
};

class B: public A
{
public:
    void foo(); // 没有virtual关键�?
};

class C: public B // 从B�l�承�Q�不是从A�l�承�Q?br>{
public:
    void foo(); // 也没有virtual关键字！
};

�q�种情况下，B::foo()是虚函数�Q�C::foo()也同��h��虚函数。因此，可以��_��基类声明的虚函数�Q�在�z��c�M��也是虚函敎ͼ�即��不再使用virtual关键字�?/p>

2.2 �U�虚函数
　　如下声明表示一个函��Cؓ�U�虚函数�Q?br>class A
{
public:
    virtual void foo()=0; // =0标志一个虚函数为纯虚函�?br>};

一个函数声明�ؓ�U�虚后，�U�虚函数的意思是�Q�我是一个抽象类�Q�不要把我实例化�Q�纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的�z��c�都会有�q�个函数�?/p>

2.3 虚析构函�?/strong>
　　析构函数也可以是虚的�Q�甚��x��U�虚的。例如：
class A
{
public:
virtual ~A()=0; // �U�虚析构函数
};

当一个类打算被用作其它类的基�c�L��Q�它的析构函数必��L��虚的。考虑下面的例子：
class A
{
public:
    A() { ptra_ = new char[10];}
    ~A() { delete[] ptra_;} // 非虚析构函数
private:
    char * ptra_;
};
class B: public A
{
public:
    B() { ptrb_ = new char[20];}
    ~B() { delete[] ptrb_;}
private:
    char * ptrb_;
};
void foo()
{
    A * a = new B;
    delete a;
}

在这个例子中�Q�程序也�怸�会象你想象的那样�q�行�Q�在执行delete a的时候，实际上只有A::~A()被调用了�Q�而B�cȝ��析构函数�q�没有被调用�Q�这是否有点儿可怕？

如果��上面A::~A()改�ؓvirtual�Q�就可以保证B::~B()也在delete a的时候被调用了。因此基�cȝ��析构函数都必��L��virtual的�?/p>
�U�虚的析构函数�ƈ没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象�c�（不能实例化的�c�）�Q�而这个类又没有合适的函数可以被纯虚化的时候，可以使用�U�虚的析构函数来辑ֈ�目的�?/p>

2.4 虚构造函敎ͼ�
　　构造函��C��能是虚的�?/p>

�?/strong>. 虚函��C��用技�?/strong>

3.1 private的虚函数

考虑下面的例子：
class A
{
public:
    void foo() { bar();}
private:
    virtual void bar() { ...}
};
class B: public A
{
private:
    virtual void bar() { ...}
};

在这个例子中�Q�虽然bar()在A�c�M��是private的，但是仍然可以出现在派生类中，�q�仍然可以与public或者protected的虚函数一样��生多态的效果。�ƈ不会因�ؓ它是private的，��发生A::foo()不能讉K��B::bar()的情况，也不会发生B::bar()对A::bar ()的override不�v作用的情��c�?/p>
�q�种写法的语意是�Q�A告诉B�Q�你最好override我的bar()函数�Q�但是你不要��它如何使用�Q�也不要自己调用�q�个函数�?/p>

3.2 构造函数和析构函数中的虚函数调�?/strong>

一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们��变成普通函��C��Q�不“�?#8221;了。也��是说不能在构造函数和析构函数中让自己“多�?#8221;。例如：
class A
{
public:
    A() { foo();} // 在这里，无论如何都是A::foo()被调用！
    ~A() { foo();} // 同上
    virtual void foo();
};
class B: public A
{
public:
    virtual void foo();
};
void bar()
{
    A * a = new B;
    delete a;
}

如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同��P��在new B的时候，A的构造函数被调用�Q�但是在A的构造函��C��Q�被调用的是A::foo()而不是B::foo()�?/p>

3.4 什么时候��用虚函数

在你设计一个基�cȝ��时候，如果发现一个函数需要在�z��c�里有不同的表现�Q�那么它?y��u)��应该是虚的。从设计的角度讲�Q�出现在基类中的虚函数是接口�Q�出现在�z��c�M��的虚函数是接口的具体实现。通过�q�样的方法，��可以将对象的行为抽象化�?/p>
以设计模式[2]中Factory Method模式��Z��Q�Creator的factoryMethod()��是虚函敎ͼ��z��c�override�q�个函数后，产生不同的Product�c�，产生的Product�c�被基类的AnOperation()函数使用。基�cȝ��AnOperation()函数针对Product�c�进行操作，当然 Product�c�M��定也有多态（虚函敎ͼ��?/p>
另外一个例子就是集合操作，假设你有一个以A�c�Mؓ基类的类层次�Q�又用了一个std:: vector来保存这个类层次中不同类的实例指针，那么你一定希望在对这个集合中的类�q�行操作的时候，不要把每个指针再cast回到它原来的�c�d��Q�派生类�Q�，而是希望对他们进行同��L��操作。那么就应该��这�?#8220;一��L��操作”声明为virtual�?/p>
现实中，�q�不只我丄��q�两个例子，但是大的原则都是我前面说到的“如果发现一个函数需要在�z��c�里有不同的表现�Q�那么它?y��u)��应该是虚�?#8221;。这句话也可以反�q�来��_��“如果你发现基�c�L��供了虚函敎ͼ�那么你最好override�?#8221;�?/p>

附：C++中的虚函数和�U�虚函数用法

1.虚函数和�U�虚函数可以定义在同一个类(class)中，含有�U�虚函数的类被称为抽象类�Q�abstract class�Q�，而只含有虚函数的�c�（class�Q�不能被�U�Cؓ抽象�c�（abstract class�Q��?/p>
2.虚函数可以被直接使用�Q�也可以被子�c�（sub class�Q�重载以后以多态的形式调用�Q�而纯虚函数必��d��子类�Q�sub class�Q�中实现该函数才可以使用�Q�因为纯虚函数在基类�Q�base class�Q?br>只有声明而没有定义�?/p>
3.虚函数和�U�虚函数都可以在子类�Q�sub class�Q�中被重载，以多态的形式被调用�?/p>
4.虚函数和�U�虚函数通常存在于抽象基�c�（abstract base class -ABC�Q�之中，被��承的子类重蝲�Q�目的是提供一个统一的接口�?/p>
5.虚函数的定义形式�Q�virtual {method body} �Q�纯虚函数的定义形式�Q�virtual { } = 0; 在虚函数和纯虚函数的定义中不能有static标识�W�，原因很简单，被static修饰的函数在�~�译时候要求前期bind,然而虚函数却是动态绑定（run-time bind�Q�，而且被两者修饰的函数生命周期�Q�life recycle�Q�也不一栗��?/p>
6.如果一个类中含有纯虚函敎ͼ�那么��M��试图对该�c�进行实例化的语句都��导致错误的产生�Q�因为抽象基�c�（ABC�Q�是不能被直接调用的。必��被子类�l�承重蝲以后�Q�根据要求调用其子类的方法�?/p>
以下��Z��个简单的虚函数和�U�虚寒数的��用演�C�，目的是抛砖引玉！
//father class
class Virtualbase
{
public:
    virtual void Demon()= 0; //prue virtual function
    virtual void Base() {cout<<"this is farther class"<};
};
//sub class
class SubVirtual :public Virtualbase
{
public:
    void Demon() { cout<<" this is SubVirtual!"<
void Base() {cout<<"this is subclass Base"<};

void main()
{
    Virtualbase* inst = new SubVirtual(); //multstate pointer
    inst->Demon();
    inst->Base();
    // inst = new Virtualbase();
    // inst->Base()
    return ;
}

----------------------------------------------------------------------------------------------

    虚函数是在类中被声明为virtual的成员函敎ͼ�当编译器看到通过指针或引用调用此�c�d��数时�Q�对其执行晚�l�定�Q�即通过指针�Q�或引用�Q�指向的�cȝ��c�d��信息来决定该函数是哪个类的。通常此类指针或引用都声明为基�cȝ��Q�它可以指向基类或派生类的对象。多态指同一个方法根据其所属的不同对象可以有不同的行�ؓ�?/p>
早绑定指�~�译器在�~�译期间即知道对象的具体�c�d��q�确定此对象调用成员函数的确切地址�Q�而晚�l�定是根据指针所指对象的�c�d��信息得到�cȝ��虚函数表指针�q�而确定调用成员函数的��切地址�?/p>
�~�译器对每个包含虚函数的�c�d��Z��个表�Q�称为vtable�Q�。在vtable中，�~�译器放�|�特定类的虚函数地址。在每个带有虚函数的�c�M��Q�编译器�U�密地置一指针�Q�称为vpointer�Q�羃写�ؓvptr�Q�，指向�q�个对象的vtable。通过基类指针做虚函数调用�Ӟ��也就是做多态调用时�Q�，�~�译器静态地插入取得�q�个vptr�Q��ƈvtable表中查找函数地址的代码，�q�样��p��调用正确的函��C��晚捆�l�发生。�ؓ每个�c�设�|�vtable、初始化vptr、�ؓ虚函数调用插入代码，所有这些都是自动发生的�Q�所以我们不必担心这些。利用虚函数�Q�这个对象的合适的函数��p��被调用，哪怕在�~�译器还不知道这个对象的特定�c�d��的情况下�?/p>
在�Q何类中不存在昄��的类型信息，可对象中必须存放�c�M��息，否则�c�d��不可能在�q�行时徏立。那�q�个�c�M��息是什么呢�Q�我们来看下面几个类�Q?/p>
class no_virtual
{
public:
    void fun1() const{}
    int  fun2() const { return a; }
private:
    int a;
}

class one_virtual
{
public:
    virtual void fun1() const{}
    int  fun2() const { return a; }
private:
    int a;
}

class two_virtual
{
public:
    virtual void fun1() const{}
    virtual int  fun2() const { return a; }
private:
    int a;
}

以上三个�c�M��Q?br>no_virtual没有虚函敎ͼ�sizeof(no_virtual)=4�Q�类no_virtual的长度就是其成员变量整型a的长度；
one_virtual有一个虚函数�Q�sizeof(one_virtual)=8�Q?br>two_virtual有两个虚函数�Q�sizeof(two_virtual)=8�Q?nbsp;有一个虚函数和两个虚函数的类的长度没有区别，其实它们的长度就是no_virtual的长度加一个void指针的长度，它反映出�Q�如果有一个或多个虚函敎ͼ��~�译器在�q�个�l�构中插入一个指针（ vptr�Q�。在one_virtual 和two_virtual之间没有区别。这是因为vptr指向一个存攑֜�址的表�Q�只需要一个指针，因�ؓ所有虚函数地址都包含在�q�个表中。这个VPTR��可以看作类的类型信息�?/p>
那我们来看看�~�译器是怎么建立VPTR指向的这个虚函数表的。先看下面两个类�Q?br>class base
{
public:
    void bfun(){}
    virtual void vfun1(){}
    virtual int vfun2(){}
private:
    int a;
}
class derived : public base
{
public:
    void dfun(){}
    virtual void vfun1(){}
    virtual int vfun3(){}
private:
    int b;
}
两个�c�VPTR指向的虚函数表（VTABLE�Q�分别如下：
base�c?br>          —————�?br>VPTR—�?gt; |&base::vfun1 |
           —————�?br>          |&base::vfun2 |
           —————�?br>
derived�c?br>           ——————�?br>VPTR—�?gt; |&derived::vfun1 |
           ——————�?br>          |&base::vfun2    |
           ——————�?br>          |&derived::vfun3 |
            ——————�?/p>
每当创徏一个包含有虚函数的�c�L��从包含有虚函数的�c�L��生一个类�Ӟ��~�译器就��个类创徏一个VTABLE�Q�如上图所�C�。在�q�个表中�Q�编译器攄��了在�q�个�c�M��或在它的基类中所有已声明为virtual的函数的地址。如果在�q�个�z��c�M��没有对在基类中声明�ؓvirtual的函数进行重新定义，�~�译器就使用基类的这个虚函数地址。（在derived的VTABLE中，vfun2的入口就是这�U�情��c��）然后�~�译器在�q�个�c�M��攄��VPTR。当使用��单��承时�Q�对于每个对象只有一个VPTR。VPTR必须被初始化为指向相应的VTABLE�Q�这在构造函��C��发生�?/p>
一旦VPTR被初始化为指向相应的VTABLE�Q�对象就"知道"它自己是什么类型。但只有当虚函数被调用时�q�种自我认知才有用�?/p>
VPTR常常位于对象的开��_��~�译器能很容易地取到VPTR的��|��从而确定VTABLE的位�|�。VPTR��L��向VTABLE的开始地址�Q�所有基�c�d��它的子类的虚函数地址�Q�子�c�自己定义的虚函数除外）在VTABLE中存储的位置��L��相同的，如上面base�c�d��derived�cȝ��VTABLE中vfun1和vfun2的地址��L��按相同的��序存储。编译器知道vfun1位于VPTR处，vfun2位于VPTR+1处，因此在用基类指针调用虚函数时�Q�编译器首先获取指针指向对象的类型信息（VPTR�Q�，然后��去调用虚函数。如一个base�c�L��针pBase指向了一个derived对象�Q�那pBase->vfun2()被编译器��译�?nbsp;VPTR+1 的调用，因�ؓ虚函数vfun2的地址在VTABLE中位于烦引�ؓ1的位�|�上。同理，pBase->vfun3()被编译器��译�?nbsp;VPTR+2的调用。这��是所谓的晚绑定�?/p>

zml_cnnk 2008-10-28 20:28 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:27:00 GMT
转蝲内容。另有其他更好的转蝲参考资料，在博文最末尾�?br />
    面向对象�~�程语言中的多重�l�承指的是一个类别可以同时从多于一个父�cȝ��承行��Z��特征的功能。与单一�l�承相对�Q�单一�l�承指一个类别只可以�l�承自一个父�c�R�?
    重温Java�Q�发现Java竟然不支持类多重�l�承�Q�直接��承类�Q�，却允许接口的多重�l�承。�?/div>
    C++中类可以多重�l�承�Q�Java中�ؓ什么不实现�q�个功能呢？多重�l�承会带来哪些问题，从而导致Java攑ּ��cȝ��多重�l�承�Q?/div>
    再一��q��Q�发现多�q�以来，多重�l�承一直是个敏感话题，赞成者看到的是免�ȝ��拙的混合�l�承的利处，反对者看到的是多处�؜淆的弊端�Q�例如变量的二义性，�q�且是多个变量。所以关于它的好处与风险之间孰轻孰重成�ؓOO界多�q�争论的焦点�?/div>
    其实最大的问题是出现拓补图�Q�也��是出现�ȝ��型��承结构（DOD�Q�，个�h感觉�q�是个致命伤。正如其名：Diamond of Death�?/div>

举个��单的例子�Q?/div>
    比如一个基�c�：动物。它有三个派生类�Q�哺乳类动物�Q�卡通类动物�Q�宠物（��实都�Ş成ISA关系�Q�。现在有一个子�cȝ��Q�从关系上推�Q�它可以�l�承自哺乳类�Q�卡通类�Q�宠物，都符合ISA�Q�如果要体现所有的�Ҏ(gu��)��，��需要全部��承，�q�样��Ş成了多重�l�承�Q�却也�Ş成了DOD�Q�这样以后问题就出现了，从猫到动物的�l�承有三条�\径，如果��Z�^�c�，卡通类与宠物类中有相同的成员函数或变量�Q�这��L��数据�l�织方式会�Ş成多义�?/div>

    C++怎么解决�q�个问题的呢�Q�虚�l�承。结果就是不得不牺牲一些内存开销�Q�因��Z��个功能要在多处被重写。�ƈ且函数表里的函数指针必须调整�Q�这样即使可以满��_��能，在后期的�l�护也很复杂�?/div>
    所以，Java才会采用�q�样折中的方法，��生生的��类多重�l�承题了出去�?/div>
    �q�且�Q�网上也有不��徏议，要尽可能避免多重�l�承�Q�不惜一切代价去避免�ȝ��l�构�Q�以避免后期不可挽回的大�q�工�?/div>

    多重�l�承的概念：C++允许��Z��个派生类指定多个基类�Q�这��L��l�承�l�构被称做多重��?/span>�?/span>

    举个例子�Q�交通工��L��可以�z��出汽车和船连个子�c�，但拥有汽车和船共同特性水陆两用汽车就必须�l�承来自汽�R�c�M��船类的共同属性�?br />　　由此我们不难惛_��如下的图例与代码�Q?

当一个派生类要��用多重��承的时候，必须在派生类名和冒号之后列出所有基�cȝ��c�d��Q��ƈ用逗好分隔。　

//�E�序作�?��宁
//站点:www.cndev-lab.com
//所有稿件均有版�?如要转蝲,请务必著名出处和作�?nbsp;

#include
using namespace std;

class Vehicle
{
    public:
        Vehicle(int weight = 0)
        {
            Vehicle::weight = weight;
        }
        void SetWeight(int weight)
        {
            cout<<"重新讄��重量"<
            Vehicle::weight = weight;
        }
        virtual void ShowMe() = 0;
    protected:
        int weight;
};
class Car:public Vehicle//汽�R
{
    public:
        Car(int weight=0,int aird=0):Vehicle(weight)
        {
            Car::aird = aird;
        }
        void ShowMe()
        {
            cout<<"我是汽�R�Q?<
        }
    protected:
        int aird;
};

class Boat:public Vehicle//�?nbsp;
{
    public:
        Boat(int weight=0,float tonnage=0):Vehicle(weight)
        {
            Boat::tonnage = tonnage;
        }
        void ShowMe()
        {
            cout<<"我是船！"<
        }
    protected:
        float tonnage;
};

class AmphibianCar:public Car,public Boat//水陆两用汽�R,多重�l�承的体�?nbsp;
{
    public:
        AmphibianCar(int weight,int aird,float tonnage)
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)
        //多重�l�承要注意调用基�c�L��造函�?nbsp;
        {

        }
        void ShowMe()
        {
            cout<<"我是水陆两用汽�R�Q?<
        }
};
int main()
{
    AmphibianCar a(4,200,1.35f);//错误
    a.SetWeight(3);//错误
    system("pause");
}

　　上面的代码从表面看，看不出有明显的语法错误，但是它是不能够通过�~�译的。这有是��Z��么呢�Q?br />　　�q�是�׃��多重�l�承带来的��承的模糊性带来的问题�?/p>
    先看如下的图�C�：

　　在图中深�U�色标记出来的地�Ҏ(gu��)��是主要问题所在，水陆两用汽�R�cȝ��承了来自Car�c�M��Boat�cȝ��属性与�Ҏ(gu��)��Q�Car�c�M��Boat�c�d��为AmphibianCar�cȝ��基类�Q�在内存分配上AmphibianCar获得了来自两个类的SetWeight()成员函数�Q�当我们调用a.SetWeight(3)的时候计��机不知道如何选择分别属于两个基类的被重复拥有了的�c�L��员函数SetWeight()�?/p>
　　�׃��q�种模糊问题的存在同样也��D��了AmphibianCar a(4,200,1.35f);执行��p�|�Q�系�l�会产生Vehicle”不是基或成员的错误�?/p>
　　以上面的代码��Z��Q�我们要惌��AmphibianCar�c�L��获得一个Vehicle的拷贝，而且又同时共享用Car�c�M��Boat�cȝ��数据成员与成员函数就必须通过C++所提供�?span style="color: #ffff00;">虚拟�l�承技术来实现�?/p>
　　我们在Car�c�d��Boat�cȝ��承Vehicle�c�d��Q�在前面加上virtual关键字就可以实现虚拟�l�承�Q?span style="color: #ffff00;">使用虚拟�l�承后，当系�l�碰到多重��承的时候就会自动先加入一个Vehicle的拷贝，当再�ơ请求一个Vehicle的拷贝的时候就会被忽略�Q�保证��承类成员函数的唯一性�?/span>
　　修改后的代码如下�Q�注意观察变化：

//�E�序作�?��宁
//站点:www.cndev-lab.com
//所有稿件均有版�?如要转蝲,请务必著名出处和作�?nbsp;

#include
using namespace std;

class Vehicle
{
    public:
        Vehicle(int weight = 0)
        {
            Vehicle::weight = weight;
            cout<<"载入Vehicle�c�L��造函�?<
        }
        void SetWeight(int weight)
        {
            cout<<"重新讄��重量"<
            Vehicle::weight = weight;
        }
        virtual void ShowMe() = 0;
    protected:
        int weight;
};
class Car:virtual public Vehicle//汽�R�Q�这里是虚拟�l�承
{
    public:
        Car(int weight=0,int aird=0):Vehicle(weight)
        {
            Car::aird = aird;
            cout<<"载入Car�c�L��造函�?<
        }
        void ShowMe()
        {
            cout<<"我是汽�R�Q?<
        }
    protected:
        int aird;
};

class Boat:virtual public Vehicle//�?�q�里是虚拟��?nbsp;
{
    public:
        Boat(int weight=0,float tonnage=0):Vehicle(weight)
        {
            Boat::tonnage = tonnage;
            cout<<"载入Boat�c�L��造函�?<
        }
        void ShowMe()
        {
            cout<<"我是船！"<
        }
    protected:
        float tonnage;
};

class AmphibianCar:public Car,public Boat//水陆两用汽�R,多重�l�承的体�?nbsp;
{
    public:
        AmphibianCar(int weight,int aird,float tonnage)
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage)
        //多重�l�承要注意调用基�c�L��造函�?nbsp;
        {
            cout<<"载入AmphibianCar�c�L��造函�?<
        }
        void ShowMe()
        {
            cout<<"我是水陆两用汽�R�Q?<
        }
        void ShowMembers()
        {
            cout<<"重量�Q?<
                <<"�I�气排量�Q?<
                <<"排水量："<
        }
};
int main()
{
    AmphibianCar a(4,200,1.35f);
    a.ShowMe();
    a.ShowMembers();
    a.SetWeight(3);
    a.ShowMembers();
    system("pause");
}

　　注意观察�c�L��造函数的构造顺序�?br />　　虽然说虚拟��承与虚函数有一定相似的地方�Q�但读者务必要��C��Q�他们之间是�l�对没有��M��联系的！

==================================================================

补充�Q?/p>
1�?nbsp;当一个类有多个父�c�L��Q�每个父�c�d��内存中依�ơ排列，然后该类自己的成员�?br />2�?nbsp;每一个父�cȝ��镜像中，都包含有独立的虚函数�?br />3�?nbsp;当把子类的指针Upcast的时候，两种Upcast的方式得到的�l�果分别指向各自的父�c�镜�?br />4�?nbsp;当两个父�c�重载的虚函��C��同时�Q�会使用Thunk机制�Q�也��是��_��虚函数表中的函数指针�q�不指向实际的虚函数�Q�而是指向一��段代码。在�q�一��段代码中，会修改This指针�Q�ECX寄存器）�Q��之指向合适的父类镜像�Q�然后再跌��{到实际的虚函��C��?br />5�?nbsp;当不使用虚��承时�Q�共同基�cȝ��成员对象�Q�在子类中会有独立两分（从两个父�c�d��自��承了一份）�?br />6�?nbsp;当��用虚�l�承�Ӟ��共同基类的成员对象也会在虚函数表中记录，讉K��它必��d��查找虚函数表�?br />
普通多重��承下的虚函数表：
http://blog.csdn.net/tangaowen/article/details/5830803
http://www.cnblogs.com/itech/archive/2009/02/28/1399995.html
虚��承下的虚函数表：
http://www.cnblogs.com/itech/archive/2009/02/27/1399996.html

zml_cnnk 2008-10-28 20:27 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:27:00 GMT
谈到字节序的问题�Q�必然牵涉到两大CPU�z��。那��是Motorola的PowerPC�p�d��CPU和Intel的x86�p�d��CPU。PowerPC�p�d��采用big endian方式存储数据�Q�而x86�p�d��则采用little endian方式存储数据。那么究竟什么是big endian�Q�什么又是little endian呢？字节��序是指占内存多于一个字节类型的数据在内存中的存��N��序，通常有小端、大端两�U�字节顺序。小端字节序指低字节数据存放在内存低地址处，高字节数据存攑֜�内存高地址处；大端字节序是高字节数据存攑֜�低地址处，低字节数据存攑֜�高地址处。基于X86�q�_��的PC机是��端字节序的�Q�而有的嵌入式�q�_��则是大端字节序的。因而对int、uint16、uint32�{�多�?字节�c�d��的数据，在这些嵌入式�q�_��上应该变换其存储��序。通常我们认�ؓ�Q�在�I�Z��传输的字节的��序即网�l�字节序为标准顺序，考虑��C��协议的一致以及与同类其它�q�_��产品的互通，在程序中发数据包�Ӟ��主机字节序转换为网�l�字节序�Q�收数据包处��网�l�字节序转换��Z��机字节序�? 其实big endian是指低地址存放最高有效字节（MSB�Q�，而little endian则是低地址存放最低有效字节（LSB�Q��?#160; 用文字说明可能比较抽象，下面用图像加以说明。比如数�?x12345678在两�U�不同字节序CPU中的存储��序如下所�C�：对于0x12345678�Q?
Big endian�Q�低------->高：12 34 56 78

Little endian�Q�低------->高：78 56 34 12

    ��Z��么要注意字节序的问题呢？你可能这么问。当�Ӟ��如果你写的程序只在单机环境下面运行，�q�且不和别�h的程序打交道�Q�那么你完全可以忽略字节序的存在。但是，如果你的�E�序要跟别�h的程序��生交互呢�Q�在�q�里我想说说两种语言。C/C++语言�~�写的程序里数据存储��序是跟�~�译�q�_��所在的CPU相关的，而JAVA�~�写的程序则唯一采用big endian方式来存储数据。试惻I��如果你用C/C++语言在x86�q�_��下编写的�E�序跟别人的JAVA�E�序互通时会��生什么结果？��拿上面�?x12345678来说�Q�你的程序传递给别�h的一个数据，��指�?x12345678的指针传�l�了JAVA�E�序�Q�由于JAVA采取big endian方式存储数据�Q�很自然的它会将你的数据��译�?x78563412。什么？竟然变成另外一个数字了�Q�是的，��是�q�种后果。因此，在你的C�E�序传给JAVA�E�序之前有必要进行字节序的�{换工作�?br>    所有网�l�协议也都是采用big endian的方式来传输数据的。所以有时我们也会把big endian方式�U�C��为网�l�字节序。当两台采用不同字节序的��L��通信�Ӟ��在发送数据之前都必须�l�过字节序的转换成�ؓ�|�络字节序后再进行传输�?/p>
    判断��端�q�是大端规则的方法：

int x = 1;
if(*(char *)&x == 1)//取x指针强制转换为char*�c�d��再取��|��此时取到的值是int最低字节�?br>     printf("little-endian\n");
else
     printf("big-endian\n");

     另外补充�Q?/p>
1�Q�BIG-ENDIAN、LITTLE-ENDIAN、跟CPU有关的，每一�U�CPU不是BIG-ENDIAN��是LITTLE-ENDIAN。网�l�字节序是指数据在网�l�上传输时是大头�q�是��头的，在Internet的网�l�字节序是BIG-ENDIAN。所谓的JAVA字节序指的是在JAVA虚拟��Z��多字节类型数据的存放��序�Q�JAVA字节序也是BIG-ENDIAN�?/p>
2�Q�所以在用C/C++写通信�E�序�Ӟ��在发送数据前务必用htonl和htons��L��整型和短整型的数据进行从��L��字节序到�|�络字节序的转换�Q�而接收数据后对于整型和短整型数据则必��调用ntohl和ntohs实现从网�l�字节序��C��机字节序的�{换。如果通信的一�Ҏ(gu��)��JAVA�E�序、一�Ҏ(gu��)��C/C++�E�序�Ӟ��则需要在C/C++一侧��用以上几个方法进行字节序的�{换，而JAVA一侧，则不需要做��M��处理�Q�因为JAVA字节序与�|�络字节序都是BIG-ENDIAN�Q�只要C/C++一侧能正确�q�行转换卛_��Q�发送前从主机序到网�l�序�Q�接收时反变换）。如果通信的双斚w��是JAVA�Q�则�Ҏ(gu��)��不用考虑字节序的问题了�?/p>

zml_cnnk 2008-10-28 20:27 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:26:00 GMT

以下讨论中将用到的例�?

class CExample
{
public:
        CExample(){pBuffer=NULL; nSize=0;}
        ~CExample(){delete pBuffer;}
        void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
        char *pBuffer; //�cȝ��对象中包含指�?指向动态分配的内存资源
        int nSize;
};

�q�个�cȝ��主要特点是包含指向其他资源的指针�?pBuffer指向堆中分配的一�D�内存空间�?nbsp;

一、拷贝构造函�?/p>
int main(int argc, char* argv[])
{
        CExample theObjone;
        theObjone.Init(40);

        //现在需要另一个对�?需要将他初始化为theObjone的状�?br />        CExample theObjtwo=theObjone;
        ...
}

    语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。其完成方式是内存拷贝，复制所有成员的倹{��完成后�Q�theObjtwo.pBuffer==theObjone.pBuffer。即它们��指向同��L��地方�Q�指针虽然复制了�Q�但所指向的空间�ƈ没有复制�Q�而是�׃��个对象共用了。这样不�W�合要求�Q�对象之间不独立了，�q��ؓ�I�间的删除带来隐�(zh��n)�。所以需要采用必要的手段来避免此�c�L��c�?/p>
    回顾一下此语句的具体过�E?首先建立对象theObjtwo�Q��ƈ调用其构造函敎ͼ�然后成员被拷贝。可以在构造函��C��d��操作来解��x��针成员的问题。所以C++语法中除了提供缺省�Ş式的构造函数外�Q�还规范了另一�U�特�D�的构造函敎ͼ�拯��构造函数�?/p>
    上面的语句中�Q�如果类中定义了拯��构造函敎ͼ��q�对象徏立时�Q�调用的��是拯��构造函敎ͼ�在拷贝构造函��C��Q�可以根据传入的变量�Q�复制指针所指向的资源�?/p>
    拯��构造函数的格式�?构造函数名(对象的引�?

    提供了拷贝构造函数后的CExample�c�d��义�ؓ:

class CExample
{
public:
        CExample(){pBuffer=NULL; nSize=0;}
        ~CExample(){delete pBuffer;}
        CExample(const CExample&); //拯��构造函�?br />        void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
        char *pBuffer; //�cȝ��对象中包含指�?指向动态分配的内存资源
        int nSize;
};

CExample::CExample(const CExample& RightSides) //拯��构造函数的定义
{
        nSize=RightSides.nSize; //复制常规成员
        pBuffer=new char[nSize]; //复制指针指向的内�?br />        memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
}

    �q�样�Q�定义新对象�Q��ƈ用已有对象初始化新对象时�Q�CExample(const CExample& RightSides)��被调用�Q�而已有对象用别名RightSides传给构造函敎ͼ�以用来作复制�?/p>
    原则上，应该为所有包含动态分配成员的�c�都提供拯��构造函数�?/p>
    拯��构造函数的另一�U�调用：当对象直接作为参��C��l�函数时�Q�函数将建立对象的��时拷贝，�q�个拯��q�程也将调用拯��构造函数�?/p>
例如

BOOL testfunc(CExample obj);

testfunc(theObjone); //对象直接作�ؓ参数�?/p>
BOOL testfunc(CExample obj)
{
        //针对obj的操作实际上是针对复制后的��时拷贝进行的
}

�q�有一�U�情况，也是与��时对象有关的�Q�当函数中的局部对象被被返回给函数调者时�Q�也��徏立此局部对象的一个��时拷贝，拯��构造函��C��被调用

CTest func()
{
        CTest theTest;
        return theTest;
}

二、赋值符的重�?/p>
下面的代码与上例�怼�

int main(int argc, char* argv[])
{
        CExample theObjone;
        theObjone.Init(40);

        CExample theObjthree;
        theObjthree.Init(60);

        //现在需要一个对象赋值操�?被赋值对象的原内容被清除�Q��ƈ用右边对象的内容填充�?br />        theObjthree=theObjone;
        return 0;
}
    也用��C��"="��P��但与之前的例子�ƈ不同�Q?strong style="color: #ffff00;">之前的例子中�Q?="在对象声明语句中�Q�表�C�初始化。更多时�?�q�种初始化也可用括号表示�?/strong>例如 CExample theObjone(theObjtwo); 而本例子中，"="表示赋值操作�?/strong>��对象theObjone的内容复制到对象theObjthree;�Q�这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。但"="的缺省操作只是将成员变量的值相应复制。旧的��D��自然丢弃。由于对象内包含指针�Q�将造成不良后果:指针的��D��丢弃了，但指针指向的内容�q�未释放。指针的��D��复制了，但指针所指内容�ƈ未复制�?/p>
    因此�Q�包含动态分配成员的�c�除提供拯��构造函数外�Q�还应该考虑重蝲"="赋值操作符受��?/p>
�c�d��义变�?

class CExample
{
        ...
        CExample(const CExample&); //拯��构造函�?br />        CExample& operator = (const CExample&); //赋值符重蝲
        ...
};
//赋值操作符重蝲
CExample & CExample::operator = (const CExample& RightSides)
{
        nSize=RightSides.nSize; //复制常规成员
        char *temp=new char[nSize]; //复制指针指向的内�?br />        memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

        delete []pBuffer; //删除原指针指向内�?nbsp; (��删除操作放在后面，避免X=X�Ҏ(gu��)��情况下，内容的丢�?
        pBuffer=temp;   //建立新指�?br />        return *this
}

三、拷贝构造函��C��用赋��D��符重蝲的代码�?/p>
CExample::CExample(const CExample& RightSides)
{
        pBuffer=NULL;
        *this=RightSides         //调用重蝲后的"="
}

zml_cnnk 2008-10-28 20:26 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:25:00 GMT

1、默认��承权限。如果不明确指定�Q�来自class的��承按照private�l�承处理�Q�来自struct的��承按照public�l�承处理�Q?br />2、成员的默认讉K��权限。class的成员默认是private权限�Q�struct默认是public权限�?br />
ps:
struct和class对于初始化都是需要在初始化列表中�q�行�Q�或者在构造函��C��赋倹{�?br />

zml_cnnk 2008-10-28 20:25 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:23:00 GMT

容器在STL中被认�ؓ是智能的。它们支持向前和向后的�P代器�Q�它们能告诉你它所保存的对象类型（通过typedef value_type�Q�；在插入和删除�q�程中它们进行了良好的内存管理；它们��报告自己包含了多少对象和自己最多能包含多少对象�Q�分别通过size和max_size取得�Q�；�q�且�Q�当容器销毁时�Q�它自动销毁每个被包含的对象�?/p>
拥有如此聪明的容器，许多�E�序员自�׃��再担心清理问题。他们认为容器会��Z��们操心。多数情况下�Q�他们正��，但是当容器包括由new生��对象指针�Ӟ��他们��׃��是太正确。毫无疑问，指针容器在销毁时�Q�会销毁它所包容的每一个元素，但是指针�?#8220;析构函数”只是一个空操作。它不会调用delete�?/p>
�l�果是，以下代码直接��D��内存资源泄漏�Q?/p>
void doSomething()

{

vector vwp;

for (int i = 0; i < SOME_MAGIC_NUMBER; ++i)

vwp.push_back(new Widget);

… // use vwp

} //Widgets are leaked here!

当离开vwp的作用范围时�Q�vwp的每一个元素都会被销毁，但是�q��ƈ不改变new所产生的对象没有被delete�q�个事实。这个删除动作是�E�序员的责�Q�Q�而不是vector的。这其实是一个功能，因�ؓ只有�E�序员才知道指针是否需要删除�?/p>
通常�Q�程序员希望它们那样�Q�删除指针）。在那种情况�Q�上例）中，使它发生其实很简单�?/p>
void doSomething()

{

vector vwp;

… // as before

for (vector::iterator i = vwp.begin();i != vwp.end(),++i) {

delete *i;

}

�?/p>
�q�能行，如果你不是十分在意它只是“能行”。问题之一是新的for循环做了很多for_each做的事，但它不像for_each一��h��析。另一个问题是代码不是异常安全。如果一个异常在vwp填上指针之后�Q�而这些指针还没有删除之前被抛出。资源泄漏再�ơ出现。幸�q�的是两个问题都可以克服�?/p>
修改for_each�c�M��的代码以使用真正的for_each�Q�需要将delete操作�|�于�Q�仿�Q�函数对象中。这像一个儿童游戏，假设你有一个喜�Ƣ与STL一��L��游戏的小孩�?/p>
template

struct DeleteObject:                  // Item 40 describes why

public unary_function { //this inheritance is here

void operator()(const T* ptr) const

delete ptr;

}

};

现在你可以这样做�Q?/p>
void doSomething()

{

… // as before

for_each(vwp.begin(), vwp.end(), DeleteObject);

}

不太走运�Q�它要求指明DeleteObject删除的对象类型（�q�里是：Widget �Q�。��o��厌，vwp是一个vector�Q�因此DeteleObject删除的当然是Widget指针�Q�这�U�冗余不只是令�h讨厌�Q�因为它可能��D��难以��查的bug出现。试想一下，例如�Q�有人故意决定要从string�l�承�Q?/p>
class SpecialString: public string { ...};

�q�是一�U�危险的产物�Q�因为string与其它标准STL容器一��P��没有virtual析构函数。公有��承一个没有虚析构函数的对象是C++一个主要的误区�Q�a major C++ no-no�Q?�q�一步的�l�节�Q�在��M��一个很好的C++书中都有讨论。在Effective C++中，它被攑֜�Item 14)。不论如何，有�h如此作了。考虑一下以下代码的行�ؓ�Q?/p>
void doSomething()

{

deque dssp;

…

for_each( dssp.begin(), dssp.end(), // undefined behavior! Deletion

DeleteObject()); //of a derived object via a base

} // class pointer where there is

//no virtual destructor

注意dssp声明��Z��存SpecialString的指针，但是for_each循环的作者告诉DeleteObject�Q�它准备删除string的指针。很�Ҏ(gu��)��发现什么样的错误会发生。SpecialString无疑在很大程度上表现为string。因此有��Z��忘记它的用户�Q�他们会不记得他们��用的是SpecialString而不是string�?/p>
可以排除�q�个错误�Q�也可以减少DeleteObject用户敲打键盘的次敎ͼ�使用�~�译器推�l�出传给DeleteObject::operator()的指针类型。所有工作只是把模板从DeleteObject�cȝ��到operator()上�?/p>
struct DeleteObject { // templatization and base

// class removed here

template II templatization added here

void operator()(const T* ptr) const

{

delete ptr;

}

}

�~�译器知道传递给DeleteObject::operator�Q�）的指针类型，因此它将自动��c�d��指针生成一个operator的实例。这�U�类型推�l�的产生�Q�取决于我们攑ּ�DeleteObject的可适应性。考虑一下DeleteObject被设计�ؓ如何使用�Q�就很难扑և�可能发生问题的地斏V�?/p>
使用�q�一新版的DeleteObject�Q�SpecialString客户的代码看��h��像这��P��

void doSomething()

{

deque dssp;

…

for_each( dssp.begin(), dssp.end(),

DeleteObject ()); // ah! well-defined behavior!

}

直接而且�c�d��安全�Q�就像我们所喜欢的那栗��?/p>
但是它还不是异常安全。如果SpecialString生��了，但还没有调用for_each�Q�一个异常被抛出�Q�泄漏将出现。这个问题可以用很多�Ҏ(gu��)��解决�Q�但最��单的也许是��用智能指针容器取代指针容器，通常使用一个引用记数的��指针�Q�如果不熟�?zh��n)��指针的概念，可以在中高��C++�ȝ��中找到。在More Effective C++中，�q�些材料在Item 28。）

STL本��n�q�不包括引用记数的智能指针，�~�写一个好的－所有情况下都正��－太富有技巧，因此除非真的需要，�q�不需要这样做。我�Q�作者）1996�q�在More Effective C++发布了了一个引用记数的��指针�Q�尽��它��Z��一些确定的��指针实现�Q�而且在发布前由多位有�l�验的开发者讨��Q�但是这些年�q�是有一堆准��的Bug被发现。很多引用记数的��指针可能��p�|的微妙情况被说明。（�l�节在More Effective C++勘误中讨论）

�q�运圎ͼ�几乎不需要自己写一个智能指针，因�ؓ已验正的实现�q�不难找。在Boost库（参考条��?0�Q�中��有一个这��L��share_ptr。��用Boost的share_ptr�Q�本条款最初的例子可以重写为：

void doSomething()

{

typedef boost::shared_ ptr SPW; //SPW = "shared_ptr

// to Widget"

vector vwp;

for (int i = 0; i < SOME_MAGIC_NUMBER; ++i)

vwp.push_back(SPW new Widget);   // create a SPW from a

// Widget*, then do a

//push_back on it

…                                  // use vwp

}   // no Widgets are leaked here, not

// even if an exception is thrown

//in the code above

千万不能被auto_ptr愚弄了，不要认�ؓ创徏auto_ptr的容器，指针会被自动删除。这是可怕是��x��Q�它是如此危险，我准备用整个条款8来说明你不应使用它�?/p>
应记住的是STL容器是智能的�Q�但它不��以知道是否要删除它包含的指针。�ؓ了避免资源泄漏，使用指针容器时应删除指针。你需要��用智能指针或在容器销毁前手工删除每一个指针�?/p>
最后，一个类��g��DeleteObject的结构可以方便地避免使用指针容器时的资源泄漏�Q�这也许会��你联惌��v�Q�也许可能创��Z��个类似的DeleteArray�Q�避免��用数�l�指针容器时的资源泄漏。当�Ӟ��q�是可能的，但是是否明智��是另一个问题了。条��?3解释了�ؓ什么动态申��h��l��L��不如vector和string对象。所以在你坐下来写DeleteArray之前�Q�请先看一看条��?3。如果幸�q�，DeleteArray的时代将永远不会到来�?/p>

zml_cnnk 2008-10-28 20:23 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:21:00 GMT
一、主要函�?nbsp;
vc中最主要函数不易理解�?/font>

CString::CString(char *p)

{

     int n=strlen(p);

     m_data = new char[n+1];

     strcpy(m_data,p);

}

CString::CString(CString &other)

{

     int n=strlen(other.m_data);

     m_data = new char[n+1];

     strcpy(m_data,other.m_data);

}

CString& CString::operator = (CString& other)

{

     delete[] m_data;

     int n=strlen(other.m_data);

     m_data = new char[n+1];

     strcpy(m_data,other.m_data);

     return *this;

}

String::~String()

{

     delete [] m_data;

}

1、Collate�Q�Compare

与一个字�W�长指针所指的字符串进行比较，与strcmp相同�Q�它们的区别是，分别调用_tcscoll�Q�_tcsicmp�?/font>

2、Delete

int Delete( int nIndex, int nCount = 1 )

�q�回值是被删除前的字�W�串的长度，nIndex是第一个被删除的字�W�，nCount是一�ơ删除几个字�W�。根据我实验得出的结果：当nCount>字符串的长度时会出错�Q�当nCount�q�大�Q�没有��够的字符删除�Ӟ��此函��C��执行�?/font>

3、FindOneOf

int FindOneOf( LPCTSTR lpszCharSet ) const;

此函数的功能是在查找lpszCharSet中的��L��一个字�W�，查到一个就把位�|�返回，没有查到�q�回0。如�Q?/font>

CString str = "0123456789";

int x = str.FindOneOf("31");

x的值是1�?/font>

4、Find

int Find( TCHAR ch ) const;

int Find( LPCTSTR lpszSub ) const;

int Find( TCHAR ch, int nStart ) const;

int Find( LPCTSTR pstr, int nStart ) const;

�q�回值查扑ֈ�的序��P��ch待搜索的字符�Q�lpszSub待搜索的字符子串�Q�nStart 从那里开始搜索。如�Q?/font>

CString str = "0123456789";

int x = str.Find("34",4);

�q�回的值是-1.

5、GetAt

TCHAR GetAt( int nIndex ) const;

�q�回标号为nIndex的字�W�，你可以把字符串理解�ؓ一个数�l�，GetAt�c�M��于[].注意nIndex的范��_��如果不合适会有调试错误�?/font>

6、Insert

int Insert( int nIndex, TCHAR ch )
int Insert( int nIndex, LPCTSTR pstr )
�q�回修改后的长度�Q?/strong>nIndex字符�Q�或字符�Ԍ��插入后的标号�?/strong>

7、Left

CString Left( int nCount ) const;

�q�回的字�W�串的前nCount个字�W��?/strong>

Right与Left�c�M��

8、MakeLower �Q�MakeUpper改变字符的大��写

MakeReverse字符倒置�Q�如�Q?/font>

       CString str = "X0123456789";

       str.MakeReverse();

str变�ؓ"9876543210X"

9�?=

const CString& operator +=( const CString& string );
const CString& operator +=( TCHAR ch );
const CString& operator +=( LPCTSTR lpsz );

��参数合�q�到自己�w�上�?/font>

如：       CString str = "0123456789";

              str+="ha";

str�?0123456789ha"�Q?/font>

10、str[]

TCHAR operator []( int nIndex ) const;

象处理字�W�数�l�一样处理字�W�串�?/font>

注意是只�ȝ��?/font>

CString str = "0123456789";

       str[0]='x';

是错误的�?/font>

11、TrimLeft,TrimRight

void TrimLeft( );

void CString::TrimLeft( TCHAR chTarget );

void CString::TrimLeft( LPCTSTR lpszTargets );

void TrimRight( );

void CString::TrimRight( TCHAR chTarget );

void CString::TrimRight( LPCTSTR lpszTargets );

CString str = "\n\t a";

str.TrimLeft();

str�?#8220;a”;

    如果没有参数,从左删除字符(\n\t�I�格�{?,臛_��遇到一个非此类字符.

当然你也可以指定删除那些字符.

如果指定的参数是字符�?那么遇上其中的一个字�W�就删除.

CString str = "abbcadbabcadb ";

str.TrimLeft("ab");

�l�果"cadbabcadb "

12、int CString::Remove( TCHAR ch );

ch删除的字�W?

�q�回删除字符的个�?有多个时都会删除.

二、CString 与char []之间的�{�?

char str[100] = ”str”;

CString sstr = “sstr”;

str.Format(“%s”,str);

str = LPCTSTR sstr;

strcpy(str,(LPCTSTR)sstr);

如果是赋�?则要:

CString s(_T("This is a test "));
LPTSTR p = s.GetBuffer();
// 在这里添加��用p的代�?br>if(p != NULL) *p = _T('\0');
s.ReleaseBuffer();
// 使用完后及时释放�Q�以便能使用其它的CString成员函数

str的值变�?

三、将NULL字节攑օ�CString�?br>1,CString str("abc\0""def", 7);
str +="g";
int nLength = str.GetLength();
nLength�?.
2,CString str("My name is hedan!");
str.SetAt(5, 0);
int nLength = str.GetLength();
注意:不是所有的CString成员函数都可以，在��用时一定要��心�?/font>

实例:动态配�|�数据源
CString strDsn,strDBQ;
strDsn = "DSN=test";
strDBQ.Format("DBQ=%s",strSourceMDBName);
CString strConnect = strDsn + " " + strDBQ ;
strConnect.SetAt(strDsn.GetLength(),'\0');
SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, "Microsoft Access Driver (*.mdb)", strConnect);

zml_cnnk 2008-10-28 20:21 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:20:00 GMT
Debug版本包括调试信息�Q�所以要比Release版本大很多（可能大数百K��x��M�Q��?
    至于是否需要DLL支持�Q�主要看你采用的�~�译选项。如果是��Z�� ATL的，则Debug和Release版本对DLL的要求差不多。如果采用的�~�译选项��Z��用MFC动态库�Q�则需要MFC42D.DLL�{�库支持�Q�而Release版本需要MFC42.DLL支持�?/p>
    Release Build不对源代码进行调试，不考虑MFC的诊断宏�Q��用的是MFC Release库，�~�译时对应用�E�序的速度�q�行优化�Q�而Debug Build则正好相反，它允许对源代码进行调试，可以定义和��用MFC的诊断宏�Q�采用MFC Debug库，寚w��度没有优化�?nbsp;

一、Debug �?Release �~�译方式的本质区�?

    Debug通常�U�Cؓ调试版本�Q�它包含调试信息�Q��ƈ且不作�Q何优化，便于�E�序员调试程序。Release �U�Cؓ发布版本�Q�它往往是进行了各种优化�Q��得程序在代码大小和运行速度上都是最优的�Q�以便用户很好地使用�?
    Debug �?nbsp;Release 的真正秘密，在于一�l�编译选项。下面列��Z��分别针对二者的选项�Q�当焉��此之外还有其他一些，�?Fd�?Fo�Q�但区别�q�不重要�Q�通常他们也不会引�? Release 版错误，在此不讨论）
    1、Debug 版本�Q?
/MDd /MLd �?/MTd�Q��?Debug runtime library(调试版本的运行时��d��数库)
/Od�Q�关闭优化开�?
/D "_DEBUG"�Q�相当于 #define _DEBUG,打开�~�译调试代码开�?主要针对assert函数)
/ZI�Q�创�? Edit and continue(�~�辑�l�箋)数据库，�q�样在调试过�E�中如果修改了源代码不需重新�~�译
/GZ�Q�可以帮助捕获内存错�?
/Gm�Q�打开最��化重链接开养I��减少链接旉��
    2、Release 版本�Q?
/MD /ML �?nbsp;/MT 使用发布版本的运行时��d��数库
/O1 �?/O2�Q�优化开养I��使程序最��或最�?
/D "NDEBUG"�Q�关闭条件编译调试代码开�?即不�~�译assert函数)
/GF�Q�合�q��复的字符�Ԍ��q�将字符串常量放到只��d��存，防止被修�?nbsp;
    实际上，Debug �? Release �q�没有本质的界限�Q�他们只是一�l�编译选项的集合，�~�译器只是按照预定的选项行动。事实上�Q�我们甚臛_��以修改这些选项�Q�从而得��C��化过的调试版本或是带跟踪语句的发布版本�?

二、哪些情况下 Release 版会出错

    有了上面的介�l�，我们再来逐个对照�q�些选项看看 Release 版错误是怎样产生的�?/p>

    1.Runtime Library�Q?/p>
链接哪种�q�行时刻函数库通常只对�E�序的性能产生影响。调试版本的Runtime Library 包含了调试信息，�q��用了一些保护机制以帮助发现错误�Q�因此性能不如发布版本。编译器提供�?Runtime Library 通常很稳定，不会造成 Release 版错误；倒是�׃�� Debug �?Runtime Library 加强了对错误的检��，如堆内存分配�Q�有时会出现 Debug 有错�?nbsp;Release 正常的现象。应当指出的是，如果 Debug 有错�Q�即 Release 正常�Q�程序肯定是�?nbsp;Bug 的，只不�q�可能是 Release 版的某次�q�行没有表现出来而已�?nbsp;

    2.优化�Q?/p>
�q�是造成错误的主要原因，因�ؓ关闭优化时源�E�序基本上是直接��译的，而打开优化后编译器会作��Z��p�d��假设。这�c�错误主要有以下几种�Q?/p>
(1) 帧指�?Frame Pointer)省略�Q�简�U�FPO�Q�：

在函数调用过�E�中�Q�所有调用信息（�q�回地址、参敎ͼ�以及自动变量都是攑֜�栈中的。若函数的声明与实现不同�Q�参数、返回倹{��调用方式）�Q�就会��生错误。但 Debug 方式下，栈的讉K��通过 EBP 寄存器保存的地址实现�Q�如果没有发生数�l�越界之�cȝ��错误�Q�或是越�?#8220;不多”�Q�，函数通常能正常执行。Release 方式下，优化会省�?EBP 栈基址指针�Q�这样通过一个全局指针讉K��栈就会造成�q�回地址错误是程序崩溃。C++ 的强�c�d��Ҏ(gu��)��能��查出大多数这��L��错误�Q�但如果用了强制�c�d��转换�Q�就不行了。你可以�?Release 版本中强制加�?/Oy- �~�译选项来关掉��指针省略�Q�以��定是否此类错误�?/p>
此类错误通常有：

MFC 消息响应函数书写错误�?/p>
正确的应�?
afx_msg LRESULT OnMessageOwn(WPARAM wparam, LPARAM lparam);
ON_MESSAGE 宏包含强制类型�{换。防止这�U�错误的�Ҏ(gu��)��之一是重定义 ON_MESSAGE 宏，把下列代码加�?stdafx.h 中（�?include "afxwin.h"之后�Q?函数原�Ş错误时编译会报错
#undef ON_MESSAGE
#define ON_MESSAGE(message, memberFxn) \
{ message, 0, 0, 0, AfxSig_lwl, \
(AFX_PMSG)(AFX_PMSGW)(static_cast< LRESULT (AFX_MSG_CALL \
CWnd::*)(WPARAM, LPARAM) > (&memberFxn) },
(2) volatile 型变量：

volatile 告诉�~�译器该变量可能被程序之外的未知方式修改�Q�如�pȝ��、其他进�E�和�U�程�Q�。优化程序�ؓ了�ɽE�序性能提高�Q�常把一些变量放在寄存器中（�c�M��?register 关键字）�Q�而其他进�E�只能对该变量所在的内存�q�行修改�Q�而寄存器中的值没变。如果你的程序是多线�E�的�Q�或者你发现某个变量的��g��预期的不�W�而你��信已正��的讄��了，则很可能遇到�q�样的问题。这�U�错误有时会表现为程序在最快优化出错而最��优化正常。把你认为可疑的变量加上 volatile 试试�?nbsp;
(3) 变量优化�Q?/p>
优化�E�序会根据变量的使用情况优化变量。例如，函数中有一个未被��用的变量�Q�在 Debug 版中它有可能掩盖一个数�l�越界，而在 Release 版中�Q�这个变量很可能被优化，此时数组��界会破坏栈中有用的数据。当�Ӟ��实际的情况会比这复杂得多。与此有关的错误有：
非法讉K��Q�包括数�l�越界、指针错误等。例�?
void fn(void)
{
    int i;
    i = 1;
    int a[4];
    {
        int j;
        j = 1;
    }
    a[-1] = 1;//当然错误不会�q�么明显�Q�例如下标是变量
    a[4] = 1;
}
j 虽然在数�l�越界时已出了作用域�Q�但其空间�ƈ未收回，因�?i �?j ��׃��掩盖��界。�?nbsp;Release 版由�?nbsp;i、j �q�未其很大作用可能会被优化掉�Q�从而��栈被破坏�?nbsp;

3. _DEBUG �?NDEBUG�Q?/p>
当定义了 _DEBUG �Ӟ��assert() 函数会被�~�译�Q��?NDEBUG 时不被编译。除此之外，VC++中还有一�p�d��断言宏。这包括�Q?nbsp;
ANSI C 断言 void assert(int expression );
C Runtime Lib 断言 _ASSERT( booleanExpression );
                   _ASSERTE( booleanExpression );
MFC 断言 ASSERT( booleanExpression );
           VERIFY( booleanExpression );
           ASSERT_VALID( pObject );
           ASSERT_KINDOF( classname, pobject );
ATL 断言 ATLASSERT( booleanExpression );
此外�Q�TRACE() 宏的�~�译也受 _DEBUG 控制�?nbsp;
    所有这些断�a�都只�? Debug版中才被�~�译�Q�而在 Release 版中被忽略。唯一的例外是 VERIFY() 。事实上�Q�这些宏都是调用�? assert() 函数�Q�只不过附加了一些与库有关的调试代码。如果你在这些宏中加入了��M��E�序代码�Q�而不只是布尔表达式（例如赋倹{��能改变变量值的函数调用�{�）�Q�那�? Release 版都不会执行�q�些操作�Q�从而造成错误。初学者很�Ҏ(gu��)��犯这�c�错误，查找的方法也很简单，因�ؓ�q�些宏都已在上面列出�Q�只要利�? VC++ �? Find in Files 功能在工�E�所有文件中扑ֈ�用这些宏的地方再一一��查即可。另外，有些高手可能�q�会加入 #ifdef _DEBUG 之类的条件编译，也要注意一下�?
    ��Z��值得一提的�? VERIFY() 宏，�q�个宏允�怽��程序代码放在布?y��u)��表辑ּ�里。这个宏通常用来��? Windows API 的返回倹{��有些�h可能��个原因而滥�?nbsp;VERIFY() �Q�事实上�q�是危险的，因�ؓ VERIFY() �q�反了断�a�的思想�Q�不能�ɽE�序代码和调试代码完全分��，最�l�可能会带来很多�ȝ��。因此，专家们徏议尽量少用这个宏�?nbsp;

4. /GZ 选项�Q?/p>
�q�个选项会做以下�q�些�?nbsp;�Q?nbsp;
(1) 初始化内存和变量�?/p>
包括�? 0xCC 初始化所有自动变量，0xCD ( Cleared Data ) 初始化堆中分配的内存�Q�即动态分配的内存�Q�例�? new �Q�，0xDD ( Dead Data ) 填充已被释放的堆内存�Q�例�? delete �Q�，0xFD( deFencde Data ) 初始化受保护的内存（debug 版在动态分配内存的前后加入保护内存以防止越界访问）�Q�其中括号中的词是微软徏议的助记词。这样做的好处是�q�些值都很大�Q�作为指针是不可能的�Q�而且 32 位系�l�中指针很少是奇数��|��在有些系�l�中奇数的指针会产生�q�行旉��误）�Q�作为数��g��很少遇到�Q�而且�q�些��g��很容易��L认，因此�q�很有利于在 Debug 版中发现 Release 版才会遇到的错误。要特别注意的是�Q�很多�h认�ؓ�~�译器会�? 0 来初始化变量�Q�这是错误的�Q�而且�q�样很不利于查找错误�Q��?
(2) 通过函数指针调用函数�Ӟ��会通过��查栈指针验证函数调用的匹配性。（防止原�Ş不匹配）
(3) 函数�q�回前检查栈指针�Q�确认未被修攏V��（防止��界讉K��和原形不匚w��Q�与�W�二��合在一起可大致模拟帧指针省�? FPO �Q?nbsp;
    通常 /GZ 选项会造成 Debug 版出错�? Release 版正常的现象�Q�因�? Release 版中未初始化的变量是随机的，�q�有可能使指针指向一个有效地址而掩盖了非法讉K��?nbsp;

    除此之外�Q?Gm /GF �{�选项造成错误的情冉|��较少�Q�而且他们的效果显而易见，比较�Ҏ(gu��)��发现�?nbsp;

��短地��_��
    Release是发行版�?比Debug版本有一些优化，文�g比Debug文�g��。Debug是调试版本，包括的程序信息更多。Release�Ҏ(gu��)��Q?build->batch�Q�build->build��O(ji��n)K. 只有DEBUG版的�E�序才能讄��断点、单步执行、��用TRACE/ASSERT�{�调试输��句。REALEASE不包含�Q何调试信息，所以体�U�小、运行速度快�?/p>

zml_cnnk 2008-10-28 20:20 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:20:00 GMT

1、函数指针同��h��可以作�ؓ参数传递给函数的�?/p>
#include
#include
using namespace std;
int test(int);
int test2(int (*ra)(int),int);
void main(int argc,char* argv[])
{
    cout<
    typedef int (*fp)(int);
    fp fpi;
    fpi=test;
    cout<    cin.get();
}
int test(int a)
{
    return a-1;
}
int test2(int (*ra)(int),int b)//�q�里定义了一个名字�ؓra的函数指�?nbsp;
{
    int c=ra(10)+b;//在调用之�?ra已经指向fpi所指向的函数地址即test函数
    return c;
}

2、利用函数指针，我们可以构成指针数组�Q�更明确点的说法是构成指向函数的指针数组�Q�这么说可能��容易理解的多了�?/p>
#include
#include
using namespace std;
void t1(){cout<<"test1";}
void t2(){cout<<"test2";}
void t3(){cout<<"test3";}
void main(int argc,char* argv[])
{
    void* a[]={t1,t2,t3};
    cout<<"比较t1()的内存地址和数�l�a[0]所存储的地址是否一�?<
    cout<
    typedef void (*fp)();//自定义一个函数指针类�?nbsp;
    fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义成一个指向函数的指针数组
    b[0]();//现在利用指向函数的指针数�l�进行下标操作就可以�q�行函数的间接调用了;
    cin.get();
}

另外�Q?/p>
void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数�l�a[0]所存储的地址是否一�?<cout<
上面的这一��段中的错误行，��Z��么不能这么调用呢�Q�指针数�l�元素所保存的只是一个内存地址�Q�既然只是个内存地址��׃��可能�q�行a[0]()�q�样地址带括��L��操作�Q�而函数指针不同，它是一个例外，函数指针只所以这么叫它就是因为它是指向函数指向内存的代码区的指针�Q�它被系�l�授予允�怸�()括号操作的权利，�q�行间接的函数调�?/strong>�Q�既然函数指针允许这么操作，那么被定义成函数指针的数�l�就一定是可以一��L��操作的�?/p>

3、类的成员函敎ͼ�

class CA
{
public:
    char lcFun(int a){ return; }
};
CA ca;
typedef char (CA::*PTRFUN)(int);
PTRFUN pFun;
void main()
{
    pFun = CA::lcFun;
    ca.(*pFun)(2);
}
在这里，指针的定义与使用都加上了“�c�限�?/span>”�?/span>“对象”�Q�用来指明指针指向的函数是那个类的这里的�c�d��象也可以是��?/span>new得到的。比如：
CA *pca = new CA;
pca->(*pFun)(2);
delete pca;
而且�q�个�c�d��象指针可以是�c�d��部成员变量，你甚臛_��以��?/span>this指针。比如：
�c?/span>CA有成员变�?/span>PTRFUN m_pfun;
void CA::lcFun2()
{
   (this->*m_pFun)(2);
}
一句话�Q��用类成员函数指针必须�?/span>“->*”�?/span>“.*”的调用�?/span>

zml_cnnk 2008-10-28 20:20 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:19:00 GMT

一、基本用法：

1、普通类�?/p>
typedef unsigned int UINT;

2、struct

typedef struct {int x; int y;} Point;

或�?/p>
typedef struct t_node {

    int Value;

    struct t_node *next;

} Node;

或�?/p>
typedef strcut t_node Node;

struct t_node {

    int Value;

    Node *next;

};

3、函数指�?/p>
typedef void (*FUNCADDR)(int);

4、类�c�d��

typedef class {

    private:

        int a;

    public:

        int b;

} MyClass;

二、深入讨论：

1、关于const 和指�?/u>

typedef char * pstr;
int mystrcmp(pstr, pstr);
　　�q�里��带我们到达�W�一�?typedef 陷阱。标准函�?strcmp()有两�?#8216;const char *'�c�d��的参数。因此，它可能会误导��Z��象下面这样声�?mystrcmp()�Q?/p>
int mystrcmp(const pstr, const pstr);
　　�q�是错误的，按照��序�Q?#8216;const pstr'被解释�ؓ‘char * const'�Q�一个指�?char 的常量指针）�Q�而不�?#8216;const char *'�Q�指向常�?char 的指针）�?/p>
    �q�个问题很容易解冻I��

typedef const char * cpstr;
int mystrcmp(cpstr, cpstr); // 现在是正��的

2、文本替�?/p>
    typedef 行�ؓ有点�?nbsp;#define 宏，用其实际�c�d��替代同义字。不同点�?typedef 在编译时被解释，因此让编译器来应付超��预处理器能力的文本替换�?/p>
例如:

typedef int (*PF) (const char *, const char *);

如果要��用下列�Ş式的函数声明�Q�那么上�q�这�?typedef 是不可或�~�的�Q?/p>
PF Register(PF pf);
展示一下如果不�?typedef�Q�我们是如何实现�q�个声明的：

int (*Register (int (*pf)(const char *, const char *)))(const char *, const char *);
3、存储类关键�?/p>
    typedef ��像 auto�Q�extern�Q�mutable�Q�static�Q�和 register 一��P��是一个存储类关键字�?/p>
�W�二个陷阱：

typedef register int FAST_COUNTER; // 错误
�~�译通不�q�。问题出在你不能在声明中有多个存储类关键字。因为符�?typedef 已经占据了存储类关键字的位置�Q�在 typedef 声明中不能用 register�Q�或��M��其它存储�c�d��键字�Q��?/p>
4、定义机器无关的�c�d��

    例如�Q�你可以定义一个叫 REAL 的��Q点类型，在目标机器上它可以i获得最高的�_�ֺ��Q?/p>
typedef long double REAL;
在不支持 long double 的机器上�Q�该 typedef 看�v来会是下面这��P��

typedef double REAL;
�q�且�Q�在�q?double 都不支持的机器上�Q�该 typedef 看�v来会是这��P��

typedef float REAL;
　　你不用对源代码做��M��修改�Q�便可以在每一�U��^��C��~�译�q�个使用 REAL �c�d��的应用程序。唯一要改的是 typedef 本��n。在大多数情况下�Q�甚臌��个微��的变动完全都可以通过奇妙的条件编译来自动实现。不是吗? 标准库广泛地使用 typedef 来创��L��q�_��无关�c�d��Q�size_t�Q�ptrdiff �?fpos_t ��是其中的例子。此外，�?std::string �?std::ofstream �q�样�?typedef �q�隐藏了镉K��的，难以理解的模板特化语法，例如�Q�basic_string�Q�allocator> �?basic_ofstream>�?/p>

zml_cnnk 2008-10-28 20:19 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:19:00 GMT

-------------------------------原理-------------------------------

某些��Z��应该在构造函��C��使用this指针�Q�因��时this对象�q�没有完全�Ş成�?/p>
但是�Q�只要小心，是可以在构造函��C��使用this指针的：

●在函数体中

●初始化列表�?/p>
因�ؓ“对象�q�没有完全�Ş�?#8221;不意味着“什么都没有”�?/p>
在进入构造函敎ͼ�及其chaining�Q�之前，Compiler会：

●给class的instance分配内存

●徏立运行时�ȝ��l�所需的信息（如vtbl�{�）

�?#�~�省�?# 构造所有类成员

-----------------------------【能�?--------------------------------

构造函数的函数体（或构造函数所调用的函敎ͼ�【能】可靠地讉K��Q?/p>
●基�c�M��声明的数据成�?/p>
●构造函数所属类声明的数据成�?/p>
�q�是因�ؓ所有这些数据成员被保证在构造函数函��C��开始执行时已经被完整的建立�?/p>
-----------------------------【不能�?--------------------------------

构造函数的函数体（或构造函数所调用的函敎ͼ�【不能】向下调用：

●被�z��c�重定义的虚函数

�q�是因�ؓ在基�cȝ��构造函数执行期��_��“对象�q�不是一个派生类的对�?#8221;�?/p>
---------------------------【有时�?----------------------------------

以下是【有时】可行的�Q?/p>
●传�?this 对象的�Q何一个数据成员给另一个数据成员的初始化程�?/p>
你必��ȝ��保该数据成员已经被初始化。好消息是你能��用一些不依赖于你所使用的编译器的显著的语言规则�Q�来��定那个数据成员是否已经�Q�或者还没有�Q�被初始化。坏消息是你必须知道�q�些语言规则�Q�例如，基类子对象首先被初始化（如果有多重和�Q�或虚��承，则查询这个次序！�Q�，然后�c�M��定义的数据成员根据在�c�M��声明的次序被初始化）。如果你不知道这些规则，则不要从this对象传递�Q何数据成员（不论是否昑ּ�的��用了this关键字）�l��Q何其他数据成员的初始化程序！如果你知道这些规则，则需要小心�?/p>
----------------------------用�?---------------------------------

好的OO设计��“高聚�?#8221;�Q�这样会产生很多��的责�Q单一的对�?其实“单一责�Q原则”�Ҏ(gu��)��是最基础的OO原则)�?/p>
那么�Q�小对象之间的协作就需要配�|?其实“协作可配�|?#8221;本��n��是我们希望的灵�z�L��所�?�Q?/p>
●比如Observer模式中subject和observer的协作需要调subject.RegistorObserver(observer)来配�|?/p>
●再比如多媒体框架DirectShow中filterGraph和videoWindow的协作需要调filterGraph.SetVideoWindow(videoWindow)来配�|?/p>
而构造函数是很典型的配置时机�Q��D例如下：

class CMyWindow : public CWnd
{
private:
CFilterGraph filterGraph;
public
CMyWindow() { filterGraph.SetVideoWindow(this); };
};
--------------------------附录------------------------------------

需要明了的是，【构�?析构/普通】和【虚/非虚】是完全独立的分�c�L��式：
●只要是“构�?析构”��?#8220;串联(chaining)”
●只要是“虚函�?#8221;��?#8220;可能obj.vfun()”

它们可以“一��L��?#8221;�?#8220;不互相干�?#8221;�Q�比如虚析构函数的情况，看下面的例子�Q?/p>
class superclass
{
   virtual ~superclass()
   {
      println("superclass::~superclass()");
   }
};
class subclass : public superclass
{
   virtual ~subclass()
   {
      println("subclass::~subclass()");
   }
};
执行
superclass * super = new subclass();

delete super;
的结果是打印�?
subclass::~subclass()

superclass::~superclass()
�q�意味着当执行delete super;�Ӟ��
●是否是chaining式call呢？是。因为是析构函数�?br>●那chaining call从哪里开始呢�Q�从subclass::~subclass() ==〉superclass::~superclass()�Q?br>因�ؓsuperclass * super的实际对象的�c�d��是subclass�?

zml_cnnk 2008-10-28 20:19 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:16:00 GMT
有下面的一个简单的�c�：

class CNullPointCall
{
public:
    static void Test1();
    void Test2();
    void Test3(int iTest);
    void Test4();

private:
    static int m_iStatic;
    int m_iTest;
};

int CNullPointCall::m_iStatic = 0;

void CNullPointCall::Test1()
{
    cout << m_iStatic << endl;
}

void CNullPointCall::Test2()
{
    cout << "Very Cool!" << endl;
}

void CNullPointCall::Test3(int iTest)
{
    cout << iTest << endl;
}

void CNullPointCall::Test4()
{
    cout << m_iTest << endl;
}

    那么下面的代码都正确吗？都会输出什么？

CNullPointCall *pNull = NULL; // 没错�Q�就是给指针赋��gؓ�I?/span>
pNull->Test1(); // call 1
pNull->Test2(); // call 2
pNull->Test3(13); // call 3
pNull->Test4(); // call 4

    你肯定会很奇怪我��Z��么这么问。一个��gؓNULL的指针怎么可以用来调用�cȝ��成员函数呢？�Q�可是实事却很让人吃惊：除了call 4那行代码以外�Q�其�?个类成员函数的调用都是成功的�Q�都能正��的输出�l�果�Q�而且包含�q?行代码的�E�序能非常好的运行�?br>    �l�过�l�心的比较就可以发现�Q�call 4那行代码跟其�?行代码的本质区别�Q�类CNullPointCall的成员函��C��用到了this指针�?br>    对于�c�L��员函数而言�Q��ƈ不是一个对象对应一个单独的成员函数体，而是此类的所有对象共用这个成员函��C��。当�E�序被编译之后，此成员函数地址卛_��定。而成员函��C��所以能把属于此�cȝ��各个对象的数据区别开, ��是靠这个this指针。函��C��内所有对�c�L��据成员的讉K��Q�都会被转化为this->数据成员的方式�?br>    而一个对象的this指针�q�不是对象本�w�的一部分�Q�不会媄响sizeof�Q?#8220;对象”�Q�的�l�果。this作用域是在类内部�Q�当在类的非静态成员函��C��讉K��cȝ��非静态成员的时候，�~�译器会自动��对象本�w�的地址作�ؓ一个隐含参��C��递给函数。也��是��_��即��你没有写上this指针�Q�编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参�Q�对各成员的讉K��均通过this�q�行�?br>    对于上面的例子来��_��this的��g��是pNull的倹{��也��是说this的��gؓNULL。而Test1()是静态函敎ͼ��~�译器不会给它传递this指针�Q�所以call 1那行代码可以正确调用�Q�这里相当于CNullPointCall::Test1()�Q�；对于Test2()和Test3()两个成员函数�Q�虽然编译器会给�q�两个函��C��递this指针�Q�但是它们�ƈ没有通过this指针来访问类的成员变量，因此call 2和call 3两行代码可以正确调用�Q�而对于成员函数Test4()要访问类的成员变量，因此要��用this指针�Q�这个时候发现this指针的��gؓNULL�Q�就会造成�E�序的崩溃�?nbsp;
    其实�Q�我们可以想象编译器把Test4()转换成如下的形式�Q?/div>

void CNullPointCall::Test4(CNullPointCall *this)
{
    cout << this->m_iTest << endl;
}

    而把call 4那行代码转换成了下面的�Ş式：

CNullPointCall::Test4(pNull);

    所以会在通过this指针讉K��m_iTest的时候造成�E�序的崩溃�?br>    下面通过查看上面代码用VC 2005�~�译后的汇编代码来详�l�解释一下神奇的this指针�?br>    上面的C++代码�~�译生成的汇�~�代码是下面的�Ş式：

    CNullPointCall *pNull = NULL;
0041171E  mov         dword ptr [pNull],0
    pNull->Test1();
00411725  call        CNullPointCall::Test1 (411069h)
    pNull->Test2();
0041172A  mov         ecx,dword ptr [pNull]
0041172D  call        CNullPointCall::Test2 (4111E0h)
    pNull->Test3(13);
00411732  push        0Dh
00411734  mov         ecx,dword ptr [pNull]
00411737  call        CNullPointCall::Test3 (41105Ah)
    pNull->Test4();
0041173C  mov         ecx,dword ptr [pNull]
0041173F  call        CNullPointCall::Test4 (411032h)

    通过比较静态函数Test1()和其�?个非静态函数调用所生成的的汇编代码可以看出�Q�非静态函数调用之前都会把指向对象的指针pNull�Q�也��是this指针�Q�放到ecx寄存器中�Q�mov ecx,dword ptr [pNull]�Q�。这��是this指针的特�D�之处。看call 3那行C++代码的汇�~�代码就可以看到this指针跟一般的函数参数的区别：一般的函数参数是直接压入栈中（push 0Dh�Q�，而this指针却被攑ֈ�了ecx寄存器中。在�cȝ��非成员函��C��如果要用到类的成员变量，��可以通过讉K��ecx寄存器来得到指向对象的this指针�Q�然后再通过this指针加上成员变量的偏�U�量来找到相应的成员变量�?br>    下面再通过另外一个例子来说明this指针是怎样被传递到成员函数中和如何使用this来访问成员变量的�?br>    依然是一个很��单的�c�：

class CTest
{
public:
    void SetValue();

private:
    int m_iValue1;
    int m_iValue2;
};

void CTest::SetValue()
{
    m_iValue1 = 13;
    m_iValue2 = 13;
}

    用如下的代码调用成员函数�Q?/div>

CTest test;
test.SetValue();

    上面的C++代码的汇�~�代码�ؓ�Q?/div>

    CTest test;
    test.SetValue();
004117DC  lea         ecx,[test]
004117DF  call        CTest::SetValue (4111CCh)

    同样的，首先把指向对象的指针攑ֈ�ecx寄存器中�Q�然后调用类CTest的成员函数SetValue()。地址4111CCh那里存放的其实就是一个�{��x��令，转蟩到成员函数SetValue()内部�?/div>

004111CC  jmp         CTest::SetValue (411750h)

    �?11750h才是�c�CTest的成员函数SetValue()的地址�?/div>

void CTest::SetValue()
{
00411750  push        ebp
00411751  mov         ebp,esp
00411753  sub         esp,0CCh
00411759  push        ebx
0041175A  push        esi
0041175B  push        edi
0041175C  push        ecx // 1
0041175D  lea         edi,[ebp-0CCh]
00411763  mov         ecx,33h
00411768  mov         eax,0CCCCCCCCh
0041176D  rep stos    dword ptr es:[edi]
0041176F  pop         ecx // 2
00411770  mov         dword ptr [ebp-8],ecx // 3
    m_iValue1 = 13;
00411773  mov         eax,dword ptr [this] // 4
00411776  mov         dword ptr [eax],0Dh // 5
    m_iValue2 = 13;
0041177C  mov         eax,dword ptr [this] // 6
0041177F  mov         dword ptr [eax+4],0Dh // 7
}
00411786  pop         edi
00411787  pop         esi
00411788  pop         ebx
00411789  mov         esp,ebp
0041178B  pop         ebp
0041178C  ret

    下面对上面的汇编代码中的重点行进行分析：
    1、将ecx寄存器中的值压栈，也就是把this指针压栈�?br>    2、ecx寄存器出栈，也就是this指针出栈�?br>    3、将ecx的值放到指定的地方�Q�也��是this指针攑ֈ�[ebp-8]内�?br>    4、取this指针的值放入eax寄存器内。此�Ӟ��this指针指向test对象�Q�test对象只有两个int型的成员变量�Q�在test对象内存中连�l�存放，也就是说this指针目前指向m_iValue1�?br>    5、给寄存器eax指向的地址赋�?Dh�Q�十六进制的13�Q�。其实就是给成员变量m_iValue1赋�?3�?br>    6、同4�?br>    7、给寄存器eax指向的地址�?的地址赋倹{��在4中已�l�说明，eax寄存器内存放的是this指针�Q�而this指针指向�q�箋存放的int型的成员变量m_iValue1。this指针�?�Q�sizeof(int)�Q�也��是成员变量m_iValue2的地址。因此这一行就是给成员变量m_iValue2赋倹{�?br>    通过上面的分析，我们可以从底层了解了C++中this指针的实现方法。虽然不同的�~�译器会使用不同的处理方法，但是C++�~�译器必��遵守C++标准�Q�因此对于this指针的实现应该都是差不多的�?/div>

zml_cnnk 2008-10-28 20:16 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:15:00 GMT

----引用的地址�Q?/p>
    �׃��引用本��n��是目标的一个别名，引用本��n的地址是一个没有意义的��|��所以在c++中是无法取得引用的内存地址的。取引用的地址��是取目标的地址�Q�c++本��n��根本不提供获取引用内存地址的方法�?/p>

----引用的赋�?/p>
    引用一但初始化,��׃��在能够被指向其它的目标，虽然�~�译不会出错�Q�但操作是不起作用的�Q�实际上�q�是指向最先指向的目标�?br /> int a=10;
int b=20;
int &rn=a;
rn=b;//把引用指向另一个目�?---变量b
上面代码中的rn=b实际在计��机看来��是a=b�Q�所以修改的�q�是a的倹{�?/p>
    void修饰是不能够声明引用的，引用是不能够声明数组�?/strong>�Q�即不能够声明引用数�l�，因�ؓ数组是一个由若干个元素所�l�成的集合，所以无法徏立一个数�l�的别名�?/p>

----�q�回�c�L��员引用：

    可以�q�回�c�L��员的引用�Q�但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某�U�业务规则（business rule�Q�相兌��的时候，其赋值常�怸�某些其它属性或者对象的状态有养I��因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针）�Q�那么对该属性的单纯赋值就会破坏业务规则的完整性�?/p>

----引用与一些操作符的重载：
    ��操作符<<�?gt;>�Q�这两个操作�W�常常希望被�q�箋使用�Q�例如：cout << "hello" << endl;　因此�q�两个操作符的返回值应该是一个仍然支持这两个操作�W�的��引用。可选的其它�Ҏ(gu��)��包括�Q�返回一个流对象和返回一个流对象指针。但是对于返回一个流对象�Q�程序必��重斎ͼ�拯��Q�构造一个新的流对象�Q�也��是��_��q�箋的两�?lt;<操作�W�实际上是针对不同对象的�Q�这无法让�h接受。对于返回一个流指针则不能连�l��?lt;<操作�W�。因此，�q�回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许�q�就是C++语言中引入引用这个概�늚�原因吧�?/p>
    赋值操作符=�Q�这个操作符象流操作�W�一��P��是可以连�l��用的�Q�例如：x = j = 10;或�?x=10)=100;赋值操作符的返回值必��L��一个左��|��以便可以被��l�赋倹{��因此引用成了这个操作符的惟一�q�回值选择�?/p>
#include
int &put(int n);
int vals[10];
int error=-1;
void main()
{
    put(0)=10; //以put(0)函数��g��为左��|��{��h(hu��n)于vals[0]=10;
    put(9)=20; //以put(9)函数��g��为左��|��{��h(hu��n)于vals[9]=10;
    cout<
    cout< }
int &put(int n)
{
    if (n>=0 && n<=9 ) return vals[n];
    else { cout<<"subscript error"; return error; }
}

    在另外的一些操作符中，却千万不能返回引用：+-*/ 四则�q�算�W�。它们不能返回引用，Effective C++[1]的Item23详细的讨��Z��q�个问题。主要原因是�q�四个操作符没有side effect�Q�因此，它们必须构造一个对象作��回��|��可选的�Ҏ(gu��)��包括�Q�返回一个对象、返回一个局部变量的引用�Q�返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作�ؓ�q�回值的三个规则�Q�第2�?两个�Ҏ(gu��)��都被否决了。静态对象的引用又因�?(a+b) == (c+d))会永�q��ؓtrue而导致错误。所以可选的只剩下返回一个对象了�?/p>

----引用和多态：
    引用是除指针外另一个可以��生多态效果的手段。这意味着�Q�一个基�cȝ��引用可以指向它的�z��c�d��例�?br /> class 　A;
class 　B�Q�public A{……};
B 　b;
A 　&Ref = b; // 用派生类对象初始化基�c�d��象的引用
Ref 只能用来讉K��z��c�d��象中从基�cȝ��承下来的成员�Q�是基类引用指向�z��c�R��如果A�c�M��定义有虚函数�Q��ƈ且在B�c�M��重写了这个虚函数�Q�就可以通过Ref产生多态效果�?br />

----引用与函数返回�?/p>
1�?/p>
#include
#include
using namespace std;

float c;
float test(float,float);
void main(int argc,char* argv[])
{
    float pn=test(3.0f,1.2f);
    cout<
    cin.get();
}

float test(float a,float b)
{
    c=a*b;
    return c;
}

　　在上面的代码中我们可能以为函数返回的��是c变量�Q�这么想可能��错了，普通情况下我们在函数内�q�行普通��D��回的时候在内存栈空间内其实是自动��生了一个��时变量temp�Q�它是返回值的一个副本一个copy�Q�函数在return的时候其实是return的这个��时��生的副本�?/p>
2、把�q�回��D��l�引用：

#include
#include
using namespace std;

float c;
float test(float,float);
void main(int argc,char* argv[])
{
    float &pn=test(3.0f,1.2f);//警告:�q�回的将是��时变�?pn引用��成��Z��时变量的别名!
    cout<
    cin.get();
}

float test(float a,float b)
{
    c=a*b;
    return c;
}

　　float &pn=test(3.0f,1.2f);�q�句在bc中能够编译通过�Q�因为bc扩展讄��Z��时变量设�|�引用，那么临时变量的生命周期将和引用的生命周期一��_��但在vc中却不能通过�~�译�Q�因��Z��但test()执行�q�后临时变量消失在栈�I�间内，�q�时候pn��成��Z��个没有明��目标的引用�Q�严重的时候会��D��内存出错�?/p>
3、返回引用给变量的情况：

#include
#include
using namespace std;

float c;
float& test(float,float);
void main(int argc,char* argv[])
{
    float pn=test(3.0f,1.2f);
    cout<
    cin.get();
}

float &test(float a,float b)
{
    c=a*b;
    return c;
}

　　�q�种�q�回引用�l�变量的情况下，在内存中�Q�test()所在的栈空间内�q�没有��生��时变量，而是直接��全局变量c的值给了变量pn�Q�这�U�方式是我们最为推荐的操作方式�Q�因��Z��产生临时变量直接赋值的方式可以节省内存�I�间提高效率�Q�程序的可读性也是比较好的。但是仅限于�q�回的变量是栈中分配的空��_��或全局变量�Q�否则返回的依然是��时变量。一般对于内�|�类型，可以使用�W�一�U�情�늛�接返回副本�?/p>
4、最后的一�U�情冉|��函数�q�回引用,�q�且发��D��l�一个引用的情况�Q?/p>
#include
#include
using namespace std;

float c;
float& test(float,float);
void main(int argc,char* argv[])
{
    float &pn=test(3.0f,1.2f);
    cout<
    cin.get();
}

float &test(float a,float b)
{
    c=a*b;
    return c;
}

　　�q�种情况同样也不产生临时变量�Q�可��d��性能都很好，但有一点容易弄错，��是当c是非main的局部变量或者是在堆内存中��时开辟后来又被fee掉了以后的区域，�q�种情况和返回的指针是局部指针的后果一样严重，会导致引用指向了一个不明确的地址�?/p>
----其他用法�Q?/p>
    在引用的使用中，单纯�l�某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中�Q�解军_��块数据或对象的传递效率和�I�间不如意的问题。用引用传递函数的参数�Q�能保证参数传递中不��生副本，提高传递的效率�Q�且通过const的��用，保证了引用传递的安全性。引用与指针的区别是�Q�指针通过某个指针变量指向一个对象后�Q�对它所指向的变量间接操作。程序中使用指针�Q�程序的可读性差�Q�而引用本�w�就是目标变量的别名�Q�对引用的操作就是对目标变量的操作�?/p>

zml_cnnk 2008-10-28 20:15 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:14:00 GMT

一、C语言中调用C++函数

��?C++ 函数声明为``extern "C"''�Q�在你的 C++ 代码里做�q�个声明�Q�，然后调用它（在你�?C 或�?C++ 代码里调用）。例如：

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后�Q�你可以�q�样使用 f()�Q?/p>

void f(int);

void cc(int i)

{

    f(i);



}

当然�Q�这招只适用于非成员函数。如果你惌��?C 里调用成员函敎ͼ�包括虚函敎ͼ��Q�则需要提供一个简单的包装�Q�wrapper�Q�。例如：

// C++ code:

class C

{

       // ...

       virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

       return p->f(i);

}

然后�Q�你��可以这栯��?C::f()�Q?/p>

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

       double d = call_C_f(p,i);



}

如果你想�?C 里调用重载函敎ͼ�则必��L��供不同名字的包装�Q�这��h��能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后�Q�你可以�q�样使用每个重蝲�?f()�Q?/p>

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

       f_i(i);

       f_d(d);



}

注意�Q�这些技巧也适用于在 C 里调�?C++ �c�d��Q�即使你不能�Q�或者不惻I��修改 C++ 头文件�?/p>

二、C++中调用C函数

要让你的C代码既能被C代码又能被C++调用虽说�Ҏ(gu��)��Q�但是还是有需要注意的地方�?/p>
现有三个文�g分别如下�Q?/p>
#ifndef TESTC_H
#define TESTC_H

#ifdef __cplusplus
extern "C" {
#endif

int add(int a, int b);

#ifdef __cplusplus
}
#endif

#endif

#include "TestC.h"

int add(int a, int b)
{
    return (a + b);
}

#include "stdio.h"
#include "TestC.h"

int main()
{
       printf("add = %d\n", add(2, 5));

       return 0;
}

说明�Q?br>file TestC.h是C的头文�g�Q�file TestC.c是其实现文�g�Q�file TestCpp.cpp是调用C函数的C++文�g�?br>文�gTestC.h中的TESTC_H定义是�ؓ了头文�g保护�Q?#8221; #ifdef __cplusplus”�q�个不能�~�少�Q�你可以��L��看C的标准库头文件中都有�q�个�Q�如”stdio.h”。有了这个宏�~�译器就知道现在是C�q�是C++在调用它�?br>��Z��么要区分C与C++调用呢？其深层次原因是因为C和C++�~�译器在�~�译和链接时对于函数的处理不一栗��C++��Z��支持函数重蝲在编译时会加入函数参数及�c�d��信息。如上面的add�Ҏ(gu��)��Q�C�~�译器编译后在符号库中的名字为_add�Q�而C++�~�译器则会��生像_add_int_int之类的名字。C++正是依靠�q�种机制实现了函数的重蝲�?br>extern关键字表�C�将函数或变量声明�ؓ全局�c�d��Q�与之相对应的是static。static限定函数或变量的作用域�ؓ本文件。extern�q�有一个作用就是与”C”�q�在一起��用，即extern “C”通知�~�译器将extern “C”所包含的代码按照C的方式编译和链接

zml_cnnk 2008-10-28 20:14 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:10:00 GMT

前言
　　熟�?zh��n)�C的程序员都知道union�Q�联合体�Q�的用法�Q�利用union可以用相同的存储�I�间存储不同型别的数据类型，从而节省内存空间。当讉K��其内成员时可�?."�?->"来直接访问。在C++出现后，它��承了union�q�保留了其在C中的�Ҏ(gu��)��。但是在C++中的union又有了新的扩展，�q�需要大家了解，要不然你会感到费解和�q�h��。下面我讲两炏V�?br />
　　一、在union中存储对�?br />　　在C中union中可以存储�Q意类型的内置数据�c�d��Q�那么在C++中union是否可以存储对象呢？�q�是让我们看一个例子吧�Q�这比�Q何言语都能说明问题，不是吗？
#pragma warning(disable : 4786)
#include
using namespace std;
class TestUnion
{
    public:
　 TestUnion(long l):data_(l)
　 {
　　};
　 int data_;
};
typedef union _tagUtype_
{
　 TestUnion obj;
}UT;
int main (void)
{
　 return 0;
}
　　�q�样不行�Q�union中不可以存储TestUnion�cȝ��对象�Q�但在C中union可以存储struct呀�Q��ؓ什么不能存储类的对象呢�Q�很��单，请问�Q�在C中union可以存储带有构造函数的struct吗？对了�Q�在C中的struct是没有构造函数的。所以如果C++中union可以存储有构造函数的�cȝ��对象��׃��太符合逻辑�Q�那不是说C++和C完全兼容吗？不错�Q�正因�ؓ�q�一点，C++中union不可以存储有构造函数的�cȝ��对象�Q�但是可以存�?strong style="color: #ffff00;">不带构造函�?/strong>的类的对象，�q�样��和C保持一致了�Q�不想信你试试。对TestUnion�cȝ��声明�q�行如下修改�Q?br />class TestUnion
{
　 public:
　 int data_;
};
　　再进行编译，一切OK�Q�。但是这样却失去了C++的构造初始化�Ҏ(gu��)��，�q�样做是没有��M��意义的，我只是在说其在C++中的语义�Q��ƈ不是推荐大家使用�Q�绝对不推荐�Q�。但是我们可以在union中存储对象的指针�Q�从而引用不同的对象�c�d��。不用我再多说了吧，大家�q�是试试吧！　

    同理�Q�除了不能加构造函敎ͼ�析构函数/拯��构造函�?赋��D��符也是不可以加。此外，如果我们的类中包含了��M��virtual函数�Q�编译时�Q�我们将收到如下的错误信�?
　　error C2621: union ‘__unnamed‘ : member ‘obj‘ has copy constructor
　　所以，打消在union中包含有构造函�?析构函数/拯��构造函�?赋��D��符/虚函数的�cȝ��对象的念��_��老老实实用你的C风格struct�?

二、类中union的初始化
　　�׃��union的共享内存特点，我们可以使我们的�c�d��储不同的型别而不��费内存�I�间�Q�在�c�M��我们可以声明一个union存储不同型别的指针，�C�Z��如下�Q?br />#pragma warning(disable : 4786)
#include
using namespace std;
class TestUnion
{
    enum StoreType{Long,Const_CharP};
    union
    {
        const char* ch_;
        long l_;
    }data_;
    StoreType stype_;

public:

    TestUnion(TestUnion&);
    TestUnion& operator=(const TestUnion&);
    TestUnion(const char* ch);
    TestUnion(long l);
    operator const char*() const {return data_.ch_;}
    operator long() const {return data_.l_;}
};
TestUnion::TestUnion(const char* ch):data_.ch_(ch),stype_(Const_CharP)
{
}
TestUnion::TestUnion(long l):data_.l_(l),stype_(Long)
{
}
int main (void)
{
    TestUnion pszobj("yuankai");
    TestUnion lobj(1234);
    cout<(pszobj)< cout<
    return 0;
}
真是不幸�Q�编译都通不�q�，好象没有什么问题呀�Q��ؓ什么呢�Q�data_.ch_(ch)和data_.l_(l)有问题吗�Q�如果你问一个C�E�序员他会告诉你�Q�绝�Ҏ(gu��)��问题。你不会��L��疑编译器有问题吧�Q�不好意思！我一开始就是这么想的，真是惭愧。费解，�q�h��。让我们来看看构造TestUnion对象时发生了什么，�q�样你就会明白了。当创徏TestUnion对象�Ӟ��自然要调用其相应的构造函敎ͼ�在构造函��C��当然要调用其成员的构造函敎ͼ�所以其要去调用union成员的构造函敎ͼ�但是其�ؓ匿名的，有没有构造函数可调用�Q�所以出�?/strong>。很明显在C++中union和class一样它可以有构造函敎ͼ�不能如此直接引用其成员。struct同样有这限制。只要我们给其定义一个构造函��C��么问题都解决了。示例如下：

class TestUnion
{
    enum StoreType{Long,Const_CharP};
    union DataUnion //不能匿名
    {
        DataUnion(const char*); //声明const char*构造函�?br />        DataUnion(long); //声明long构造函�?br />        const char* ch_;
        long l_;
     }data_;
     StoreType stype_;
public:
     TestUnion(TestUnion&);
     TestUnion& operator=(const TestUnion&);
     TestUnion(const char* ch);
     TestUnion(long l);
     operator const char*() const {return data_.ch_;}
     operator long() const {return data_.l_;}
};
TestUnion::TestUnion(const char* ch):data_(ch),stype_(Const_CharP)
{//注意data_(ch)�Q�这里直接引用data_
}
TestUnion::TestUnion(long l):data_(l),stype_(Long)
{//注意data_(l)�Q�这里直接引用data_
}
TestUnion::DataUnion::DataUnion(const char* ch):ch_(ch)
{
}
TestUnion::DataUnion::DataUnion(long l):l_(l)
{
}
    不过我更推荐如下的编�E�风�?
class TestUnion
{
　　union DataUnion//其实仅仅是非匿名
　　{
　　    const char* ch_;
　　    long l_;
　　} data_;
public:
　　TestUnion(const char* ch);
　　TestUnion(long l);
};
TestUnion::TestUnion(const char* ch)
{
　　data_.ch_ = ch;
}
TestUnion::TestUnion(long l)
{
　　data_.l_ = l;
}

zml_cnnk 2008-10-28 20:10 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:09:00 GMT

#include
#include
using namespace std;
void main()
{
    int num = 0;
    srand((unsigned)time(NULL));
    for (int i=0; i<10; ++i)
    {
        num = rand()%10;
        cout<    }

}

zml_cnnk 2008-10-28 20:09 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:02:00 GMT

bool               -

char                  8bits

wchar_t            16bits

short                 16bits�Q�半个机器字长）

int                     16bits�Q�一个机器字长，通常大小32bits�Q?6bits也许是最��存储空��_��

long                  32bits�Q�一或两个机器字长）

float                 32bits�Q?位有效数字，一般一个机器字长）

double              64bits�Q?0位有效数字，一般两个机器字长）

long double       96�?28bits�Q?0位有效数字，一�?�?机器字长�Q?/p>

zml_cnnk 2008-10-28 20:02 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:01:00 GMT

O�?/font>

      const int r[ ]={1,2,3,4};
      struct S {int a,b;};
      const S s[ ]={(1,2),(3.4)}; //以上两种都是帔R��集合�Q�编译器会�ؓ其分配内存，所以不能在�~�译期间使用其中的��|��例如�Q?font face="Times New Roman">int temp[r[2]];�q�样的编译器会报告不能找到常量表辑ּ��?/font>

一、对于指�?/font>

1.       const int *r=&x; //声明r��Z��个指向常量的x的指针，r指向的对象不能被修改�Q�但他可以指向�Q何地址的常量�?/font>

2.       int const *r=&x; //与用�?font face="Times New Roman">1完全�{��h(hu��n)�Q�没有�Q何区别�?/font>

3.       int * const r=&x; //声明r��Z��个常量指针，他指�?font face="Times New Roman">x�Q?font face="Times New Roman">r�q�个指针的指向不能被修改�Q�但他指向的地址的内容可以修攏V�?/font>

4.       const int * const r=&x; //�l�合1�?font face="Times New Roman">3用法�Q?font face="Times New Roman">r是一个指向常量的帔R��型指针�?/font>

二、对于类型检�?/font>

    可以把一个非const对象赋给一个指�?font face="Times New Roman">const的指针，因�ؓ有时候我们不想从�q�个指针来修改其对象的��|��参数传递）�Q�但是不可以把一�?font face="Times New Roman">const对象赋值给一个非const指针�Q�因��样可能会通过�q�个指针改变指向对象的��|��但也存在使这�U�操作通过的合法化写法�Q��用类型强制�{换可以通过指针改变const对象�Q?/font>
const int r=100;
int * ptr = const_cast(&r); //C++标准�Q?font face="Times New Roman">C语言使用�Q?font face="Times New Roman">int * ptr =(int*)&r;�Q�具体请见强制类型�{换的详解�Q?/font>

三、对于字�W�数�l?/font>
    �?font face="Times New Roman">char * name = “china”; �q�样的语句，在编译时是能够通过的，但是”china”是常量字�W�数�l�，��M��想修改他的操作也能通过�~�译但会引�v�q�行旉��误，如果我们想修改字�W�数�l�的话就要��?font face="Times New Roman">char name[ ] = “china”; �q�种形式�?/font>

四、对于函�?/font>

1.       void Fuction1 ( const int r ); //此处为参��C��?font face="Times New Roman">const��|��意义是变量初��g��能被函数改变�?/font>

2.       const int Fuction1 (int); //此处�q�回const��|��意思指�q�回的原函数里的变量的初��g��能被修改�Q�但是函数按��D��回的�q�个变量被制成副本，能不能被修改��没有了意义�Q�它可以被赋�l��Q何的const或非const�c�d��变量�Q�完全不需要加上这�?font face="Times New Roman">const关键字。但�q�只对于内部�c�d��而言�Q�因为内部类型返回的肯定是一个��|��而不会返回一个变量，不会作�ؓ左��g��用）�Q�对于用戯��定义�c�d��Q�返回值是帔R��是非帔R��要的�Q�见下面条款3�?/font>

3.

Class CX; //内部有构造函敎ͼ�声明�?/font>CX(int r =0)
CX Fuction1 () { return CX(); }
const CX Fuction2 () { return CX(); }
如有上面的自定义�c?font face="Times New Roman">CX�Q�和函数Fuction1()�?font face="Times New Roman">Fuction2(),我们�q�行如下操作�Ӟ��
Fuction1() = CX(1); //没有问题�Q�可以作为左��D��?/font>
Fuction2() = CX(1); //�~�译错误�Q?font color="#ff0000">const�q�回值禁止作为左��D��用，因�ؓ左值把�q�回��g��为变量会修改其返回��|��const声明��止�q�种修改�?/font>

4.       函数中指针的const传递和�q�回�Q?/font>
int F1 (const char * pstr); //作�ؓ传递的时候��?font face="Times New Roman">const修饰可以保证不会通过�q�个指针来修改传递参数的初��|��q�里在函数内部�Q何修�?font face="Times New Roman">*pstr的企��N��会引��L��译错误�?/font>
const char * F2 (); //意义是函数返回的指针指向的对象是一�?font face="Times New Roman">const对象�Q�它必须赋给一个同��h��指向const对象的指针�?/font>
const char * const F3(); //比上面多了一�?font face="Times New Roman">const�Q�这�?font face="Times New Roman">const的意义只是在他被用作左值时有效�Q�它表明了这个指针除了指�?font face="Times New Roman">const对象外，它本�w�也不能被修改，所以就不能当作左值来处理�?/font>

5.       函数中引用的const传递：
void F1 ( const X& px); //�q�样的一�?font face="Times New Roman">const引用传递和最普通的函数按��g��递的效果是一模一��L��Q�他��止对引用的对象的一切修改，唯一不同的是按��g��递会先徏立一个类对象的副本，然后传递过去，而它直接传递地址�Q�所以这�U�传递比按��g��递更有效�?/font>
        另外只有引用�?font face="Times New Roman">const传递可以传递一�?strong>临时对象�Q�因��Z��时对象都�?font face="Times New Roman">const属性，且是不可见的�Q�他短时间存在一个局部域中，所以不能��用指针，只有引用�?font face="Times New Roman">const传递能够捕捉到�q�个家伙�?/font>

五�?/font>对于�c?/font>

1.       首先�Q�对�?font face="Times New Roman">const的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函��C��内进行初始化const成员变量会引��L��译错误。初始化成员列表形如�Q?/font>
X:: X ( int ir ): r(ir) {} //假设r是类X�?font face="Times New Roman">const成员变量

2.       const成员函数。提到这个概念首先要谈到�cȝ��const对象�Q�正像内�|�类型能够定�?font face="Times New Roman">const对象一��P��const int r=10;�Q�，用户自定义类型也可以定义const对象(const X px(10);)�Q�编译器要保证这个对象在其生命周期内不能够被改变。如果你定义了这��L��一�?font face="Times New Roman">const对象�Q�那�?/font>�~�译器�ؓ了保证对象的const�Ҏ(gu��)��，对于�q�个对象的一切非const成员函数的调�?/span>都会被禁止�ƈ在编译期间报错（除构造函数和析构函数�Q�。所以如果你惌��你的成员函数能够�?font face="Times New Roman">const对象上进行操作的话，��p��把这个函数声明�ؓconst成员函数�?br />     假如f( )是类中的成员函数的话�Q�它的声明�Ş如：
int f( ) const; //const攑֜�函数的最�?br />�~�译器会对这个函数进行检查，在这个函��C��的�Q何试图改变成员变量和调用�?font face="Times New Roman">const成员函数的操作都被视为非法�?/font>�cȝ��构造和析构函数都不能是const函数�?/font>

3.       建立了一�?font face="Times New Roman">const成员函数�Q�但仍然想用�q�个函数改变对象内部的数据，�q�样的要求也会经帔R��刎ͼ��其是在一个苛�ȝ��面试考官那里。首先我们要弄清楚考官的要求，因�ؓ有两�U�方法可以实玎ͼ�如果�q�位考官要求不改变原来类的�Q何东西，只让你从当前�q�个const成员函数入手�Q�那么你只有使用前面提到的类型强制�{换方法。实例如下：
//假如有一个叫�?font face="Times New Roman">X的类�Q�它有一�?font face="Times New Roman">int成员变量r�Q�我们需要通过一�?font face="Times New Roman">const成员函数f( )来对�q�个r�q�行++r操作�Q�代码如�?/font>
void X::f( ) const
{ (const_cast(this)) -> ++r; } //通过this指针�q�行�c�d��强制转换实现
另外一�U�方法就是��用关键字�Q?strong>mutable�?/strong>如果你的成员变量在定义时是这个样子的�Q?/font>
mutable int r ;
那么它就告诉�~�译器这个成员变量可以通过const成员函数改变。编译器��׃��会再理会对他的检查了�?/font>

zml_cnnk 2008-10-28 20:01 发表评论

zml_cnnk — Tue, 28 Oct 2008 12:00:00 GMT

一、预处理的由来：
    在C++的历史发展中�Q�有很多的语�a�特征�Q�特别是语言的晦涩之处）来自于C语言�Q�预处理��是其中的一个。C++从C语言那里把C语言预处理器�Q�被Bjarne博士��U�CؓCpp�Q�不知道是不是C Program Preprocessor的简�U�ͼ��l�承�q�来�?/p>

二、常见的预处理功能：
    预处理器的主要作用就是把通过预处理的内徏功能对一个资源进行等��h��换，最常见的预处理有：文�g包含�Q�条件编译、布局控制和宏替换4�U��?/p>
    文�g包含�Q?/p>
#include 是一�U�最为常见的预处理，主要是做为文件的引用�l�合源程序正文�?br>    条�g�~�译�Q?/p>
#if�Q?ifndef�Q?ifdef�Q?endif�Q?undef�{�也是比较常见的预处理，主要是进行编译时�q�行有选择的挑选，注释掉一些指定的代码�Q�以辑ֈ�版本控制、防止对文�g重复包含的功能�?/p>
    布局控制�Q?/p>
#progma�Q�这也是我们应用预处理的一个重要方面，主要功能是�ؓ�~�译�E�序提供非常规的控制��信息�?br>    宏替换：

#define�Q�这是最常见的用法，它可以定义符号常量、函数功能、重新命名、字�W�串的拼接等各种功能�?/p>

三、预处理指��o�Q?br>    预处理指令的格式如下�Q?br>#directive tokens
#�W�号应该是这一行的�W�一个非�I�字�W�，一般我们把它放在�v始位�|�。如果指令一行放不下�Q�可以通过�q�行控制�Q�例如：
#define Error if(error) exit(1)

�{��h(hu��n)�?br>#define Error
if(error) exit(1)
不过我们��Z��化赯��Q�一般都不怎么�q�么用，更常见的方式如下�Q?br># ifdef __BORLANDC__
if_true<(is_convertible::value)>::
template then::type Make;
# else
enum { is_named = is_named_parameter::value };
typedef typename if_true<(is_named)>::template
then::type Make;
# endif
下面我们看一下常见的预处理指令：
#define 宏定�?br>#undef 未定义宏
#include 文本包含
#ifdef 如果宏被定义��p��行编�?br>#ifndef 如果宏未被定义就�q�行�~�译
#endif �l�束�~�译块的控制
#if 表达式非零就对代码进行编�?br>#else 作�ؓ其他预处理的剩余选项�q�行�~�译
#elif �q�是一�U?else�?if的组合选项
#line 改变当前的行数和文�g名称
#error 输出一个错误信�?br>#pragma 为编译程序提供非常规的控制流信息
    下面我们对这些预处理�q�行一一的说明，考虑到宏的重要性和�J�琐性，我们把它攑ֈ�最后讲�?br>
四、文件包含指令： #include
�q�种预处理��用方式是最为常见的�Q��^时我们编写程序都会用刎ͼ�最常见的用法是�Q?br>#include //标准库头文�g
#include //旧式的标准库头文�?br>#include "IO.h" //用户自定义的头文�?br>#include "../file.h" //UNIX下的父目录下的头文�g
#include "/usr/local/file.h" //UNIX下的完整路径
#include "..file.h" //Dos下的父目录下的头文�g
#include "usrlocalfile.h" //Dos下的完整路径
�q�里面有2个地方要注意�Q?br>1、我们用�q�是?
我们��d��使用�Q�而不�?lt;iostream.h>,��Z��么呢�Q�我想你可能�q�记得我曄��l�出�q�几点理由，�q�里我大致的说一下：首先�Q?h格式的头文�g早在98�q?月䆾��p��标准委员会抛弃了�Q�我们应该紧跟标准，以适合时代的发展。其�ơ，iostream.h只支持窄字符集，iostream则支持窄/宽字�W�集。还有，标准对iostream作了很多的改动，接口和实现都有了变化。最后，iostream�l��g全部攑օ�namespace std中，防止了名字污染�?br>2�?lt;io.h>�?io.h"的区别？
其实他们唯一的区别就是搜索�\径不同：
对于#include �Q�编译器从标准库路径开始搜�?br>对于#include "io.h" �Q�编译器从用��L��工作路径开始搜�?br>
五、编译控制指令：
�q�些指��o的主要目的是�q�行�~�译时进行有选择的挑选，注释掉一些指定的代码�Q�以辑ֈ�版本控制、防止对文�g重复包含的功能。��用格式，如下�Q?br>1、如果identifier��Z��个定义了的符��P��your code��׃��被编译，否则剔除
#ifdef identifier
your code
#endif
2、如果identifier��Z��个未定义的符��P��your code��׃��被编译，否则剔除
#ifndef identifier
your code
#endif
3、如果expression非零�Q�your code��׃��被编译，否则剔除
#if expression
your code
#endif
4、如果identifier��Z��个定义了的符��P��your code1��׃��被编译，否则your code2��׃��被编�?br>#ifdef identifier
your code1
#else
your code2
#endif
5、如果epression1非零�Q�就�~�译your code1�Q�否则，如果expression2非零�Q�就�~�译your code2�Q�否则，��q��译your code3
#if expressin1
your code1
#elif expression2 //呵呵�Q�elif
your code2
#else
your code3
#enif

六、其他预�~�译指��o
    除了上面我们说的集中常用的编译指令，�q�有3�U�不太常见的�~�译指��o�Q?line�?error�?pragma�Q�我们接下来��q��单的谈一下�?br>1�?line的语法如下：
#line number filename
例如�Q?line 30 a.h 其中�Q�文件名a.h可以省略不写�?/p>
�q�条指��o可以改变当前的行号和文�g名，例如上面的这条预处理指��o��可以改变当前的行号�?0�Q�文件名是a.h。初看�v来似乎没有什么用�Q�不�q�，他还是有点用的，那就是用在编译器的编写中�Q�我们知道编译器对C++源码�~�译�q�程中会产生一些中间文�Ӟ��通过�q�条指��o�Q�可以保证文件名是固定的�Q�不会被�q�些中间文�g代替�Q�有利于�q�行分析�?br>2�?error语法如下�Q?br>#error info
例如�Q?/p>
#ifndef UNIX
#error This software requires the UNIX OS.
#endif
�q�条指��o主要是给出错误信息，上面的这个例子就是，如果没有在UNIX环境下，��׃��输出This software requires the UNIX OS.然后诱发�~�译器终止。所以�ȝ��来说�Q�这条指令的目的��是在程序崩溃之前能够给��Z��定的信息�?br>3�?pragma

它是非统一的，他要依靠各个�~�译器生产者，例如�Q�在SUN C++�~�译器中�Q?br>// 把name和val的�v始地址调整�?个字节的倍数
#progma align 8 (name, val)
char name[9];
double val;

或是如下用法�Q?br>//在程序执行开始，调用函数MyFunction
#progma init (MyFunction)

七、预定义标识�W?br>��Z��处理一些有用的信息�Q�预处理定义了一些预处理标识�W�，虽然各种�~�译器的预处理标识符不尽相同�Q�但是他们都会处理下面的4�U�：
__FILE__ 正在�~�译的文件的名字
__LINE__ 正在�~�译的文件的行号
__DATE__ �~�译时刻的日期字�W�串�Q�例如： "25 Dec 2000"
__TIME__ �~�译时刻的时间字�W�串�Q�例如： "12:30:55"
例如�Q�cout<<"The file is :"<<__FILE__"<<"! The lines is:"<<__LINE__<

八、预处理何去何从
    如何取代#include预处理指令，我们在这里就不再一一讨论了。C++�q�没有�ؓ#include提供替代形式�Q�但是namespace提供了一�U�作用域机制�Q�它能以某种方式支持�l�合�Q�利用它可以改善#include的行为方式，但是我们�q�是无法取代#include�?br>    #progma应该��是一个可有可无的预处理指令，按照C++之父Bjarne的话��_��是�Q?#progma被过分的�l�常的用于将语言语义的变形隐藏到�~�译�pȝ��里，或者被用于提供带有�Ҏ(gu��)��语义和笨拙语法的语言扩充�?#8221;
    对于#ifdef�Q�我们仍然束手无�{�，��q��是我们利用if语句和常量表辑ּ��Q�仍然不��以替代她，因�ؓ一个if语句的正文必��d��语法上正��，满��c�L��查，即��他处在一个绝不会被执行的分支里面�?/p>

zml_cnnk 2008-10-28 20:00 发表评论

zml_cnnk — Tue, 28 Oct 2008 11:59:00 GMT

// explicit关键�?/p>
    c++中的explicit关键字用来修饰类的构造函敎ͼ�表明该构造函数是昑ּ�的，��x��l�构造时的隐式�{换。如果c++�cȝ��构造函数有一个参敎ͼ�那么在编译的时候就会有一个缺省的转换操作�Q�将该构造函数对应数据类型的数据转换��c�d��象，如下面所�C�：

class MyClass
{
public:
    MyClass( int num );
}
....
MyClass obj = 10; //ok,convert int to MyClass
    在上面的代码中编译器自动��整型�{换�ؓMyClass�c�d��象，实际上等同于下面的操作：
MyClass temp(10);
MyClass obj = temp;
    上面的所有的操作��x��所谓的"隐式转换"�?/p>
    如果要避免这�U�自动�{换的功能�Q�可以将�cȝ��构造函数声明�ؓ"昄��"�Q�也��是在声明构造函数的时候前面添加上explicit卛_��Q�这样就可以防止�q�种自动的�{换操作，如果我们修改上面的MyClass�cȝ��构造函��Cؓ昄��的，那么下面的代码就不能够编译通过了，如下所�C�：
class MyClass
{
public:
    explicit MyClass( int num );
}
....
MyClass obj = 10; //err,can't non-explict convert

// 隐式�cȝ��型�{�?br />
    �q�种效果一般都是通过�c�L��造函数实现的。那些可以用单个实参来调用的构造函敎ͼ�定义了从形参�c�d��到该�cȝ��型的一个隐式�{换。例如如下情况：
xxx(valueOfType1);//对于接受ClassType�c�d��参数的函数xxx�Q�参��C��递中执行了隐式�{换�?br />xxx(ClassType(valueOfType1));//与上面一句效果相同，只是昄��的��用了对应的构造函数�?br />    另外需要注意上面两个语句中传递的�cȝ��型参数的生命周期仅限制在xxx函数中�?br />    如果需要抑制这�U�由构造函数定义的隐式转换�Q�可以如上面所说将构造函数声明�ؓexplicit�Q�且仅用于声明）�?br />
// 从类�c�d��的�{�?br />    与隐式类�c�d��转换不同�Q�前者是到类�c�d��的�{换，而现在是利用转换操作�W?/strong>�Q��ɾl�定�cȝ��型的对象转换成�ؓ其他�c�d��对象。这�U��{换�ؓ什么有用呢�Q�这�U�方法�ؓ了�ɾc�L��持�؜合类型表辑ּ��Q�且可以减少�c�需要的支持功能的操作符数目。定义方法：通用形式�?operator type();
class A
{
public:
    A()
    {
        ……
    }
    operator B() const
    {
        return AtoB(A());
    }
    ……
};
    转换函数一般不应该改变被�{换的对象�Q�因此�{换操作符通常应该定义为const�?br />
// Reference
    详情误��《C++ Primer�?th Edi中的5.12�?2.4�?4.9�Q�还有google资源�?/p>

zml_cnnk 2008-10-28 19:59 发表评论

zml_cnnk — Tue, 28 Oct 2008 07:05:00 GMT
     摘要: 在C++中，内存分成5个区�Q�他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区�?
栈，��是那些��q��译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等�?
堆，��是那些由new分配的内存块�Q�他们的释放�~�译器不�ȝ��Q�由我们的应用程序去控制�Q�一般一个new��p��对应一个delete。如果程序员没有释放掉，那么在程序结束后�Q�操作系�l�会自动回收�?
…�?

  阅读全文

zml_cnnk 2008-10-28 15:05 发表评论

zml_cnnk — Tue, 28 Oct 2008 06:46:00 GMT
     摘要: 我们知道�Q�用C++开发的时候，用来做基�cȝ��cȝ��析构函数一般都是虚函数。可是，��Z��么要�q�样做呢�Q�下面用一个小例子来说明：
有下面的两个�c�：
class ClxBase
{
public:
…�?

  阅读全文

zml_cnnk 2008-10-28 14:46 发表评论

zml_cnnk — Tue, 28 Oct 2008 06:29:00 GMT
     摘要: 很多人听说过标准auto_ptr��指针机制�Q�但�q�不是每个�h都天天��用它。这真是个遗憾，因�ؓauto_ptr优雅地解决了C++设计和编码中常见的问题，正确��C��用它可以生成健壮的代码。本文阐�q�C��如何正确�q�用auto_ptr来让你的代码更加安全——以及如何避免对auto_ptr危险但常见的误用�Q�这些误用会引发间断性发作、难以诊断的bug�?
…�?

  阅读全文

zml_cnnk 2008-10-28 14:29 发表评论

zml_cnnk — Tue, 28 Oct 2008 05:46:00 GMT
     摘要: 一、什么是模板
模板是根据参数类型生成函数和�cȝ��机制�Q�有时称为“参数决定类型”）。通过使用模板�Q�可以只设计一个类来处理多�U�类型的数据�Q�而不必�ؓ每一�U�类型分别创建类�?
例如�Q�创��Z��个类型安全函数来�q�回两个参数中较?y��u)��的一个，如果不��用Templates�Q�必��要�~�写一�p�d��如下的函敎ͼ�
…�?

  阅读全文

zml_cnnk 2008-10-28 13:46 发表评论

zml_cnnk — Mon, 27 Oct 2008 14:56:00 GMT
1、概�?/span>
    Scott Meyers在�?/span>More Effective C++》中举了个例子，不知你是否还记得�Q�在你还在上学的时候，你的父母要你不要看电视，而去复习功课�Q�于是你把自己关在房间里�Q�做��Z��副正在复习功评��样子�Q�其实你在干着别的诸如�l�班上的某位女生写情书之�cȝ��事，而一旦你的父母出来在你房间要��查你是否在复习时�Q�你才真正捡赯��本看书。这��是“拖�g战术”�Q�直��C��非要做的时候才��d��?/span>
    当然�Q�这�U�事情在现实生活中时往往会出事，但其在编�E�世界中摇��n一变，��成��Z��最有用的技术，正如C++中的可以随处声明变量的特点一��P��Scott Meyers推荐我们�Q�在真正需要一个存储空间时才去声明变量�Q�分配内存）�Q�这样会得到�E�序在运行时最��的内存花销。执行到那才会去做分配内存这�U�比较耗时的工作，�q�会�l�我们的�E�序在运行时有比较好的性能。必竟，20%的程序运行了80%的时间�?/span>
    当然�Q�拖延战术还�q�不只是�q�样一�U�类型，�q�种技术被我们�q�泛地应用着�Q�特别是在操作系�l�当中，当一个程序运行结束时�Q�操作系�l��ƈ不会急着把其清除出内存，原因是有可能�E�序�q�会马上再运行一�ơ（从磁盘把�E�序装入到内存是个很慢的�q�程�Q�，而只有当内存不够用了�Q�才会把�q�些�q�驻留内存的�E�序清出�?/span>
    写时才拷贝（Copy-On-Write�Q�技术，��是�~�程�?/span>“懒惰行�ؓ”——拖�g战术的��物。�D个例子，比如我们有个�E�序要写文�g�Q�不断地�Ҏ(gu��)��|�络传来的数据写�Q�如果每一��?/span>fwrite或是fprintf都要�q�行一个磁盘的I/O操作的话�Q�都��直就是性能上巨大的损失�Q�因此通常的做法是�Q�每�ơ写文�g操作都写在特定大��的一块内存中�Q�磁盘缓存）�Q�只有当我们关闭文�g�Ӟ��才写到磁盘上�Q�这��是��Z��么如果文件不关闭�Q�所写的东西会丢��q��原因�Q�。更有甚者是文�g关闭旉��不写��盘�Q�而一直等到关机或是内存不够时才写��盘�Q?/span>Unix��是�q�样一个系�l�，如果非正帔R��出，那么数据��׃��丢失�Q�文件就会损坏�?/span>��Z��性能我们需要冒�q�样大的风险�Q�还好我们的�E�序是不会忙得忘了还有一块数据需要写到磁盘上的，所以这�U�做法，�q�是很有必要的�?br />
2�?/span>标准C++�c?/span>std::string�?/span>Copy-On-Write
      在我们经�怋�用的STL标准模板库中�?/span>string�c�，也是一个具有写时才拯��技术的�c�R�?/span>C++曑֜�性能问题上被�q�泛地质疑和指责�q�，��Z��提高性能�Q?/span>STL中的许多�c�都采用�?/span>Copy-On-Write技术。这�U�偷懒的行�ؓ的确使��?/span>STL的程序有着比较高要性能�?/span>
�q�里�Q�我想从C++�c�L��是设计模式的角度为各位揭开Copy-On-Write技术在string中实现的面纱�Q�以供各位在�?/span>C++�q�行�c�d��设计时做一点参考�?/span>
在讲�q�这��Ҏ(gu��)��术之前，我想��单地说明一�?/span>string�c�d��存分配的概念。通过常，string�c�M��必有一个私有成员，其是一�?/span>char*�Q�用戯��录从堆上分配内存的地址�Q�其在构造时分配内存�Q�在析构旉��攑ֆ�存。因为是从堆上分配内存，所�?/span>string�c�d��l�护�q�块内存上是格外��心的，string�c�d��q�回�q�块内存地址�Ӟ��只返�?/span>const char*�Q�也��是只读的，如果你要写，你只能通过string提供的方法进行数据的改写�?br />
2.1�?/span>�Ҏ(gu��)�?/span>
      ��p��及里�Q�由感性到理性，我们先来看一�?/span>string�cȝ��Copy-On-Write的表面特征。让我们写下下面的一�D늨�序：
#include
#include
using namespace std;
main()
{
string str1 = "hello world";
string str2 = str1;
printf ("Sharing the memory:\n");
printf ("\tstr1's address: %x\n", str1.c_str() );
printf ("\tstr2's address: %x\n", str2.c_str() );
  str1[1]='q';
str2[1]='w';
printf ("After Copy-On-Write:\n");
printf ("\tstr1's address: %x\n", str1.c_str() );
printf ("\tstr2's address: %x\n", str2.c_str() );
return 0;
}
      �q�个�E�序的意囑ְ�是让�W�二�?/span>string通过�W�一�?/span>string构造，然后打印出其存放数据的内存地址�Q�然后分别修�?/span>str1�?/span>str2的内容，再查一下其存放内存的地址。程序的输出是这��L��Q�我�?/span>VC6.0�?/span>g++ 2.95都得��C��同样的结果）�Q?/span>
> g++ -o stringTest stringTest.cpp
> ./stringTest
Sharing the memory:
str1's address: 343be9
str2's address: 343be9
After Copy-On-Write:
str1's address: 3407a9
str2's address: 343be9
从结果中我们可以看到�Q�在开始的两个语句后，str1�?/span>str2存放数据的地址是一��L��Q�而在修改内容后，str1的地址发生了变化，�?/span>str2的地址�q�是原来的。从�q�个例子�Q�我们可以看�?/span>string�cȝ��Copy-On-Write技术�?/span>

2.2�?/span>深入
      在深入这前，通过上述的演�C�，我们应该知道�?/span>string�c�M��Q�要实现写时才拷贝，需要解决两个问题，一个是内存�׃�n�Q�一个是Copy-On-Wirte�Q�这两个主题会让我们产生许多疑问�Q�还是让我们带着�q�样几个问题来学习吧�Q?/span>
1�?/span> Copy-On-Write的原理是什么？
2�?/span> string�c�d��什么情况下才共享内存的�Q?/span>
3�?/span> string�c�d��什么情况下触发写时才拷贝（Copy-On-Write�Q?/span>?
4�?/span> Copy-On-Write�Ӟ��发生了什么？
5�?/span> Copy-On-Write的具体实现是怎么��L��Q?/span>
      喔，你说只要看一�?/span>STL�?/span>stirng的源码你��可以找到答案了。当�Ӟ��当然�Q�我也是参考了string的父模板�c?/span>basic_string的源码。但是，如果你感到看STL的源码就好像看机器码�Q��ƈ严重打击你对C++自信心，乃至产生了自己是否懂C++的疑问，如果你有�q�样的感觉，那么�q�是�l�箋往下看我的�q�篇文章吧�?/span>
OK�Q�让我们一个问题一个问题地探讨吧，慢慢地所有的技术细节都会��Q出水面的�?br />
2.3�?/span>Copy-On-Write的原理是什么？

      有一定经验的�E�序员一定知道，Copy-On-Write一定��用了“引用计数”�Q�是的，必然有一变量�c�M��?/span>RefCnt。当�W�一个类构造时�Q?/span>string的构造函��C��Ҏ(gu��)��传入的参��C��堆上分配内存�Q�当有其它类需要这块内存时�Q�这个计��Cؓ自动累加�Q�当有类析构�Ӟ��q�个计数会减一�Q�直到最后一个类析构�Ӟ��此时�?/span>RefCnt�?/span>1或是0�Q�此�Ӟ��E�序才会真正�?/span>Free�q�块从堆上分配的内存�?/span>
是的�Q�引用计数就�?/span>string�c�M��写时才拷贝的原理�Q?/span>
      不过�Q�问题又来了�Q�这�?/span>RefCnt该存在在哪里呢？如果存放�?/span>string�c�M��Q�那么每�?/span>string的实例都有各自的一套，�Ҏ(gu��)��不能共有一�?/span>RefCnt�Q�如果是声明成全局变量�Q�或是静态成员，那就是所有的string�c�d��享一个了�Q�这也不行，我们需要的是一�?/span>“民主和集�?/span>”的一个解��x��法。这是如何做到的呢？呵呵�Q��h生就是一个糊涂后��L��知，知道后和又糊涂的循环�q�程。别急别急，在后面我会给你一一道来的�?/span>

2.3.1�?/span>string�c�d��什么情况下才共享内存的�Q?/span>
      �q�个问题的答案应该是明显的，�Ҏ(gu��)��常理和逻辑�Q�如果一个类要用另一个类的数据，那就可以�׃�n被��用类的内存了。这是很合理的，如果你不用我的，那就不用�׃�n�Q�只有你使用我的�Q�才发生�׃�n�?/span>
      使用别的�cȝ��数据�Ӟ��无非有两�U�情况，1�Q�以别的�c�L��造自己，2�Q�以别的�c�赋倹{��第一�U�情冉|��会触发拷贝构造函敎ͼ��W�二�U�情况会触发赋值操作符。这两种情况我们都可以在�c�M��实现其对应的�Ҏ(gu��)��。对于第一�U�情况，只需要在string�cȝ��拯��构造函��C��做点处理�Q�让其引用计数篏加；同样�Q�对于第二种情况�Q�只需要重�?/span>string�cȝ��赋值操作符�Q�同样在其中加上一点处理�?/span>
      唠叨几句�Q?/span>
1�Q�构造和赋值的差别
对于前面那个例程中的�q�两句：
string str1 = "hello world";
string str2 = str1;
不要以�ؓ�?/span>“=”��是赋值操作，其实�Q�这两条语句�{��h(hu��n)于：
string str1 ("hello world"); //调用的是构造函�?/span>
string str2 (str1); //调用的是拯��构造函�?/span>
如果str2是下面的�q�样情况�Q?/span>
string str2; //调用参数默认为空串的构造函敎ͼ�string str2(“”);
str2 = str1; //调用str2的赋值操作：str2.operator=(str1);
2) 另一�U�情�?/span>
char tmp[]=”hello world”;
string str1 = tmp;
string str2 = tmp;
�q�种情况下会触发内存的共享吗�Q�想当然的，应该要共享。可是根据我们前面所说的�׃�n内存的情况，两个string�cȝ��声明和初始语句�ƈ不符合我前述的两�U�情况，所以其�q�不发生内存�׃�n。而且�Q?/span>C++现有�Ҏ(gu��)��也无法让我们做到对�q�种情况�q�行�cȝ��内存�׃�n�?/span>

2.3.2�?/span>string�c�d��什么情况下触发写时才拷贝（Copy-On-Write�Q?/span>?
      哦，什么时候会发现写时才拷贝？很显�Ӟ��当然是在�׃�n同一块内存的�c�d��生内�Ҏ(gu��)��变时�Q�才会发�?/span>Copy-On-Write。比�?/span>string�cȝ��[]�?/span>=�?/span>+=�?/span>+、操作符赋��|��q�有一�?/span>string�c�M��诸如insert�?/span>replace�?/span>append�{�成员函数�?/span>
      修改数据才会触发Copy-On-Write�Q�不修改当然��׃��会改啦。这��是托�g战术的真谛，非到要做的时候才��d��?br />
2.3.3�?/span>Copy-On-Write�Ӟ��发生了什么？
      我们可能�Ҏ(gu��)��那个讉K��计数来决定是否需要拷贝，参看下面的代码：
If ( RefCnt>0 ) {
char* tmp = (char*) malloc(strlen(_Ptr)+1);
strcpy(tmp, _Ptr);
_Ptr = tmp;
}
      上面的代码是一个假想的拯��Ҏ(gu��)��Q�如果有别的�c�d��引用�Q�检查引用计数来��L��Q�这块内存，那么��需要把更改�c�进�?/span>“拯��”�q�个动作�?/span>
我们可以把这个拷的运行封装成一个函敎ͼ�供那些改变内容的成员函数使用�?br />
2.3.4�?/span>Copy-On-Write的具体实现是怎么��L��Q?/span>
      最后的�q�个问题�Q�我们主要解决的是那�?/span>“民主集中”的难题。请先看下面的代码：
string h1 = “hello”;
string h2= h1;
string h3;
h3 = h2;
string w1 = “world”;
string w2(“”);
w2=w1;
      很明显，我们要让h1�?/span>h2�?/span>h3�׃�n同一块内存，�?/span>w1�?/span>w2�׃�n同一块内存。因为，�?/span>h1�?/span>h2�?/span>h3中，我们要维护一个引用计敎ͼ��?/span>w1�?/span>w2中我们又要维护一个引用计数�?/span>
      如何使用一个��y妙的�Ҏ(gu��)��产生�q�两个引用计数呢�Q�我们想��C��string�cȝ��内存是在堆上动态分配的�Q�既然共享内存的各个�c�L��向的是同一个内存区�Q�我们�ؓ什么不在这块区上多分配一点空间来存放�q�个引用计数呢？�q�样一来，所有共享一块内存区的类都有同样的一个引用计敎ͼ�而这个变量的地址既然是在�׃�n��Z��的，那么所有共享这块内存的�c�都可以讉K��刎ͼ�也就知道�q�块内存的引用者有多少了�?/span>

      于是�Q�有了这样一个机�Ӟ��每当我们�?/span>string分配内存�Ӟ��我们��L��要多分配一个空间用来存放这个引用计数的��|��只要发生拯��构造或是赋值时�Q�这个内存的值就会加一。而在内容修改�Ӟ��string�c�Mؓ查看�q�个引用计数是否�?/span>0�Q�如果不为零�Q�表�C�有人在�׃�n�q�块内存�Q�那么自己需要先做一份拷贝，然后把引用计数减��M��Q�再把数据拷贝过来。下面的几个�E�序片段说明了这两个动作�Q?/span>
//构造函敎ͼ�分存内存�Q?/span>
string::string(const char* tmp)
{
_Len = strlen(tmp);
_Ptr = new char[_Len+1+1];
strcpy( _Ptr, tmp );
_Ptr[_Len+1]=0; // 讄��引用计数
}
//拯��构造（�׃�n内存�Q?/span>
string::string(const string& str)
{
if (*this != str){
this->_Ptr = str.c_str(); //�׃�n内存
this->_Len = str.szie();
this->_Ptr[_Len+1] ++; //引用计数加一
}
}
//写时才拷�?/span>Copy-On-Write
char& string::operator[](unsigned int idx)
{
if (idx > _Len || _Ptr == 0 )
{
static char nullchar = 0;
return nullchar;
}
_Ptr[_Len+1]--; //引用计数减一
char* tmp = new char[_Len+1+1];
strncpy( tmp, _Ptr, _Len+1);
_Ptr = tmp;
_Ptr[_Len+1]=0; // 讄��新的�׃�n内存的引用计�?/span>

return _Ptr[idx];
}
      哈哈�Q�整个技术细节完全��Q出水面�?/span>
      不过�Q�这�?/span>STL�?/span>basic_string的实现细节还有一点点差别�Q�在你打开STL的源码时�Q�你会发现其取引用计数是通过�q�样的访问：_Ptr[-1]�Q�标准库中，把这个引用计数的内存分配在了前面�Q�我�l�出来的代码是把引用计数分配以了后面�Q�这很不好）�Q�分配在前的好处是当string的长度扩展时�Q�只需要在后面扩展其内存，而不需要移动引用计数的内存存放位置�Q�这又节省了一�Ҏ(gu��)��间�?/span>
      STL中的string的内存结构就像我前面�ȝ��那个图一��P��_Ptr指着是数据区�Q��?/span>RefCnt则在_Ptr-1 或是 _Ptr[-1]处�?br />
2.4�?/span>臭虫Bug
      是谁说的“有太阳的地方��׃��有黑�?/span>”�Q�或许我们中的许多�h都很�q�信标准的东西，认�ؓ其是久经考验�Q�不可能出错的。呵呵，千万不要有这�U�迷信，因�ؓ��M��设计再好�Q�编码再好的代码在某一特定的情况下都会�?/span>Bug�Q?/span>STL同样如此�Q?/span>string�cȝ��q�个�׃�n内存/写时才拷贝技术也不例外，而且�q�个Bug或许�q�会让你的整个程�?/span>crash掉！不信�Q�！那么让我们来看一个测试案例：
      假设有一个动态链接库�Q�叫myNet.dll�?/span>myNet.so�Q�中有这样一个函数返回的�?/span>string�c�：
string GetIPAddress(string hostname)
{
static string ip;
……
……
return ip;
}

而你的主�E�序中动态地载入�q�个动态链接库�Q��ƈ调用其中的这个函敎ͼ�
main()
{
//载入动态链接库中的函数
hDll = LoadLibraray(…..);
pFun = GetModule(hDll, “GetIPAddress”);
//调用动态链接库中的函数
string ip = (*pFun)(“host1”);
……
……
//释放动态链接库
FreeLibrary(hDll);
……
cout << ip << endl;
}

      让我们来看看�q�段代码�Q�程序以动态方式蝲入动态链接库中的函数�Q�然后以函数指针的方式调用动态链接库中的函数�Q��ƈ把返回值放在一�?/span>string�c�M��Q�然后释放了�q�个动态链接库。释攑֐��Q�输�?/span>ip的内宏V�?/span>
      �Ҏ(gu��)��函数的定义，我们知道函数�?/span>“��D��?/span>”的，所以，函数�q�回�Ӟ��一定会调用拯��构造函敎ͼ�又根�?/span>string�cȝ��内存�׃�n机制�Q�在�ȝ��序中变量ip是和函数内部的那个静�?/span>string变量�׃�n内存�Q�这块内存区是在动态链接库的地址�I�间的）。而我们假讑֜�整个�ȝ��序中都没有对ip的��D��行修改过。那么在当主�E�序释放了动态链接库后，那个�׃�n的内存区也随之释放。所以，以后�?/span>ip的访问，必然做造成内存地址讉K��非法�Q�造成�E�序crash。即使你在以后没有��用到ip�q�个变量�Q�那么在�ȝ��序退出时也会发生内存讉K��异常�Q�因为程序退出时�Q?/span>ip会析构，在析构时��׃��发生内存讉K��异常�?/span>
      内存讉K��异常�Q�意味着两�g事：
1�Q�无��Z��的程序再漂亮�Q�都会因��个错误变得暗淡无光，你的声誉也会因�ؓ�q�个错误受到损失�?br />2�Q�未来的一�D�|��_��你会被这个系�l��错误所煎熬�Q�在C++世界中，扑ֈ��q�排除这�U�内存错误�ƈ不是一件容易的事情�Q��?br />      �q�是C/C++�E�序员永�q�的心头之痛�Q�千里之堤，溃于蚁穴。而如果你不清�?/span>string�cȝ��q�种特征�Q�在成千上万行代码中找这样一个内存异常，��直就是一场噩梦�?/span>
备注�Q�要�Ҏ(gu��)��上述�?/span>Bug�Q�有很多�U�方法，�q�里提供一�U�仅供参考：
string ip = (*pFun)(“host1”).cstr();

3�?/span>后记
      文章到这里也应该�l�束了，�q�篇文章的主要有以下几个目的�Q?/span>
1�Q?/span> 向大家介�l�一下写时才拯��/内存�׃�n�q�种技术�?/span>
2�Q?/span> �?/span>STL中的string�c�Mؓ例，向大家介�l�了一�U�设计模式�?/span>
3�Q?/span> �?/span>C++世界中，无论你的设计怎么�_��y�Q�代码怎么�E�_��Q�都难以照顾到所有的情况。智能指针更是一个典型的例子�Q�无��Z��怎么设计�Q�都会有非常严重�?/span>BUG�?/span>
4�Q?/span> C++是一把双刃剑�Q�只有了解了原理�Q�你才能更好的��?/span>C++。否则，必将引火烧��n。如果你在设计和使用�c�d��时有一�U?/span>“�?/span>C++��像玩火�Q�必��d��万小�?/span>”的感觉，那么你就入门了，�{�你能把�q�股“�?/span>”控制的得心应手时�Q�那才是学成了�?/span>

zml_cnnk 2008-10-27 22:56 发表评论

zml_cnnk — Mon, 27 Oct 2008 14:51:00 GMT
class Singleton
{

public:

    static Singleton* Instance();

protected:

    Singleton();

private:

    static Singleton* _instance;

};

相应的实�?/span> cpp 文�g是：

Singleton* Singleton::_instance;

Singleton* Singleton::Instance()
{

    if( _instance == 0){

        _instance = new Singleton;

    };

    return _instance;

}

    ��构造函数设计成 protected 的目的是防止�?/span> class 外面 new �Q�有人可能会设计�?/span> private �Q�假如考虑到有可能会��l�这个类的话�Q�还是将构造函数设计成 protected 比较好，�q�需要加一�?/span> virtual 析构函数。�ؓ了防止别人复�?/span> Singleton 对象�Q?/span>

Singleton* pSingleton = Singleton::Instance();

Singleton s1 = *pSingleton;

Singleton s2 = *pSingleton;

需要将拯��构�?/span>(copy constrUCtor)函数变成 private�?/span>

    但是�q�里存在的问题是�Q�什么时�?/span>删除 Singleton 对象�Q�按�?/span> C++ 的一个基本原则，对象在哪里创建就在哪里销毁，�q�里�q�应该放一�?/span> destroy �Ҏ(gu��)��来删�?/span> Singleton 对象。假如忘了删除就比较�ȝ��?/span>Instance 函数�q�存�?/span>多线�E�同时访问的加锁问题。假如把 Instance 函数开始和�l�尾放上加锁和解锁，整个函数性能会下降很多。这不是一个好的设计�?/span>

    有一个小��的改动�Q�可以避免忘了删�?/span> Singleton 对象带来内存泄露的问题。那��是�?/span> std:auto_ptr 来包�?/span> Singleton 对象,定义一个类静�?/span>auto_ptr成员对象�Q�在析构静态的auto_ptr 变量的时候时候自动删�?/span> Singleton 对象。�ؓ了不让用�?/span> delete Singleton 对象�Q�需要将析构函数�?/span> public 变成 protected。以下是头文�?/span> SingletonAutoPtr.h �Q?/span>

#include

using namespace std;

class CSingletonAutoPtr

{

private:

    static auto_ptr m_auto_ptr;

    static CSingletonAutoPtr* m_instance;

protected:

    CSingletonAutoPtr();

    CSingletonAutoPtr(const CSingletonAutoPtr&);

    virtual ~CSingletonAutoPtr();

    //allow auto_ptr to delete, using protected ~CSingletonAutoPtr()

    friend class auto_ptr;

public:

    static CSingletonAutoPtr* GetInstance();

    void Test();

};

对应�?/span> SingletonAutoPtr.cpp 如下�Q?/span>

#include "SingletonAutoPtr.h"

#include

//initial static member vars here

CSingletonAutoPtr* CSingletonAutoPtr::m_instance = NULL;

auto_ptr CSingletonAutoPtr::m_auto_ptr;

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

// Construction/Destruction

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

//下列代码没有�l�过验证�Q?/p>
CSingletonAutoPtr::CSingletonAutoPtr()

{

    cout << "CSingletonAutoPtr::CSingletonAutoPtr()" << endl;

    //put single object into auto_ptr object

    m_auto_ptr = auto_ptr(this);

}

CSingletonAutoPtr::~CSingletonAutoPtr()

{

    cout << "CSingletonAutoPtr::~CSingletonAutoPtr()" << endl;

}

CSingletonAutoPtr* CSingletonAutoPtr::GetInstance()

{

    //begin lock

    //....
if(m_instance == NULL)

        m_instance = new CSingletonAutoPtr();
//end lock

    //...
return m_instance;

}

void CSingletonAutoPtr::Test()

{

    cout << "CSingletonAutoPtr::Test()" << endl;

}

调用�Ҏ(gu��)��Q?/span>

CSingletonAutoPtr* pSingleton = CSingletonAutoPtr::GetInstance();

pSingleton->Test();

      写一�?C++ 中的 Singleton 需要这么费�Ԍ��大大��Z��我们的意料。有很多��Z��未用�q?auto_ptr�Q�而且 std:auto_ptr 本��n��ƈ不完��，它是��Z��对象所有权机制的，相比之下�Q�Apache Log4cxx 中有一�?auto_ptr, 是基于对象计数的�Q�更为好用。只是�ؓ了用一个好�?auto_ptr 而不得不�?log4cxx , 对于很多��目来说�Q�也不太好。当然了�Q�ANSI C++ �?STL �?std:auto_ptr 对于写上面的例子已经��_��用了�?nbsp;
    另外一个思�\是，�?/span> GetInstance 函数设计�?/span> static member 可能更好�Q�因��Z��般来��_��Singleton 对象都不大，static member 虽然必须一直占用内存，问题不大。这里的析构函数必须设成 public 了。以下是头文�?/span> SingleStaticObj.h

class CSingletonStaticObj

{

private:

    static CSingletonStaticObj m_instance;

protected:

    CSingletonStaticObj();

   CSingletonStaticObj(const CSingletonStaticObj&);

public:

    virtual ~CSingletonStaticObj(); //must public

    static CSingletonStaticObj& GetInstance();

    void Test();

};     对应�?/span> SingleStaticObj.cpp 文�g为：#include "SingletonStaticObj.h"

#include

#include

using namespace std;

CSingletonStaticObj CSingletonStaticObj::m_instance;CSingletonStaticObj::CSingletonStaticObj()

{

    cout << "CSingletonStaticObj::CSingletonStaticObj()" << endl;

}

CSingletonStaticObj::~CSingletonStaticObj()

{

    cout << "CSingletonStaticObj::~CSingletonStaticObj()" << endl;

}

CSingletonStaticObj& CSingletonStaticObj::GetInstance()

{

    return m_instance;

}

void CSingletonStaticObj::Test()

{

    cout << "CSingletonStaticObj::Test()" << endl;

}

     调用�Ҏ(gu��)��Q?/span>

CSingletonStaticObj& singleton = CSingletonAutoPtr::GetInstance();

singleton.Test();

从代码量来说�Q�似乎��?/span> static member ref 更�ؓ��单。我更偏向于用这�U�方法�?/span>

    但是�Q��ƈ不是所有情况下面都适合�?/span> static member singleton。比如说�Q?/span>GetInstance 需要动态决定返回不同的 instance 的时候，��׃��能用。�D例来��_��FileSystem::GetInstance, �?/span> windows 下面�q�行可能需要返�?/span> new WinFileSystem, Linux/Unix 下面�q�行可能需要返�?/span> new LinuxFileSystem�Q�这个时候还是需要用上面�?/span> auto_ptr 包含 singleton 指针的方法�?/span>

zml_cnnk 2008-10-27 22:51 发表评论

zml_cnnk — Mon, 27 Oct 2008 13:22:00 GMT
     摘要: for(iterator it = begin(); it != end(); ++it)
或�?
for(iterator it = begin(); it != end(); it++)
区别是什么呢�Q�？
…�?

  阅读全文

zml_cnnk 2008-10-27 21:22 发表评论