effective c#

template expression is an lvalue, then both T and Paramtype are deduced as lvalue references, where the reference folding syntax is used. If the passed-in template expression is an rvalue, then the T-type deduction follows the CASE1 rule. Case 3:paramtype is neither a Pointer nor a Referencevoid f (T param); If the passed-in template expression type is a reference, the type of T ignores the reference. If the remainder of the expression is const,t and ignored, Volatile,t

"Effective C + +" chapter eighth: Customizing New and delete Understand the behavior of New-handler. New and delete are not functions, they are operators that request and release memory. What happens when new proposes to get a memory request failure? The old compiler returns a null pointer. Now, if the application fails, an error handler is called First, which is New-handler. This is like a callback fun

! = sizeof (Base) {:: operator delete (rawmemory); return;} Now, return the memory referred to by rawmemory; return;}if the object being deleted derives from a base class and the latter lacks a virtual destructor, the size_t value passed to operator delete by C + + may be incorrect. At this point, operator delete may not function correctly.Please remember:(1) operator new should contain an infinite loop in which to attempt to allocate memory, and if i

Effective C + + guide (Introduction)Terminology (terminology)A declarative (declaration) is a name and type (type) that tells the compiler something, but omits the details. The following are declarative:extern int x; // Object declaration Type std::size_t numdigits (int number); // Function-Declarative class Weight; // class declarative template

the execution period with the overloaded template function parameter matching behavior at compile time.TMP has been proven to be "Turing complete", using TMP to declare variables, execute loops, write and Invoke functions ... A higher-level syntax is provided for the TMP-designed library (for example, Boost's MPL). " However, this component looks very different relative to the normal C + + counterpart, such as the TMP if-else conditional sentence sho

returned.Auto Createinitlist () {return123 }; Error: Cannot infer the type of}// {1, 2, 3}Similarly, the rules apply to the parameter type specifier of the lambda that is used by auto for c++14, which produces a generic lambda (generic lambda).=[v] (const//123 }); // the error cannot be deduced. Type of //{1, 2, 3}The end result is that the auto type deduction

*************************************** Reprint Please specify the Source: Http://blog.csdn.net/lttree ********************************************Ii. Constructors,destructors and Assignment OperatorsRule 10:have Assignment operators return a reference to *thisRule 10: Make operator= return a reference to *thisWith regard to assignment, there is a very interesting chain code:int x,y,z;x = y = z = n; Chained form of assignmentMoreover,C + + adopts r

Article 01: Treat C + + as a language federalC + + = C (c basic syntax) + object-oriented C + + (class, encapsulation, inheritance, polymorphism ...) + Template C + + (Generic programming) + STL (container, iterator, algorithm, function object).clause 02: Replace # define as

is, expression templates), it is possible to eliminate those temporary objects and merge loops. So TMP uses less memory. The speed of operation is also improved. Be able to generate custom design pattern implementations. Using policy-based Design's tmp-based technology, it is possible to produce some templates to express independent design items (so-called policies). They are then able to combine them at will, resulting in pattern fulfillment with customized behavior. TMP is not f

destroyed, and ' mutexptr ' count to 0 o'clock ' unlock (Mutexptr.get ()) ' will be called. }; Copy the underlying resource. When you can have any underlying resource, you can copy it directly. For example string : Memory has a pointer to space, and when it is copied it copies that space. Transfer ownership of the underlying resource. auto_ptrThis is done by handing over resources to another resource management object, with its own resources empty. Unless noted, this blog article is

copy at a time, while also avoiding the object's cutting problem when the catch clause is passed in, while also supporting polymorphism (Rtti when virtual function calls), but still cannot avoid cutting problems when re-throw (except using "throw;" Statement4. Note: "More effective C + +" In this section advocates the use of pass-by-reference, but I think that by reference and by value each has its pros an

resulting in a recursive call caused by the stack overflow; The second time the const char returned by Const_cast minus the const version of opsrator[] matches the return type of the function.Note that the Non-const version cannot be called with the const version because the NON-CONST version is highly likely to change the value of the object, which contradicts the const feature of the const version.6. Note: There are some misunderstandings before const_cast behavior, for the following code:#in

"Effective C + +"Article 34: Differentiating between interface inheritance and implementation inheritancePublic inheritance is made up of two partsFunction Interface Inheritancefunction Implementation InheritanceThree types of inheritance that may be facedDerived class only interfaces that inherit member functionsDerived class inherits the interface and implementation of the function, but also wants to over

Three resources management of reading notes of "effective C + +"Preparation of Knowledge: The so-called resource is that once it is used, it will have to be returned to the system. The most common resources are dynamically allocated memory, and other common resources are file descriptors, mutexes, glyphs and brushes for graphical interfaces, database connections, and network sockets. Auto_ptr is a "Cl

Yesterday bought a "effective C #", saw a few item, although not originally read "Effective C + +" when the shock, but also harvested a lot. Put the key points in the following, some provisions add their own understanding, the right as a reading note:-) Item 1:always Use Properties Instead the Accessible Data members

members that do not use the list initialization, the compiler automatically calls its corresponding default constructor, and then assigns the new value to the function body immediately after entering it.Given that member variables like const or reference must be initialized and cannot be assigned, it is best to always use the member initialization list.For example:#include When I want to put the "initialize" process in the function body, the GCC error is as follows:error:uninitialized member '

); Lengthisvalid=true; } returntextLength;}2.const to the right of the asterisk indicates that the pointer is constant, and the left side of the asterisk indicates that the object is constant. const char * p= " hello " ; // non-const pointer,const data char * const p= " hello ; // const pointer,non-const data const char * const p= " hello ; // const pointer,const data If the object is a constant, the keyword const is written before the type or before the asterisk.void F1 (const

The first time to study one months, read the "Big Talk design mode" and "Effective C + +" two books, the first half of the two books are relatively easy, but later parts, such as: C + + memory, exception and template knowledge is difficult to understand. It may be that you rarely use exception handling and template relationships with yourself. I insisted on one m

to invoke a different version of a function for one-way, two-way, random iterators, with the help of iterator_traits: * /Templateclass iterator>void dosomething (Iterator iter){_dosomething (Iter,iterator_traits// This allows you to determine the type of the iterator using the parameters passed in.// Here is very brief, mainly this thing is not simple to describe, detailed content can refer to the STL source code Analysis.}#48 know the template meta-programming{// is a template meta-programming

, it is not possible to set the initial value when defined.Here is an example of how to use:/** * */#include#includeusing namespacestd;classmytest{//"Mytest::maxnumber1": only static const integer data members can be initialized in a class//int maxNumber1 = 5; //"Mytest::maxnumber1": only static const integer data members can be initialized in a class//const int maxNumber2 = 5; //"Mytest::maxnumber1": only static const integer data members can be initialized in a class//static int maxNumber3 = 5