久久久久久久久久看片,国产成人免费,都市激情在线视频

amenglai — Fri, 28 Aug 2009 00:37:00 GMT

��C��天，�l�于�?#8220;C++ primer”��d��了。花�?/span>4个月的时间。千�a�万语�Q�但是不知从何说赗��一句话吧，�q�是一本很值得�ȝ��书，不管你是Java�E�序员还�?/span>C++�E�序员或者是.Net�E�序员�?/span>

��Z��么？因�ؓ�q�是一�ơ方法论的学习过�E�，而不仅仅是一�U�语�a�的学习�?/span>

�ȝ��本书�Q�按郭�d�U�的话说�Q�得有过日子的心�Q�就一��一��读下去�Q�体会，反省�Q�动手练习�?/span>

具体到我�Q�我看的是英文第四版�Q�用的编译器�?/span>MinGW。这本书不仅可以学习C++�Q�也是一本很好的学习��p��的教材。英语很地道�Q�而且对于词汇量的要求也不是很高（相对Martin大叔的书来说�Q��?/span>

之所以选择MinGW只是因�ؓ�?#8220;�?#8221;�Q�因为我�q�x��主要是用Java�?/span>C�Q�其实工作中是没啥机会��?/span>C++的。�ؓ了把主要�_�֊�攑֜�C++本��n�Q�所以�ƈ没有�?/span>VC之类庞大�?/span>IDE工具�?/span>

我看书的�q�度的确不算快，只有周一到周五这5天，周六、周日都用在�?/span>huohuo鬼�؜上，基本上没啥精力看书了�?/span>

在看“C++ primer”的这4个月的时间里我还在业余时间里做了两个��项目。所以看书的旉��q�不是很规律。但是我的经验就是坚持�?/span>

我很享受�q?/span>4个月的时光。有�Ӟ��我觉得这书咋像小说一样好看呢�Q�上下班的�\上，我都想下一��大师会讲些啥呢�Q�有�Ӟ��写着写着java,甚至有些恍惚�Q�偶��想�Q�这要是C++多好�Q�可以这栯��样写了�?/span>

感谢Lippman�Q�带�l�我的快乐�?/span>Bye-Bye�?/span>

amenglai 2009-08-28 08:37 发表评论

amenglai — Fri, 28 Aug 2009 00:35:00 GMT

摘要: Chapter 18. �Ҏ(gu��)��工具与技�? 18.1 优化内存分配Optimizing Memory Allocation 分配内存和创建对象是两个不同的概��c��分配内存，�q�不一定会立即创徏对象。同��P��内存释放和对象撤销也是两个不同的概��c�? 18.1.1. C++ 中的内存分配 new操作�Q�给指定的类型分配内存�ƈ在新分配的内存上构造指定类型的对象�?.. 阅读全文

amenglai 2009-08-28 08:35 发表评论

amenglai — Wed, 12 Aug 2009 03:10:00 GMT

摘要: �W�十七章 Tools for Large Programs 用于大型�E�序的工�?�q�一章值得仔细品味�?17.1 异常处理�Q�Exception Handling�Q?C++异常处理包括�Q?1. throw 表达式（throw expressions�Q? throw 引发了异常条件。a throw raises an e... 阅读全文

amenglai 2009-08-12 11:10 发表评论

amenglai — Tue, 28 Jul 2009 09:29:00 GMT

摘要: �W�十六章模板和泛型编�E?在C++中模板是泛型�~�程的基��。（In C++, templates are the foundation for generic programming.�Q?16.1 模板定义Template Definitions 16.1.1 定义函数模板 Defining a Function Template 函数模板是和�c�d��无关的函数定义，它被当作是公... 阅读全文

amenglai 2009-07-28 17:29 发表评论

C++ Primer �?��M��W�记 �W�十五章面向对象�~�程

amenglai — Wed, 15 Jul 2009 08:36:00 GMT

摘要: Chap 15 Object-Oriented Programming 15.1 OOP总览 �l�承 inheritance hierarchy 动态绑�?在C++里，当虚函数通过基类的引用或者指针被调用�Ӟ��׃��发生动态绑定。（In C++, dynamic binding happens when a virtual function is called through... 阅读全文

amenglai 2009-07-15 16:36 发表评论

C++ Primer �?��M��W�记 �W�十四章

amenglai — Wed, 01 Jul 2009 00:33:00 GMT

