欧美四级剧情无删版影片,亚洲美女精品久久,中文精品99久久国产香蕉

【note】Effective C++ (2) - Shifting from C to C++

keyws — Tue, 22 Aug 2006 09:24:00 GMT

Shifting from C to C++

1. To C++ programmer, for example, a pointer to a pointer looks a little funny. Why, we wonder, wasn’t a reference to a pointer used instead?

const char chr[] = "chenzhenshi&guohonghua";

const char* pchr = chr;

const char** ppchr = &pchr;

const char*& rpchr = pchr; // a reference to a pointer

std::cout << pchr << ' ' << *ppchr << ' ' << rpchr << std::endl;

2. C is a fairly simple language. All it really offers is macros, pointers, structs, arrays, and functions. No matter what the problem is, the solution will always boil down to macros, pointers, structs, arrays, and functions. Not so in C++. The macros, pointers, structs, arrays and functions are still there, of course, but so are private and protected members, function overloading, default parameters, constructors and destructors, user-defined operators, inline functions, references, friends, templates, exceptions, namespaces, and more. The design space is much richer in C++ than it is in C: there are just a lot more options to consider.

Item 1: Prefer const and inline to #define

3. The Item might better be called “prefer the compiler to the preprocessor�?

4. const char* pc;

pc = a1;

std::cout << pc << std::endl;

pc = a2;

std::cout << pc << std::endl;

const char* const pcc = "a const pointer to a const char array";

std::cout << pcc << std::endl;

// error C2166: l-value specifies const object

// pcc = a1; // error!

std::cout << pcc << std::endl;

5. You can define a const variable in a class, but it must be static const, and have a definition in an implementation file.

// .h file

class try_const

{

public:

static const int num;

};

// .cxx file

const int try_const::num = 250;

6. You can get all the efficiency of a macro plus all the predictable behavior and type safety of a regular function by using an inline function.

Template

Inline const type& max (const type& a, const type& b)

{

Return a > b ? a : b ;

}

7. Given the availability of consts and inlines, your need for the preprocessor is reduced, but it's not completely eliminated. The day is far from near when you can abandon #include, and #ifdef/#ifndef continue to play important roles in controlling compilation. It's not yet time to retire the preprocessor, but you should definitely plan to start giving it longer and more frequent vacations.

Item 2: Prefer to

8. scanf and printf are not type-safe and extensible.

9. In particular, if you #include , you get the elements of the iostream library ensconced within the namespace std (see Item 28), but if you #include , you get those same elements at global scope. Getting them at global scope can lead to name conflicts, precisely the kinds of name conflicts the use of namespaces is designed to prevent.

Item 3: Prefer new and delete to malloc and free

10. The problem with malloc and free(and their variants) is simple : they don’t know about constructors and destructors.

11. free 操作不会调用析构函数�Q�如果指针所指对象本�w�又分配了内存，则会造成内存丢失�?/span>

Item 4: Prefer C++ style comments

Memory Management

12. Memory management concerns in C++ fall into two general camps: getting it right and making it perform efficiently.

Item 5: Use the same form in corresponding uses of new and delete

13. When you use new, two things happen. First, memory is allocated. Second, one or more constructors are called for that memory. When you use delete, two other things happen: one or more destructors are called for the memory, then the memory is deallocated.

14. The standard C++ library includes string and vector templates that reduce the need for built-in arrays to nearly zero.

Item 6: Use delete on pointer members in destructors

15. Speaking of smart pointers, one way to avoid the need to delete pointer members is to replace those members with smart pointer objects like the standard C++ Library’s auto_ptr.

Item 7: Be prepared for out-of-memory conditions

Item 8: Adhere to convention when writing operator new and operator delete

Item 9: Avoid hiding the “normal�?form of new

Item 10: Write operator delete if you write operator new

让我们回�q�头�ȝ��看这样一个基本问题：��Z��么有必要写自��q�� operator new �?/span> operator delete �Q�答案通常是：��Z��效率。缺省的 operator new �?/span> operator delete ��h��非常好的通用性，它的�q�种灉|��性也使得在某些特定的场合下，可以�q�一步改善它的性能。尤其在那些需要动态分配大量的但很��的对象的应用程序里�Q�情冉|��是如此�?/span>

