C++ 程序设计语言（特别版）（英文影印版）的笔记(41)

>我来写笔记

按有用程度 按页码先后 最新笔记

第372页

Marmot

As always,the error handler itself can use the standard set of fundamental techniques for error reporting and recovery. Each time an exception is passed along to caller, the view of what went wrong changes.If suitable information is passed along in the exception, the amount of information available to deal with the problem could increase. In other words, the fundanmental aim of the error-handling... (更多)

As always,the error handler itself can use the standard set of fundamental techniques for error reporting and recovery. Each time an exception is passed along to caller, the view of what went wrong changes.If suitable information is passed along in the exception, the amount of information available to deal with the problem could increase. In other words, the fundanmental aim of the error-handling techniques is to pass information about an error from the original point of detection to a point where there is sufficient information available to recover from the problem, and to do so reliably and conveniently.
(收起)

2012-04-24 21:17:25 回应

收藏
推荐
第347页

Marmot

Alias of parameterizes and Inheritance: what virtual functions provide is called run-time polymorphism , and what templates offer is called compile-time polymorphism or parametric polymorphism. How to choose between these two techniques? In either case, we manipulate objects that share a common set of operations. If no hierarchical relationship is required between these objects, they ar... (更多)

Alias of parameterizes and Inheritance:
what virtual functions provide is called run-time polymorphism , and what templates offer is called compile-time polymorphism or parametric polymorphism.
How to choose between these two techniques?
In either case, we manipulate objects that share a common set of operations. If no hierarchical relationship is required between these objects, they are best used as template arguments. If the actual types of these objects cannot be known at compile-time, they are best represented as classes derived from a common abstract class. If run-time efficiency is at a premium, that is, if inlining of operations is essential, a template should be used.
(收起)

2012-02-17 09:10:32 回应

收藏
推荐
第418页

Marmot

.A pointer to a member is a value that identifies a member of class.Pointers to members look like pointer type,but it is not an ordinary pointer. 1. Ordinary pointer and pointers to members could be implicitly converted to null constant pointer both. 2. Ordinary pointer and pointers to members could be implicitly converted to bool type both. 3. Ordinary could be implicitly converted to... (更多)

.A pointer to a member is a value that identifies a member of class.Pointers to members look like pointer type,but it is not an ordinary pointer.
1. Ordinary pointer and pointers to members could be implicitly converted to null constant pointer both.
2. Ordinary pointer and pointers to members could be implicitly converted to bool type both.
3. Ordinary could be implicitly converted to void* cv pointer. Pointers to members could not be implicitly converted to void* cv pointer.
4. An rvalue of type “pointer to member of B of type cv T,” where B is a class type, can be implicitly converted to an rvalue of type “pointer to member of D of type cv T,” where D is a derived class of B.In conrast, a pointer to B could not implicitly converted to a pointer to D. In face, both rules exist to preserve the fundamental guarantee that a pointer may never point to an object that doesn't at least have properties that the pointer promises. By refusing these conversion, perhaps the compliers saves us from a run-time error. (收起)

2012-02-10 09:52:49 回应

收藏
推荐
第336页

Marmot

When both ordinary function and template function join in the overloading resolution,guess what happans? I think one of the possibilities is going to be a gork. The brief rule is as follows: 1. Find the set of function template specializations that will take part in overload res-olution; 2. Consider only the most specialized template function in the following steps. 3. Do overload res... (更多)

