effective c#

to a constWe immediately noticed another difference between passing parameters and passing exceptions. An object thrown by an exception (as explained earlier, always a temporary object) can be captured by a generic reference, and it does not need to be captured by a reference to a const object (reference-to-const). forwarding a temporary object to a parameter of a non-const reference type (see clause M19) is not allowed in a function call, but is allowed in the exception. Let's go back to the

The fifth chapter of effective C + +: realizing Delay the occurrence of variable definitions whenever possible. The readability of a program is often improved only if the variable is defined just before it is used, because it is not easy to forget the meaning of the variable that it represents. On the other hand, this can improve the performance of the program, if you do not need a variable to allocate,

parameter passed to operator new[] may have a value that is larger than the memory of the generation object, since clause 16 mentioned that dynamically allocated arrays may contain additional space to hold the number of elements.Second , C + + guarantees that the deletion of pointers is always safe, so in the program, we operate with the following code for NULL pointers:voidoperatordelete(voidthrow(){ if(rawMemory==0return; 归还rawMemory所指内存;}fin

virtual//Article 12: Do not forget every ingredient when copying an object//1. Copy all member variables of this class and call the appropriate copy function of its base class//2. The copy constructor is usually close to the work done by the copy assignment operator, but it is best not to let one call another, and a new function should be defined for the two functions to be called. //3. It is unreasonable to make the copy assignment operator call the copy constructor, because it is like trying

1. Built-in and | | The operator has a "short-circuit evaluation" feature. For if the first operand is true, then returns to true, no longer evaluates the second operand, | | Instead, use this feature to write the following code:Char *p; .. if (p>0strlen (P) >) ...View CodeOnce overloaded, and | | The left and right operand is two no points before and after the parameters, that is, the characteristics of short-circuit evaluation is not when the function is called, all parameters are evaluated

Make the interface easy to use correctly, not easily misusedsuch as the topic, our own program interface is user-oriented, the purpose of the program is not only to solve the problem, but also to make users easy to use, so, we must ensure that our program interface has a strong robustness.How to ensure the robustness of the interface, different circumstances have different processing results, the author lists the following examples of the corresponding methods.1. Design a class to represent the

Auto_ PTR pursues the meaning of replication.Copying functions, including the copy constructor and the copy assignment operator, can be created automatically by the compiler, so you have to write them yourself unless the compiler builds what you want to do. Note:Copying a Raii object must replicate the resources it manages, so the copying behavior of the resource determines the copying behavior of the Raii object.The general and common RAII class copying behavior is: Suppress copying, execute t

Suppose you have the following two functions:int Priority (); void processwidget (STD::TR1::SHARED_PTRThe call to Processwidget is as follows:Processwidget (STD::TR1::SHARED_PTRnew Widget, priority ());Before the compiler outputs a processwidget call code, you must first account for the individual arguments that will be passed. The first argument above consists of two parts: Execute the "new Widget" expression Call the Tr1::shared_ptr constructor So before calling Processwidget

delete the derived class object as you would like.When a class is not intended to be used as a base class, making its destructor virtual is often a bad idea.Because the virtual function is implemented, additional overhead is required (pointer vptr to the virtual function table).STL containers do not have virtual destructors, so it is best not to derive them.Please remember: A base class with polymorphic properties should declare a virtual destructor. If a class has any virtual func

. Who should take the new type member?Similar to the one above, is the encapsulation of classes, in some cases, member variables should be private, and in the public function provides access to these member variables get and set functions. If necessary, you can make the yuan, but friends should also use caution, because some compilers support is not very good, on the other hand, friends become a special case of the destruction of encapsulation, will bring security risks.10. What is an undeclared

1. Return a reference to *thisIt is customary to return a reference to itself, which can be done such as (a=c). Modify () a similar operation that can form a chained operation, otherwise the modification is just a temporary object. This is one of the most common builder patterns in Java2. Self-assignment detection and exception safetyBefore the assignment is self-detected, the same is returned directly. If it is not detected, it can easily cause the r

member function: : Length () const{ if (!lengthisvalid) { textLength = Std::strlen (ptext);//Now it can be lengthisvalid = true; } return textLength;}So avoid duplication in the const and NON-CONST member functionsThis problem is caused by the above problem, although mutable can solve the problem of variables, but if this thing is very long,We're going to need some two long, long monsters, so scary!.This requires Non-const to invoke the const thing to avoid duplication,

according to the object.Unlike N and composite, private inheritance can cause empty base class optimizations, which can be important for library developers working on minimizing the size of objects.Article 40: Use multiple inheritance wisely and prudentlyThose classes that use virtual inheritance often produce objects that are larger than those that use non-virtual inheritance, and that accessing member variables of a virtual base class is slower than accessing a member variable of a non-virtua

are proxy classes that are visible to the user, such as std::shared_ptr,std::unique_ptr. Other proxy classes are not visible to the user, such as: Std::vector The technology called expression templates used in some C + + libraries is also part of this category, which is designed to improve the efficiency of numerical calculation code. Example 2:= m1 + m2 + m3 + M4;If the operator+ operation returns a proxy class such as: SumBecause the type o

As an experienced programmer, no matter what language you used to use C # before, we synthesized a few practical ways to get you to develop effective code. Sometimes, the efforts we make in our previous environment are. NET environment is the opposite. Especially when you try to optimize some code manually. Your behavior often prevents the JIT compiler from making the most efficient optimizations. Your extr

name to represent a traits member name.IterT> void workWithIterator(IterT iter) { typename::std::iterator_traits::value_type value_type; value_type temp(*iter); …… }Finally, TypeName related rules have different practices on different compilers. This means that the interaction between TypeName and nested subordinate names may cause headaches in terms of portability.Summarize When declaring the template parameter, the Prefix keyword class and typename are i

in the destructor. The possible exceptions should be disposed of. Guarantees that the object can be completely freed . Since unsafe code always appears in destructors, we can only swallow exceptions or exit programs . Suchclass Dbconn{ Public: ~Dbconn{ if(!closed){ Try{ DB.Close(); } Catch(...) { Cerr"Database shutdown failed"Endl; //or exit the program directly //Std::abort (); }