摘要: Overloaded Operations and Conversions (重蝲操作和�{�? 14.1 定义重蝲操作�W�（Defining an Overload Operators�Q?重蝲操作�W�必��至��有一个操作数的类型是�c�R�?重蝲操作�W�必��至��有一个操作数是类�c�d��和枚丄��型。（An overloaded operator must have at least one ... 阅读全文

amenglai 2009-07-01 08:33 发表评论

C++ Primer �?��M��W�记 �W�十三章

amenglai — Wed, 24 Jun 2009 00:17:00 GMT

Chapter 13. Copy Control

13.1 The Copy Constructor

首先�Q�这真是一个有��的命题。我老喜�Ƣ。这让我惌��v的是Java�?/span>clone。（写下�q�句话时我还没有看这一节，只是一个预感）

�q�瘾啊。（写下�q�句话时我刚刚读完这一节，�q�没有来得及整理�W�记�Q�理��思�\�Q?/span>

什么叫做拷贝构造函敎ͼ�

拯��构造函数有一个�Ş参，�q�且�q�个形参是指向同一个类的对象的引用。（The constructor that takes a single parameter that is a (usually const) reference to an object of the class type itself is called the copy constructor.�Q?/span>

对象定义的�Ş�?/span>

c++支持两种形式的初始化�Q?/span>

1. 直接初始化，使用初始化式�Q?/span>initializer�Q�，直接调用对应的构造函数�?/span>

2. 拯��初始化，使用’=’。先调用构造函数生成��时对象，然后再调用拷贝构造函数把临时对象拯��到我们要创徏的对象里。（Copy-initialization first uses the indicated constructor to create a temporary object. It then uses the copy constructor to copy that temporary into the one we are creating�Q?/span>

string null_book = "9-999-99999-9"; // copy-initialization

string empty_direct; // direct-initialization

对于�cȝ��对象�Q�当指定单一的实参或者�ؓ了拷贝明��构��Z��时对象时�Q�才能��用拷贝初始化。（For objects of class type, copy-initialization can be used only when specifying a single argument or when we explicitly build a temporary object to copy.�Q?/span>

ifstream file2 = "filename"; // error: copy constructor is private

// This initialization is okay only if

// the Sales_item(const string&) constructor is not explicit

Sales_item item = string("9-999-99999-9");

额外唠唠Sales_item item = string("9-999-99999-9");

只有�?/span>Sales_item的构造函��C��没有�?/span>Sales_item(const string&)�q�个构造函数声明�ؓexplicit�Ӟ��q�个初始化才正确。这其中包含了一个隐式的�c�d��转换�Q�由实参string("9-999-99999-9");生成Sales_item�c�d��的对象，然后再调�?/span>copy函数拯��l?/span>item�?/span>

但是�Q�咋�q�么多但是呢�Q�如果这么写Sales_item item2 = item;��又不一样了。这样就变成了调用赋值操作符�?/span>

合成复制构造函�?/span>

复制构造函数是逐成员拷贝（memberwise copy�Q��?/span>

即��我们不能�?/span>array�q�行copy�Q�但是如果一个类包含有数�l�类型的成员�Q�合成的复制构造函��C��会拷贝这个的数组。数�l�中的每个元素都会进行复制。（Even though we ordinarily cannot copy an array, if a class has a member that is an array, then the synthesized copy constructor will copy the array. does so by copying each element.�Q?/span>

自定义拷贝函�?/span>

class Foo {

public:

Foo(); // default constructor

Foo(const Foo&); // copy constructor

// ...

};

��L��拯��

�Ҏ(gu��)��Q?/span>��是把拷贝函数声明�ؓprivate�?/span>

大多数类都应该定义拷贝构造函数和默认构造函数�?/span>

如果一个类里面定义了一个构造函敎ͼ��~�译期就不会再�ؓ�q�个�cȝ��成默认构造函敎ͼ�而需要自己来定义了�?/span>

温习一下什么是默认构造函敎ͼ��Q�唉�Q�忘记的真快啊）

默认构造函数没有�Ş参。如果定义的对象不提供初始化式（initializer�Q�就会调用默认构造函数。（The default constructor is used whenever we define an object but do not supply an initializer.�Q?/span>

如果一个构造函��Cؓ所有�Ş参提供缺省的实参�Q�也可以叫做是默认构造函数。（A constructor that supplies default arguments for all its parameters also defines the default constructor.�Q?/span>

13.2 The Assignment Operator

如果�c�自己没有定义赋值操作符�Q�那么编译器合成赋值操作符。（注意�Q�这�z�L��~�译器干的）

重蝲操作�W�（overloaded operators�Q?/span>

操作�W�重载的形参列表�Q�这里要包括this形参�Q�如果操作符是成员函数的话）以及�q�回值必��d��操作�W�所需要的操作数相同�?/span>

�q�句话咋理解呢？

Sales_item trans, accum;

trans = accum;

1. 形参列表

操作�W?/span>’=’是二元操作符�Q�它的操作数是两个：�W�一个操作数是左边的操作敎ͼ��W�二个操作数是右边的操作数。上面这个例子，如果我们需要重�?/span>’=’�Q�第一个操作数是被�l�定�?/span>this指针上，�W�二个操作数是一�?/span>Sales_item�c�d��的对象一般来��_��双��操作��C��般都是作�?/strong>const引用传递�?/span>�Q?/span>Usually, the right-hand operand is passed as a const reference.�Q��?/span>

Sales_item& operator=(const Sales_item &);

2.            �q�回�?/span>

赋值操作符的返回值类型应该和内置�c�d��的返回值类型相同。（The return type from the assignment operator should be the same as the return from assignment for the built-in types�Q�内�|�类型的赋��D��回的是左操作数的引用�Q�因此赋值操作符也必��返回和它的�cȝ��型相同的引用。具体到Sales_item�Q?/span>’=’操作�W�重载的�q�回值是Sales_item的引用�?/span>

class Sales_item {

public:

      // other members as before

      // equivalent to the synthesized assignment operator

      Sales_item& operator=(const Sales_item &);

};

合成赋值操作符

合成赋值操作符也是逐个成员赋��|��memberwise assignment�Q�。对于数�l�是�Ҏ(gu��)��个元素进行赋倹{�?/span>

// equivalent to the synthesized assignment operator

Sales_item& Sales_item::operator=(const Sales_item &rhs)

{

      isbn = rhs.isbn;              // calls string::operator=

      units_sold = rhs.units_sold; // uses built-in int assignment

      revenue = rhs.revenue;        // uses built-in double assignment

      return *this;

}

13.3 The Destructor

什么时候调用析构函敎ͼ�

// p points to default constructed object

   Sales_item *p = new Sales_item;

   {

       // new scope

       Sales_item item(*p); // copy constructor copies *p into item

       delete p;             // destructor called on object pointed to by p

   }

以上�q�个例子说明在两�U�情况下会调用析构函敎ͼ�

当变量在作用域范围之外的时候，自动被撤销�Q?/span>destroied�Q?/span>

指向对象的指针被删除�Q?/span>deleted�Q�，�q�个对象也就被撤销�Q?/span>destroied�Q?/span>

�q�一步说明的是指向对象的指针或者是引用即��Z��作用域，析构函数也是不会被执行的。就�q�是以上面的例子来说明：

// p points to default constructed object

   Sales_item *p = new Sales_item;

   {

       // new scope

       Sales_item *ghost = new Sales_item;

       Sales_item item(*p); // copy constructor copies *p into item

       delete p;             // destructor called on object pointed to by p

   }

ghost�q�个��鬼即��Z��作用域实际上也是没有被删除滴�Q�占用的内存�I�间也是没有被释放滴。这��L��E�序跑上N遍，机器��׃��惌��牛一��h��了。哎�Q�（

另外当容器撤销�Ӟ��容器中的元素的析构函��C��会被调用�Q?/span>Destructors are also run on the elements of class type in a container - whether a library container or built-in array - when the container is destroyed�Q?/span>

啥时需要写昑ּ�的析构函�?/span>

析构函数用来释放构造函数或对象生存周期内所需的资�?/span>( Ordinarily they are used to relinquish resources acquired in the constructor or during the lifetime of the object.)

另外析构函数也不仅仅是用来释放资源。析构函数可以执行类设计者希望执行的��M��操作�Q�这些操作和�c�d��象��用完毕之后执行。（A destructor is not limited only to relinquishing resources. A destructor, in general, can perform any operation that the class designer wishes to have executed subsequent to the last use of an object of that class.�Q?/span>

首要原则是：如果�c�需要析构函敎ͼ�那么它一定也需要拷贝构造函敎ͼ�copy constructor�Q�和赋值操作符�Q?/span>assignment operator�Q��?/span>

合成析构函数

析构函数和拷贝构造函敎ͼ�copy constructor�Q�和赋值操作符�Q?/span>assignment operator�Q�不同，��是即��你定义了自己的析构函敎ͼ��?/span>delete�Ӟ��先调用你自己的析构函敎ͼ�然后�q�是要调用合成的析构函数�Q?/span>synthesized destructor�Q��?/span>

析构函数执行的顺序：和构造函数恰恰相反。按照成员在�c�里面定义的相反的顺序撤销成员。（it destroys the members in reverse order from which they are declared in the class. For each member that is of class type, the synthesized destructor invokes that member's destructor to destroy the object.�Q?/span>

自定义析构函数和合成析构函数的执行顺序：先自定义析构函数�Q�然后再执行合成析构函数�?/span>

class Sales_item {

public:

     // empty; no work to do other than destroying the members,

     // which happens automatically

      ~Sales_item() { }

     // other members as before

};

13.4 A Message-Handling Example

需求描�q�ͼ�

新徏Message�Q�是�?/span>folder无关的，通过调用save�?/span>Message保存到指定的folder。一�?/span>Message可以同时属于不同�?/span>folder。因�?/span>Message中就包含了一�?/span>folder的指针集合。另外每�?/span>folder里也要包括指向这�?/span>Message的指针�?/span>

copy Message�Q�包括拷�?/span>Message的文本内容以及一�p�d��?/span>folder指针。同时对于每�?/span>folder也要�q�加一个指向拷贝后�?/span>Message的指针�?/span>

赋值操作（assignment�Q�：�q�个最�?/span>:D。先要把�{�号左边�?/span>message对象�?/span>folder中删除，再删除对象；然后把右�?/span>message对象的文本内容和folder拯��q�来�Q�同时还要向folder指针�q�加指向左边message的指针�?/span>

destroy�Q�除了要撤销�q�个Message对象�Q�同时也要删除掉各个folder里面指向�q�个Message的指针�?/span>

大师抽象出来两个操作�Q?/span>

�?/span>message�?/span>folder中删除：

void remove_Msg_from_Folders();

�?/span>message�q�加到指定的folider�Q?/span>

void put_Msg_in_Folders(const std::set&);

拯��构造函�?/span>

如果我们定义自己的拷贝构造函敎ͼ�那么我们必须昑ּ�拯��M��我们惌��拯��的成员，因�ؓ昑ּ�定义考别构造函数是不会自动拯��M��东西的。（When we write our own copy constructor, we must explicitly copy any members that we want copied. An explicitly defined copy constructor copies nothing automatically.�Q�就是说你要打算自己�q�就全部自己�qԌ��别指望编译器会�ؓ你拾遗补�~��?/span>

13.5 Managing Pointer Members

Smart Point

大师�l�出的办法就是对指针�q�行��装�Q�定义一个新�c�，它包含有指针�Q�以及��用的�ơ数。下面这个类的定义高�Q�实在是高！��是�q�个友元的定义�?/span>

// private class for use by HasPtr only

class U_Ptr {

      friend class HasPtr;

      int *ip;

      size_t use;

      U_Ptr(int *p): ip(p), use(1) { }

      ~U_Ptr() { delete ip; }

};

拯��控制成员copy-control members

包含指针成员的对象经帔R��要定义拷�?/span>-控制成员。（Objects with pointer members often need to define the copy-control members.�Q?/span>

拯��-控制成员包括:

l 赋值操作（assignment operator�Q?/span>

l 析构函数

l 拯��构造函敎ͼ�copy constructor�Q?/span>

smart pointer�c�，使用计数器来��理�?/span>smart pointer�c�R��拷�?/span>-控制成员都会影响计数器的倹{�?/span>

复习澄清一下：

l ‘.’�Ҏ(gu��)��作符�Q?/span>’*’解引用操作符的优先��

‘.’�Ҏ(gu��)��作符的优先��高于解引用，所以要�q�样子写�Q?/span>

Sales_item *sp = &item1;

(*sp).same_isbn(item2); // run same_isbn on object to which sp points

l valuelike classes�?/span>pointlike classes有什么区别？

�q�仅仅是一�U�很说法而已�Q?/span>valuelike classes�Q�它的�?/span>copy后实际上是对应两个对象；�?/span>pointlike classes�Q?/span>copy的是指针�Q�因�?/span>copy后实际上是指向的同一个对象�?/span>

amenglai 2009-06-24 08:17 发表评论

C++ Primer �?��M��W�记 �W�十二章

amenglai — Tue, 16 Jun 2009 01:17:00 GMT

Classes

12.1. �cȝ��定义和声�?/span> Class Definitions and Declarations

�c�d��?/span>

大师仅仅写了�q�么一个类定义的简单的例子�Q�却有这么多的东西可以说说啊

class Sales_item {

public:

    // operations on Sales_item objects

    double avg_price() const;

    bool same_isbn(const Sales_item &rhs) const

        { return isbn == rhs.isbn; }

    // default constructor needed to initialize members of built-in type

    Sales_item(): units_sold(0), revenue(0.0) { }

private:

    std::string isbn;

    unsigned units_sold;

    double revenue;

};

double Sales_item::avg_price() const

{

    if (units_sold)

        return revenue/units_sold;

    else

        return 0;

}

·       Member: data, functions or type definitions.

·       构造函�?/span>Constructors初始化：

// default constructor needed to initialize members of built-in type

Sales_item(): units_sold(0), revenue(0.0) { }

�q�种写法是初始化内置数据�c�d��?/span>

·                 const:表示functions不会修改数据成员。这可以用在查询或者判断类型的functions上�?/span>

·       成员函数member functions必须在类的内部声明，成员函数的定义是否放在类定义里面是可选的。如果放在类里面�Q�那�?/span>

数据抽象和封�?/span>Data Abstraction and Encapsulation

�c�背后蕴�늚�基本思想是数据抽象和��装。（The fundamental ideas behind classes are data abstraction and encapsulation.�Q�数据抽象这�U�技术依赖于接口和实现的分离。（Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation.�Q?/span>

多么�_��的话�Q�包含了面向对象的深��d��义。大师啊�?/span>

�cȝ��用户�Q?/span>user of class�Q�是谁？�E�序�?/span>programmer�?/span>user of class��如�?/span>user of application�?/span>

�cȝ��用户最兛_��啥？最兛_��的是接口�?/span>

关于�c�d��义的更多内容 more on class definitions

使用Typedef��化类

class Screen {

public:

    // interface member functions

    typedef std::string::size_type index;

private:

    std::string contents;

    index cursor;

    index height, width;

};

注意�Q?/span>

typedef是放�?/span>public部分的，�q�样Screen的用户都能够使用�q�个typedef�?/span>

成员函数可被重蝲Member Functions May Be Overloaded

昑ּ�指定 inline 成员函数Explicitly Specifying inline Member Functions

成员函数定义�?/span>inline。这个定义即可以在函数声明里�Q�也可以在类定义之外。在�c�d��明和�c�d��义里把函数指定�ؓinline都是合法的。（It is legal to specify inline both on the declaration and definition.�Q?/span>

�c�d��明与�c�d��?/span>

�c�d��义一般要攑֜�头文件中�?/span>

�c�d��明后�Q�即使没有类定义�Q�也可以作�ؓ引用或者指针来使用�Q?/span>

class LinkScreen {

       Screen window;

       LinkScreen *next;

       LinkScreen *prev;

};

LinkScreen定义完成之前�Q�我们就定义了指�?/span>LinkScreen�c�d��的指针�?/span>

�q�里引入了两个基本感念：

前向声明forward declaretion�Q?/span>

class Screen; //definition of the Screen class

�q�就是一个前向声明。表�C?/span>Screen是一个类�c�d��Q?/span>class type�Q��?/span>

不完全类�?/span>incompete type�Q�在前向声明之后�Q�类定义之前Screen��是一个不完全�c�d��。意思是说知�?/span>Screen是个�c�d��Q�但是不知道�q�个�c�d��包括那些成员�Q?/span>members�Q�。不完全�c�d��只能用在有限的几�U�方式，它可以用来定义这�U�类型的指针或者是引用�Q�也可以用在把这�U�类�c�d��作�ؓ形参或者返回值类型的函数声明。（An incomplete type may be used to define only pointers or references to the type or to declare (but not define) functions that use the type as a paremeter or return type.�Q?/span>

在创建某个类�c�d��的对象前�Q�这个类�c�d��必须完整定义。这��L��译器��能够知道要��U�类型的对象保留多大的存储空间�?/span>

12.2 隐含的this指针 The Implicit this Pointer

何时使用this�Q?/span>

��单的��_��是当我们需要引用整个对象而不是对象中的成员的时候。最常见的情冉|��在返回值是被调用的对象的引用的函数里。（when we need to refer to the object as a whole rather than to a member of the object. The most common case where we must use this is in functions that return a reference to the object on which they were invoked.�Q?/span>

this是指针，因此如果�q�回值是当前对象的引用，那么�q�回语句一定是�Q?/span>

return *this;

刚开始看到这个的时候，��L��?/span>Java搞�؜�Q�因�?/span>Java是没有指针，所以返回的只能�?/span>this�Q�显式��用的时候也�?/span>this�?/span>

�?/span>const成员函数里返�?/span>*this

�q�里有两个规则：

对于一般的�?/span>const成员函数�Q?/span>this的类型是一�?/span>const pointer。这意味我们可以修改this指向的对象的��|��但是不能修改this保存的地址。（In an ordinary nonconst member function, the type of this is a const pointer to the class type. We may change the value to which this points but cannot change the address that this holds.�Q?/span>

对于const成员函数�Q?/span>this的类型是一个指�?/strong>const 对象�?/span>const pointer。这意味我们既不可以修改this指向的对象的��|��也不能修�?/span>this保存的地址。（In a const member function, the type of this is a const pointer to a const class-type object. We may change neither the object to which this points nor the address that this holds.�Q?/span>

��Z��const的重�?/span>

可以定义两个操作�Q�一个是const�Q�另一个不是，�q�也��是重蝲�?/span>

class Screen {

public:

     // interface member functions

     // display overloaded on whether the object is const or not

     Screen& display(std::ostream &os)

                   { do_display(os); return *this; }

     const Screen& display(std::ostream &os) const

                   { do_display(os); return *this; }

private:

      // single function to do the work of displaying a Screen,

      // will be called by the display operations

      void do_display(std::ostream &os) const

                        { os << contents; }

      // as before

};

�q�样const对象使用const成员函数�Q�非const对象可以使用��M��成员函数�Q�不�q�最好还是��用非const的成员函数�?/span>

�Ҏ(gu��)��下面的例子（��Z��指针形参是否指向const的函数重载）�Q?/span>

Record lookup(Account&);

Record lookup(const Account&); // new function

可变数据成员Mutable Data Members

即��对象�?/span>const�Q�有时我们也希望其中的某些数据成员是可以修改的，�q�就引出�?/span>mutable�?/span>

可变数据成员�l�不�?/span>const�Q�即使对象是const。这�?/span>const的成员函��C��是可以修改可变数据成员的�?/span>

定义�Q?/span>

class Screen {

public:

// interface member functions

private:

     mutable size_t access_ctr; // may change in a const members

     // other data members as before

};

12.3 �cȝ��作用范围

12.4构造函数Constructors

构造函��C��能声明�ؓconst�?/span>

��的方法：使用构造函数初始化�?/span>Constructor Initializer�?/span>

// recommended way to write constructors using a constructor initializer

Sales_item::Sales_item(const string &book):

     isbn(book), units_sold(0), revenue(0.0) { }

Constructor Initializer

以下是正��的写法�Q?/span>

// recommended way to write constructors using a constructor initializer

Sales_item::Sales_item(const string &book):

     isbn(book), units_sold(0), revenue(0.0) { }

但是�q�种写法乍一看似乎和下面不��?/span>Constructor Initializer的效果一��P��

// legal but sloppier way to write the constructor:

// no constructor initializer

Sales_item::Sales_item(const string &book)

{

    isbn = book;

    units_sold = 0;

    revenue = 0.0;

}

NO�Q?/span>NO�Q�不一栗��后一�U�写法那��像郭�d�U�相声说的房都烧没了�Q�就剩下个防盗门�Q�于谦还开门进厅R�?/span>isbn的初始化是在构造函数执行之前完成的。上面这个写法先用缺省的string的构造函数初始化isbn�Q�在构造函数的函数体执行时�Q?/span>isbn又重新赋��gؓbook。没效率啊！但是对于内置�c�d��来说�Q�两�U�方式无论是在结果上�q�是在性能上又都是没有区别的�?/span>

构造函数的执行分成两个步骤�Q?/span>

初始化阶�D�，�cȝ��数据成员是在�q�个阶段初始化的�?/span>

一般计��阶�D�，�q�就是指构造函数函��C��的执行�?/span>

在计��阶�D�前初始化阶�D�就开始了。（Initialization happens before the computation phase begins.�Q?/span>

在一些特定的情况下必��M��?/span>Constructor Initializer�Q�这些特�D�的情况包括�Q?/span>

数据成员没有�~�省的构造函�?/span>

数据成员�?/span>const或者是引用

for example:

// legal but sloppier way to write the constructor:

// no constructor initializer

class ConstRef {

public:

     ConstRef(int ii);

private:

     int i;

     const int ci;

     int &ri;

};

// no explicit constructor initializer: error ri is uninitialized

ConstRef::ConstRef(int ii)

{              // assignments:

      i = ii;   // ok

      ci = ii; // error: cannot assign to a const

      ri = i;   // assigns to ri which was not bound to an object

}

正确写法�Q�只有用constructor initializer才有��Z��?/span>const和引用进行初始化�?/span>

ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }

成员初始化顺�?/span>

成员的初始化��序��是成员的定义的��序。第一个定义的成员�W�一个初始化�Q�然后是下一个，以此�c�L��。（The order in which members are initialized is the order in which the members are defined. The first member is initialized first, then the next, and so on.�Q?/span>

�cȝ��型的数据成员的初始化Initializers for Data Members of Class Type

Constructor Initializer初始化式使用�cȝ��某一个构造函数来完成�?/span>

// alternative definition for Sales_item default constructor

Sales_item(): isbn(10, '9'), units_sold(0), revenue(0.0) {}

�~�省构造函�?/span>

只有在类没有定义��M��一个构造函数时�Q�编译器才会自动生成�~�省的构造函数�?/span>

隐式�cȝ��型�{�?/span> Implicit Class-Type Conversions

12.5. 友元Friends

友元?y��u)��是允许其它特定的类和方法来讉K��它的�?/span>public的成员。（The friend mechanism allows a class to grant access to its nonpublic members to specified functions or classes.�Q?/span>

友元定义�Q?/span>

class Screen {

     // Window_Mgr members can access private parts of class Screen

     friend class Window_Mgr;

     // ...rest of the Screen class

};

友元不是�cȝ��成员�Q�但是他们是�cȝ��接口的组成部分。（even if they are not members of the class, they are "part of the interface" to the class.�Q?/span>

友元可以是：

l �c?/span>

l �cȝ��成员函数

class Screen {

// Window_Mgr must be defined before class Screen

friend Window_Mgr&

     Window_Mgr::relocate(Screen::index r, Screen::index c,

                      Screen& s);

     // ...rest of the Screen class

}

l 一般的非成员函�?/span>

友元声明和范�?/h3>
友元声明和友元定义之间存在的�怺�依赖关系使得我们��心地构造类。再看上面的例子:

Window_Mgr必须要的Screen前定义。但是成员方�?/span>relocate要在Screen定义后才能定义。靠�Q�这��像是先有蛋�q�是先有鸡一��h��巴�?/span>

class Screen {

// Window_Mgr must be defined before class Screen

friend Window_Mgr&

     Window_Mgr::relocate(Screen::index r, Screen::index c,

                      Screen& s);

     // ...rest of the Screen class

}

12.6. static �c�L��员static Class Members

�q�句话是�?/span>static class member的最重要的解释：

静态数据成员独立于�cȝ��M��对象而存在，每个静态数据成员是和类相关的对象，而不是和�cȝ��对象相关。（a static data member exists independently of any object of its class; each static data member is an object associated with the class, not with the objects of that class.�Q?/span>

使用静态数据成员的好处

l static成员的名字的作用范围是类�Q�因此可以避免和其它的类的成员或者全局对象的名字的冲突�?/span>

l 强制�q�行��装�?/span>static成员可以�?/span>private的，而全局对象是不可以的�?/span>

l 如果�?/span>static成员兌��到某个特�D�的�c�M��Q�这��h��于阅��M��码�?/span>

静态成员函数static member function

在静态成员函敎ͼ�static member function�Q�中是不能��?/span>this指针的。这其实很好理解�Q�因�?/span>this指针指向的是对象�Q�而静态成员函数�ƈ不属于�Q何的对象�?/span>

静态数据成员static data members

静态数据成员可以是��M��的类型：const�Q�引�?/span>reference�Q�数�l�，指针�c�R�?/span>

class Account {

public:

    // interface functions here

    void applyint() { amount += amount * interestRate; }

    static double rate() { return interestRate; }

    static void rate(double); // sets a new rate

private:

    std::string owner;

    double amount;

    static double interestRate; //�q�是声明

    static double initRate();

};

// define and initialize static class member�Q�这是定�?/span>

double Account::interestRate = initRate();

以上是一个完整的static的定义，要注意以下几点：

1.      静态数据成员要在类定义体之外来定义。（static data members must be defined (exactly once) outside the class body.�Q?/span>

2.      静态成员不能通过构造函数进行初始化�Q�而是在定义的时候就完成了初始化。（static members are not initialized through the class constructor(s) and instead should be initialized when they are defined.�Q?/span>

3.      关键�?/span>static只是用在�c�M��内的成员声明�Q�而当在类的外面的寚w��态数据成员进行定义时�Q�就不要再��用关键字static。（The static keyword, however, is used only on the declaration inside the class body. Definitions are not labeled static.�Q?/span>

整型�c�d��的静态数据成员可以在�c�d��义体内直接定义，只要是初始化值是帔R��表达式�?/span>

a const static data member of integral type can be initialized within the class body as long as the initializer is a constant expression

period的定义就是这��P��

class Account {

public:

      static double rate() { return interestRate; }

      static void rate(double); // sets a new rate

private:

      static const int period = 30; // interest posted every 30 days

      double daily_tbl[period]; // ok: period is constant expression

};

// definition of static member with no initializer;

// the initial value is specified inside the class definition

const int Account::period;

注意�Q�虽�?/span>period在类定义体内完成了初始化�Q�但是还是要在类定义之外定义数据成员。（When a const static data member is initialized in the class body, the data member must still be defined outside the class definition.�Q?/span>

静态成员不是类对象的一部分

也正因�ؓ如此�Q�对于非静态成员的非法的��用方式，对于静态成员来说就是合法的。例如：静态成员的�c�d��可以是它所属类的类型。非静态数据成员被严格限制只能是它所属类的对象的引用或者是指针。（the type of a static data member can be the class type of which it is a member. A nonstatic data member is restricted to being declared as a pointer or a reference to an object of its class:�Q?/span>

class Bar {

public:

      // ...

private:

      static Bar mem1; // ok

      Bar *mem2;       // ok

      Bar mem3;        // error

};

amenglai 2009-06-16 09:17 发表评论

amenglai — Thu, 04 Jun 2009 03:22:00 GMT

泛型��法

��法��Z��保持独立性，不��用容器类型，而��?strong>�q�代�?/strong>�?/span>

��法�l�不执行容器操作。算法仅仅是�Ҏ(gu��)��q�代器和�q�代器操作来操作的。因此所有会改变�q�代器的操作在通用��法里都不会出现。例如增加或删除元素。但是这些通用��法有可能会修改容器中元素的��|��也可能会在容器中�U�d��元素�?/span>

11.2 初窥��法

必须要包含一下的头文�Ӟ��

#include

#include

只读��法

accumulate

�q�个��法的参数很好说明了��法实际上是不知道元素的�c�d��的。第三个参数指定了�v始��|��因�ؓaccumnulate不知道它正在汇�ȝ��元素的类型�?/span>

int sum = accumulate(vec.begin(), vec.end(), 42);

另一个例子：

string sum = accumulate(v.begin(), v.end(), string(""));

�q�里一定要指定起始值是string�Q�而绝不能写成字符串常量，因�ؓ字符串常量对应的数据�c�d��?/span>const char*�?/span>

有趣�Q?/span>

find_first_of

需要两对�P代器�Q?/span>

size_t cnt = 0;

list::iterator it = roster1.begin();

// look in roster1 for any name also in roster2

while   ((it = find_first_of(it, roster1.end(),

             roster2.begin(), roster2.end()))

                != roster1.end()) {

   ++cnt;

   // we got a match, increment it to look in the rest of roster1

   ++it;

}

roster1�?/span>list�Q?/span>roster2可以�?/span>deque�Q?/span>vector�Q�只要我们可以用==操作比较�q�两个序列中的元素。尤其是�Q�如�?/span> roster1 �?/span> list 对象�Q�则 roster2 可以�?/span> vector 对象�Q�因�?/span> string 标准库�ؓ string 对象�?/span> char* 对象定义了相�{�（==�Q�操作符�?/span>

�ȝ��一下�P代器实参�c�d��

l 标记范围的两个实参类型必��ȝ��匹配，必须指向同一个容器中的元素（或者超出容器末端的下一位置�Q�，�q�且如果两者不相等�Q�则�W�一个�P代器通过不断地自增，必须可以到达�W�二个�P代器�?/span>

l 带有两对�q�代器参数。每对�P代器中，两个实参的类型必��ȝ��匹配，但不要求两对之间的类型匹配。特别是�Q�元素可存储在不同类型序列中�Q�只要这两序列的元素可以比较卛_��?/span>

写容器算�?/span>

写容器算法最重要的一�Ҏ(gu��)��必须保证��法所写的序列臛_��要和被写入的元素数目一样大。（we must take care to ensure that the sequence into which the algorithm writes is at least as large as the number of elements being written.�Q�就是说如果指定的要写入的序列范围必��L��有效的，必须大于要写入的元素数目�Q�就是说不能��界�?/span>

看个最一目了然的例子��是�Q?/span>

vector vec; // empty vector

// disaster: attempts to write to 10 (nonexistent) elements in vec

fill_n(vec.begin(), 10, 0);

back_inserter

使用back_inserter之所以安全，是因为如果指定的范围��界�Q�它执行的�ƈ不是数据修改操作而是数据��d��操作�?/span>

容器元素重新排序��法

unique

sort

stable_sort

谓词predicates

再次解读�q�代�?/span>Iterators

三类�q�代器：

l insert iterators插入�q�代�?/span>

l iostream iterators

l reverse iterators反向�q�代�?/span>

insert iterators

inserter是�P代器适配器，它和容器�l�定�Q��生一个�P代器�Q�这个�P代器向绑定的容器插入元素。当我们通过inserter�q�代器赋值时�Q��P代器插入新的元素。（An inserter is an iterator adaptor that takes a container and yields an iterator that inserts elements into the specified container. When we assign through an insert iterator, the iterator inserts a new element.�Q?/span>

又分�?/span>3�c�：

back_inserter�Q��?/span>push_back创徏一个�P代器

front_inserter: 使用push_front创徏一个�P代器

inserter�Q�在指定的位�|�后创徏�q�代�?/span>

list ilst, ilst2, ilst3;     // empty lists

// after this loop ilst contains: 3 2 1 0

for (list::size_type i = 0; i != 4; ++i)

     ilst.push_front(i);

// after copy ilst2 contains: 0 1 2 3

copy (ilst.begin(), ilst.end(), front_inserter(ilst2));

// after copy, ilst3 contains: 3 2 1 0

copy (ilst.begin(), ilst.end(), inserter (ilst3, ilst3.begin()));

iostream iterators

istream_iterator:�?/span>input stream

ostream_iterator:�?/span>output stream

定义��P代器stream Iterators

��P代器都是模板Templates�?/span>Example:

istream_iterator cin_it(cin);    // reads ints1 from cin

istream_iterator end_of_stream; // end iterator value

while(cin_it != end_of_stream)

{

   //do something

}

// writes Sales_items from the ofstream named outfile

// each element is followed by a space

ofstream outfile;

ostream_iterator output(outfile, " ");

istream_iterator上的操作

++it & it++

�q�代器加1�Q�一般前�~��?/span>1�Q�返回的是增加后的�P代器的引用。后�~��?/span>1�Q��P代器也加1�Q�但是返回的是未�?/span>1的那个倹{�?/span>

大师�l�出了一�?/span>istream_iterator�?/span>ostream_iterator�q�两�U��P代器的最�l�典的应用，输入转输出，有这�?/span>sample�q�是很容易理解这两个东西�Q?/span>

// write one string per line to the standard output

ostream_iterator out_iter(cout, ""n");

// read strings from standard input and the end iterator

istream_iterator in_iter(cin), eof;

// read until eof and write what was read to the standard output

while (in_iter != eof)

    // write value of in_iter to standard output

    // and then increment the iterator to get the next value from cin

   *out_iter++ = *in_iter++;

��P代器的限�?/h4>
1.      不能�?/span>ostream_iterator中读入数据，同时也不能向istream_iterator写入数据�Q?/span>It is not possible to read from an ostream_iterator, and it is not possible to write to an istream_iterator.�Q?/span>

2.      一旦给ostream_iterator赋��|��q�个写入的操作就提交了。一旦赋��|��在后�l�的操作中就不能修改。此外，每个ostream_iterator只能用作输出一�ơ。（Once we assign a value to an ostream_iterator, the write is committed. There is no way to subsequently change a value once it is assigned. Moreover, each distinct value of an ostream_iterator is expected to be used for output exactly once.�Q?/span>

3.      �?/span>ostream_iterator里没�?/span>->操作�?/span>

��Z��P代器使用��法

既然��P代器基本上可以看做一般意义上的�P代器�Q�那么前面所描述的算法应该同时也适用在流�q�代器上。于是，针对��P代器�Q�我们也可以�q�行排序�Q�比较等��法操作�?/span>

istream_iterator cin_it(cin);    // reads ints from cin

istream_iterator end_of_stream; // end iterator value

// initialize vec from the standard input:

vector vec(cin_it, end_of_stream);

sort(vec.begin(), vec.end());

// writes ints to cout using " " as the delimiter

ostream_iterator output(cout, " ");

// write only the unique elements in vec to the standard output

unique_copy(vec.begin(), vec.end(), output);

reverse iterators

从这张图上可以看出普通�P代器和反向�P代器的区别，另外二者都能够执行自增和自减操作，形式是一��L��Q�但本质是不同的。例如�Ş式上都是自增�Q��P代器都会�?/span>begin�?/span>end方向�U�d��Q�但是二者却是反方向的。这样做的最大好处是�Q�我们能够透明��C��用算法向前或者向后处理容器�?/span>

利用�q�代器处�?/span>string

可以辑ֈ�java�?/span>StringToken的功能：我喜�Ƣ这�D�代�?/span>

// find first element in a comma-separated list

string::iterator comma = find(line.begin(), line.end(), ',');

cout << string(line.begin(), comma) << endl;

反向�q�代器获得最后一个单词：

// find last element in a comma-separated list

string::reverse_iterator rcomma = find(line.rbegin(), line.rend(), ',');

// wrong: will generate the word in reverse order

cout << string(rcomma.base(), line.end()) << endl;

反向�q�代器可以代表�P代器范围以及�q�个范围是不对称的事实��生一个重要的�l�论。当我们用一般的�q�代器对反向�q�代器初始化或者赋值时�Q�所得到的�P代器所指向的元素和初始��g��一栗��（The fact that reverse iterators are intended to represent ranges and that these ranges are asymmetric has an important consequence. When we initialize or assign a reverse iterator from a plain iterator, the resulting iterator does not refer to the same element as the original.�Q?/span>

泛型��法�l�构

Nothing to say�?/span>

其实��是对算法进行了分类�Q�同时对于算法的命名习惯加以阐述�Q�看完了�Q�觉得蟩�q�也无妨哈�?/span>

容器�Ҏ(gu��)��法

��是针对list�Q��ؓ了性能优化�Q�对于算法，list重新实现�?/span>

amenglai 2009-06-04 11:22 发表评论

amenglai — Thu, 04 Jun 2009 03:22:00 GMT
     摘要: 兌��容器 Associative Containers 兌��容器包括�Q?l map l set l multimap l multiset 10.1 初步知识�Q�pair�c�d�� 创徏和初始化pairs Examples: ...  阅读全文

amenglai 2009-06-04 11:22 发表评论

amenglai — Thu, 04 Jun 2009 03:21:00 GMT
     摘要: ��序容器 Sequential Containers �c�d��中定义了3�U�顺序容器：vector, list, deque�?对应3�U�适配器：stack, queue, priority_queue�?什么是适配器？每种适配器都会对应一�U�容器，�Ҏ(gu��)��原始数据�c�d��的操作重新定义了接口�?9.1 定义��序容器容器初始化的�Ҏ(gu��)��有： 1.  ...  阅读全文

amenglai 2009-06-04 11:21 发表评论

amenglai — Mon, 25 May 2009 09:29:00 GMT

The IO Library标准 IO �?/span>

8.1 An Object-Oriented Library

标准IO库实际上是针对三�c�L��stream的操�?/span>

stream

Header

Type

console

iostream

istream

ostream

iostream

提供

char

wchar_t

cin

wcin

…

string stream

sstream

istringstream

ostringstream

stringstream

file

fstream

ifstream

ofstream

fstream

对于IO对象来说是不能拷贝或赋值的�Q�因此这些写法都是会��M�h的：

ofstream out1, out2;

out1 = out2;   // error: cannot assign stream objects

ofstream print(ofstream);

out2 = print(out2); // error: cannot copy stream objects�Q��Ş参不能是IO�c�d��

l         形参不能�?/span>IO�c�d��。返回��g��不能�?/span>IO�c�d��?/span>

l         IO对象也不能保存在vector�q�样的集合容器里�?/span>

8.2 条�g状�?/span>Condition States

条�g状态成员是做什么用的？

是用来详�l�地描述当前的流�Q?/span>stream�Q�的状态。例如：是否可用�Q�或者遇��C��某种�Ҏ(gu��)��的错误。这些状态信息即可以讉K��Q�也可以讄��?/span>

每个��对象（stream object�Q�都会包含一个成员（member�Q�，�q�个成员通过setstate�?/span>clear操作�q�行��理。它的类型是iostate�?/span>

每个 IO �c�还定义了三�?/span> iostate �c�d��的常量��|��分别表示特定的位模式�?/span>

strm::badbit�Q?/span>badbit 标志着�pȝ��U�的故障�Q�如无法恢复的读写错误�?/span>

strm::failbit�Q�如果出现的是可恢复的错误，如在希望获得数值型数据时输入了字符�Q�此时则讄�� failbit 标志�?/span>

strm::eofbit�Q�是在遇到文件结束符时设�|�的�Q�此时同时还讄��?/span> failbit�?/span>

对于IO�cȝ��条�g状态的操作�Q�不��是查询的，eof(),fail(),bad(),�q�是赋值操作，clear(),setstate()�Q�应该都是位操作�?/span>

8.3 ��理输出�~�冲 Managing the Output Buffer

会被清空�Q?/span>

1.        The program completes normally. All output buffers are emptied as part of the return from main.

�E�序正常�l�束。作�?/span> main �q�回工作的一部分�Q�将清空所有输出缓冲区�?/span>

2.        At some indeterminate time, the buffer can become full, in which case it will be flushed before writing the next value.

在一些不��定的时候，�~�冲区可能已�l�满了，在这�U�情况下�Q�缓冲区��会在写下一个��g��前刷新�?/span>

3.        We can flush the buffer explicitly using a manipulator such as endl, flush, ends.

用操�U늬�昑ּ�地刷新缓冲区�Q�例如行�l�束�W?/span> endl�?/span>

4.        We can use the unitbuf manipulator to set the stream's internal state to empty the buffer after each output operation.

在每�ơ输出操作执行完后，�?/span> unitbuf 操作�W�设�|�流的内部状态，从而清�I�缓冲区�?/span>

5.        We can tie the output stream to an input stream, in which case the output buffer is flushed whenever the associated input stream is read.

可将输出��与输入��关联（tie�Q��v来。在�q�种情况下，在读输入��时��刷新其兌��的输出缓冲区�?/span>

前提�Q�如果程序非正常�l�束�Q�输出缓�Ԍ��Output buffer�Q�是不会��h��的�?/span>

��Q�在每个输出都用endl的结��?/span>

关于endl�?/span>"n的区别？

如果��单的从输��Z��看，二者肯定是没有区别的。但�?/span>endl会刷新输�?/span>cout�?/span>buffer�?/span>

cin�?/span>cout�l�定

�l�果是：��M��读输入流的尝试都��首先刷��C��之绑定的输出��的�~�冲区（buffer�Q�。：

cin.tie(&cout);

cin.tie(0); //break tie to cout, cout no longer flushed when cin is read

交互�pȝ��一定要保证输出��和输入��是�l�定在一��L��?/span>

8.4 文�g输入和输�?/span> File Input and Output

fstream header

l         ifstream

l         ofstream

l         fstream

基本语法格式�Q?/span>

// construct an ifstream and bind it to the file named ifile

ifstream infile(ifile.c_str());

// ofstream output file object to write file named ofile

ofstream outfile(ofile.c_str());

注意�Q�文件名要��?/span>C风格的字�W�串�?/span>

l         文�g��可以和文�g重新�l�定。但是在重新�l�定前要先关闭流�Q��ƈ清空文�g��的状态，否则上一�ơ的文�g��的状态就会是重新�l�定后的初始状态�?/span>

l         关闭��对象，都不可能改变��对象内部的状态�?/span>Closing a stream does not change the internal state of the stream object.

ios_base::openmode

truncate

当文件打开时清�I�文件的所有内容，如果使用�q�个属性对文�g臛_��要有写入的权�?/span>

Sample
// opens in binding it to the given file

ifstream& open_file(ifstream &in, const string &file)

{

    in.close();     // close in case it was already open

    in.clear();     // clear any existing errors

    // if the open fails, the stream will be in an invalid state

    in.open(file.c_str()); // open the file we were given

    return in; // condition state is good if open succeeded

}

�q�是一个标准的文�g重新�l�定的代码，包括了以上的注意事项�?/span>

8.5 字符串流String Streams

字符串流和文件流其实很类伹{��独有的��是利用字符串流来实现格式化输入/输出�?/span>

输出

int val1 = 512, val2 = 1024;

ostringstream format_message;

// ok: converts values to a string representation

format_message << "val1: " << val1 << ""n"

               << "val2: " << val2 << ""n";

输入�Q?/span>

// str member obtains the string associated with a stringstream

istringstream input_istring(format_message.str());

string dump; // place to dump the labels from the formatted message

// extracts the stored ascii values, converting back to arithmetic types

input_istring >> dump >> val1 >> dump >> val2;

cout << val1 << " " << val2 << endl; // prints 512 1024

amenglai 2009-05-25 17:29 发表评论

C++ Primer �?��M��W�记 �W�七�?

amenglai — Wed, 20 May 2009 06:22:00 GMT
     摘要: 7.2 Argument Passing 参数传�?Reference Parameters引用形参引用形参�q�没有对对象�q�行copy�Q�而是指向它绑定的对象�?�q�段代码是引用�Ş参的�l�典用法�Q? void swap(int &v1, int &v2) ...  阅读全文

amenglai 2009-05-20 14:22 发表评论

C++ Primer �?��M��W�记 �W�六�?

amenglai — Wed, 20 May 2009 06:21:00 GMT

switch

switch语句我用的的��不多，�q�是习惯写成if-else的�Ş式�?/span>

switch 中的控制��：

It is a common misunderstanding to expect that only the statements associated with the matched case label are executed. However, execution continues across case boundaries until the end of the switch statement or a break is encountered.

存在一个普遍的误解�Q�以为程序只会执行匹配的 case 标号相关联的语句。实际上�Q�程序从该点开始执行，�q�跨��?/span> case 边界�l�箋执行其他语句�Q�直�?/span> switch �l�束或遇�?/span> break 语句为止�?/span>

�?/span>2�U?/span>switch常见的错误写法：

l           case 标号必须是整型常量表辑ּ��?/span>

l           如果两个 case 标号��h��相同的��|��同样也会��D��~�译时的错误�?/span>

Switch内部的变量定义：

对于 switch �l�构�Q�只能在它的最后一�?/span> case 标号�?/span> default 标号后面定义变量�?/span>

do while语句

用作条�g判断的变量一定要定义在��@环体之外�Q?/span>

// repeatedly ask user for pair of numbers to sum

string rsp; // used in the condition; can't be defined inside the do

do {

   // ...

} while (!rsp.empty() && rsp[0] != 'n');

do while 循环不可以采用如下方式定义变量：

// error: declaration statement within do condition is not supported

do {

    // ...

    mumble(foo);

} while (int foo = get_foo()); // error: declaration in do condition

不过其实自己写代码时�Q�这个各色的写法一般是不会出现的�?/span>

Using the Preprocessor for Debugging�Q��用预处理器进行调试）

预处理器�q�定义了其余四种在调试时非常有用的常量：

__FILE__ 文�g�?/span>

__LINE__ 当前行号

__TIME__ 文�g被编译的旉��

__DATE__ 文�g被编译的日期

断言assert是一�U�预处理宏，assert 宏就求解条�g表达式，如果�l�果�?/span> false�Q?/span>assert 输出信息�q�且�l�止�E�序的执行。如果该表达式有一个非�Ӟ��例如�Q?/span>true�Q��|��?/span> assert 不做��M��操作�?/span>

amenglai 2009-05-20 14:21 发表评论

C++ Primer �?��M��W�记 �W�五�?

amenglai — Wed, 20 May 2009 06:19:00 GMT

5.3 位操作符(The Bitwise Operators)

��量不要使用�W�号�?/strong>�q�行位运��，因�ؓ�W�号位的处理和机器有兟�?/span>

�?/span>XOR的描�q�真是简单明了，For each bit position, the result is 1 if either but not both operands contain 1; Otherwise, the result is 0.

输入输出标准库重载了�U�M��操作�W?/span>>>�?/span><<用于输入和输出�?/span>

复合表达式的求��|��Evaluating Compound Expressions�Q?/span>

�q�里面有两个关键词：

l         Precedence

Precedence specifies how the operands are grouped.优先�U�规定的是操作数的结合方�?/span>

l         associativity

Associativity specifies how to group operators at the same precedence level.�l�合性规定了��h��相同优先�U�的操作�W�如何分�l��?/span>

例如�Q?/span>

赋值操作符是右兌��

ival = jval = kval = lval       // right associative

(ival = (jval = (kval = lval))) // equivalent, parenthesized version

��数操作�W�是左关�?/span>

ival * jval / kval * lval       // left associative

(((ival * jval) / kval) * lval) // equivalent, parenthesized version

5.4 赋值操作符�Q?/span>Assignment Operators�Q?/span>

让你不得不佩服，Lippman�q�样的大师仅仅赋值操作符�Q?/span>Assignment Operators�Q�就可以讲出�q�么多的内容�?/span>

l         赋��D��是叛_��联，它的�q�回值是左操作数�Q�类型�ؓ左操作数的类型（The result of an assignment is the left-hand operand, the type of the result is the type of the left-hand operand.�Q��?/span>

�q�样��好理解�q�样的赋��D��句了�Q?/span>

先执�?/span>jval = 0;�q�回值是jval �Q�再执行ival = jval�?/span>

int ival, jval;

ival = jval = 0; // ok: each assigned 0

l         赋值操作的优先�U�低�?/span>

下面的条件语句返回值是true�Q�因为先执行赋��D��句，�q�回值是i�Q?/span>i大于0�Q�因此条件语句判断�ؓtrue�?/span>

if (i = 42)

下面的条件语句返回值是false�Q�因为先执行赋��D��句，�q�回值是i�Q?/span>i�{�于0�Q�因此条件语句判断�ؓfalse�?/span>

if (i = 0)

5.5 Increment and Decrement Operators自增和自减操作符

l         重点

前置和后�|�操作符

l         ��

只在必要的时候才使用后置操作�W��?/span>

l         区别

前置和后�|�操作符的返回值是不同的，�q�是最重要的区别，也是理解的基��?/span>

前置操作�W�：值加1�Q�再�q�回。（It increments the value and returns the incremented version.�Q?/span>

后置操作�W�：必须保留原始��|��Q�原始值加1�Q�返回的�l�果是未增加的倹{��（The postfix operator must store the original value so that it can return the unincremented value as its result.�Q?/span>

l         代码

cnt�?/span>的返回值是cnt�?/span>

vector ivec;           // empty vector

int cnt = 10;

// add elements 10...1 to ivec

while (cnt > 0)

    ivec.push_back(cnt--); // int postfix decrement

*iter++��是*(iter++)�Q?/span>++操作的优先��高于*�Q�所以先执行iter++�Q�这个操作的�q�回值是iter�Q�然�?/span>iter+1.再执行解引用操作*�Q�这个解引用操作的操作数是返回的iter�?/span>

vector::iterator iter = ivec.begin();

// prints 10 9 8 ... 1

while (iter != ivec.end())

    cout << *iter++ << endl; // iterator postfix increment

Sizeof

�Q�如果是�q�回对象�?/span>size�Q�那�?/span>sizeof的返回值是不是和数据有养I��

赋值顺�?/span>

l         && �?/span> || 操作�W�计��其操作数的�ơ序�Q�当且仅当其��x��作数��实影响了整个表辑ּ�的值时�Q�才计算�q�两个操作符的右操作数�?/span>

&& and || operators specify the order in which their operands are evaluated: In both cases the right-hand operand is evaluated if and only if doing so might affect the truth value of the overall expression.

�Q�这句话说的真是严�}。）

l         一个表辑ּ�里，不要在两个或更多的子表达式中对同一对象做自增或自减操作�?/span>

Do not use an increment or decrement operator on the same object in more than two subexpressions of the same expression.

5.11 new �?/span> delete 表达式（The new and delete Expressions�Q?/span>

new表达式返回的是一个指针，�q�个指针指向新分配的一个对象�?/span>

int *pi = new int; // pi points to dynamically allocated,

delete pi;

但是�q�样写就不是动态分配的指针

int i;

int *pi = &i;

delete pi; //因�ؓpi指向的是一�?/span>local变量

后面的写法是不能执行delete表达式的�?/span>

�?/span>new动态创建的对象一定要执行delete来删除。否则内存就会被耗尽�?/span>

大师�l�了以下的徏议：

l         Setting the pointer to 0 after the object it refers to has been deleted makes it clear that the pointer points to no object.�Q�一旦删除了指针所指向的对象，立即��指针置�?/span> 0�Q�这样就非常清楚地表明指针不再指向�Q何对象。）

l         Reading or writing to the object after it has been deleted. This error can sometimes be detected by setting the pointer to 0 after deleting the object to which the pointer had pointed.�Q�读写已删除的对象。如果删除指针所指向的对象之后，��指针置�?/span> 0 ��|��则比较容易检��出�q�类错误。）

l         Applying a delete expression to the same memory location twice. This error can happen when two pointers address the same dynamically allocated object. If delete is applied to one of the pointers, then the object's memory is returned to the free store. If we subsequently delete the second pointer, then the free store may be corrupted.�Q�对同一个内存空间��用两��?/span> delete 表达式。当两个指针指向同一个动态创建的对象�Q�删除时��׃��发生错误。如果在其中一个指针上�?/span> delete �q�算�Q�将该对象的内存�I�间�q�还�l�自由存储区�Q�然后接着 delete �W�二个指针，此时则自由存储区可能会被破坏。）

amenglai 2009-05-20 14:19 发表评论

amenglai — Wed, 06 May 2009 01:59:00 GMT

�W�四�?/span>数组和指�?/span>

Arrays and Points

vector�?/span>array�c�M��的地方就是它们都是同一对象�c�d��的集合。不同点�?/span>array是固定长度的�?/span>iterator之于vector��如同指针之�?/span>array�?/span>

vector数组�c�d��不能是引用（reference4.1 Array
Arrayl         classl         Character Arraystringstringnull+1.

size_t,vectorsize_type
for (size_t ix = 0; ix != array_size; ++ix)

                    ia[ix] = ix;

4.2 Pointers

什么是指针

Pointers are iterators for arrays.指针是用于数�l�的�q�代器�?/span>

pointer holds the address of another object:。具体来��_��指针保存的是另一个对象的地址�?/span>

string *sp = &s; // sp holds the address of s

*sp里面*代表sp是一个指针�?/span>

Best practice�Q�指针初始化�Ӟ��如果不能指向具体的地址�Q�就讄��?/span>0�Q�这样在�E�序中就可以��出指针没有指向一个对象（object�Q��?/span>

指针初始化和赋值操作的�U�束

指针初始化和赋�?/span>

只有4�c�d��可以初始化指针和指针赋��|��

1.��gؓ0的常量表辑ּ�。不能把��M��?/span>int赋值给指针�Q�即使这�?/span>int的值是0�Q�但是可以把值是0�?/span>const 或者数�?/span>0赋值给指针�?/span>NULL定义�?/span>0�Q�所以也可以使用�?/span>NULL叫做预处理变量�?/span>

int *pi = NULL

2.�c�d��匚w��的对象的地址

3.另一对象末的下一地址

4.同类型的其它有效的指�?/span>

void*指针�Q�这是一个特�D�类型的指针�Q�它能够是�Q何对象的地址。它?y��u)��是说明它的值是一个指针，但是指针所指向的对象的�c�d��是不可知的�?/span>

因此void*指针只能执行通用的操作：

l         指针比较

l         传递给function或者作�?/span>function的返回倹{�?/span>

l         赋值给另一�?/span>void*指针

Operations on Pointer�Q�指针操作）

注意*在这里是一�?/span>operator�?/span>dereference a pointer。解引用操作�Q?/span>dereference operator�Q�返回指定对象的左�?/span>lvalue。因此可以进行赋值操作�?/span>

引用和指针的区别�Q?/span>

1.        引用��L��指向对象object。引用必��d��始化�Q�但指针是可以仅仅定义，而无需初始化的�?/span>

2.        赋��|��引用的赋��g��改变引用所�l�定的对象的��|��引用是不能重新绑定新的对象的。一旦初始化�Q�引用��L��指向同一个对象�?/span>

引用�Q?/span>

int &ri = ival, &ri2 = ival2;

ri = ri2;    // assigns ival2 to ival�q�里ri�?/span>ri2�q�是指向2个不同的地址单元

指针�Q?/span>

int ival = 1024, ival2 = 2048;

int *pi = &ival, *pi2 = &ival2;

pi = pi2;    // pi now points to ival2�Q?/span>pi�?/span>pi2都指向了同一个地址单元

指向指针的指�?/span>**ppi�Q�代码：

int ival=1024;

int *pi = &ival;

int **ppi=π

int *pi2 =*ppi; //或�?/span> int *pi2 = pi;

�?/span>ppi解引�?/span>2�ơ，��可以得�?/span>ival的��g��?/span>

1.        使用指针讉K��数组单元

当��用数�l�的名字�Ӟ��q�个名字��p��动�{换�ؓ指向数组�W�一个单元的指针�?/span>

int ia[] = {0,2,4,6,8};

int *ip = ia; // ip points to ia[0] 定义ip是指针，赋��gؓia

指针的算数运��会产生一个新指针�?/span>

两指针相减得到的数据�c�d��?/span>ptrdiff_t。它是一�?/span>

int last = *(ia + 4); // ok: initializes last to 8, the value of ia[4]

如何获得一个数�l�的�l�尾�Q?/span>

const size_t arr_size = 5;

int arr[arr_size] = {1,2,3,4,5};

int *p = arr;           // ok: p points to arr[0]

int *p2 = p + arr_size; // ok: p2 points one past the end of arr

p2��是指向了数�l�的�l�尾�?/span>

指向const对象的指针和const指针

1.        指向const对象的指�?/span>

如果指针指向的是一�?/span>const对象�Q�那么肯定不希望它能够修改这�?/span>const对象的倹{��那么这��L��指针如何定义�Q?/span>

const double *cptr; //cptr是指�?/span>const double�c�d��的指�?/span>

对于�q�个定义的理解是�q�样子的�Q?/span>

A.        �q�里的限定词�Q?/span>qualifier�Q?/span>-const是限�?/span>cptr指向的数据类型必��L��const double�Q�而不是限�?/span>cptr本��n�?/span>

B.        cptr本��n不是const

C.       不能做的是用cptr��M��改它指向的对象的�?/span>

但是也可以把指向const对象的指针赋��gؓ�?/span>const对象的地址。（A pointer to a const object can be assigned the address of a nonconst object�Q?/span>

int val=10;

const int *cptr = &val;

val=30;   //�q�样写是对的

*cptr = 30; //�q�样写会��M�h�?/span>L

不过我想�Q�这只不�q�是代码上的文字游戏而已�Q�如果程序这样写�Q�也�怼��M�h的。�؜乱！

�q�种指针的用途是作�ؓ�Ҏ(gu��)��的参敎ͼ��q�可以保证这个参��C��会在�Ҏ(gu��)��中被修改。（哎，要不怎么说是大师呢，佩服�Q�）

2.        const指针

const指针的值是不可以修改的�Q�但�?/span>const指针指向的对象的值是可以修改的�?/span>

int errNumb = 0;

int *const curErr = &errNumb; // curErr is a constant pointer

*curErr = 0; // ok: reset value of the object to which curErr is bound

3.        指针�?/span>typedef

复习�Q?/span>

typedef 可以用来定义�c�d��的同义词�?/span>wages��是double的同义词

typedef double wages;       // wages is a synonym for double

�Q�以下的�q�段很饶人啊�Q?/span>

typedef string *pstring; //pstring�?/span>string的同义词�Q��ƈ�?/span>pstring是指针类�?/span>

const pstring cstr; //�q�是指向string�?/span>const指针�Q�而不是指�?/span>const string的指�?/span>

�W�一�l�：pstring�c�d��是指�?/span>string�c�d��的指针类型�?/span>

�W�二�l�：const是用来修�?/span>pstring�c�d��的，const pstring��是const�?/span>string指针

�W�三�l�：�q�不存在��单的文字替换的游戏：const pstring cstr;�{�于const string* cstr;所以就是指�?/span>const string的指针。错误！

4.3 C风格字符�?/span>

不徏议在C++中��?/span>C风格的字�W�串�Q�原因是它有“many many”的安全问题�?/span>

1.        什么是C风格的字�W�串�Q?/span>

它不是一�U�类型，而是以空字符 null �l�束的字�W�数�l��?/span>

定义�Q?/span>

char ca2[] = {'C', '+', '+', '"0'}; // explicit null

char ca3[] = "C++";     // null terminator added automatically

const char *cp = "C++"; // null terminator added automatically

char *cp2 = ca2;   // points to first element of a null-terminated char array

遍历字符�?/span>

const char *cp = "some value";

while (*cp) {

    // do something to *cp

    ++cp;

}

2.        字符串函�?/span>

C标准库提供了一�p�d��的字�W�串函数�Q�但是这些函数都不检查参数的合法性（限制条�g�Q�。这��是Lippman不徏议在C++中��?/span>C风格的字�W�串的原因�?/span>

主要的限�Ӟ��

1.        传递给�q�些标准库函数的指针必须是非�I�的�?/span>

2.        每个指针必须是以null�l�尾的�?/span>

3.        数组的长度要��_��?/span>

strlen(s)�Q�返回的�?/span>s的长度，但是�q�里�q�不包含null�Q�因此数�l�的实际长度�?/span>strlen(s)+1�?/span>

3.        使用动态数�l?/span>

��Z��么要使用动态数�l�？

通常是因为在�~�译时无法知道数�l�的�l�数�Q�所以才需要动态创��数组�?/span>

size_t n = get_size(); // get_size returns number of elements needed

int* p = new int[n];

如果是普通的定义数组�Q�以上的定义是根本无法实现的�Q�因为在�~�译期是不能��定数组的大��的。只能这样定义：

const n=45;

int p[n];

因此��可以得出结论：动态数�l�主要是用于当数�l�的��寸不能在编译期��定的情��c�?/span>

数组释放�Q?/span>

delete [] p ;

4.        疑问代码�Q?/span>P139�Q�：

我认为在const size_t len = strlen(pc +1); �q�行存在�W�误�Q�应该是

const size_t len = strlen(pc )+1;

否则copy后得到的�l�果pc2不是C风格的字�W�串�Q�因为最后一个单元的内容�?/span>’g’而不�?/span>null�?/span>

const char *pc = "a very long literal string";

const size_t len = strlen(pc +1);     // space to

// performance test on string allocation and copy

for (size_t ix = 0; ix != 1; ++ix) {

     char *pc2 = new char[len + 1]; // allocate the space

     strcpy(pc2, pc);               // do the copy

     cout << "pc2=" << pc2 << endl;

     cout << "pc2[25]=" << (pc2+25) << endl;

     delete [] pc2;                 // free the memory

}

4.4多维数组 Multidimensioned Arrays

C++实际是没有多�l�数�l�的�Q?/span>

int ia[3][4]

可以理解为数字大��是3�Q�每个单�?/span>element又是一个大��是4�?/span>int数组。或者叫�?/span>3�?/span>3列�?/span>

1.        指针和多�l�数�l?/span>

�q�段代码��如�?#8220;�?#8221;字的N多种写法一��P��

       int ia[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

       //*ip是一个指针变量，它指向的是长度是4�?/span>int数组�?/span>

       int (*ip)[4]=ia;

       //*ipo是一个指针数�l?/span>

       int *ipo[4] ;

       ipo[2]=ia[2]; //�Ҏ(gu��)��针数�l�的单元赋�?/span>

       //*ipt��是一个最普通的指针�Q�对指针变量赋�?/span>

       int *ipt=ia[2];

       //

       int (*ipn)[4]=ia;

       ipn=&ia[2]; //也可以写�?/span>ia+2



       cout << "(*(ip+2))[0]=" << (*(ip+2))[0] << endl;

       cout << "ipo[2][0]=" << ipo[2][0] << endl;

       cout << "ipt[0]=" << ipt[0] << endl;

       cout << "(*ipn)[0]=" << (*ipn)[0] << endl;

打印�l�果是一��L��Q�都�?#8216;8’�?/span>

2.        以下2�U�定义的区别�Q�圆括号是必不可��的�Q?/span>

指针数组�Q?/span>

int *ip[4]; // array of pointers to int

如果从内向外阅读 ip 的声明，则可理解为：*ip �?/span> int[4] �c�d��——即 ip 是一个指向含�?/span> 4 个元素的数组的指针�?/span>

int (*ip)[4]; // pointer to an array of 4 ints

�q�一步的理解�Q?/span>

int (*ip)[4]=ia;

ip=&ia[2]; //也可以写�?/span>ia+2

刚开始，我觉得应该写�?/span>ip=ia[2];�l�果得到报错信息�Q?/span>

error: cannot convert `int[4]' to `int (*)[4]' in assignment

因�ؓia[2]��是一个数�l�啊�Q�再惛_��果这样写ip=ia[2];�q�就相当�?/span>

int ia[4]= {0,1,2,3};

int *ip=ia;

ip=ia[2];

当然是错误的�?/span>

amenglai 2009-05-06 09:59 发表评论

amenglai — Tue, 28 Apr 2009 08:25:00 GMT

�W�三�?/span>标准库类�?/span>

Library Types

3.1 Namespace

��Z��么要�?/span>namespace�Q?/span>

namespace��是��Z��区分重名的类�?/span>

名字�I�间的主要作用是解决标识�W�冲�H�问题�?/span>
比如C++ Standard Library��是在名字空�?/span>std下，如果没有名字�I�间�Q�其中的list��非常可能和自己定义的一些标识符重复�?/span>
两种使用�Ҏ(gu��)��Q?/span>
1�?/span> std::list myIntList;
2、在cpp文�g的开头加�?/span>using namespace std;
    �q�样在文件中��可以直接��?/span>list myIntList了�?/span>

3.2 string

初始化：

string s1;

string s2(s1);

string s3("value");

string s4(n, 'c');

��d��string对象�Q�有两种方式

1.        使用��d��操作�W?/span>cin

cin >> s1 >> s2;

2.        使用getline()函数

getline(cin, line)

输入操作�W�会忽略开头的�I�格�Q�直至遇到第一个空白字�W�（leading space�Q�就停止��d��。和输入操作�W�不一��L��是，getline() �q�不忽略行开头的换行�W��?/span>

String.size()�q�回的不�?/span>int或�?/span>unsigned数据�c�d��Q�而是一个和机器无关�?/span>string::size_type�Q�虽然不知道string::size_type的具体类型，但可以肯定的是它一定是unsigned�c�d��?/span>

string st1, st2 = "The expense of spirit";

st1 = st2; // �q�是两个对象�Q?/span>replace st1 by a copy of st2

更加关键的是st1 = st2;的执行过�E�：

1实际上是把原来分配给st1的空间删除掉�Q?/span>

2再分配新的空��_��copy�q�来st2的内宏V�?/span>

3.3 vector

vector中包含的必须是统一的数据类型�?/span>

vector不是一�U�类型，�q�是一个模�?/span>template�?/span>

vector�q�不需要预先分配内存空间�?/span>

初始化：

vector v1;

vector v2(v1);

vector v3(n, i);

vector v4(n);

vector的大��?/span>

    vector<int> ivec(10,1);

    vector<int>::size_type size = ivec.size();

tip�Q?/span>

如果要取�?/span>vector的大��，要定义数据类型是vector::size_type。这�?/span>Java有很大的不同�Q�随意性很��了�?/span>

3.4 Introducing Iterators

每个容器�c�d��都会定义自己的�P代类型�?/span>

vector对应的�P代类型就�?/span>vector::iterator�?/span>

每个容器�c�d��中都会包含一个成员（member�Q�，�q�个成员是容器的�q�代器的实际�c�d��?/span>

只要一�U�类型实��C��q�代器所定义的所有操作，那么�q�种�c�d��可以称为是一个�P代器�c�d��Q?/span>iterator type�Q�。因此�P代器�c�d��有很多种�?/span>

每种容器�c�d��都定义了对应�?/span>iterator�c�d��Q�但是�ƈ不是所有的容器�c�d��都定义下表烦引的方式。因此应使用容器讉K��容器的单元�?/span>

讉K��当前单元的��D��使用解引用操作符*�Q�解引用操作�W�返回的是一个倹{�?/span>

for (vector::iterator iter = ivec.begin();

                                iter != ivec.end(); ++iter)

*iter = 0; //set element to which iter refers to 0

const_iterator

我刚开始不是很明白��Z��么要定义const_iterator�c�d��Q�后来看了下面的代码 – 以只��L��式遍历一�?/span>vector�Q�就明白�?/span>

定义�Q?/span>const vector::iterator it

遍历�Q?/span>++it�Q?/span>

遍历�Q?/span>++it //错误�Q?/span>

所以要�q�样定义�Q?/span>

vector::const_iterator it

遍历�Q?/span>++it // ok

// an iterator that cannot write elements

vector::const_iterator

// an iterator whose value cannot change

const vector::iterator

��M��操作改变�?/span>vector�?/span>size�Q�那么现有的iterator都会失效。就是说�Q?/span>

先执�?/span>vector::iterator iter = ivec.begin()

然后�q�加element�Q?/span>ivec.add(9);

那么前面�?/span>iter��失效了�?/span>

3.5 bitset

首先明确�q�和vector一��P��都是模板template�?/span>bitset只有大小的不同�?/span>

bitset<32> bitvec; // 32 bits, all zero

bitset初始�?/span>

bitset b;

bitset b(u);

bitset b(s);

bitset b(s, pos, n); //b �?/span> string 对象 s中含有的位串的副本，�?/span>pos位置截取n�?/span>bit

从构造函数可以看出，bitset是指定长度的�Q�这�?/span>vector有点不一栗��?/span>

�?/span>string初始�?/span>bitset�Q�要注意的是string�?/span>bitset的顺序是相反的：��是说从叛_��左读string�?/span>bit�?/span>

例如�Q?/span>

string strval("1100");

bitset<32> bitvec4(strval);

那么bitvec4的第2位，�W?/span>3位才�?/span>1.即��是对string的截串处理也应保�?strong>从右向左�?/strong>�?/span>

amenglai 2009-04-28 16:25 发表评论

stream	Header	Type
console	iostream	istream ostream iostream	提供 char wchar_t cin wcin …
string stream	sstream	istringstream ostringstream stringstream
file	fstream	ifstream ofstream fstream

久久久久久久久久看片,国产成人免费,都市激情在线视频

C++ Primer �?��M���W�记 �W�十五章 面向对象�~�程

C++ Primer �?��M���W�记 �W�十四章

C++ Primer �?��M���W�记 �W�十三章

13.1 The Copy Constructor

对象定义的�Ş�?/span>

合成复制构造函�?/span>

自定义拷贝函�?/span>

��L��拯���

大多数类都应该定义拷贝构造函数和默认构造函数�?/span>

13.2 The Assignment Operator

重蝲操作�W�（overloaded operators�Q?/span>

合成赋值操作符

13.3 The Destructor

什么时候调用析构函敎ͼ�

啥时需要写昑ּ�的析构函�?/span>

合成析构函数

13.4 A Message-Handling Example

拯���构造函�?/span>

13.5 Managing Pointer Members

Smart Point

拯���控制成员copy-control members

复习澄清一下：

C++ Primer �?��M���W�记 �W�十二章

12.1. �cȝ��定义和声�?/span> Class Definitions and Declarations

�c�d���?/span>

数据抽象和封�?/span>Data Abstraction and Encapsulation

关于�c�d��义的更多内容 more on class definitions

使用Typedef���化类

成员函数可被重蝲Member Functions May Be Overloaded

昑ּ�指定 inline 成员函数Explicitly Specifying inline Member Functions

�c�d��明与�c�d���?/span>

12.2 隐含的this指针 The Implicit this Pointer

何时使用this�Q?/span>

�?/span>const成员函数里返�?/span>*this

��Z��const的重�?/span>

可变数据成员Mutable Data Members

12.3 �cȝ��作用范围

12.4构造函数Constructors

Constructor Initializer

成员初始化顺�?/span>

�cȝ��型的数据成员的初始化Initializers for Data Members of Class Type

隐式�cȝ��型�{�?/span> Implicit Class-Type Conversions

12.5. 友元Friends

12.6. static �c�L��员static Class Members

使用静态数据成员的好处

静态成员函数static member function

静态数据成员static data members

整型�c�d��的静态数据成员可以在�c�d��义体内直接定义，只要是初始化值是帔R��表达式�?/span>

静态成员不是类对象的一部分

11.2 初窥���法

只读���法

accumulate

find_first_of

�ȝ��一下�P代器实参�c�d��

写容器算�?/span>

容器元素重新排序���法

再次解读�q�代�?/span>Iterators

insert iterators

iostream iterators

定义����P代器stream Iterators

istream_iterator上的操作

��Z������P代器使用���法

reverse iterators

利用�q�代器处�?/span>string

泛型���法�l�构

容器�Ҏ(gu��)�����法

8.1 An Object-Oriented Library

8.2 条�g状�?/span>Condition States

8.3 ���理输出�~�冲 Managing the Output Buffer

会被清空�Q?/span>

8.4 文�g输入和输�?/span> File Input and Output

ios_base::openmode truncate 当文件打开时清�I�文件的所有内容，如果使用�q�个属性对文�g臛_��要有写入的权�?/span>

8.5 字符串流String Streams

C++ Primer �?��M���W�记 �W�七�?

C++ Primer �?��M���W�记 �W�六�?

switch

do while语句

Using the Preprocessor for Debugging�Q���用预处理器进行调试）

C++ Primer �?��M���W�记 �W�五�?

C++ Primer �?��M��W�记 �W�十五章面向对象�~�程

C++ Primer �?��M��W�记 �W�十四章

C++ Primer �?��M��W�记 �W�十三章

��L��拯��

拯��构造函�?/span>

拯��控制成员copy-control members

C++ Primer �?��M��W�记 �W�十二章

�c�d��?/span>

使用Typedef��化类

�c�d��明与�c�d��?/span>

11.2 初窥��法

只读��法

容器元素重新排序��法

定义��P代器stream Iterators

��Z��P代器使用��法

泛型��法�l�构

容器�Ҏ(gu��)��法

8.3 ��理输出�~�冲 Managing the Output Buffer

ios_base::openmode

truncate

当文件打开时清�I�文件的所有内容，如果使用�q�个属性对文�g臛_��要有写入的权�?/span>

C++ Primer �?��M��W�记 �W�七�?

C++ Primer �?��M��W�记 �W�六�?

Using the Preprocessor for Debugging�Q��用预处理器进行调试）

C++ Primer �?��M��W�记 �W�五�?

2. 以下2�U�定义的区别�Q�圆括号是必不可��的�Q?/span>