When both ordinary function and template function join in the overloading resolution,guess what happans? I think one of the possibilities is going to be a gork.
The brief rule is as follows:
1. Find the set of function template specializations that will take part in overload res-olution; 2. Consider only the most specialized template function in the following steps. 3. Do overload resolution for this set of functions, plus any ordinary functions as for ordinary functions.If a template function argument has been determined by template argu-ment deduction (§13.3.1), that argument cannot also have promotions, standard conversions, or user-defined conversions applied[even though,these conversions can be used if the function argument don't involved in the deduction of a template parameter]. 4.If a function and a specialization are equally good matches, the function is preferred.
The principle of the resolution rule is selecting the most specified function,with less conversion and deduction.
(收起)

2012-01-11 19:17:13 回应

收藏
推荐
第329页

Marmot

How to begin learning template: Similarly, when trying to understand a template, it is often useful to imagine its behavior for a particular type argument such as char before trying to comprehend the template in its full generality. (更多)

How to begin learning template:

Similarly, when trying to understand a template, it is often useful to imagine its behavior for a particular type argument such as char before trying to comprehend the template in its full generality.
(收起)

2012-01-03 15:27:32 回应

收藏
推荐
第300页

Marmot

The name look-up and overloading-resolution are the two leading complicated thing when we write program using C++,although wo may not notice that.We can find this in class-deriving, function or operator overloading, variable definition or declaration,almost everywhere. It is so complicated that I cannot clearly understand all this things. Oh well, Maybe I get it one day, and pigs might fly... (更多)

The name look-up and overloading-resolution are the two leading complicated thing when we write program using C++,although wo may not notice that.We can find this in class-deriving, function or operator overloading, variable definition or declaration,almost everywhere. It is so complicated that I cannot clearly understand all this things. Oh well, Maybe I get it one day, and pigs might fly.
There are some advices that can reduce the complexity and make less error when we use C++:
1. minimize the scope.
When a variable can be defined in the inner scope,don't do that in the outer.
When a variable is used only in one translation unit,using unnamed namespace is a good idea.
When a class is only used by another one class, make it nested.
When using-declaration is tidy, don't use using-directive.
Make sure that everything is in namescope,and nothing is in global namespace.
2. obey the naming rule
The rule is the rule Obeying the naming rule can avoid name-conflicting and make the code easy to maintain. If don't do that, the program will be as tidy as pigsty soon.
3. Use overloaded functions (including constructors) only if a reader looking at a call site can get a good idea of what is happening without having to first figure out exactly which overload is being called.
This rules is quoted in Google C++ style Guide. There are exhaustive explanation on the website.
Google C++ style Guide: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Displaying_Hidden_Details_in_this_Guide#Function_Overloading
(收起)

2011-12-16 13:12:54 回应

收藏
推荐
第264页

Marmot

The operator=(assignment), &(address-of), ,(comma) have predifined meaning when applied to class object. Some words about =(assignment): The assignment operator could be implicitly defined by complier.The memberwise[ http://book.douban.com/annotation/15504159/ ] copy is done when using implicitly-defined assignment operator. The assignment operator is used by object which has been co... (更多)

The operator=(assignment), &(address-of), ,(comma) have predifined meaning when applied to class object.
Some words about =(assignment):
The assignment operator could be implicitly defined by complier.The memberwise[ http://book.douban.com/annotation/15504159/ ] copy is done when using implicitly-defined assignment operator. The assignment operator is used by object which has been construct.by contrast, the copy construction is used when object is constructing.
Because a copy assignment operator is implicitly declared for a class if not declared by the user, a base class assignment operator is always hidden by the copy assignment operator of the derived class.The operator assignment of base class is not inherited.
There is a large article discussing the operator assignment.When I saw the length of the article, I know why google C++ rules suggest using function instead of operator assignment.BTW, this article discuss the error handling of new operator,I think gc is the best solution for this kind of problem.But,unfortunately,C++0x doesn't support this feature.
Some words about &(address-of):
The operator& is advised to avoid overloading.The overloading makes the forward-declare object confused.

[5.3.1.4]The address of an object of incomplete type can be taken, but if the complete type of that object is a class type that declares operator&() as a member function, then the behavior is undefined (and no diagnostic is required). The operand of & shall not be a bit-field.
But there is a programmer who write an article about how to use address operator overloading avoiding deleting object on stack.[ http://www.artima.com/weblogs/viewpost.jsp?thread=102857 ], but I think complier can tell us this bug and this advantage is trivial.
Some words about ,(comma operator):
We can not implement semantics of short circuit.So overloading this operator is not a good idea.
(收起)

2011-12-06 10:46:26 回应

收藏
推荐
第263页

Marmot

There are three operators which cann't be overloaded. <1> :: [scope resoultion] <2> . [member selection] <3> .* [member selection by pointer to member] The overloading of four operator below could be only nonstatic member class <1> -> [Structure dereference ] <2> = [assignment ] <3> [] [subscript ] <4> () [b... (更多)

There are three operators which cann't be overloaded.
<1> :: [scope resoultion]
<2> . [member selection]
<3> .* [member selection by pointer to member]
The overloading of four operator below could be only nonstatic member class
<1> -> [Structure dereference ]
<2> = [assignment ]
<3> [] [subscript ]
<4> () [brackets]
This ensures that the first operand of these operators could be lvalue.
(收起)

2011-12-04 20:54:55 回应

收藏
推荐
第245页

Marmot

In some condition,compiler will implicitly define copy constructor. [12.8]The implicitly-defined copy constructor for a class perform a memberwise copy of its subobjects.The order of copying is the same as the order of initialization of bases and members in a user-defined constructor.Each subobject is copied in the manner appropriate to its type: ------ if the subobject is of class type,the copy... (更多)

In some condition,compiler will implicitly define copy constructor.
[12.8]The implicitly-defined copy constructor for a class perform a memberwise copy of its subobjects.The order of copying is the same as the order of initialization of bases and members in a user-defined constructor.Each subobject is copied in the manner appropriate to its type: ------ if the subobject is of class type,the copy constructor for the class is used; ------ if the subobject is an array, each element is copied, in the manner appropriate to the element type; ------ if the subobject is fo scalar type, the bulit-in assignment operator is used.
There is four copy constructor types confusing me.
1. bitwise copy, copy the class bit by bit.
2. shadow copy, same as bitwise copy
3. memberwise copy
4. deep copy, A deep copy will allocate a new chunk of memory when copying the content from the memory pointed to by pointers so that there is a new own copy of dynamic data. (收起)

2011-11-24 18:05:22 回应

收藏
推荐
第247页

Marmot
Some details about member-initializer-list [12.6.2.2]Names in a mem-initializer-list are looked up in the scope of the constructor's class and, if not found in that scope, are looked up in the scope containing the constructor's definition. Unless the mem-initializer-id names a nonstatic data member of the constructor's class or a direct or virtual base of that class, the mem-initializer is ill-fo... (更多)
Some details about member-initializer-list
[12.6.2.2]Names in a mem-initializer-list are looked up in the scope of the constructor's class and, if not found in that scope, are looked up in the scope containing the constructor's definition. Unless the mem-initializer-id names a nonstatic data member of the constructor's class or a direct or virtual base of that class, the mem-initializer is ill-formed.A mem-initializer-list can initialize a base class using any name that denotes that base class type.
```
struct A{};
typedef A global_A;
struct B:public A{B();};
B::B():global_A(){};             //OK,global_A denotes class A.
```
The members' constructors are called before the body of the containing class' own constructor is executed. the constructors are called in the order in which they are declared in the class rather than the order in which they appear in the initializer list. To avoid confusion, it is best to specify the initializers in declaration order. The member destructors are called in the reverse order of constructor.
[12.6.2.5]initialization shall proceed in the following order: --- First, and only for the constructor of the most derived class as describe below, virtual base classes shall be initialized in the order they appear on a depth-first left-to-right traversal of the directed acyclic graph of base classes, where "left to right" is the order of appearance of the base class names in the derived class base-specifier-list. --- Then,direct base classes shall be initialized in declaration order as they appear in the base-specifier-list(regardless of the order of mem-initializers) --- Then,nonstatic data member shall be initialized in the order they were declared in the class definition (again regardless of the orderof mem-initializers) --- Finally, the body of the constructor is executed. [Note:the declaration order is mandated to ensure that base and member subobjects are destoryed in the reverse order of initialization]
```
struct A
{
A(int i):a(i){}
int a;
}

struct B:public A
{
B():b(2),A(b){}                //undefine behavior
int b;
}
```
(收起)
2011-11-22 21:37:39 回应

收藏
推荐

<前页 1 2 3 4 5 后页>

笔记是你写在书页留白边上的内容；是你阅读中的批注、摘抄及随感。

笔记必须是自己所写，不欢迎转载。摘抄原文的部分应该进行特殊标明。

>C++ 程序设计语言（特别版）（英文影印版）