Pan-type programming: type string (Typelists) and applications

Wild programming: type string (Typelists) and app Andrei AlexandRescu

It's hard to say how this started. I personally only say: Start me in the USENET newsgroup comp.lang.c . Moderated (by way of advice) See some posts, there is a weird template recursive. Later, when it encountered huge difficulties in the realization of the ABSTRACT FACTORY, some structure appeared in my mind. Others have also been independent of similar work because various types of strings are everywhere. Czarnecki and Eisnecker have introduced a type string that actually contains constant integer values ​​in [1]. The MPL library also defines a type string, and there are some algorithms for operation type strings. Modem C Design also introduces a simple type string implementation and uses it in at least five generic components (Functor, Visitor, AbstractFactory, StaticDispatcher, Tuple), is not two automatic class hierarchics (GenScatterHierarchy and GenlineArchy) ). The applicability of the type string is now certified. Know that type skewers will definitely improve your technology and help you better understand the current C libraries now. This article has again introduced the type string and fun program that can solve practical problems. You can't ask the type string as a Christmas husband asked it to Christmas gifts, but if you absorb any new knowledge of C like a block sponge, you can still find a lot of interesting things, so, continue to read. So what is a type string? Is the type string is also a strange strange template monster? In fact, type strings are too simple, nothing, C community does not use the type string so much unhealried. Template struct type; typef h head; typef t tail;} This is all of the type strings, really don't spend any strength. But with this small piece of code you can build a type string of any length. The technology used is the tail composition of LISP for a long time ago (Tail Composition)

TypeDef Typelist > floating_point_types;

You can do this because the type string is a type so that it can be used as a type of a large type string. According to conventions, a type string can only appear in another tail position of another type, and cannot be a head position; thus makes the operation of the type string easier, but does not reduce flexibility. We almost have to complete, we only need to define an auxiliary type, this auxiliary type as the end flag of the type string (similar to the NIL of Lisp). We call it null_typelist:

Class null_typelist {};

The correct style of the type string of this saving floating point type is:

TypeDef Typelist >> floating_point_types;

Line-shaped generation type string: three ways do not need to see any good eyes, as long as several members, the established type strings will become very ugly. All of these: Nested template instances, in order to avoid and >> Operators confused in adjacent> must be split, it makes the type string too difficult to use several methods for processing this problem, Loki [3] uses macro definitions The definition is as follows:

#define Typelist_1 (T1) TYPELIST (T1, Null_Typelist> #define Typelist_2 (T1, T2) Typelist #define Typelist_3 (T1, T2, T3 Typelist # Define Typelist_50 ...

Just like you can see, each macro definition relies on one. Loki defines the "constructor" of the type string with up to 50 members. More than 50, you either define a new macro definition, either manually connect the type string. I should know that the use of macro is not a good solution. Text conversion is very powerful, but the C preprocessor is too simple. When you think you have used it, it will always bite you behind it. In this example, the problem is that you cannot use these macros to be used with touchpads, even the simplest touchpad. for example:

TypedEf Typelist_2 (Vector , vector ) Storage_choices;

The preprocessor can handle parentheses, but cannot handle angle . In this case, Typelist_2 macro text contains 4 parameters for the pre-processor - (!) Vector , (3) Vector , not think Two two of you want. Worse, some preprocessors will not report an error - only quietly ignoring the parameters (3) and (4) and generate a unused macro show to make your headache. A better solution is to use templates to generate type strings. The following is an idea implementation:

Template strulist, null_typelist null_typelist> {typedef typefelist type;}

Template Struct Cons {Typelist > Type;}

Template Stuct Cons {Typelist > TYPE;}