keyws 2006-08-22 17:24 发表评论

【note】《C++ Primer �Q?8.4节“动态分配的对象”》学习笔�?

keyws — Tue, 22 Aug 2006 06:54:00 GMT

动态分配的对象�Q�程序员完全控制分配与释放，分配在程序的�I�闲存储区（free store)的可用内存池中�?span lang="EN-US">

1�Q�单个对象的动态分配与释放�Q?span lang="EN-US">
new表达式没有返回实际分配的对象�Q�而是�q�回指向该对象的指针。对该对象的全部操作都要通过�q�个指针间接完成�?span lang="EN-US">
随机分配的内存具有随机的位模式，��初始化，例如�Q?span lang="EN-US">

int* pi = new int(0);

�I�闲存储区是有限的资源，若被耗尽�Q?span lang="EN-US">new表达式会��p�|�Q�抛�?span lang="EN-US">bad_alloc异常�?span lang="EN-US">
�q�样做没有必�?span lang="EN-US">:

if ( pi != 0 )
delete pi;

说明�Q�如果指针操作数被设�|��ؓ0�Q�则C++保证delete表达式不会调用操作符delete()。所以没有必要测试其是否�?span lang="EN-US">0�?span lang="EN-US">
�?span lang="EN-US">delete表达式之后，pi被称作空悬指针，��x��向无效内存的指针。空悬指针是�E�序错误的根源，��对象释放后，��该指针讄��?span lang="EN-US">0�?span lang="EN-US">

2�Q?span lang="EN-US">auto_ptr
auto_ptr�?span lang="EN-US">C++标准库提供的�c�L��板，它可以帮助程序员自动��理�?span lang="EN-US">new表达式动态分配的单个对象�Q�但是，它没有对数组��理提供�c�M��支持。它的头文�g为：

#include < memory >

�?span lang="EN-US">auto_ptr对象的生命期�l�束�Ӟ��动态分配的对象被自动释放�?span lang="EN-US">
auto_ptr�c�L��板背后的主要动机是支持与普通指针类型相同的语法�Q�但是�ؓauto_ptr对象所指对象的释放提供自动��理。例�Q?span lang="EN-US">

// �W�一�U�初始化形式
std::auto_ptr< int > pi( new int (1024) ); //

auto_ptr �c�L��板支持所有权概念�Q�当一�?span lang="EN-US">auto_ptr对象被用另一�?span lang="EN-US">auto_ptr对象初始化赋值时�Q�左边被赋值或初始化的对象��拥有了�I�闲存储区内底层对象的所有权�Q�而右边的auto_ptr对象�?font color="#ff0000">撤消所有责�?/font>。例�Q?span lang="EN-US">

    std::auto_ptr string > pstr_auto( new std:: string ( "Brontonsaurus" ) );
     // �W�二�U�初始化形式
    std::auto_ptr string > pstr_auto2( pstr_auto );

判断是否指向一个对象，例：

     // �W�三�U�初始化形式
    auto_ptr < int > p_auto_int;
     if ( p_auto_int. get () == 0 )

     else
         // 重置底层指针�Q�必��M��用此函数
        p_auto_int.reset( new int ( 1024 ) );

3�Q�数�l�的动态分配与释放
��使用C++标准�?span lang="EN-US">string,避免使用C风格字符串数�l��?span lang="EN-US">
为避免动态分配数�l�的内存��理带来的问题，一般徏议��用标准库vector�?span lang="EN-US">list�?span lang="EN-US">string容器�c�d��?span lang="EN-US">

4�Q�常量对象的动态分配与释放
可以使用new表达式在�I�闲存储区内创徏一�?span lang="EN-US">const对象�Q�例�Q?span lang="EN-US">

// 此时必须初始化，否则�~�译错误
const int * pci = new const int (1024);