Template Struct Con {Typelist >> TYPE;

The above example supports up to four types, you can use cons:

TypeDef Cons :: Type Floating_point_types;

The CONS template is based on partial specilization. When you instantiate CONS , first filled the default value to the fourth parameter of CONS, so it is actually cons , then, the compiler put this Examples and four defined specialty versions match. The first special version does not match because it requires T2 to be null_typelist, but the actual T2 here is Double, the same, the second specialization version does not match because T3 is wrong. The third special version is a valid candidate object because it accepts T1, T2, T3 as any type. This is not over, the compiler also checks the fourth special version, this special version can also match because it accepts T1, T2, T3, T4 as any type, so T4 is null_typelist no problem. But slowly, when you say "Compile During error", the third translation version has been selected because it is more applicable than the fourth. The algorithm that determines "more applicable" is quite complex, but intuitively, a partial special version of a touchpad is more suitable than another more general version (formerly a smaller scope of application). When using a practical parameter string to match the partial test version of several templates, the most priding versions of the parameters can be accepted. In our example, the third Cons version is selected because it matches cons instance, and it is more thased than the fourth. This is because the fourth accepts any type of corresponding T4, and the third is to accept T4 is null_typelist, so it is more special. You can extend CONS to accept any number of types, but unfortunately, you cannot extend the upper limit of cons. Either you use certain pre-processors again. The third method uses a function method to see below: Template struct cons;

Template struct cons {typef typefiPelist type;};

Template Struct Cons {Typelist > Type;};

Template Struct Cons {Typelist >> TYPE;};

Template Struct Cons {Typelist >> Type;

Now if you define a macro:

#define Typelist (a) cons :: type; you can write this:

TypeDef Typelist (Float, Double, Long Double) FLOATING_POINT_TYPE;

If you can succeed, people believe that two pairs of parentheses are so beautiful, this is really good. Ok, I know that I need to explain it. The first thing, void (*) (t1) is a C type (I have no misplaced words!): A function pointer accepts a parameter of T1, returns Void. This type is more familiar with VOID (* FUN) (T1), which actually contains a structure of the name. The CONS Template class is used to receive a function pointer for one, two, three or four parameters to pick up. Then Typelist macro opens this structure: Typelist (Float, Double, long double) becomes cons :: type is actually Typelist >> Now make a summary, the above solution is no perfect; only the language itself supports the variable template parameters, you will get clear, convenient, scalable, easy The advantage of use. The remainder of this article we will use the second method - the one of CONS <...> :: Type. It is time to start using the type string. Previous article [4] introduced how to calculate the length of the type string. Let's take a look at a new application of type strings for practical problems.

Improved (Ad-Hoc Visitation) Visitor Design Pattern provides a clear solution for complex issues. But its defect limits its application. Essentially, the visitor mode provides you with a safe way to increase the operation of the class level, without modifying this class hierarchy itself, the price is: When the class level changes, you have to change all of these operations. To know the details, look at the famous "design model" [5] or specially speaking C "Modern C Design" [3]. A rarely mentioned and access-related issues is: You must support access modes in the class level. This support refers to an accept member function in this support. In other words, if you can't rewrite a class hierarchy that does not support access, you can't access it. If you do not support access, and if you want to add an action in the class level, you don't rewrite it. Then you are destined to use the annoying Switch-ON-Type method. In the real world, it is very common: you use the base class in the old class library to increase your own inheritance class. Imagine, for example, there is a class level with documentItem as the root, real type to Textarea, VectorGraphics, and Bitmap. These are inherited directly from DocumentItem. In order to add actions SomeOperation, you can do this:

void SomeOperation (DocumentItem * p) {if (TextArea * pTextArea = dynamic_cast (p)) {... processing TextArea object ...} else if (VectorGraphics * pVectorGraphics = dynamic_cast <VectorGraphics *> (p)) {... Processing VectorGraphics Objects ...} else if (Bitmap * Pbitmap = Dynamic_cast <bitmap *> (p)) {... Processing Bitmap Objects ...} else {throw "unknown type passed";}} Extremely ugjite, the above code has a conceptual problem: it cannot discover the mistake of "forgot to process this type" at compile. If our level of assumptions are extended with a new type of PieChart, or the SomeOperation code forgot to handle an existing type, the only solution can only be used to throw a runtime accident, if there is such a code is not Too bad, but three are even more definitely. Will slowly turn your program into the Isle of the Moreo Doctor [6] A partial solution to this problem is: some mechanism comes from the generation and extracting the part of performing Dynamic Conversion (CASTS) from the code. . This way, only the only place needs maintenance when you change the class level. There is a good type of string here. Consider the following code</p> <p>Template <Class Tlist> Class Adhocvisitor;</p> <p>Template <Class H, Class T> Class Adhocvisitor <Typelist <h, t>> public adhocvisitor <t> {public: Using Adhocvisitor <T> :: Visit; Virtual Void Visit (h *) ​​= 0; Template <class someclass> Void Startvisit (SomeClass * P) {if (h * pfound = Dynamic_CAST <h *> (p)) {visit (pfound);} else {adhocvisitor <t> :: startvissit (p);}}};</p> <p>template <class H> class AdHocVisitor <typelist <H, null_typelist>> {public: virtual void Visit (H *) = 0; template <class SomeClass> void StartVisit (SomeClass * p) {if (H * pFound = dynamic_cast <H *> (p)) {visit (pfound);} else {throw "unknown type passed";}}};</p> <p>Adhocvisitor accepts a type of string as its parameters and uses technologies similar to CONS. That is to say, Adhocvisitor has two partial specialization versions, a header of the processing type string and recursively handled the tail of the type string, and the other is to stop recursive. The first special version defines a pure virtual function Visit (h *), H is the header of the type string. In addition, AdhocVisitor inherits itself, is an AdhocVisito instantiated with this type of string. Essentially, AdhocVisitor <TL> defines a pure virtual function VIIT for each type in the type string. This is a nice start because this is the requirements of the visitor model. But we also need actual dispatch calling Visit, this is the work of StartVisit, and this function is very interesting. We started from the first version of the first special version of Adhocvisitor. Attempts here to act on incoming pointers (worth noting that this pointer can be any type). If the conversion is successful, StartVisit calls the pure virtual function VISIT and incorporate the conversion result to Visit to perform access. If the conversion is unsuccessful, StartVisit calls AdhocVisitor <T> :: StartVisit. Adhocvisitor <T> is the base class of AdhocVisitor <typeList <h, t>>. So the call above is actually only a direct call to the base class member function. The base class member function will continue to execute Dynamic_cast to find the correct type. Regeneration must stop somewhere, this is the second ADHOCVISITOR version of the task. That special version processes only one type of string (the other is null_typelist). The difference here is that when Dynamic_cast failed, StartBisit throws an accident. You will see it immediately, this is actually not as bad as it looks like. Let us now look at how to use newly defined Adhocvisitor. Suppose we use a simple main function instead of the above definition. Int main () {typedef cons <TextArea, VectorGraphics, Bitmap> :: type MyHierarchy; DocElement * p = new Bitmap; Struct ConcreteVisitor: AdHocVisitor <MyHierarchy> {void Visit (TextArea * p) {...} void Visit (VectorGraphics * p) {...} Void Visit (Bitmap * p) {...}}; contRetevisitor Visitor; Visitor.StartVisit (P);</p> <p>Let us see how this is working. The first line defines a type of string MyHierarchy contains Textarea, VectorGraphics, and Bitmap. Note that root DOCELEMENT is not part of the type string. The Concretevisitor class is directly defined in the main function - this is reflecting the name of the specific implementation "即 (Ad Hoc). As you guessed, Concretevisitor inherits and overloads the three pure virtual functions of AdhocVisitor <myhieracechy> declaration. When the main function is called startvisit with P, the mechanism described above starts running and smoothly performing the correct VISIT overload version.</p> <p>Analysis is as important as the details of the analysis and exploration code. The efficiency has to be recognized. Compare the clumsy IF / ELSE solution of the most in front, we still use Dynamic_cast, and we have made extra virtual function calls ( Visit). The virtual function call can be easily eliminated by the following steps: * Accept the second template parameter EFFector in AdhocVisitor, and inherited from it * Let AdhocVisitor assume that these Visitor functions are defined in the Effector and use them, rather than using them in AdhocVisitor. * (Optional) In each successful Dynamic_cast branch, the EFFECTOR :: Visage is guaranteed to have the correct form (return value and parameter list). By obtaining the address of the Effector :: Visit, it can be easily implemented when compiling. * Take Concretevisitor from main. Put Concretevisitor in the function. Concept, there is no error. However, 唉, C does not allow local types to be passed as template parameters. * Use the AdhocVisitor template to incorporate the type string and your Concretevisitor class as a template parameter, you can call StartVisitation to start access. Why not discuss this optimization from the beginning (instead of practicing it as a hateful practice to the reader)? This optimization solution requires some other very difficult questions, and this article only focuses on type string usage issues. Coupled all the scenarios need to have a class level information. But it is very important. You must notice the Switch-Type solution requires you to disperse the information of the class level into the code. Based on the type of string, let you concentrate this information, you only need to provide a TypedEf. , Then you only modify it when you modify the class level.</p> <p>Maintenance Don't forget that our discussion is in a special environment: You can't add a function to the class level you want to modify. That is from the beginning, I have given us some defects. That is to say, it has brought very important maintenance based on the resolution of type strings. Suppose you forget to handle Bitmap types in your Concretevisitor class:</p> <p>Struct Concretevisitor: adhocvisitor <myhierarchy> {void visit (textarea * p) {...} void visit (vectorgraphics * p) {...}};</p> <p>This way the compiler will not let you instantiate Concretevisitor, because AdhocVisitor <myhierarchy> defines a pure virtual function void visit (Bitmap *), as you know, the pure virtual function must be overloaded. In other words, you get a guarantee, once you correctly define the MyHierarchy string, all the parts that have been forgotten in all codes will be pointed out in compile. This only is very attractive in the only design that needs maintenance. (However, unfortunately, this solution cannot be handled in Concretevisitor has a hypothetical handler (for example, the situation of Void Visit (IrrelevantType *))</p> <p>Conclusion This article introduces a type string implemented with C , with a complete use example. The type string is strong and important, mostly because it can achieve a new common method (IDioms). This is a better solution for complex issues. Most importantly, the type string encourages you to reach by letting you extract the bored repetitive code.</p> <p>Reference book [1] K. Czarnecki and U. Eisnecker. Generative Programming: Methods, Tools, And Applications (Addison-Wesley Longman, 2000). [2] See <www.boost.org>. [3] A. AlexandRescu. MODERN C Design (Addison-Wesley Longman, 2001). [4] J. Vlissides and A. Alexandrescu. "To code or Not to Code II," C Report, June 2000, <www.research.ibm.com/designpatterns/ Pubs / pH-jun00.pdf>. [5] E. Gamma, et al. Design Patterns (Addison-Wesley Longman, 1995). [6] Hg Wells' Novel The Island of Dr. Moreau (Dover, 1996) Describe A crazy doctor deforming the animal in an isolated island. Then, he did not expect his creatures to change back to the original shape, and he brought many damage to him during this period. Andrei Alexandrescu is a doctoral student at Washington, Seattle, also of the author of "Modern C Design" book. You can contact him via www.moderncppdesign.com. Andrei is also a C seminar (<www.gotw.ca/cpp_seminar>). A superior lecturer.</p></div><div class="text-center mt-3 text-grey"> 转载请注明原文地址:https://www.9cbs.com/read-23046.html</div><div class="plugin d-flex justify-content-center mt-3"></div><hr><div class="row"><div class="col-lg-12 text-muted mt-2"><i class="icon-tags mr-2"></i><span class="badge border border-secondary mr-2"><h2 class="h6 mb-0 small"><a class="text-secondary" href="tag-2.html">9cbs</a></h2></span></div></div></div></div><div class="card card-postlist border-white shadow"><div class="card-body"><div class="card-title"><div class="d-flex justify-content-between"><div><b>New Post</b>(<span class="posts">0</span>) </div><div></div></div></div><ul class="postlist list-unstyled"> </ul></div></div><div class="d-none threadlist"><input type="checkbox" name="modtid" value="23046" checked /></div></div></div></div></div><footer class="text-muted small bg-dark py-4 mt-3" id="footer"><div class="container"><div class="row"><div class="col">CopyRight © 2020 All Rights Reserved </div><div class="col text-right">Processed: <b>0.043</b>, SQL: <b>9</b></div></div></div></footer><script src="./lang/en-us/lang.js?2.2.0"></script><script src="view/js/jquery.min.js?2.2.0"></script><script src="view/js/popper.min.js?2.2.0"></script><script src="view/js/bootstrap.min.js?2.2.0"></script><script src="view/js/xiuno.js?2.2.0"></script><script src="view/js/bootstrap-plugin.js?2.2.0"></script><script src="view/js/async.min.js?2.2.0"></script><script src="view/js/form.js?2.2.0"></script><script> var debug = DEBUG = 0; var url_rewrite_on = 1; var url_path = './'; var forumarr = {"1":"Tech"}; var fid = 1; var uid = 0; var gid = 0; xn.options.water_image_url = 'view/img/water-small.png'; </script><script src="view/js/wellcms.js?2.2.0"></script><a class="scroll-to-top rounded" href="javascript:void(0);"><i class="icon-angle-up"></i></a><a class="scroll-to-bottom rounded" href="javascript:void(0);" style="display: inline;"><i class="icon-angle-down"></i></a></body></html><script> var forum_url = 'list-1.html'; var safe_token = 'Bmt4h_2FY4vW2Cc4yIMb8ulHWCgbTeJ6ral4nSziSN0XlDQgaRS3lQU5IQOSEjt_2FGFNuiMU24ochxIPlHyp2St0w_3D_3D'; var body = $('body'); body.on('submit', '#form', function() { var jthis = $(this); var jsubmit = jthis.find('#submit'); jthis.reset(); jsubmit.button('loading'); var postdata = jthis.serializeObject(); $.xpost(jthis.attr('action'), postdata, function(code, message) { if(code == 0) { location.reload(); } else { $.alert(message); jsubmit.button('reset'); } }); return false; }); function resize_image() { var jmessagelist = $('div.message'); var first_width = jmessagelist.width(); jmessagelist.each(function() { var jdiv = $(this); var maxwidth = jdiv.attr('isfirst') ? first_width : jdiv.width(); var jmessage_width = Math.min(jdiv.width(), maxwidth); jdiv.find('img, embed, iframe, video').each(function() { var jimg = $(this); var img_width = this.org_width; var img_height = this.org_height; if(!img_width) { var img_width = jimg.attr('width'); var img_height = jimg.attr('height'); this.org_width = img_width; this.org_height = img_height; } if(img_width > jmessage_width) { if(this.tagName == 'IMG') { jimg.width(jmessage_width); jimg.css('height', 'auto'); jimg.css('cursor', 'pointer'); jimg.on('click', function() { }); } else { jimg.width(jmessage_width); var height = (img_height / img_width) * jimg.width(); jimg.height(height); } } }); }); } function resize_table() { $('div.message').each(function() { var jdiv = $(this); jdiv.find('table').addClass('table').wrap('<div class="table-responsive"></div>'); }); } $(function() { resize_image(); resize_table(); $(window).on('resize', resize_image); }); var jmessage = $('#message'); jmessage.on('focus', function() {if(jmessage.t) { clearTimeout(jmessage.t); jmessage.t = null; } jmessage.css('height', '6rem'); }); jmessage.on('blur', function() {jmessage.t = setTimeout(function() { jmessage.css('height', '2.5rem');}, 1000); }); $('#nav li[data-active="fid-1"]').addClass('active'); </script>