我们不能在空闲存储区创徏内置�c�d��元素�?span lang="EN-US">const数组�Q�原因是�Q�我们不能初始化�?span lang="EN-US">new表达式创建的内置�c�d��数组的元素。例�Q?span lang="EN-US">

const int * pci = new const int [100]; // �~�译错误

5 �Q�定�?span lang="EN-US">new表达�?span lang="EN-US">
new表达式的�W�三�U��Ş式允许程序员要求��对象创建在已经被分配好的内存中。称为：定位new表达式（placement new expression)。程序员�?span lang="EN-US">new表达式中指定待创建对象所在的内存地址。如下所�C�：
new �Q?span lang="EN-US">place_address) type-specifier
注意�Q?span lang="EN-US">place_address必须是个指针�Q�必��d��含头文�g。这��设施允许程序员预分配大量的内存�Q�供以后通过�q�种形式�?span lang="EN-US">new表达式创建对象。例如：

    #include < iostream >
    #include < new >      // 必须包含�q�个头文�?/span>

     const int chunk = 16 ;
     class Foo
     {

    } ;

     char * buf = new char [ sizeof (Foo) * chunk ];

     int main( int argc, char * argv[])
     {
         // 只有�q�种形式的创建，没有配对形式的delete
        Foo * pb = new (buf) Foo;

        delete[] buff;

         return 0 ;
    }

keyws 2006-08-22 14:54 发表评论

【note】Effective C++ (1) - Introduction

keyws — Sun, 20 Aug 2006 08:10:00 GMT

Introduction

1. A declaration tells compilers about the name and type of an object, function, class, or template, but it omits certain details.

2. A definition, on the other hand, provides compilers with the details. For an object, the definition is where compilers allocate memory for the object. For a function or a function template, the definition provides the code body. For a class or a class template, the definition lists the members of the class or template.

3. When you define a class, you generally need a default constructor if you want to define arrays of objects.Incidentally, if you want to create an array of objects for which there is no default constructor, the usual ploy is to define an array of pointers instead. Then you can initialize each pointer separately by using new.

4. Probably the most important use of the copy constructor is to define what it means to pass and return objects by value.

5. From a purely operational point of view, the difference between initialization and assignment is that the former is performed by a constructor while the latter is performed by operator=. In other words, the two processes correspond to different function calls. The reason for the distinction is that the two kinds of functions must worry about different things. Constructors usually have to check their arguments for validity, whereas most assignment operators can take it for granted that their argument is legitimate (because it has already been constructed). On the other hand, the target of an assignment, unlike an object undergoing construction, may already have resources allocated to it. These resources typically must be released before the new resources can be assigned. Frequently, one of these resources is memory. Before an assignment operator can allocate memory for a new value, it must first deallocate the memory that was allocated for the old value.

// a possible String constructor
String::String( const char * value)
{
     if (value)
     {
         // if value ptr isn't null
        data = new char [strlen(value) + 1 ];
        strcpy(data,value);
    }
     else
     {
         // handle null value ptr3
        data = new char [ 1 ];
         * data = ' \0 ' ; // add trailing
         null char
    }
}

// a possible String assignment operator

String & String:: operator = ( const String & rhs)
{
     if ( this == & rhs)
         return * this ; // see Item 17

    delete [] data; // delete old memory

    data = // allocate new memory
         new char [strlen(rhs.data) + 1 ];

    strcpy(data, rhs.data);

     return * this ; // see Item 15
}

6. These different casting forms serve different purposes:

const_cast is designed to cast away the constness of objects and pointers, a topic I examine in Item 21.

dynamic_cast is used to perform "safe downcasting," a subject we'll explore in Item 39.

reinterpret_cast is engineered for casts that yield implementation-dependent results, e.g., casting between function pointer types. (You're not likely to need reinterpret_cast very often. I don't use it at all in this book.)

static_cast is sort of the catch-all cast. It's what you use when none of the other casts is appropriate. It's the closest in meaning to the conventional C-style casts.

keyws 2006-08-20 16:10 发表评论