c++-annotations-10.5.0/COPYING0000644000175000017500000004310312635354026014526 0ustar frankfrank GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. c++-annotations-10.5.0/INSTALL0000644000175000017500000000207412635354026014526 0ustar frankfrankTo install the C++ Annotations: 0. To use the `build' script you must have `icmake'. Below it is assumed you do. 1. Inspect the directories defined in INSTALL.im and change their definitions if that would suit you better. 2. Execute: ./build docs 3. Execute: ./build install or, if you'd rather have compressed .html, .dvi, .pdf and .ps files: ./build cinstall To both ./build install and ./build cinstall you may optionally add a directory below which you'd like all documents to be installed. If not specified, the root (/) directory is used. INSTALL.im's paths are appended to / or to your explicitly specified directory. E.g., the cpp-annotations man page is by default installed in /usr/share/man/man7 but if you issue the command ./build install /tmp/cpp-annot it will end up in /tmp/cpp-annot/usr/share/man/man7 You must likely be the `root' user to use the default (i.e., /). Frank c++-annotations-10.5.0/INSTALL.im0000644000175000017500000000203612635354026015130 0ustar frankfrank // DOC is the directory in which all standard documentation will be stored // in this directory the non-development related information is stored. It // is not used if not defined (or defined empty) #define DOC "/usr/share/doc/cpp-annotations" // MAN is the directory in which the manual pages will be stored // They are stored below man7 #define MAN "/usr/share/man" //========================================================================== // The following /bin/cp option is used to keep, rather than follow // symbolic references. If your installation doesn't support these flags, // then change them into available ones. // -P, --no-dereference // never follow symbolic links in SOURCE // --preserve[=ATTR_LIST] // preserve the specified attributes (default: // mode,ownership,timestamps), if possible additional // attributes: context, links, all // -d same as --no-dereference --preserve=links #define CPOPTS "-d" c++-annotations-10.5.0/README0000644000175000017500000000102512635354026014350 0ustar frankfrankThe cplusplus.latex.zip, cplusplus.ps.zip and cplusplus.pdf.zip archives contain both cplusplus.* and cplusplusus.* files. The cplusplus.* files were created with the (European) A4 paper size in mind: the related PostScript and PDF files should be printable without problems on A4 sized paper. The cplusplusus.* files were created with the (U.S.) Letter paper size in mind: the related PostScript and PDF files should be printable without problems on US_Letter sized paper. Vector graphics were created by the 'inkscape' programc++-annotations-10.5.0/README.PORTUGUESE0000644000175000017500000000127312635354026016056 0ustar frankfrankNOTE TO READERS OF THE PORTUGUESE TRANSLATION The Portuguese translation of the C++ Annotations is lagging somewhat behind. My apologies for that, but I realize it's a lot of work to upgrade from the 7-series to versions 8 and I'm completely dependent on Sergio Bacchi for upgrades of the Portuguese translation. My advice to readers preferring the Portuguese translation is to read that translation and then check the English version for the latest texts, examples and explanations. Starting with the 8.3.1 release I've removed the Portuguese translations from the source archives, as they're really lagging too much behind by now. However, they remain available at the svn repository. Frank. c++-annotations-10.5.0/README.figures0000644000175000017500000000267312636515577016040 0ustar frankfrankThe primary figures are stored in zip/svg.zip. These are vector graphic figures that can be manipulated or created by the `inkscape' program. When creating or modifying figures: =================================== cd zip ./prepare this will extract the zips in their appropriate directories. Then ==== cd svg chdir to the appropriate directory and start inkscape with the name of the figure to create/edit When a figure is created or modified, save its .svg format. A new picture can be given a certain size. >>> USE PICTURE SIZES OF 190 X 280 MM, just a bit smaller than A4: -> shift-ctrl d to define the size -> within the inkscape window: 5 to zoom in or use the zoom icon (3rd magnifying glass icon) Save the image using ctrl-S, and then ===================================== (save .eps and .pdf formats in the svg directory) Save As When saving select export object size, not the page size Save in the format Encapsulated Postscript (eps) and PDF (There's no need to convert the pdf to gif: that happens at ./install below) Having performed all image-editing, cd back to ~/zip and run: ============================================================= ./install This also installs the files at the ../latex and ../html directories Finally: ======== ./collect to update the zips. c++-annotations-10.5.0/README.legalese0000644000175000017500000000145412635354026016136 0ustar frankfrank Legal considerations for the C++ Annotations The C++ Annotations are distributed under the GNU General Public License, version 2 (see the file COPYING) or later. You are encouraged to read the C++ Annotations and to share the C++ Annotations with others. You are also encouraged to include links to the C++ Annotations in your own WWW documents and you are free to publish the C++ Annotations on your web-site. If you intend to use the C++ Annotations for educational purposes please let me know: the more people tell me they use them, the easier it becomes for me to continue and maintain the C++ Annotations. Direct all correspondence concerning suggestions, additions, improvements or changes in this document to the author: Frank B. Brokken September 2006 c++-annotations-10.5.0/README.newchapter0000644000175000017500000000010412635354026016504 0ustar frankfrankWhen a new chapter is added, adapt single/target.shtml accordingly c++-annotations-10.5.0/README.papersize0000644000175000017500000000173612635354026016362 0ustar frankfrankThe cplusplus.latex.zip, cplusplus.ps.zip and cplusplus.pdf.zip archives contain both cplusplus.* and cplusplusus.* files. The cplusplus.* files were created with the (European) A4 paper size in mind: the related PostScript and PDF files should be printable without problems on A4 sized paper. The cplusplus.* files were created with the (U.S.) Letter paper size in mind: the related PostScript and PDF files should be printable without problems on US_Letter sized paper. The files cplusplus.pt_BR.odt.zip and cplusplus.pt_BR.pdf.zip contain Portugese translations of the Annotations, using, resp., the OpenOffice and PDF document formats. The translation was performed by Sergio Bacchi (s dot bacchi at gmail dot com). It's an impressive piece of work, and since the Annotations appear like hot rolls from a bakery, its virtually impossible for Sergio to keep up with the latest version. So, please don't bug him (or me :-) when his translations lag a version or two behind. Frank c++-annotations-10.5.0/TODO0000644000175000017500000000021312635354026014156 0ustar frankfrankAdd weak_ptr is_default_constructible instead of has_trivial_default_constructor, and other remove the has_trivial things -- all done -- c++-annotations-10.5.0/build0000755000175000017500000000757212635354026014532 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/cppannotations #define LOGENV "CPPANNOT" #include "INSTALL.im" #include "compilers.im" list g_log; string g_logPath = getenv(LOGENV)[1], g_logMark, // unique-marker for g_log entries g_cwd = chdir("."); // current WD, including trailing / int g_echo = ON; int g_installing; // set to 1 by install. int g_lognr; // unique-marker number counter for g_log entries #include "icmake/cuteoln" #include "icmake/backtick" #include "icmake/run" #include "icmake/mark" #include "icmake/md" #include "icmake/md5sum" #include "icmake/log" #include "icmake/logzipr" #include "icmake/logzip" #include "icmake/writelog" #include "icmake/findall" #include "icmake/loglink" #include "icmake/loginstall" #include "icmake/clean" #include "icmake/programs" #include "icmake/man" #include "icmake/docs" #include "icmake/latex" #include "icmake/pre" #include "icmake/install" #include "icmake/distclean" #include "icmake/zips" #include "icmake/examples" #include "icmake/verify" #include "icmake/github" #include "icmake/readlog" #include "icmake/remove" #include "icmake/removedir" #include "icmake/uninstall" void main(int argc, list argv, list envp) { string option; if (argv[1] == "-q") { g_echo = OFF; argv -= (list)"-q"; } echo(g_echo); option = argv[1]; if (option == "clean") clean(1); if (option == "examples") examples(); if (option == "programs") { programs(0); programs(1); exit(0); } if (option == "distclean") distclean(); if (option == "pre") pre(); if (option == "docs") docs(); if (option == "html") runhtml(); if (option == "latex") latex(); if (option == "ps") runps(); if (option == "txt") runtxt(); if (option == "verify") verify(); if (option == "zips") zips(); if (option == "man") { man(); exit(0); } if (option == "github") github(); if (option == "uninstall") uninstall(); if (option == "install") install(argv[2]); printf("Usage: build [-q] what\n" "Where\n" " [-q]: run quietly, do not show executed commands\n" "`what' is one of:\n" " clean - clean up remnants of previous compilations\n" " distclean - clean remnants of locally run ./bin/ scripts\n" "\n" " docs - construct the C++ Annotations\n" " Run 'build programs' and 'build pre' at least\n" " once before 'build docs'\n" "\n" " examples - compile all examples\n" " install [base] - install the C++ Annotations in the locations\n" " defined in the INSTALL.im file, optionally\n" " below 'base'\n" " html - force the html construction\n" " latex - force the latex construction, (cf 'verify')\n" " man - build the manual page (requires Yodl)\n" " pre - prepare files for independent `docs' call\n" " ps - create .ps/.pdf files afer 'build latex'\n" " programs - build support programs\n" " txt - force the txt construction\n" " verify - run after `build docs' to find overfull boxes\n" " or undefined references in\n" " tmp/docs/latex/cplusplus.log\n" " zips - zip archives (after doc)\n" " uninstall - remove installed files and empty directories\n" " github - prepare github's gh-pages update\n" " (internal use only)\n" "\n" ); exit(1); } c++-annotations-10.5.0/changelog0000644000175000017500000004107312636507366015361 0ustar frankfrankC++-annotations (10.5.0) * Rewrote the section about converting time to text, covering std::localtime, std::gmtime, std::put_time as well as the full table of put_time's format specifiers. * Removed the sections at the beginning of each chapter encouraging readers to send in suggestions for improvements. Instead, this encouragement is now shown at the end of the Annotation's `abstract'. * Updated the kindle-book conversion script, so that cplusplus.css is not used with the kindle book construction. * Several typos were fixed. -- Frank B. Brokken Wed, 23 Dec 2015 13:09:08 +0100 C++-annotations (10.4.1-pre) * Improved the html layout, following suggestions by Harmen Stoppels * Removed repeated 'mailus' files from chapter openings. The 'mailus' info is now shown as part of the abstract. -- Frank B. Brokken Sat, 19 Dec 2015 22:19:18 +0100 C++-annotations (10.4.0) * Added a section about reference bindings to the Overloading chapter * Added cplusplus.css which can be used to fine-tune the layout of the Annotatiions' html conversion. * Standardized the installation procedure * Fixed typos -- Frank B. Brokken Sun, 11 Dec 2015 17:12:31 +0100 C++-annotations (10.3.0) * Added new sections about expression templates, about attributes, about shared mutexes, about shared locks, about heterogeneous lookups, about sized deallocation functions, and about moving and swapping streams * Added new C++14 elements to relevant sections * Reorganized the section about lambda expression * Added the file ./compiler.im providing all #defines for compiling the support programs. See that file for specific information. * Fixed a compilation problem encountered with g++-5. * Fixed some typos. -- Frank B. Brokken Sun, 16 Aug 2015 15:21:10 +0200 C++-annotations (10.2.0) * Rewrote the sections covering the regular expression matching classes. * The section about lambda expression also covers generic lambda expressions. * The coverage of binders now concentrates on stl::bind. * Added a section about stl::placeholders to chapter 4 (Namespaces) * Removed superfluous 'return 0;' statements from main functions. * Conversion related stamp files (e.g., html-stamp) no longer used. Build-commands are now unconditionally executed. * Added a section to class templates covering a bare bones implementation of not_fn, which will likely be added in C++17. * Added some notes about C++17. * Several cosmetic improvements were made. * Html files now use html5. -- Frank B. Brokken Thu, 28 May 2015 12:06:01 +0200 C++-annotations (10.1.0) * Typos and added a section about regular expression, moving the topic from containers to stl. * Fixed various typos and inconsistencies -- Frank B. Brokken Wed, 24 Dec 2014 19:54:28 +0100 C++-annotations (10.0.0) * Added new chapter: Multi Threading, containing all previously defined sections related to multi threading. A paragraph about std::distance was added, some typos were repaired, and other cosmetic changes were made to this version. * Redefined the standard verb(...) yodl macro by a version which does not do the extra newlines before and after the verbatim section. * The build script was extended. The support script `pathbuild' is not used, but can be used in cases where an additional element to PATH must be used. * All verbatim file inclusions are now run through the new release of yodlverbinsert. -- Frank B. Brokken Thu, 30 Oct 2014 20:17:12 +0100 C++-annotations (9.9.1) * Fixed LaTex formatting problems rendering (in particular) the cplusplusus.ps/pdf files (note: cplusplusUS) less useful (cf. scythal's user review on http://sourceforge.net/projects/cppannotations/). -- Frank B. Brokken Thu, 05 Jun 2014 14:16:31 +0200 C++-annotations (9.9.0) * STL facilities for specifying absolute and relative time were rewritten and are now in a separate section, instead of using subsections of the section about Multi Threading. Sections about condition_variables were also rewritten. * c++0x has been replaced by c++11 -- Frank B. Brokken Tue, 03 Jun 2014 13:24:54 +0200 C++-annotations (9.8.2) * Extended and completed the list of available type traits (in section `Available Type Traits', chapter `Advanced Templates') -- Frank B. Brokken Fri, 07 Mar 2014 14:49:22 +0100 C++-annotations (9.8.1) * Added explanatory paragraphs about using static_casts to derived classes using shared_ptr or unique_ptr objects holding pointers to base classes (cf. the class 'unique_ptr' and Casting shared pointers) * Added explanatory paragraphs about defining (const_)iterators and (const_)reverse_iterators (cf. 21.14.2: Implementing a `reverse_iterator'). * Added an example showing how to declare a bound friend function template to a class template (cf. Templates instantiated for specific types as friends) C++-annotations (9.8.0) * Added a section about static polymorphism to the class templates chapter * Removed the `text to anything convertor' section, which is now obsoleted by existing std::string conversion functions. * Removed the C++11 labels from section headers, as the C++11 standard has been implemented by g++ 4.8.2. Note that the --std=c++11 compiler flag is still required. * Several typos were fixed -- Frank B. Brokken Sat, 18 Jan 2014 13:55:37 +0100 C++-annotations (9.7.3) * Fixed several typos. -- Frank B. Brokken Wed, 21 Aug 2013 15:00:30 +0200 C++-annotations (9.7.2) * Repaired some minor flaws, which were still waiting to be processed. * Added for internal use steps to create a Kindle version of the Annotations (see also http://www.amazon.com, look for ('c++ annotations') -- Frank B. Brokken Thu, 30 May 2013 12:45:58 +0200 C++-annotations (9.7.1) * Added changes of 9.7.0 to the Annotations' `what's new' section * Release 9.7.0 was not published as a separate release. -- Frank B. Brokken Thu, 30 May 2013 09:43:34 +0200 C++-annotations (9.7.0) * Added several new sections about time specification (stl/time, etc.) * Added new section about 'this_thread' (stl/thisthread) * Added new section about locks (stl/locks) * Added new section (classes/ambiguity) about Ambiguity Resolution. * Added new section 'system_error' (exception/systemerror) * Added new section 'the class `error category'' (exception/errorcategory) * Added new section 'the class `error code'' (exception/errorcode) * Rewrote all sections about multi-threading) * Rewrote the section about lamba expressions * Replaced references to `ascii-z string' by `null terminated byte string' (NTBS), following the C++11 standard's terminology. * Repaired flaws in function names and return tyes of several sto* functions in string/convertors.yo * `0b' constants are not mentioned in the C++11 standard (but maybe compiler supported) * In section references `C++11, 4.7' the `, 4.7' was dropped * intro/main.yo was updated -- Frank B. Brokken Wed, 29 May 2013 20:11:20 +0200 C++-annotations (9.6.0) * Updated the list of C++ keywords * Added advancedtemplates/noexcept.yo covering the noexcept keyword * Updated the string chapter -- Frank B. Brokken Thu, 10 Jan 2013 20:23:05 +0100 C++-annotations (9.5.0) * Updated (to the current C++11 state) the reference of member functions of the Abstract Containers. * Added a new section (Allocators) just before introducing the sequential containers. * Rephrased sentenses like 'this member s' to 's', in particular in the chapter on Abstract Containers. * Repaired typos, reformulated the section about nested namespaces (Meir Shani). -- Frank B. Brokken Fri, 14 Dec 2012 12:53:53 +0100 C++-annotations (9.4.0) * Added new section make_shared in the stl chapter. -- Frank B. Brokken Thu, 28 Jun 2012 20:48:47 +0200 C++-annotations (9.3.0) * Coverage of the static_cast and reinterpret_cast was refined, following a suggestion provided by Gido Schoenmacker. -- Frank B. Brokken Tue, 06 Mar 2012 20:34:11 +0100 C++-annotations (9.2.1) * Starting this release all release tags (using names that are identical to the version number, so for this release the tag is 9.2.1) are signed to allow authentication. -- Frank B. Brokken Mon, 27 Feb 2012 13:42:38 +0100 9.2.0 * Converted scanner generations from flex to flexc++ * Rewrote the Concrete chapter's section about polymorphic semantic values * Rewrote the Containers chapter's section about unrestricted unions * Removed the Concrete chapter's section about unrestricted union semantic values -- Frank B. Brokken Sun, 26 Feb 2012 17:10:55 +0100 9.1.0 * Added sections about features of C++11 now implemented in g++-4.7 * Added a script to create a beautiful C++ bound book * Repaired typos and stuff -- Frank B. Brokken Fri, 20 Jan 2012 11:50:01 +0100 9.0.2 * Removed excessive use of the verb 'will' from the Annotations. * The required operators for each of the standard interators (input, output, forward, bidirectional, random_access) are now explicitly mentioned in the paragraphs covering them. -- Frank B. Brokken Mon, 12 Sep 2011 16:01:07 +0200 9.0.1 * Repaired some new annoying typos and slightly rephrased some paragraphs of the `Koenig lookup' section. -- Frank B. Brokken Wed, 20 Jul 2011 12:21:33 +0200 9.0.0 * The form of move special members (move constructors, move assignment operators, other functions defining rvalue type parameters) was synchronized with the form proposed by the C++0x standard. This resulted, in the Annotations relaxing the principle of const-correctness, and in modifying the declarations and implementations of move special members in this release. This shift in position (adopted by the Annotations since its very early releases) profoundly affects much of the Annotation's contents, and warrants an upgrade to the next major release. See the remarks in the `what's new' file for more details. * Several sections were added and sometimes moved. The section about 'unrestricted unions' was completed and moved to the `Containers' chapter, and an new section about adding binary operators to classes using function templates was added to the Annotations' final chapter (concrete examples). * Repaired badly formatted LaTeX table of contents: see bin/latexonly * Many typos were repaired 8.3.1 * Many typos, textual corrections and clarifications were processed, almost all were provided by Francesco Poli. * Sections about move operations were split into subsections * The Portuguese translations are lagging too much behind. I've removed them from the source archives, although they remain available at the svn repository. -- Frank B. Brokken Mon, 20 Dec 2010 15:25:30 +0100 8.3.0 * New sections about various (member) function adaptors * Sections about statistical sampling functions added/modified * Sections referring to C++0x elements now assume g++ 4.4 is available and the required compiler version is no longer listed for those sections * Typos repaired -- Frank B. Brokken Tue, 07 Sep 2010 12:12:18 +0200 8.2.0 * Bumped up the version. Should have been done earlier, considering that the 'what's new' file already refers to version 8.2.0. * Added 'export' to the list of keywords * New typos and unclear passages were processed/improved * KNOWN ISSUE WITH THE PDF VERSION: Due to a known bug in the ps2pdf conversion the pdf versions of the Annotations may show multiple Error: Illegal entry in bfrange block in ToUnicode CMap error messages. Once the bug has been repaired a new sub-minor release of the Annotations will be made available. -- Frank B. Brokken Thu, 26 Aug 2010 09:03:37 +0200 8.1.2 * New typos and unclear passages were processed/improved -- Frank B. Brokken Thu, 06 May 2010 19:39:46 +0200 8.1.1 * Many typos and minor cosmetic flaws that had escaped the previous update were processed -- Frank B. Brokken Thu, 11 Mar 2010 21:00:43 +0100 8.1.0 * The text and examples of the Annotations have completely been overhauled. Before this final 8.1.0 release two pre-releases were issued, partially completing the overhaul (see the two entries below) Over the years many inconsistencies had crept into the text and examples, that are now removed; streamlining the text and the examples. All of the code examples have received a work-over, removing endl in favor of '\n', making virtual functions private, etc., etc. Many sections labeled C++0x were improved and sections in the table of contents showing C++0x now also mention the g++ version in which the new feature will be made available, using `?' if this is as yet unknown. No version is shown if the feature is already available in g++ 4.3 (or in one of its subreleases, like 4.3.3). I received a host of suggestions from Francesco Poli (thanks, Francesco (and several others), for all the effort you've put into sending me those corrections). -- Frank B. Brokken Mon, 01 Mar 2010 09:11:21 +0100 8.1.0~pre2 * Cleanup completed until (including) chapter 16 -- Frank B. Brokken Thu, 24 Dec 2009 11:36:44 +0100 8.1.0~pre1 * Removed the 'template concepts' section from advancedtemplates: removed from the C++0x standard. * Started a cleanup operation on the C++ Annotations aiming at improving its internal consistency in examples and text. In this version completed until (including) chapter 8. -- Frank B. Brokken Thu, 05 Nov 2009 21:08:10 +0100 8.0.1 - Added --std=c++0x to the g++ compiler options 8.0.0 - New sections added describing elements of the new C++0x standard New chapters: name spaces, generic algorithm. The Portuguese translation of the Annotations (in the contributions directory) are still at version 7.0.0., Sergio Bacchi wrote that a new version is currently under construction. 7.3.1 - Readers are referred to sourceforge for the C++ Annotations archives 7.2.2 - Textual modifications and minor modifications of the programs due to new Bobcat library. 7.0.1 - Processed extensive feedback received from Eric S. Raymond and Edward Welbourne. Reorganized yo/string/members.yo. See the yo/history.yo file for details. 7.0.0 - Added new chapter (advanced template applications) and changed many other things. See the yo/history.yo file for details. 6.5.0 - Changed all unsigned types to size_t (where appropriate) Added the Portuguese translation to the distribution, since Sergio Bacchi's acceptance was received Repaired various minor problems in compiling/running examples Moved in-class definitions of member functions to below their class Added paragraphs about size_t and other derived int-types and about implementing pure virtual member functions 6.4.1 - Legal restriction leftover removed from Chapter 2's introduction. Portuguese translation and `The history of C' removed from the distribution, until formal permission to include them is received from their authors. Changes down to 6.2.4: see yo/history.yo -- Frank B. Brokken Tue, 19 Sep 2006 13:03:29 +0200 6.2.4f - fixed basic-type counting in par. 3.3 -- Frank B. Brokken Thu, 07 Sep 2006 14:04:27 +0200 6.2.4 - See yo/history.yo 6.2.2 - See yo/history.yo 6.2.0 - See yo/history.yo 6.1.3(-pre) Repaired several textual imperfections and delete -> delete [] where new [] was used. 6.1.2. This file was defined to summarize intermediate modifications. - description of ios condition flags refined - description of string::getline() refined. - open_mode `creat' changed into `trunc' (reading and writing streams) 6.1.1b Minor textual modifications since 6.1.0 c++-annotations-10.5.0/compilers.im0000644000175000017500000000206712635354026016023 0ustar frankfrank// This file was added shortly before the Gnu C and C++ release 5 of the // compilers became available. A new version of the compilers can simply be // tested by specifying the new compilers' version at CVERSION // // To check the software using the 5-version of the bobcat library that // library can be made available in a separate directory (e.g., // ISN // /usr/lib/bobcat-5) and an /etc/ld.so.conf.d/bobcat-5.conf file can be // ISN // prepared specifying /usr/lib/bobcat-5. That directory should then have the // ISN // libbobcat-5.so* library and links, and after `ldconfig -v' the linker will // ISN // detect the proper library. #define CVERSION "" //#define CVERSION "-5" // the used compilers #define GPP "g++" ${CVERSION} #define GCC "gcc" ${CVERSION} // options to be used by the compilers #define COPT "-Wall -O2 -fdiagnostics-color=never -g" #define CPPOPT "--std=c++14 -Wall -O2 -fdiagnostics-color=never -g" // extra library for the C++ programs #define BOBCAT "bobcat" //#define LPATH "/lib" #define LPATH "/tmp/bobcat" c++-annotations-10.5.0/contrib/0000755000175000017500000000000012635354026015132 5ustar frankfrankc++-annotations-10.5.0/contrib/classtemplates/0000755000175000017500000000000012635354026020156 5ustar frankfrankc++-annotations-10.5.0/contrib/classtemplates/cloneable.h0000644000175000017500000001022012635354026022246 0ustar frankfrank/* Cloneable template class protects a derived object from slicing when used with stl containers Author: Jesse van den Kieboom Jesse provides the following example based on his class template Cloneable: vector > vec; vec.push_back(B()); vec.push_back(B()); Cloneable a = B(); a->(functie op A/B) Cloneable b = B(); a = b; */ #ifndef __CLONEABLE_H__ #define __CLONEABLE_H__ namespace jessevdk { template class Cloneable { Base *d_base; public: /* Default constructor */ Cloneable(); template Cloneable(Cloneable const &other); /* Specialisation needed to override default copy constructor */ Cloneable(Cloneable const &other); template Cloneable(Other const &other); /* Deconstructor */ virtual ~Cloneable(); /* Public functions */ template Cloneable &operator=(Cloneable const &other); /* Specialisation needed to override default assignment operator */ Cloneable &operator=(Cloneable const &other); template Cloneable &operator=(Other const &other); /* Operators */ Base &operator*(); Base const &operator*() const; Base *operator->(); Base const *operator->() const; operator Base&(); private: /* Private functions */ void destroy(); template Cloneable &assign(Other const &other); }; /* Constructors */ template inline Cloneable::Cloneable() { d_base = new Base(); } template template inline Cloneable::Cloneable(Other const &other) { /* Clone other */ d_base = other.clone(); } template inline Cloneable::Cloneable(Cloneable const &other) { /* Clone other from cloneable */ d_base = other->clone(); } template template inline Cloneable::Cloneable(Cloneable const &other) { /* Clone other from cloneable */ d_base = other->clone(); } /* Destructor */ template inline Cloneable::~Cloneable() { destroy(); } template template Cloneable& Cloneable::assign(Other const &other) { /* Assign other to this cloneable with self-destroy check */ if (d_base != &other) { destroy(); d_base = other.clone(); } return *this; } template Cloneable& Cloneable::operator=(Cloneable const &other) { return assign(*other); } template template Cloneable& Cloneable::operator=(Cloneable const &other) { return assign(*other); } template template Cloneable& Cloneable::operator=(Other const &other) { return assign(other); } template inline void Cloneable::destroy() { delete d_base; } /* Operators */ template inline Base &Cloneable::operator*() { return *d_base; } template inline Base *Cloneable::operator->() { return d_base; } template inline Base const &Cloneable::operator*() const { return *d_base; } template inline Base const *Cloneable::operator->() const { return d_base; } template inline Cloneable::operator Base&() { return *d_base; } } #endif /* __CLONEABLE_H__ */ c++-annotations-10.5.0/contrib/concrete/0000755000175000017500000000000012635354026016734 5ustar frankfrankc++-annotations-10.5.0/contrib/concrete/refcountautoptr.h0000644000175000017500000001172312635354026022355 0ustar frankfrank#ifndef INCLUDED_REFCOUNTAUTOPTR_H_ #define INCLUDED_REFCOUNTAUTOPTR_H_ #include // Implementation of auto_ptr using reference counting. // This implementation was provided and offered for inclusion in the // C++ Annotations by Jesse van den Kieboom (jesse at icecrew.nl). template class auto_ptr { class auto_ptr_data { Type *d_ptr; size_t d_refcount; public: typedef Type element_type; auto_ptr_data(element_type *ptr = 0); ~auto_ptr_data(); element_type *get() const; // Refcounting size_t refcount() const; auto_ptr_data *ref(); bool unref(); element_type *release(); private: auto_ptr_data(auto_ptr_data const &other); // NI void destroy(); }; auto_ptr_data *d_data; public: /// The pointed-to type. typedef Type element_type; explicit auto_ptr(element_type *ptr = 0); auto_ptr(auto_ptr const &other); ~auto_ptr(); // Assignment operator auto_ptr &operator=(auto_ptr &other); // Dereference operators element_type &operator*() const; element_type *operator->() const; // Get and release element_type *get() const; element_type *release(); void reset(element_type *ptr = 0); private: void destroy(); }; /// auto_ptr_data template auto_ptr::auto_ptr_data::auto_ptr_data(element_type *ptr) : d_ptr(ptr), d_refcount(!ptr ? 0 : 1) { } template auto_ptr::auto_ptr_data::~auto_ptr_data() { // Destroy our pointer if (d_refcount) destroy(); } template inline size_t auto_ptr::auto_ptr_data::refcount() const { return d_refcount; } template inline Type *auto_ptr::auto_ptr_data::get() const { return d_ptr; } template Type *auto_ptr::auto_ptr_data::release() { // This function releases the pointer so it's no longer // maintained by this object. if (!d_refcount) return 0; --d_refcount; Type *tmp = d_ptr; d_ptr = 0; return tmp; } // Refcounting template typename auto_ptr::auto_ptr_data *auto_ptr::auto_ptr_data::ref() { if (d_ptr) ++d_refcount; return this; } template bool auto_ptr::auto_ptr_data::unref() { if (!d_refcount) return false; --d_refcount; if (!d_refcount) destroy(); return d_refcount != 0; } template void auto_ptr::auto_ptr_data::destroy() { delete d_ptr; d_ptr = 0; } /// auto_ptr template inline auto_ptr::auto_ptr(element_type *ptr) { d_data = new auto_ptr_data(ptr); } template inline auto_ptr::auto_ptr(auto_ptr const &other) : d_data(other.d_data->ref()) {} template inline auto_ptr::~auto_ptr() { destroy(); } template auto_ptr &auto_ptr::operator=(auto_ptr &other) { if (&other != this) { destroy(); d_data = other.d_data->ref(); } return *this; } template inline Type &auto_ptr::operator*() const { return *d_data->get(); } template inline Type *auto_ptr::operator->() const { return d_data->get(); } template inline Type *auto_ptr::get() const { return d_data->get(); } // Warning: when releasing a refcounting auto pointer the data // itself is released and no longer maintained by any of the // auto pointers. All these auto pointers will now return 0. // It's your responsibility to handle this properly (and to // free the released pointer of course) template Type *auto_ptr::release() { Type *ptr = d_data->release(); return ptr; } template void auto_ptr::reset(Type *ptr) { // Prevent creating a wild pointer by resetting if (ptr == d_data->get()) return; // Unref current data destroy(); // Set new data d_data = new auto_ptr_data(ptr); } template void auto_ptr::destroy() { if (!d_data->unref()) delete d_data; } #endif c++-annotations-10.5.0/contributions/0000755000175000017500000000000012635354026016374 5ustar frankfrankc++-annotations-10.5.0/contributions/FAQ0000644000175000017500000000217012635354026016726 0ustar frankfrank1. Too many consts? -------------------------------------------------------------------------- 1. Too many consts? > int compareWrapper(void const *p1, void const *p2) > { > return > Person::compare > ( > static_cast(p1), > static_cast(p2) > ); > } > Isn't it const *const * one const * too much? To answer your question: well, you could omit one const, but it blurrs the intention. Person::compare's prototype is int Person::compare(Person const *const *p1, Person const *const *p2); which mentions two consts: the parameters are pointers to pointers should not be modified nor should be modified what these latter pointers point to. Hence two consts in the static cast. The last const matches the const in void const *, and the first const matches the intention of Person::compare's function. Leave out the last const and the compiler complains, leave out the first const and the compiler will pass a non-const pointer to a const * parameter, which by itself is OK, but blurrs your intention. c++-annotations-10.5.0/contributions/makebook.sh.gz0000644000175000017500000000502312635354026021137 0ustar frankfrank‹b­ñNmakebook.shÅYmWKþœùµ#›‘Ȩ IîI‚çÅÄ=FXA÷æ&¹ž˜fÈÌ 1Âߧº{Þr¿,ÉÑ¡§ºº^Ÿªj·þ±×q½½Ž c‹ZC1QØ ÜID‘OÑ4ðÈ¡æÉ)õüît,¼ˆ\/Bwà9x+Âõý€À¤çzõÒ¡Žïßî‚ß©„`44q"Ä›@à¿ôD z%~ãñ{rðb2¨bûž]¶C·'l¿oOœ‰JV37jNX Ýï"M;#!ýÀ¸žÙ}ù½ïCÒ0rîCù5tÆø=,”a|øxQûP¯¶¡·ðø]a¿h\×/[g‹ªµ¿»¿[¶øûÛFë¬ý±Z6Œ‹æe½ºO[ää÷IŒ'ѽV O1^ϸ¨5›S9IÔj¶ªÏ‰?1]8" z¥†¥m­Š"QL\öFJâ†tø¬~E£þ¡Ùþج½«Wå¡»“^ß8o¼«Ž[!½1ò†ÑsÅvÑx0øðúqµðP^Èçpèö#ù$ºCŸlA濧n±K;¢ëLC˜èw3¥0ëߢÀ!±Ó\)Yá.4Ñ77ÂBýxa, #tî“c¯Ï×û‰ÌÂCbð…Iö'>\Ÿ/è =}šŠ)hN‘ú8f? ay@׉èÍ›zãÔ0ð^¹yAŸüIäú^ø…ÞôÝ‘8ÂKMꛎo~6ÈñzrÇ»‡íAnɶ‘ÒŸpèÏà(.Wy« ÊkPÞq€ú^J/d辂îëÔQ–ãH„¡6*Hî«Žë'$cŽ×vß–_¬; ©àY‘”¥ˆ=lì‰Îtå-ìÑäË;Âošto=> ¤­ƒ'Ž¿ôÂP&S’ûìu»2DÀ­|¶™ÓعçÍè³È¨ÐCþ;á2Ç™ Í‘-…[ù¨L˜1rôýQOôXã‰<%R )W³YØQçë8€æB|u–بŒ]áâ(LãWÐ;e–’¡Ì‚}QÆÈúõã«vííyíÆ¡Š$nù§ëõ}„üعEô•ªŸ^Ÿ7kí÷Àªü0äœJØ,Š’Æ…[`ÖþÎIï@½–øj_av˜R¼`Š+ÏSŠ—Lñr…âEJñSü¶Bñ2¦xÆo8¥LÕì²I¶á~< Jãz3ÒY9›ÌJæŽI87ÏdÁýÿ½háAÑ"î4Õ„êKcTbºK¸,í1x ³¼±µÔØvDìªm.ezbHÚ\9¹¥gÀ¥niæOG=(¡r¥‚ï$Âí$2‹¦&‘g,Ðþ”šþË‚@"$ÑݤÄD%Ü{&îx<†Ž=½"§£ÈÀW1Rè¦ XI+OÚ!–&‹dÓf.m“ÿŠYÙ`84Ùò¢„1j­%[²÷ÌK½ L%š —“|—¤{U°.å4—Ä‘³”ôØònWÞÈKâ ÆÄí±1~îX1 s-ðv[;Ã!ÏíŠ5ÞÀ&4ðŸè—ƒ5í+bANÄ ™Ý®{+Zmo ~q}ÔäfB•ÇÛyŸYõ‹ÖÙ»‹êfjì¥jĹ% §¥DrhB½)ÃC6ÉÒø«îA¤`‹ÌX‹‚§PÇÙƒ(6¥ZæÒåÕd{'<8‘m2Ó¨ž®l£= *Ó«š9ÆJ¾lè]4šµ«VOokíã÷d‡'õë³ãz%o¸¨¸v˜­„²‹ÉÂç< ȪÙZkû»…pèžýQ?ùP?9«á PôÔd´Ã† Nі禌ùœ³h¥é2PŠ VËIÕê'ºÄÓÜ$îddzgâØ7i[£ŸÐÒ,įË…y&7š2gÓšƒÌÕƒÖß4]–×æFŠ[«œØ¦ñÿ—Ž2óÅɘõ¡nü~dRc‹.ÕÅo|‰—zöt‘>68cjí«Ktp–•T¿ÉH_B2"îb쉲¸¬N]¼¢.w#Ü’ ¾îFÙÛ$jªŒ¼Û²+Ë‹›‰3CÜZ䶚êõyY¯¿¨W \ìáR=âʨ¸¥tôÑ9ýl›—àY<Á_|m•%à`Xï4Ét3SH&¦Þ±‰Mnô}RÜn?}âGÂò+ôÖLµÿõù‚ûÇRBñÿAã·AEc++-annotations-10.5.0/contributions/sator.proton0000644000175000017500000000242012635354026020765 0ustar frankfrankSubject: Thanks for the great book Date: Tue, 19 Feb 2013 03:26:06 +0900 Hi Frank, First I want to thank you for the excellent work you've put on the C++ Annotations (v9.6.0) book. I read it to refresh my knowledge on C++, and I can really feel it's a great book, especially for someone who wants to get a deeper knowledge on C++. I'd also like to tell you that I have converted the HTML files into MOBI book. I did it so I can read the book on my Kindle apps, and I should tell you that the conversion works without much difficulty, with the result looks really great on Kindle. I don't know if you've tried the conversion yourself, but as a token of my appreciation for your kindness to share the great book, I'd like to share the OPF file I had used to create the MOBI version. If you find the idea for MOBI conversion is good, please feel free to use (and reuse) the file. (It's just an XML file containing the metadata for the book, which you can inspect and edit for yourself.) To create the MOBI book, you just have to put it on the same directory as all the HTML files, and feed the OPF file to KindleGen tool (which is freely available from Amazon). Also, if you wish I could provide you with the MOBI file. Thank you, and please keep up the good work. Best regards, Sator Proton c++-annotations-10.5.0/contributions/java_cpp_keywords.html0000644000175000017500000001514212635354026022777 0ustar frankfrank Java Keywords and C++ Keywords

SAINT MARY'S UNIVERSITY
Department of Mathematics and Computing Science

Language Reference Material

Java Keywords and C++ Keywords

This page contains a table of both Java and C++ keywords, showing which are common to both languages and which appear in one language but not the other. Within each column of the table, the keywords are listed in alphabetical order.

C++ only Common Java only
    abstract
and    
and_eq    
asm    
    assert
auto    
bitand    
bitor    
    boolean
bool    
  break  
    byte
  case  
  catch  
  char  
  class  
compl    
  const  
const_cast    
  continue  
  default  
delete    
  do  
  double  
dynamic_cast    
  else  
enum    
explicit    
    extends
extern    
  false  
    final
    finally
  float  
  for  
friend    
  goto  
  if  
    implements
    import
inline    
    instanceof
  int  
    interface
  long  
mutable    
namespace    
    native
  new  
not    
not_eq    
    null
operator    
or    
or_eq    
    package
  private  
  protected  
  public  
register    
reinterpret_cast    
  return  
  short  
signed    
sizeof    
  static  
static_cast    
    strictfp
struct    
    super
  switch  
    synchronized
template    
  this  
  throw  
    throws
    transient
  true  
  try  
typedef    
typeid    
typename    
union    
unsigned    
using    
virtual    
  void  
  volatile  
wchar_t    
  while  
xor    
xor_eq    
Total = 40 Total = 33 Total = 19
c++-annotations-10.5.0/contributions/README.makebook0000644000175000017500000000262212635354026021045 0ustar frankfrankThe following recipe was provided by Jurjen Bokma (j dot bokma at rug dot nl) for creating a neatly bound C++ Annotations book. He gave me one as a 2011 X-mas present, and I think it's a great gift. Thanks, Jurjen! The recipe then, is: - gunzip makebook.sh.gz - Call the script like this: ./makebook.sh --t7 -p2 cplusplus.pdf (t7 is for 7-sheet signatures, see below, and p2 is to prepend two empty pages, which you may or may not like/do) - Have the output, cplusplus_book.pdf, printed. For normal-size output, you need A3 paper. I use 60-gram paper, so I can keep all in one book. Print double-sided, short-edge-bind. - Separate the printout into bundles of 7 sheets. Don't mess up the order. - Fold every bundle neatly in half. - Take these folded signatures to a book binder, e.g. http://www.boekbinderijerends.nl and wait a few weeks, or try to DIY. Background: A bound book is made up of signatures, stacks of a small number n (e.g. 7) of sheets double the size of the book's page, folded in half. Each of these signatures gets sewn into the book casing. So the A4 PDF being processed must be reshuffled so that the pages are printed on A3 paper, in signatures of n sheets formed by 4*n original pages. That is what the script does. This results in an A4 sized book. If you need other sizes, adapt accordingly. c++-annotations-10.5.0/contributions/porter.scobey0000644000175000017500000001174012635354026021120 0ustar frankfrankFrom porter.scobey@SMU.CA Sun Sep 17 16:54:15 2006 Received: from smtp1.rug.nl (smtp1.rug.nl [129.125.50.11]) by suffix.rc.rug.nl (8.13.7/8.13.7/Debian-2) with SMTP id k8HEsFqe020630 for ; Sun, 17 Sep 2006 16:54:15 +0200 Received: from smtp1.rug.nl ([129.125.50.11]) by smtp1.rug.nl (SMSSMTP 4.1.0.19) with SMTP id M2006091716540904671 for ; Sun, 17 Sep 2006 16:54:09 +0200 Received: from mail3.rug.nl (mail3.rug.nl [129.125.50.14]) by smtp1.rug.nl (8.12.11.20060308/8.12.11) with ESMTP id k8HEs7ba029629 for ; Sun, 17 Sep 2006 16:54:07 +0200 (MEST) Resent-Message-Id: <200609171454.k8HEs7ba029629@smtp1.rug.nl> Received: from by mail3.rug.nl (CommuniGate Pro RULES 4.3.9) with RULES id 26722890; Sun, 17 Sep 2006 16:54:07 +0200 X-Autogenerated: Mirror Resent-From: Resent-Date: Sun, 17 Sep 2006 16:54:07 +0200 Received: from smtp1.rug.nl ([129.125.50.11] verified) by mail3.rug.nl (CommuniGate Pro SMTP 4.3.9) with SMTP id 26722881 for f.b.brokken@rug.nl; Sun, 17 Sep 2006 16:54:07 +0200 Received: from smtp1.rug.nl ([129.125.50.11]) by smtp1.rug.nl (SMSSMTP 4.1.0.19) with SMTP id M2006091716540704669 for ; Sun, 17 Sep 2006 16:54:07 +0200 Received: from HUSKY0.SMU.CA (Husky0.smu.ca [140.184.1.100]) by smtp1.rug.nl (8.12.11.20060308/8.12.11) with ESMTP id k8HEs5Hr029615 for ; Sun, 17 Sep 2006 16:54:05 +0200 (MEST) Received: from [140.184.170.51] ("port 1263"@[140.184.170.51]) by HUSKY1.SMU.CA (PMDF V6.2-X25 #30841) with ESMTP id <01M7AU3VD1VW8ZFLAU@HUSKY1.SMU.CA> for f.b.brokken@rug.nl; Sun, 17 Sep 2006 11:54:04 -0300 Date: Sun, 17 Sep 2006 11:54:04 -0300 From: Porter Scobey Subject: Re: java_cpp_keywords.html In-reply-to: <20060916171615.GA16340@rc.rug.nl> To: f.b.brokken@rug.nl Cc: George Danchev , Tony Mancill Message-id: <450D618C.7070206@smu.ca> MIME-version: 1.0 Content-type: text/plain; format=flowed; charset=ISO-8859-1 Content-transfer-encoding: 7bit User-Agent: Thunderbird 1.5.0.7 (Windows/20060909) References: <20060916171615.GA16340@rc.rug.nl> X-Spam-Flag: NO X-Scanned-By: milter-spamc/1.4.366 (smtp1.rug.nl [129.125.50.11]); Sun, 17 Sep 2006 16:54:09 +0200 X-Scanned-By: milter-spamc/1.4.366 (smtp1.rug.nl [129.125.50.11]); Sun, 17 Sep 2006 16:54:07 +0200 X-Spam-Status: NO, hits=-4.80 required=4.00 X-Spam-Report: Spam detection software on "smtp1.rug.nl". Questions: postmaster@rug.nl Content analysis details: (-4.8 points, 4.0 required) FS_GAPPY_2=0.241,USER_IN_WHITELIST=-5 ____ Status: RO X-Status: A Content-Length: 2373 Lines: 65 Hello Frank, Thanks for your e-mail. Please accept this reply as permission to perform the two actions you mention below. To be more specific, you have permission to use my file at http://cs.stmarys.ca/~porter/csc/465/notes/java_cpp_keywords.html for inclusion in your site at ftp://ftp.rug.nl/contrib/frank/documents/annotations and also in your Annotations package to be offered to Debian. Furthermore, you may use this file with or without acknowledging its origin, you may modify it in any way that you deem necessary or convenient for your purposes, and you may pass along this permission to subsequent users if required. Best regards, Porter Scobey +--------------------------------------------------------------+ | Porter Scobey | McNally North 104 | | Associate Professor | (902)420-5790 (voice) | | Mathematics and Computing Science | (902)420-5035 (fax) | | Saint Mary's University | porter.scobey@smu.ca | | Halifax, NS, Canada B3H 3C3 | http://cs.smu.ca/~porter | +--------------------------------------------------------------+ Frank B. Brokken wrote: > Dear Mr. Scoby, > > I am the author of an Internet-published document called the `C++ > Annotations', which have been around for about a decade (currently: > http://www.icce.rug.nl/documents/). People who want to have a copy of their > own may download the document in various formats from > ftp://ftp.rug.nl/contrib/frank/documents/annotations. > > When they do visit that ftp site, they also find a copy of a page I downloaded > from your website: > http://cs.stmarys.ca/~porter/csc/465/notes/java_cpp_keywords.html > containing a list if C++ and Java keywords. > > However, I'm in the process of offering the Annotations to the Debian-Linux > distribution, and by doing so I think I should obtain your permission to > include your html file in the package that's currently being built for Debian > > In order to avoid embarrassment caused by improper handling of publication > rights, I'd like your permission to: > > - Keep java_cpp_keywords.html on > ftp://ftp.rug.nl/contrib/frank/documents/annotations > - Include the file in my C++ Annotations package as offered to Debian. > > Thanks in advance for your reaction to my request, > > Kind regards, > > [Cc: George Danchev, Tony Mancill] > > c++-annotations-10.5.0/contributions/GGD.algorithm0000644000175000017500000000314612635354026020711 0ustar frankfrankFrom d.j.heijs@wing.rug.nl Tue Jan 30 02:10:13 2001 Received: from oosix.icce.rug.nl (root@oosix.icce.rug.nl [129.125.14.80]) by suffix.icce.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with ESMTP id CAA11404 for ; Tue, 30 Jan 2001 02:10:13 +0100 Received: from dep.cpedu.rug.nl (dep.cpedu.rug.nl [129.125.28.200]) by oosix.icce.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with ESMTP id CAA25169 for ; Tue, 30 Jan 2001 02:10:15 +0100 Received: from skylos (client44-109.kabelA.oprit.rug.nl [129.125.44.109]) by dep.cpedu.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with SMTP id CAA31441 for ; Tue, 30 Jan 2001 02:10:13 +0100 X-Authentication-Warning: dep.cpedu.rug.nl: Host client44-109.kabelA.oprit.rug.nl [129.125.44.109] claimed to be skylos Message-ID: <000701c08a59$d376baf0$0201a8c0@skylos> From: "Dirk-Jan Heijs" To: Subject: Gave ggd functie Date: Tue, 30 Jan 2001 02:13:16 +0100 MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit X-Priority: 3 X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook Express 5.50.4133.2400 X-MimeOLE: Produced By Microsoft MimeOLE V5.50.4133.2400 Status: ROr Hoi Frank, gisteren hoorde ik van een vriend een mooie functie om de grootste gemene deler van twee getallen uit te rekenen (het grootste getal waardoor beide getallen deelbaar zijn). Hier is hij: // Copyright by Gerton Lunter int ggd(int a, int b) { while(a ^= b ^= a ^= b %= a); return(b); } // Copyright by Gerton Lunter Gaaf he? (Heb je er nog leuk commentaar op?) Groetjes, Dirk-Jan c++-annotations-10.5.0/html/0000755000175000017500000000000012635526566014450 5ustar frankfrankc++-annotations-10.5.0/html/cplusplus.opf0000644000175000017500000000767212635354026017212 0ustar frankfrank C++ Annotations Version 10.4.1-pre en-us EA989A949A Frank B. BrokkenThe University of Groningen9036704707Computing, Internet01/10/2013 annotations.gif c++-annotations-10.5.0/html/pointermembers/0000755000175000017500000000000012635354026017471 5ustar frankfrankc++-annotations-10.5.0/html/pointermembers/fig/0000755000175000017500000000000012635354026020236 5ustar frankfrankc++-annotations-10.5.0/html/pointermembers/fig/personfig.gif0000644000175000017500000000314112635354026022720 0ustar frankfrankGIF89a T€ÿÿÿ!ù, TÿŒ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎsÀ ‡Ä¢ñˆL*—ÌŸª J§TäÐËœ)®¶ç=…¿ºqÉ\©ª×À zôž°çT7¶{ÏĵûHÿó÷¸3ØPh‡H¦p¸À¨—‡áh#‰@iai€)£©)yÑ ÃùyFšfJ6z•¨X‰ê¹ªŠÕ¶P ø*ê§ÛÛá• ¢ŠÇ*›p÷éKQŒâŒ\™™œ{l­G}« Ì,èÝm©½œKWD n¨îP¾-íqn”.*¼u_-‹Ê›ÉÞø­0~«wËà:„i–BØ/!ÃfI`ÃGo°Šÿpb˜ñQ«dý ,¹eDMê9ò#Ì”!#¡ŒÑRâK›1eò¹Ó^O—3IÖ:4gÄœ_”ÞteGžT+ÆS95+ºª4ƒÝÄï©Ï¯`O%+*ìY´.Þ,˶(T¯qYª¥[7V׫yÓšÅÛWÌ]¾[¸…«³ðŠÃk?´α^£;‰´Rf÷/áiÜøpžƒì’©e*Ãå¯\O´¦ÁÆGð¶kÍ”E¯†7ºµ­ÏªUûù8 ø;ãÃG‡îÙ´iwîHçknˆ7ê¥'†žÚ•ëÒ¯žzÜÞËïÌ—e籯'ÝH»òZÂ`Ïÿ`|‚t·ˆ{¶£_sëÝwj"¨„Õ-X`„çá~ŒUÁuèy¨}q‘Üt˜agßX*r%"@̉ÇÚzà´™n³õg†nDÁÇ¢d× ?òóÜ°¡hBZd‘K>öž“OvDäDSB„ØJW®ø]jZ} fUîf™få–=i©ffm~Å曧ÉSœtyçHvæI%ŸŠìégcæè AJbˆŠPè¢r9Š¤¢*9i FzæTjfšÕ¦’Vj%¨‚…v©¨õ™4›©‹Ñ8žª«¢éê3GÄúê´ÖÚê­x䪫¬¼öúã¯À–¢ã°k,£¥ÿ‹l²!4ë,1ÉrÊ©bÔfjí§3, Z]ÜÎÙ×·²fKnaâŽj®¶e¥[n`çâ鮺8…%,òú•†‰¶‹á½”ÆåV¾ìÙÂßm»fлPö{áŽ/Ú'\3þ¶ÅO…R8¡¾íLl½©b·à ƒü »ŸÔ*)gbÉñh±Æ!Ü^ƒ/ŸŒó‰±Lr‡»óˆ ?Œ¢Ìc²°Ï/â#y§ð›—ÂLBííÏ«RŠŽR÷©gË[+»¦×VwÛ”ØX{Fò×ÏŽ½QÚl[§Ù&wíöÙY,½cÔo{¹ÚÞð†ë÷ÂzÛM–Ú‚8“×–™íâagâ\yR’ÿƒ=7噾yÕ•¯yùÚŸ×zcÿ5U:^*ÿ™ú¿-¶~4ZI[×ZÁcü±Äg›ÇàwD›Ø²Ï»ÇÌ]ð<×¼ñ¨s{Ç·h³æA§”2õ)^ ìRϽ.ÍgÈ}ò#±„Ûí ÀØût 2ŸýðJ‹}ûí觩þèzj*èú_Æ¿ã¤iŒ^€ò¶&yN±C\á¹Pvdþ(Á R0ƒ< 'èÀñyðf$”ž 9/Ç©q*ÔÊÿX÷¬Åu3äC£…Ãêp‡<졸‹ÆO„$bKˆÂ.‰KT"™øD'ŽˆT¬¢¯ˆÅ,ÿj±‡†Ì¥XD(N1‰dlb£xÆ1šqhdãßÇ8ÊqŽt¬£ kx7!>͈ä£åðh/¶PSéd§üè?D’FÒ£î¹?Fî ’”d JÂP“2ä$ =yGPæÑ’„ÂdI‰ƒ.º.Œ`übYùJWº–³”eo©F\ÒR—¶Ì¥/wùË^s˜Â,fÅHÌc¶R™±df-ÉKhSšÉü£(íeHB¦0›ò@e¤¼9 Sºl™ÖD¦1ËIÎDš“šçTg:yÍF‚ÓRâ^<'¹Nt6SŸÏäg4ý9M€VÓû$h? úO„T¡…g>ÚN‡¾38’÷¼äÒ‘¢%é9ɻҒˆD¥*1yG AòŒ°\d$ÿèIÑ•òz™^.…·Ëìá¢4]0Q7LÕ“u·4e/··Ìî5ó{¿tå1WËQVS˜×D]2ívJV¦Ò›«c4#ôJYƲ“³ld6U·ÍºuSœ—„ç7å©DNÒ2Ÿ\'릩áº@ºÎí¬lµi^º×”ºõ v¥``Ý7Xt4½ª Bµžô¯+=¬…úTÊFª¶Äk8ÛºY½v–¯õôª\ŠYkŽ¶Ÿ’uã?;>Çbµ¯8…,Oa×ÒNÕ¶ÄLmb]»XÞ6¶:•mSi[×Ó&Ô¸`E.õ4 ÎæÿÒÓ¹œ….!íYÙ Zw¨Ø­nv¹[à&Õ»K¯V…Û §^Ö² U.YqkÖvÕ¯Ÿ…¯tAÛEêž÷ºÚÍï}·›^!2÷¹Žn€=;_àÙ·¿è5-{çªÞÚ^ñ¿Ž0L_ X´ &m‚o»áÜ6zÝolE\7´oý0U,XÖÅð qG<ã×øÄõÅp‡™Zâ®8Ã…ð„%\a"Ë×ÂÂ;°‚wÌ` ×ÉÉõ¯{YCñrÕÄáE1`a\Å{™Ë\“1’ms2öœç7ÿÇËÎq>t½=/Gß¿^³ôÒ4=AOMÔ53õ%,6UÇLÖY¾u_Ýé_‡zØ¥>vª—Ýê3{×..±‹4o'{Ú5G¦XÁ½î?oË8µ G*3~ÿ”ÖYówµÜå¾9<ÎÏx<6^7ŠïOä…þxrVÞ6“Wúåk“yýt^ï›ojè±>µÑÃæóøA½XTÖ×ÇõV}ò¾ÙËÇöIÁ½ÖN¢ÒïF÷»?;€ïâ÷Äøhˆ{¿æÃÄù°€— êåØÏ>í`}ótŸ"ß>“Èâ{È?bîÃ/nÂO¢¶“ßñ¿wÄö³À~ñÔ¿ ÷Èÿ±Œ‘ÿïôÿùw*¿ðÝA€é€x ¨ x ¨ ˆ¸5bw¨¡$4Òhâ)[¢‘0Ö‚Ï{Ã’0A}a(O+¼ê‡y5ò'fb+uB,¬")¸"H;Ø $(ƒ¨’ƒ8H-j’)ŒÐƒÒ„Çðƒ^!68ƒãÇ%¿"|… „Ða…úP«q‚Ðr+Â…èW…/ÈyZ˜ƒÔ¢)C(it.æ‡FHB˜'*G)f Xèy8€e%Axƒ¹r†¸,w¨€cHLH+RØ…5˜†Ñòˆlˆ{¨“Ø ‰Ø„S¨*[¸‚ÉÒ‚P‰ÈŠ·p‰^ÿ¡ˆxóp&‘˜¢H­X ¯ˆ‡Hzñç†ëgz}‡‹N7‹§§‹@ó‹ÀŒÂ8ŒÄXŒÆxŒÈ˜ŒÊ¸ŒÌØŒÎøŒÐØ‹äP‹q…«Ø-䢱¨ª·‚±gÞÄ/ÚX¨ç#UqŽK"Ž/€--²’¸(ë¨ê˜ ìˆ0˜¢†–È‚±Ò,c·w‡2¸à~Éw¸‰‹!+9¿÷s2)Ù&Õx©¸²¨_¡ÞP‘Ý¢‘úÇé 9‘™‘9Á‘úHx(¹’´©H‡8&‚¨’öˆ%¶*³â¯b#3µ‡’8ùw:‰*g“0’7Ø‘‰”Ù“Jÿ)’+ŽKù”úX•°È‘Rù‘$é’Ti•5I†Lé‘[ ”¯"–!–¤•fÉ•Si”nù•q$j©–k —^É’LW0sé/º‚"ú£@¤B:¤DZ¤Fz¤Hš¤Jº¤LÚ¤Nú¤P¥R:¥TZ¥Vz¥Xš¥Zº¥\Ú¥^ú¥`¦b:¦dZ¦fz¦hš¦jº¦l:/aè"›Ñ¦0àø}×(§X/‹r§0x: ø.|ªI÷§yê~:3¨†Šîמ~¨P¨Ú¸qQè,ÝÙ‰Sø¨•j ž ©­ÿ¡,O7ª¾"©Ÿú‰¡‚xBª¡|)©A©«Z…­*œè$˜(uñª´z«œÀ®ZŠÁ ©¨8«Šº¬Âº Ī«ÀʬÉʬ¨*­ÍŠ ÏJÇŠ¨\q»ú,×:¬¹ª­ÒʭѪ¬Éj«á*Ùê­çŠ®›ê®Æj­ëJ ¡šÇš®"¯ùª¬êZ¯@ñ%§1­üJ¯Y°’à©—Q­Ë° ‹® ¨á9±rbX±àºžý± {/xâ­¼º…¾:²…ò«‹­zÚ­Êwuöò±Qè+' ªtª²¦z±™8wL‚¨ª³wð¦¤j°¬ ´‰Ê³àY´F{ÿš´ôÿˆ´LÛ´;û´Ïç´RûK[µX›µZ»µ\Ûµ^ûµ`¶b;¶d[¶f{¶h›¶j»¶lÛ¶nû¶p·r;·t[·v{·x›·z»·|Û·~û·€¸‚;¸„[¸†{¸ˆ›¸Š»¸ŒÛ¸Žû¸¹’;¹”[¹–{¹˜›¹š»¹œÛ¹žû¹ º¢;º¤[º¦{º¨›ºª»º¬Ûº®ûº°»²;»´[»¶{»¸›»º»»¼Û»¾û»J«}Â;¼Ä[¼Æ{¼ÈKrSCe4dnÍkq¯¥q¶CS°oÿöm÷kS´¼ÎkDÝËDÐÛ[á‹9Ôûl×k½ÙlÛ‹GÌë½ã{lÒ½êö=å;qÿ7Yé;l<Ľï{nó›nÚ–qÿÛ?õ{¿nhúÕg|Ä¿ñ+¾ ü[ ¿,9|¾ófÀÕ{Áû˾߻EüE|q!\9œ¿fÂá–ÀüH <Âì ÃÀ\T,ql¾ëëJí ¾ì¿4,ÂALÂ6¬ÃâÖmŒÃÌÃü^ ÇpO¼n„TÂG,pULp*i ÌÁýû¼?ìÅ2 Ä™¶=TœÅãvÅ—ÄøÛF-<Ä/ìÆ1 Ç3<ÆÝSÆûeÆHŒÂï¦Æ> y=ìÁ]ì¾_,Èa¼?v¬ÀwœÈˆ¼È+,:mLlj&Çb¬k‘ ÉsÈœÉZ¬Èš|Æ[ÌÄÿìÃ…LÈ’ Æ¥@˜¼ÉŒ¬ÊœÇh¬6LÉlÉ|Ê¢l˔ʞÌɬÜË»¼Ê¨Ëû6˲\Ë´¼q¸L8ºìÊxlÅ͌żÌ\<È·|ÌBlÍò›Ìª•LìËÌÍß Ìª#Ìù&ÅÃlÌÅŒÌØìAËìÌàìÎâ Ï­Ì:äÅ•œÎ׌ÏÙ¼Îä[ÄöËÇ7¼ÆŸLN ÂÚ\ÐNœ=í ÍñÌÐóìÐÞLÏÓ<ÊÕ¬ÏoÌÏslÑýì^ÝÍ¿üÐi¼ÃÝÄ]ÒM¼Ð!ýÊê«Òú«ÇdSÏ gÎå|Ïç¬Îí;(­½,}Â;Âï|60 Å1MÓ3MÌ5Ïš”Ó+ÿýÌ)ÍÔ:íÔÒÔ2mÏF]Ôè|Ôû<ÅþœÃÿìÒØËÆ}Ð$=Ö¡œË[ ÐF Õ- Ö LÍ€ìÖÑ“ŒÕì|Ö^¾=½Çw­Á"Q&]Öq}ÓsmÕ5ÌÑiýÓMØOÍÂa-צìؤ ÙM×ýO}Ù‡íÈ-ØÍÙ‘íÙ“MØÓk×y p¥ýÕjÍÓí×d × -Ô°]ǤÚ>ÝЉmÛ‹­ÙmMÑoÍÛMÙ ÜŒ£ÔkMÛz}ÚxmÜ/½ÙÂÝÙÍýÙÏÚTMÀ³­ØKmÝÅݪÍØ»-Ö€ýÚS=Ô—\ݸ}ÝåÝç½Ýº=Òßý×®ÐÄ­Þ ÛóÿmÞõÝ6RMÔÓmÓÑÝÛÞ­Dñ]Û÷-ß Ñm:ù]ÕûÔ¢ÕýýÛÀàǭܨ­Ý^àÊ“àWÝà Úþ-Ù®Õ†ÝÕÈÍ×%®Ä}ÍSîíÛà­ßâMÝ#ÎÕ2ŽÖ¤áüÍáq â¾àáä=à~àBÎ@=6Îà<ÞáÞâ ®Ð?Žáô åö-åèM:GÞãIžã¾ã/~ãÂ#á¦MáÉmáNæËÝÝ:ÎäžåÁã8ýäC.ÏTNàqnàãÌÜn>Øl®ç]Žä}NÄ1Nã3¾×(ÎÖìýÞ­Íâð çD>çAÞèu~ÛVŽç{îÜyné•Ý—ŽÊŒ.ç‘ÿåŸ>å¡Žß”þçJ¾éÒmêZ¾ä`^áéýèžé².Ñh¾åjîåªÞ晞;­>æ¯^æ¿æf®>W~ê»âK¾âbÔë&.æÍ>ì¾^ägNNÉ[íÖ~íØžíÚnruˆG}lß. Q T»zá ãþW{åÎîéÞ랎í.ïïÞ|ñµçî ÷Nî÷êžhtýž@ïuûîÿÎT8x|ÿ>Kð t /ðïÏv 0ïrñ_}/«vððxWïàwòù~ Ú9ïìx(?0¿ò2Ë•1_}¾(u¼Ø˜Ôhy=”®”óT·ó·ù†Aÿó`ÿyôF‹¶ôL¯ôOõ%ô€Gô¢i©7¿ V¯óXÿñÁ°õC/#¯4ÏóK„!Ÿ~MŸô]/«pö€·ír¨Ë÷Z‡‡ivOsç7öô·÷þ.ö^¯õk]ïe_ôRߎݗø²ø0— Ö—õXù:GŽß™ög›¿–os’ÿ!åù®?‚,”ÏŸ÷H0¹²°|ɲ ñ†°ú|ßú÷ˆêi*Œ8™`ûû,àˆ›¢'¥„ úˆg0 †ßê„ÈoÊot£¯‰°Ú$Î),?ýHWýhh³«B*‚h¯ÜOÿªXx9 ü7Àþ—/üÚüêÿÏ&©‡Ò_ø-Äïˆ*ˆC;ʾ^œ´Ú‹³Þ¼û¿AàH–扦êʶ.(¾òL×ö=ŸÄGMÞÆ„AŸN¸K*Wº¥ó J§”&õŠÍÖ¬·_ïK ZÀ±W‹î¦×ì¶;É}ËçØ8ýŽWÚóü¾ß¹÷'8ChxXˆ¸ÈبØé÷Iy7Y‰™™v©Ù™Åé**ZjúBzªºµÚZç +;K[k{‹›«»ËÛëû ,N^n~Žž®¾ÎÞîþ/?\ÄÖ”J¿ƒ¯?Èßß)ŸS¬@°à@ Fÿ:8ƒ D€`¨èðF‰)alÁ±#‰EFYÒä{dª~¹øÞì®7Ïîœÿ<ûîW ËT½÷£ÒñìïE¿Û|®eØq5`‚*H_s1ׄ“ÇvÜIˆ“acùµYx 6vM…Tqh‰€ € 6hR² %›R„U›O(b¸`{.vUãŽ1öUQ=͸TY@ùTSË­Èâ Lâd†Û-eFÄéqa“£ø# ySRÙ%EÚ©ž–O< e˜é¸ˆšú\‰e™fÂÑãœgÖ¨¤[‰¤ž~þ h ‚Jh¡†Šh¢Š.Êh£Ž> i¤’NJi¥–^Ši¦šnÊi§ž~ j¨¢ŽJj©¦žŠjªª®Êj«®¾ k¬²ÎJk­¶ÞŠk®ºîÊk¯¾Nþ l°ÂKl±Æ‹l²Ê.Ël³Î> m´ÒNKmµÖ^‹m¶ÚnËm·Þ~ n¸âŽKn¹æž‹nºê®Ën»î¾ o¼òÎKo½öÞ‹o¾úzš;c++-annotations-10.5.0/html/iostreams/ioclasses.gif0000644000175000017500000001434312635354026021125 0ustar frankfrankGIF89aXX‘ÀÀÀÿÿÿ!ù,XXÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·›€÷ ‹Çä²ùŒN—¹ì¶ûm æôºýŽÏë÷ü¾'8HXØ!÷—¨¸È¸h))‰Øhy‰ù÷8ÉÙé‰U™):š¹ùyŠšzJÚêêgª*;K÷z‹›[ËÛë[š+ìºûk|ŒL<Ì\šü ­°Ü\ÍX,­=Kmí ».®Úým®;ž®NyÞ¾ïVîîŽ-ŸÿD_~¯0`~ý¾ýˆ0á‚­T1b † ›=”ˆ1ã‰rÿ^ª}éwQ£È‘‡öt´xÒÉ•,CPd–²]È–4kNÓõ;b4ÉÙÉhžtÂè™i3)MjB‡0ÆçS¨S£Î±z©Ò­#9ËIQʘ&Ç’-ÊìUVg¡r}ûÖkV¶b›ö!³jÓ2€àúM*7¨`´`ùà­„•ðI¾Yÿ:nØ)âÅ“¥^ë43fªš{îªS¯Ñµ£ “Q\ëéÆŸ[K\¶µäÂeÒÞ vjXÚE]ûVø²¢0­¿‹K .qãÌ‘!Oþjyó齞_CÓP:õí²¬;Â^P;÷ñŸ¼C%ž¼zvçU®ÿË|{LéáÛ#¾¥ú÷ûoÿɯß5þ x €* Jaà-¡! :xW„2!…&]Èá<zÔaˆÿ}h‘ˆ&^‘!‰¬Èb)ª8T‹2îãp3޸ċ5º…cF¨dBId‚>©…‘H.)Ž’L>y”R¾6e• 9ie–´`©e—¨pée˜œ€)f™š‰f”i®é›nÆ÷fœµ)g.Ú‰gyyî9 |þI„Ÿ€úƒ „ªƒ¡ˆ.Zƒ¢Œ> ƒ£Nº‚¤”^j‚¥˜n꧞þøi¨Bh*j©Ê˜Šj¢©®«®Ê@ꫯÆ*+«´Öšê­¸šªë®¢öêë§ÀËé°Äbjì±”ÿ&«,¤Ì6Ëè³Ð"*í´„Vk- ØfËç¶Üæéí·v†+®œä–ûæ¹è²©îºi¶ë®™ðÆ+æ¼ôziï½Z櫯•üö;å¿C)ðÀö‰0‘‡©#)/¼ÔCÌRÃèQ¼¯Ägi±(o,RÇ΀°Æ$K)2}'£lòÊL¦|ÉÇ.Có~3¿ÜòÍ>Ö܈Ì: ij€?ïœóÐ3íˆÑ=" Ò82ȹ^05a,`ŠÏ™jwõZ³øR[6ŽêµÕ좮®ÒÝóõ‰aóœvÙ„öj›ÀÇBý _DPõß^O½I ‚S]xâ]#€¡‡;††‹‘÷#ÿ?ŽxÕ’N5ã›gøà‹wÞ,CvÉÔéG‘@9äšË½ùà°Kîyí 4žBëX3^¸ëu“<íˆÇzðYç}»ð{K›hª£ÃºÞ»Oƒ|ðÊoûôÔç.}öÕ'¿ýì¶[|,½‹_Ìùľ=×d•mK‡ï½úå×9ø™Ë?då—ç? Ý tö»þÖžÁ uQF÷¾w@åÝ}¤ßÖt×€BP|$àa‡=r+šYàl(& jï{škáøÌWÁ F/rúû o8;òÉ΃׳_ñD˜-^†4&äLß\òº Òw“#^?»ýáN†3„€ —(Åÿ¾.r„뢡è¿(~î‰Ó"HlvS˜Ä&¿sš'̨ÆÒ†7b£÷Üا¢áQD|{ÇݦÇ?r¨¤‰¹FCò1Š„"ëØÈA22’zäê(y!KB“Òd_8ÙÉI‚ò`¢å{<¹"S•-šÒ<5«Ù"gbSFÚÜ&Ø®éÍa‚™ál8Ë9Ès¢ÓBÝ\g:ÇéNq~€œñŒF;ëéHuâs•úD ær@Ïêôó7<Ä …Eüó`mÍAÆ ª ÿ¡qX(|îYœ4tÁ¢3D(GaõQõ`Ô7@ÒE/èшÎà¤m¨c®8º °´£½œàb:Æ,úÏ|7%ƒFêPŽb1¡4\ÃþtÊDžΧ(Mê1‡†Jõ©3P=ƒSѵª=í^T V£:p‹_•"SÖ³2žÌ©jNѪU³N£qMkAýfÓ¹u¯dM"_Ê‹«>Æ­K$j^ÑöW°Ö®9ìT‘úÔÅ2Ö­¦e/‹Ù_"1³œí¬gÕzЖ«}Eìa§TЩt³ªM­bkØÒÊ]j­^ýêØÇ–´­­©l_KÑÑâö·dCàJm»ÕáöV·pÿírQXàþS¸®•,kM®ö­Üìt¿›Üê2¶©Ö®bûÚëÒö¸B¥®nƒ ^Ô¾7¤óÌ­dáÞùn ëe/G‡^ëv·¹¼MïXŸëÝÓ–×¾AÀ.7iSó&Ø´¥•¯t÷ë wW€ †,eÚ_ÿ>4©¨E°YïK]8½+Ux×…„XÄ }1½ZVX…x%î„_¬E.òÞ1³ dçæ÷®zS²Ÿ4Ý™v ¿D^©‘!ÌãZ.¾–rQ¹|]ú&éÊmø0(Äœg“fFšAAf6´Ù s¦sœ¹Pg*äYÏwþÏ›éüg;CnŽÿš¿9htÚm}†Ö¢ÙèÒEZY–g¹*"LwHÓïTô¤÷öéõ…!UÖ2!ÁéLnÉÊøGªcø§ÏÊz~«`µL±–e…Îz×AäŽlÖ.ʵr™®—*<Út‡LÕ¯½Èg MÆ;´^ÇÁ-w9ÌÛp¸iO;ÓâN\ ë~;ÙÆc¡·õ®]*Ç×å>b¢ˆšnO™‡ÖóáWQï2àööAWhíêðàì6ä}‹Wo‰à~TÕ»;˜í.ÜxþBñBF;ä—\N•Ì\!ÿÍ‹N4m‘ìl’—œÜ2ß$ÍkžÊMãü“#ß9.{ÿîsÝççFÐc9ô½;Gÿù;tr4—ŸzÔSñèÐê[úÕ¿4u¡?Ýë]'zÙ•~vœ½@aoÛÚKbõ´ÃA°üWL].R›úãv‹ø-ßþƲô¬îIXRÖ–Á‡û]?€ïÄ‹Äžcjn§¢¼–õÞ‹¦ò‘¯zû˜’Õ|d/v‘£QÄÖZÌWêÆmœ_Áèq1”\WÄ ož²ܤñt¦×ýÌušæ…÷±ýðuÃË[¼†ÿöaÇû<ÚKOø¤?>PƒÆ¼_N>NtRŧŽ. ,!g:Ò^÷pé¶6 ¡ßîæóÄêOCû†hÄÿü‹_1å׿ùÑo6ç}à÷yÍsÔg}i€égcê•xdð'Aï§Lõä7GH€ã×{¤w~L!wþwBýg~¨q}zñ™qØ6‘x‘¯’Ñ‘(KXmóHós¡è6õ“ÊWQT¶wàØUl(;àõr{v1é“<‰hx#”á Œ,™„y7(â¡”éP”ÿ‰”Д바P© 0×&…•Ú’•C¹'SɕಕÏØ-aÙjII–·¦•T©–±v–×8–k)–]Ù–•êà•q –pY–iù•n)—z‰–l ˜~™—}I—f9˜‡É—xI˜xr—{)˜†ù”‘ɘŠI™Y™uò˜ù–’É~‹‰™¡Y˜™ù™—É™¢é˜s9™IšV„˜žéš yš³™š‰¹š ›góš­©›²Ù˜–Éš¨ œ¸É›Gi.ªYšÁI›Ã9šÂy›Í¹œÏY›¹iœq²™¿©™È›¦‰ÉIœÎéÐÙÛ©œãÙ›ÜÉœæé&×™žã¢çYI?)“ÒI—òcÿaŸ÷IŸy—ŸV‰  MP—.U* N0 À¡  J3úp Š Ê š#¡Jjz¡ª¡…‡¡š¡:¢"z%Z!š¢ j¢Ê¢µæ¡%º¢$ú¢ :£7ú„*Š£4 4(Ú£'£Íh£5ª£ø ¤;š£Fʤ?:¤Á£Jê£-š¤2Z¤AÚ¤Tú¤³µ¤Xê¥Z:¥V*¤aJ¤cz¤e £d ¥]*¥gš.š¥Hº¥v¥b§ÊT¥hê¤jÊ¥WÚ¦wú¦yº¦~j§_*§|J§lZ¨º§nÚ§f ¨š¦Žš¨„ª§Œ ¦”Z\–:¨š pj¨xÿ:§› ©¡Ú©“©•Zª˜º¨pП¯Zh«³ª~=F«òÉ©u«»ŠY~v¤—Ù¾ú«—ÂZoX‚¬¹PæS¬ÙA¬ÏÚJ]7Ò Ñj­[¬ÙêãÄ­Ýw¬ßêØš­ÍZ­âjäj­æÊ8èš®.®ìê5îê ʯ¹z®ôZ"ð*®òJ5ú "üú­þ*9»¯ÞÚ¯øÚ®; öš°Ôº° ˬê*­»¬âæ°«°ó*±+°Üj±ë±«±˱"«u[®û¯(›²$ ²,[°.‹‹*»®2{±Ò–±1k²-K³Ûh³‹³?Œû¬!K´ ³+ÿÛ³3›´#³´7Û´9ûl;Ë´dIµ¿fµR‹µOë1F[¬Hëµ1¶¿*¶cÛ3e;’ðé´h;nv¯Së¶Ð6OqÛµsû¶pW²w‹·M´G;´}ë·Q+´r+¸G¸ûg‚>Áx«¸¦±5Ãyõª¶øuؽà{t€<®üº‰H½Ü[ƒØÿ{9±½f1ˆã缈…Ç{{‰aÅGÀì«¿È'v\Yë ˆ‹(~hÀƒÁ<Áñ› À9¨¾ô‹¾Æ7Áç‡ÚªÀ‹{Á ‡Çwˆ¬{œˆìÂ-Œ`‹zCˆ…ÝPzèƒ ”…9÷¾û§%x½˜Ë½C„¿ïÄRøV˜‚c¡®ô{ÄùG…ŸGƒ4¼Äx·E\  yt$‚C¬½”1º3|G¬};˜Àz›ÃiÜ¿£ËÆØ—}™±ÃÓÊ·],½hÇIL„þ‹¹mìÁeÇ[Ŧ‚ü†¬ƒq,¾#\ÃzL‚lìÃ:¸Èhô}{,‡& Çí{ƹzÇjL¾Ž¬…Øÿ'ÀE辡 ÉìÉ[ŒÃP\Ê’ÜÈŸ<À(øÇMœÊœ÷‡T Ãò«Ã˜œÈï[Æ ô¸¦KÇšÑËŒìÈBø…°ŒÉŸû¸3œÇs'„›¼Èˆ ®¤ Ä?\D©<Å%„ÅU˜Æ«\ÌF\ÅÓÜQX½Ë ΪÌÇÐìǺ,Î~¹ÀRhÍSØÊÁlBیΠäÍæœÇ±l³̸ †ÇüÊEHˆ]ëÏ6øÀ œ¾Ö[ }ˆ Ðíˆ"ŒÆ¸\Éå›ÂÝÂ%LÍÃÔ|ÁÒ{X¼ÀÊ‹¼(Ð*½Íû›ÉãœÂ&| <Ó+}Â_ìÑr¼­ˆ}(}½ÍŠˆÓl´ÿüÂRÌÑÍ-͈» Ò =ÒüëÓ}Ò÷{Òb,Ӧ܈&ý…«Ëu¹[#ÅKºµk¶¥[ÖȪÌa«Ö‚ÀÒÖiMÖp=Èr-Ö‘8Çr×xÖk kl}¹´Ôjv»­‡[pšü°{Ø¿WÑ\{ØH‰ëÖu-Ù Ó{Ù—m¬Š­ÙŠÌÙÙ<ËØ¡ÝÎPiØ mÚ: ·‹½Ù«}ÚV“Ú= Û±=7³=ÕµMÑžMÚ¯]Ûs Øþضº ÜüHÛÄ×íèÛ°]Ü.iÙ«ÝÜc]ÚÐÜ•8ݦÝz½ÜÔý×ÆÛÈÝÝÎ}Ý¡ÝÊ­ÚàMÙt=Þœ]ÞÖ½ÝØ]Ý°¸Þ—ÿÝÞòýÞäßžøÖÌß«¸ßÜÞÁÍ|Y»#õ­ßÏ ßá-Ý÷ÍÞý-‹Žß¬Å«0‰³náÀd«Îk®á®0Q 5j¾â$5â»R⮑âu⸲âŸñâXÕâµãƒ5ã²Rã/u㳲㮒ãñã~äp1äqÑã¶rä«Rä\±ä[ÑäJñ䀑ä¹2å¨å6qå5‘åKQå¼Ò奲åñå¿2æ¡æSæÂ’æžræ+ááo«ç¾O,hužQ‚熦ç{nÀÒæ~ž;}.è&^d…nèwŽè6~è‹ã„î茮è‘NäNéBné—nä®é•ÿÎéÎä™êRþé£Nê“nê\^ê©®ê¨Îên.ê¯ë«.ë$èµŽå±Žë ®ë»Ž·îëhNëÁN%ÃN슚yÇnë½®ìÎ1ç²ÖìçÚÑ>ŠÓNí­hí×΋ٮí‚@à@ÛíØþÙáîí¸MîÂíç.gæ®îxÆîíž$ïï  ïóNgõnïz†ïùÎ ûÎïPðíJûïñžî?ÿµO𜌧ð ?Ϻ‹»"áð_ñVíÕUíÏö[Ô ÌîMh̼ѽÕ5-ÓЋñ÷¾ÇNÌÍOl¿þÇ̹,È-ïò ŃŒÊXÁ6Ïò8ð“\‚ß;Ï4ÿ­Ð‡Ìζ-ôOHôøçÅ4Î ¬ÎJóMßïåëÂ[ŸÑ­Ñv˜Ó¬õÓküÆLÝÔ$l½P]ÎR=ö Yðoÿ#þ.÷×E÷uopw÷ç¦÷{Ÿ(}ï÷ øo qOøyoø‡Ï÷‰¯øÏø/øù…?î“ø•où‹ù™ïø›Ïù‘ïùŸOù½-úá&ù¥ïÏí¨ÿF¬ß®2°Ïë²ÿë´_û¶_§¸/ªº¿ª¼¨¾ªÀÿû¨Ä?üÆÿŸÈ¿ûÊ"üÎïûÐÏûÒ¯ûÔûÖoûØOûÚ/ûÜûÞïúàÏúâúä_úæ/úèÿùêÏùìŸùîoùðÿ?ùòùôßøö¯øøøúOøS—ÛF9iµg½y÷ Å‘,Í31ЕmÝŽå™®íÛRñïý‰]™T.™Mç3s„N©U뛥Hµ]cóV_Ëk÷—³ÚsûŸ××õ}ÿ‹/°Ððgq‘±Ñ‘CñQr’R2²3S3ïrÓóT¬3”´Ô´iôTu•5±õ6V!€¶Öö7Ww—·××W6X-Àø9Yy™¹ÙùÚ9u˜º©8:[{›zÚ<œ»»Üüœù[|†>~[½½Þžä]^_™þþ †|üêóaBÿ 6‚•ßÔª[]ÅjkØX$qi£õµ™V±kûTÌeÖkKµléÚq÷%Þ’sëö}3PW²²yÛ`øØ­~ˆ Ÿ=›ÎodM€ß&|¸ò.ËŠ73Ö|RrhJwÓ‘{l¹ô鼂I£vìVtlG­×:IÙçƪ_c†,ø!ܵUû¾}»2fΫ{ƒþ<ÐpÔ«s›¶~¼tuíÍûA÷î‡òeåŒw¿xe+;c++-annotations-10.5.0/html/stl/0000755000175000017500000000000012635354026015240 5ustar frankfrankc++-annotations-10.5.0/html/stl/fig/0000755000175000017500000000000012635354026016005 5ustar frankfrankc++-annotations-10.5.0/html/stl/fig/heap.gif0000644000175000017500000000250212635354026017410 0ustar frankfrankGIF89ah´€ÿÿÿ!ù,h´ÿŒ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçôºýŽÏë÷ü6à(8HØw¨¢ˆØXÅøé8ù$ÙaI™™„¹Á©ù9ä™! ZÚ#ú§`È@jêŠCj éÙúj;Û@{Ë«“»€Ú+ló›P<ŒürlÐZ›ü,²<Ë ]­Bx HmÝ]âLî=¾H~î!.¡ŽÞ®jî_ÁA/ßnïO^èÿŸŸ@ûœPð B} ‚Hè0bˆR¬¨ð"Fƒÿ7 ìè À‘$Kš<‰2¥Ê•,·…Dr\Lo3»Õ´v³ZNh;ŸõLöYÐaC…íu”WÒ[Km5}õÔUT=-ýѬJˆ&<œ[uvåùÕgX c…–%zÖhZ¤k•ê’ÕL++¸ËÄêzÇÐf^fÚîêõ óÁT5Ǧqã ¸ï^¯‰ “{Xqb°%ãE™ïbÊ‘_fœy¢`È%û«* ËÒ˜œ˜j²ÝH¤/Õ&x»Sn ƒÓ€ìæ÷îQÃ1?#uºâŽ›ÁšÕ&ôÕS²> »#í¸#ò~|ñ|Èï1Oõe`õšÙ£ÏóOü;óíÔ9=¿~«\öûÿÿo]H\h`‚[h‚ :˜„Y0Øœ„XPh†óXx…†å(!ˆrh…‡‘øŠT˜¸Žÿýð¢1žâŒmár£ É’c ;òðãAúÒ# Cæp$,E*³¤ IÞð$1M¶e UÒp%ŽÙ¸¥Œ¬2š—õÄ&‚½&’뙦’eÖ"œ–…¦æ›õpYæbî%瞀õif‹y ©§ êÃf›P ('ê虉Òé&Ÿ:椟aúe§~Ö(§^J䣛•êé ¨Žªj–¶Z)©¬E*묢‚Z뢙¦Jë[àÄi(¬ºJÊë­¸}z졶ÿ!«³:[ ²Éöº¬´ÍZû,¶ÑR;­±×rû­·Ù‚;®¸ÛšÛ ´éj».¹ç®Z­»í¢[¡Œ5Ú»Œ÷Ò˜o,{!{í…ø Àÿ溢À¢‰°Á*Nq°oKqpGQ1rC‘ñsW"€%)òHFt 2“*;yrÈF¾¼r(.ÇÌBSõ¡ì"Ì,ÓÎþêL%ÐBøÌ„ÍB¯póÌ;/tD/a4Ï×´OÔL×LµQûJªßšýfÚõ 3v—c– Óp¸#˜]‡Ùn—=å†]n÷ÜÂΫ(ÞÑÄýÆÛvŸª6¥ïîýwxu£p½‰gˆÛtÀ)ί_jºiÞ®ÿ->ð\’‹=9åëÑyæ–Ÿêè|•.x{Îô´º©d‡~öÝ•Ïnë]¨×n:ëi§ßî¸ÿüç²kv;í—ûŽ8¢­g‡¼1Á¼ð¸/zîýyÍKoýó£B}ìÔëî:ïòm?ç÷éï|ùѯÿùò&Z|zÊ{νùÔ™_½æáC¾¹ùu}ö9Ürè>þaï|sƒß’—=½½On,Üx ¯*.| là hÁv}Ô ã8Bí¥°}4ÝMHA®°w3„ßàDè=Ž°…+ÏÖî—¯… lAÛ†Ä$*q‰Ll¢ŸÅ(JqŠT¬¢¯ˆÅ,jq‹\좿Æ0ŠqŒd,£ψÆ4Š¡;c++-annotations-10.5.0/html/threading/0000755000175000017500000000000012636511225016400 5ustar frankfrankc++-annotations-10.5.0/html/threading/time.gif0000644000175000017500000004461712636511225020041 0ustar frankfrankGIF89aL†÷                  "#$&!()+,-.036 ""))*+ 0033 #$""&&(())++ &!'=!0033%%%!&,#(/-????15>>@#D%B+U.A0W0_4%@4f8m;p=DDQQUUWWBBAAddffww@@%29C3:D8?JBBDDQQTTUU:AM:BN;COv@wAddffwwDM[FO]GP^ZZZooOKTcMWgR\mOo`]j|^j}dglkkk…HˆJN“P™SŸWª]»f¾hÌoÝxˆˆ™™ªª»»ÌÌÝÝîîÿÿŒŒwbo‚ft‰iwŒm{‘ˆˆ™™ªª»»u„›î‚ÿ‹ÌÌÎÎÝÝîîÿÿ‹‹ŠŠŠ€‘«Œžºž¢©©©©¸¸¸˜¬Ê˜­Ë£¹Ù¯ÆéÄÆÇæææ!ùÉ!ÿ ICCRGBG1012ÿ mntrRGB XYZ acspAPPLöÕÓ, descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desÿc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ ÿ„¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-ÿ8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ùÿ  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Úÿ*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+ÿ4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÿÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ ÿkÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·ÿh·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿ,L†þ$H° Áƒ*\È°¡Ã‡#JœH1™ÀŠ3jÜȱ£Ç CŠIRãÅ’(Sª\©ð$Ë—0cÊœI³¦Mƒ.oêÜù2'ÏŸ@ƒ J´¡Ï¢H“&<ª´©Ó§P£"d*µêMªV³jÝÊU$Ö®`G~ K¶¬Ù®c§¦=Kv-Û·pãò¼ ®Ý»wÚ•+×-ß¿€‡¤ë²nAÃzý ~ªx±ãÇ—&>\¸q䦖/kÞÜwiÎÌœ‡‚Mº´V¦ˆ§<¹—`êÕ¯];dÛukœ¶+·¬ø5aÔ·Õ ®Ú´ñão §·y^ʽ)cuN¼õmêØqþ†nñ·séѵþ‡ï>~5òóèÑzö\¹=÷ɶÁ/ Û·ûÜïÉLJ¯¿ýüˆ˜}-¥gàP)'œ|XoóÙ§Û~å=Hax¾]Èÿ‘÷ j†(¢hë-Ø¡… g”„2à†Ÿ È[m¾ᇒ¨ãŽ5)Û})2÷]DôÍø\…1æ6dw(æׇ?.‰TV©’Úù¢ƒ£È¢€P¸âu>¥F¦“2Ô¥•l¶ižZì¹ØdD~Éd~EŠ×àn´Á†$š{Îçæ „V„¥œarÉQ‘}♨™ÓéI#az–—¦ põqȦœvê駜R訃•ø#¢•nég„@6y§†þ‰&i’A¦ ¨¬ýÁõÇ.¼öêë¯Àö: ©Ävt¨—^˜§¥§þG¦–®. ©²2—%kb×®ÁvÛí°Å†‹Q™x]ëݹO ‰#Ÿ2>kX^å2ÙnµŒÖ«b¹G¦+]unëí¿¿‚+îÀD|iOtù ð¯¹Ä‹¯,qÓyeº.°~@<ñÇ9lqJØfì­.¹›HÇ‚ì2®"¯9na wK"*³ÌkÄ/,3‚ñÚôsQÜòšH ‡T± ,"0áG"ºH"N{ܳËC_mhÍ·À+ËOóZ,Fë¼ ÏZœuÚ­-TÑ]“ÝkزˆÐëÊV³-²þÞ2¹TѻȲ|3ÞeçÍ·¸~/Žé[€ó ºì6,LÜm6ÚŽÚxçÅA~÷ûPn9ι w"}(ºç¯_Y3æ‰Bz""øá°Uøˆ¤Ÿ;±ŸŸ«èÿ˹ñVo¼ó:Ež|ÀÌ }ì×Û$ýô-W?hö ƒOÓö WîíòÞï(¾ãëÏTEP¼?ñÃOõç/é»Ù>Hÿ K2ÀžÉÀ L ÈÀ:ðŒ 'HÁpQTºàN4²F ム¡GHšð„(L¡ WøAKppfû’l^e¢(eå…Bë_G<ÈÂúð‡þ@ "2\h•ïð ;üÊÖÈŠ‚Ãé#<¢§HE±ˆäª£¨¥¬j¦‰‹bÇHÆ1^±*“šÒžd”%yñ2`$˜ËHÇ:öðŒR1gÕFžæ‹OÜÈ‘! 2ˆáˆL¤"ÉÈF:ò‘Œ¤$Ù â1*z<ÞÏ´|¡ÌÈ ƒ€D˜ò”¨L¥*WÉÊVºò•°Œå)™` KƱNpÒ¤ªØ¨&O&”¡¬È(½Æ½bó˜Èœ[-[xKˆÜH Yäãl–H”fB„OȦ6·ÉÍnn³ Þ §8E Ãa&óœèL§¯ü°Ì!Zsšë‰&wèD«åÕb;KLÜ2—j³ÐÅ-˜ 7°-±[l}ÑÒᆰ¸ ;.1gqˆD,·¹Ì}nagÁàY¤Lp„3ÜÜÈF`{ qw«Bƒ¼°ñ®Ö™*:ØFR»Áô’µ»s[)âÇ]a™NÀ'vqpõÊ<¾z Æ]Ó-1WìÜŽÅ‚°Àš\åð €Yäøl^k±¯~\L·¥F9}̇‚R §ø½,KDw=;QkÙÅcªA`€Á8º¼B3þ‚׬`]ˆ@nòMéLT¯Ž˜hvseëØ7«w´ÿrr0Mbb%[ËKÝ2RcC{6e½h?Q|¾*ˆ5(¥.Ž:¹DìV¬»¦•:ßÞâ´³Ýט´@TnÓU8D§¯:8ßñªÔ¾´xÝ:eë™XÏê•ðšçfÒ"ËÎýloÝ_I—ÒAhxc*èAËÄ´vcÁ çÂÀûôY«P;?èÖÒÎ4ÎnAîcWÌÎþ/´£ýÓi³´ÚÖ¦H¯bWzWtÌ,³¿ÿÅmÝEßùn¶®2€#Cà 8°žpg.\â‘~é¤7ÌñŽ{üã ¹ÈþGNrW××÷=KÎò–s'%gNóšÛüæ8¿ Ê·âKôìû ð úþàW?ùé/èM ßû‚>¿¥}èùs¸§Nu’7A=‡ ‰¯Ì”7dUûÔ¯ÎÐ’Ñ$ÄÕìº×v±»ŒdÇL·žC8®Ý!m»Þ¥w¥Ðý¼yÇþX°Ãƒ çj­„è Ã0Û½3¼–¿I°„@ \ ÈX@Èa€”¿|ˆ•‰‹ˆ Ü“?yŠC9»Fù¾I ÇNé»LìªÄu¼O¬ÆRܨT|ÆÄÛŶ° ^ü¨ûÅ‹ËËŽÚÅil˽¼Æ”{µ[Ù»«j€ÞÛàÛÌ!ˆ•Fl¤ô+–NL«P|ÆS\ŹìÅÛ쨿ŒË¶`ÇÜÅžPÎßÌÁÉü1,Í,úÌJÍð|€ey–Yù¥×Œ—Ù<«á\ËìÍƼËÇܨã¬Î=Ì€°Û¬Ë ËÆuZχ*ÏIAÏM€{Ù—ü÷—¥Ü¢ûüˆ °ÿL¼ŠKÎìŵ`þmШ|ÐY¼Á¶PÁ&íÐÈŒ«O†Ÿq™ ï|ÑŽIÑHaÑ<ÔøÑx×ϱ À[ü¸ |ÀHí ¡€À¨ PlÆQk›À A`|ÁOÕSýÐíÜxN±ÓB½•>]@½ÖpMÔ_gÔ ë¸È{ד Ñpõj פØÖDñÖ~Ôr½˜t׈}×z ½Ö׃m†€=‚ýØ]Øˉٙ½ØêÁ×h¨”íB €Ã€”ÙB¾ Ú!8ÚH¤ÿWÚhÙ¹wØš}ÛµÊÙ\ÑØ8 ‹ÐÊ¡­¥؈” €¨ªëÛÀÍÚ`¥\šÇz:{þK±¯ì¯¶ÛØ=¹6½×i€´@ÍÌ-·œû“|ÚÜß Ï«MŠ±K€jɃ°¾Ô¤!$ ipßøßú½ßüÝßþýßà®ß’pÖäÙËÍÚí͈I`ÞYñ¶ ϪJ‘ .€ï”þGÛ£§¤KjZPµÜ+ˆŽ±þ7­¥ þ i”$þˆ{+®ëj®èJ¬X ­; “½ ¿Ú®ƒÀÐÈ ÜÇ );ââzÓ͈}¸”a°âr;..¯‚Hˆ¿Ðâ¯û§¯‘hã8N ‹êK€2N®ÒJ­‹ É꺦è®þG´ó-¦¾œ Žàþ7 Ÿ:‹µçþý7æsŒ€¿0¶z>´µÈ³h+³ðM͘ÃƱwè~›–|Zä?‘²xÞ+»ç­ìçTj€Ay«øéRꌃn‹¬¸èÆ0XÀèX³Õˈ¾ê4kè/Ûæ9ÚÑÃZÝG;çtn¼ÍâŸz ÝüGº¨nÏɚžâK¾Œ¾¶Z ³¾äìÛ”Î){ªÄ¾I •ÕHèÊ>Ý+é·Õ^ÍÄ>¸_»½ãíâ ³Ðþî}¨·8Nx¾þëeìâí¼ Ì»ÿgŠåŽ€´ÀÉ´ \Ð_«Št벋¸½/{¹$lðùüÙ¾Ûþ©¿}ÖØ»ú¬An€¯¢8\þ¾¸«±»}ÚkÂ^€¬º »ã¥´ðdxï!ù>vuÞÝÿç A.¿ŸÝ‡“`Ú(¶¬Ðé~y¾äÛò¯ ¬0༜+¶¦òíçm ®à¤D/€Å`ôH€Vß¾ ‰ôVïŒ_Oõ0üòøîs;ºæ‹óé›õ.ß:_=O?ßX;½˜î’8ÌŠ“°·êë”…Ÿ‡v ÷X¾‚“µèÃ8ÜÂ<Üö/Â[ËøÇnÚå €¯)K t‹Ä8Ü„‰Ï‡ç/9 ‹ßøHy’¨ùÔöHú¿îjÛîÿÃ0Kù ÙüÄ °£çM¼÷‘gµ»âòþ½É¬”S/ˆL 9ÎɨÏôROÈr žzДžL)ˆ\€ÉÖÊI@ Ä@ °¯@ÇßÏ­“ð튔´ noëüzª”LÉŠ†1c¾Â ‚ÂAA€ qŒH‹F„1ŒàÄŠ #³ð ,ùÂÃJ…Ã)Œ“àHYŠÄR1L±™º"éË,BÑ Ó—‰dM>…õi#dU­^ÅšUëV®]½~¶ª%©eÍžE›VíYkݾ…딋̙XxÒ•I+ID¤xçâXðàÀÅôüòWñâµ&ŒÖ½+Ø×@‚}éb!LpPfÎ=wþ.qÄ¥Œ§ŠEZõjÖcM¿†¶mlÚjÿÒý5ˆÖàI{7F’YlÒÅÏÅ?Ó4š.—ÚÍß:–™{·à‰ÇNð¯a“>0råKæš5OöíÝ¿‡_þ|úõíßw¿Ê*YçýÏö/ÀÛŒ -‰HÄñ ¹„ ºâB£Áè4,a0°?<Ã3;ïµô°¢CWd±E_„1Fg¤±ÆMqd?w”Gç1H!?sÐÇ%2Ið@üPD%é*Ñ´¯JÑF+¯Ä2ËqÔÑH/›ðKÓ–X©L3ÏD³L/9“–4ËtóM8åôþ%N9¡O=í¬“Î:£³?a²PCE4QEe´QGýp¦ÐÓªJ-/Å4S¹t-PÃô4®%® µTSOE•Ô0• .°HµT,\-UŠQI¥5VRgå"V)¸ø5XWƒýÕU`‹VŠP›ÓµYgŸ…¶Ù$¢¥¶ZkK¥mJ«,eRHÑ4ÜOÅq9E†¿eu]#h7®xÝ¥·^/çµ÷Am«âöF8à7àñ ssì4ßÚðUxaxV â†'¦.‰+6±RñÆTPXK8 ]u1þåþ¾˜-•_†Ù嘛Û™~Wä8FRHùÊ‘þîrf·Zš­‡_#ºh¥CMzé²jæ6•;ä ¸cRF.XQ> âç« æYES@â>(åŽÐVñª‘E•±Ë>;íµKY$ä ‚ˆSTq¸åFRˆ9î@âF„Óu:­¦#O†exM›œrÍýË|s¨Y\•œUÀàR>PñgKWåtOE9ˆ=çTüV%þ†]vÚEïXÕï âö¿uçS>>€Ôzs¨:_Úrê+—>{O¯üs]WqtSÅyáÃνü×;Ý€K)°¿c÷ó&¹ùòåŸ_|ý[4™ö¦'@£YsDàŽþ¸ç4ïѯ~b»Ôw¾Ep‚,]û&8StÐ Ë ý‚§:ÒÍ΃tà÷ú†7±=îd\`Ì.×–£¥,7\ÏÒ@Qgk^ìLa>ÕQnæà ûD¨ R n`JÛI† ŒÂ‰ItQùb'7ÂÐz1„Y Á¨CŽQh ¤bÜè¿ï‘dllø@¹,Pc*xÅ:âOE¼c÷ˆ3p‘n‹ô¢É¦Ø˜q‘tdÌÈÄN E*Èv‡ý‰î†ÓdÙ:y#$(ol˜DÅ%Áu "Xòc3%P©ÊÔujmk%äðÊR’¬‡x¸C!¹þ=éYï‘Œ„M$™=e¾l’=ƒf4©=cSŒËÄæвٔgFÓ››&5khÍFnÓœfi¦ÊºùMvb*œÌç#¯yNz>%([g;õy¥w3ž‹œg=ëyOŒåsŸQ?íå 4Ô¡…hDy/†FÔ¢Å(*Pž“ 3(BEê"…Ö †@iJUºR– hiLeSl´œ¥çG)V³1lÁ§?jP…:T¢Õ¨GEjRÊ bæ ¶€jT¥:UªÚ‚j¨jVµšU!Ø4™8Í©9kÖ²–Õ¬]y¡S·ºV¶®µ¡E-¸êU¤Õ£b=k^õºþWÈQì©ml`1ÑP€ ˜¨jWýzS»fS§+_%;Y®¤Õ^ lf¥úÖ¨v REC'¨ªØ‰q´±äÜfd)»ÚÕZÖ¤š…-T7aˆ¨ZRE FKמ›m˜jY;ܽº–^˜ªa Ú‚Â mx®\1QÚz"f°…uƒÐX`PÅ„j`Cx¹PÀm¥JÚ†™Ö·d®Â„K\ú–Õ¸î:o-jð]ó걶@ÃgmR¨z»‚\ q`[¼ Žª¾»^Þ2&¾ïů9UÀwØÃqˆE^¥Þä+/tàjþÀô§G}êU¿z x ¯_}ìe¯yªs~zñ »"4Ë'^ë›ïý /yσIè÷jƒ'”¿|æ7ßùχ~ô¥Ï]Ú;ÝöO?>2—®ýÝûܧ!é¥RyïcOûö|ñ·_VË[ÞK®~Ó¯Ÿ~ð×û÷¿˜Âÿôñpðy¿=ã›<š1÷¬·Š«ª‚¿ø+ºùó>ñ{ÀÑ+¿ÞÃ?ì¹¼ À”õ¾{)@\«Á*¬Ã¢ªd@ s@ò³? Ì?Ô?üû< <ô›ÀÇj?Ü*Ï­XK3Ã;ÁÆJAþ[ÁïkA"”À |¼Â+¿Í?%\Bü@¬*ÛÂ-Ý’þ*üAKÁÀàë>¾{BßÀþÛ=ÒûBóó<Ü£@”ªM¨PsC¹Ò.î ´P{®èj0x³û.7|³5“ªôºBÌBœrÀ{c¼§ûÀ8”­7L³Ó1[ð/¨ 0¨ªÑ  0HÄ„ãÃA̼ 0–Q$ÅR4ÅSDÅTTÅUdÅVtÅW4EÀ£{¹©³§(Ô*5{ª»1¹jƒ>ÃLxªZ0+K4%#Är’'aÆftFc‹Ñ»û"ýÃŬÒÅ#3'ëÝú¬8Û„ 3F6EÇ[ÆgDÇt\e‘ÆdªÆw„Çx”Çy¤Çz´Ç{ÄÇ{¬œkT@)ÛE2þó5èÚ,4€Ã=”ª8+ÇÆ;Gutȇ̌ht»»{GE”*OhPÃHPËF@›°A£Ä¸­L0[X4ªr4d̼†„È–tɈHmŠ;[´È¨F_»Éì TS5Vã4O3P³7Œª ˜0ãÁY[H¿cÉ—tJ‡ŒI°›ÉDÜG)Ü*`ó³aC²d·¦|ʯtƨŒ˜¼A«¬*h“¶äJmóJ°tË$Ë dÀ²4Kͽ» _‘IpÂøˆ·ÌÀˆË™K~¬K¶ºK¼HHŠ_XèËà‘_˜„À´L™L£«>º=TÔócÔTG}ÔèŒT4œTJeTK½ÔÔÌÔÚD:Q½9OýTË ÕMÏM5ÕSÌTUÕïÛ¿N5Ôbp……°UíRXÕãJmÕ—üKâ,ˆ0Í¿tFd]^Õ/ªT)¥L=ÖâÔÍ$)­Vñ`ljìÕ.$U˜ Ö¯ŒÐmÆÓ’%HTF ;EõJ”X„Çé@ŽÞ¼w…×é0NäDM™þ°×à¤xE bÕPi-V Å‹|͉™˜P,X_à‚w}ˆÝΚ€címu‹èVìÓÀ LÊþäBe¨¢Âä²B[`¯uM $6† ×—íNò4O•[À8Nb0OÝ„ÙnY ÍP‚0æ±³cdNPe6 Lþ¯ñRƒëÒÉíê®Nh °€XS® XäDƒ6øC~žÃîš0åb®Pc.ƒÖª‚F,L 54/3v.èÊÈgc®ˆn°_ügD›*A´fo=[©„˜àfßUZýŠŒ Zp\ó)®Ûˆw6†x»y¦g¨´ç²`æK2C€D4€Ä$Ó¯Ûª”ž*Pø«CC0Ã.ýâ/ˆjI¤êÍI°¾­çjµ?«ÿªD®Î®«î³H´…N¤ªW³…¸N–ÑZ±íݘ}[¾]‰ÎÐ0˜ ‰[½ìij¡þ:KÍUkNÀhì¢þá->á(Tj¬V³BÛ7C ®³€ƒ^jþJäê„Íîlª*í”êìH^lëZpíc í¹ž1!¨H·Ðæ—Þëb5ËÍ ›ö…œöÐaÀÚÅÕkI¶áÎxÎÀe Ø×aµØ¢ÎT_½ÇÓ–mÌ–² æ c©êÆK$´ðnk¸~DîVÀí^>3ë13À„%ƒ1ð„ql°*Ãê+«íÂ;eTvé#Ým¥-Þ­-™øO ¾Ý‹@Îß5îmÞWÅæ:OÅÛêh•YzžnÓHjúïÌ–-A,aÔjñž²ØÞߪ§í¨‚o×6¯Pˆmr„k7ƒ39Ó²ßS m>S.à” `Wà_c p—†E°ß»`Säìå>þ` Æßí â`ð­spæf ÎÛ¢†F1¹ð Çjó3 ø¯Z˜6%›0¯†ëŽä3?´0ó/góù¯7óHAÛê4—DO²“‹?wÆ@‘A¯º¶Ä݌М-OžµY'M’ ñŒ9µZ”EOÁþ0Y—å ˜ RqÖˆx= ­ýZð’R¯ìgVáhö6¬”D­dä#VC ‰'wªóJ€'Ø®]‰‘¥…¼ÞO¦ô[O«¥Ý"…ܽÆø ž5†aÚ!myø vf‚G7ƒ?øÐJK[ã$qøgœø¨óJr%Oî4ž†¶m÷0 é½†[rÆez¿öž÷!M(‘˜¿ä™çµ–êîs{ªrCºVamÇmdþy§óJ"XÌu伞‰Np¼HÎaÀÝíü‚î‘OâÍ}û¬ç Åõi!áz¸`æ÷c©°÷¶±§y´_ n¿Ôµo:¯dyx¿]ãý…þ$Þ!¥ ÚÝ]à Y= Ø$]Ò(}|pÎwˆþ®îãó???€¡Ý RíׂÈýW ƒ€ Ø „/˜ …·-!†^=˜!‡MX!ˆ¥]Ø!‰SmXb‰†¸ba#¢ø¢L'˜a ‘Øx#Žþ9ê¸#=úØ##Zd1$‘Ey$’I*¹$“YÔÁ†‘F•SZ‰Ä”TθåI°ô¥Œ\Š™Y¦˜y&šiª¹&›mºù&œnÞ1& yy§—uêÚªøù'  :(¡…z(¢†â±ç˜xÞÉ(¤™õ™(¥•Zz)¢‹Fº¥£›zÊ—˜Š:* ¨B ©jú)Š²úªW¡¦:k¥¦À­«ÂÊ¡«»úZ•¬´ {(¸Îªë¯>š,³7M:,´ƒ›k³.[-¶0K ©øÉ­·¦Py * x¨".®â"Aî¥ÜñA¼†‚ûm·ª¤r‡xaì)ý"!Êþºã–‹*¡Èf :ðà°Ã?1ŽnÞ Ó§‹…“p[~9æ™[®ÃÜ0Ö õÝ#î'ß‹ß\º¥7?M3š¨,Ž7Ô·5Œ+®¤…rƒÈT¹æ˜‡Ò{﵄JÛisÞ9ŠŸ'ºÞ¤ûÝþ·ó˜¢Kx̃zzãÒÊž–/a05V$ $79Lb·!œù%m€ ˜¤-7ò%kÊÞ®›?ôŒ÷_Êó^g,Q”BPøÓßQ‚=-``*šÆ<DZr>)ît‰ï]0ƒ¿°Ýi0¸ò½h^ð~76Plb}'TáØ:†²¡¡h£_ý:,QÀuªà¡ëÄES B‡SÅ)>€„~™KˆfB‚¹Šh.UÐKP@ôÓI¡D8ÈaŠ§ ¸x 'ñˆÚ«àO\1 r°'j4ÎuBB;¡Ä|fÛ„!z‡G¾md³(ÊŠ íx9äгFåCK!þ!Z—Šw,(H bI™`¹cƒˆ„&â C”¤Ä¤&#¦  ‹h±ÄR ¿ø$&ÑTn2!$ÄJxW¶KX fÈ#(ÌÐeïlÄ4¦!<3ØBšAh,Љ6X@›+Dƒ!‚ ?´a¢˜Ç¬&΀@š ‡‡Äò¨TˆaòL$·#É_@ ßë¥@r9Éï²”Æ(¨1jŒ N ¥„CÊ”bÀàÆ(,Ê…"lŽÊÓIìX¶sÚ¢5'f˜6’ÚÂÔliÚ††˜¶”š& d-Ö¹Ò<Ž /i ÍfÈwF(þž÷ôÓ)yTbmÏüÔ%BJ ñ T( e¨D«jŒîƒ¸dzÂQc°¢=‘0GÊÓM¤slž@3ÍÆR—Ž®5u+5;Cðµ<=Û\J6–’m¨DmQ—ªX|6µ«0€[ŠÕ¬þäªßÃ*V¹ ,X-ƒ:áh1ºpÖÑ~T¤ƒå©!ÚŠNOì”lv}íK=AÍpz¢¶ž€¡\ÿjWµžÍ‡ePb+\ ®G’J@)ú„LV¬kÄìe¿ÇUWPÕªkDÈ’ñÑ”¤õ´cc+ÙÞŠ[ÞÖõ¥°Å«-6¡>¸±tA8[lØÎßu¸öe,' Bä&t2þÃT3»ƒúbÀýentµÊÕb€ªÅÐèNÆj òõj"¦Ika .Sm-/ˆ«iS Œ³ìì_C¡Z²`¼¶0,}D„"иÆ6¾1Žs¬ãó¸Ç>îqS߆/ ¶£.Â0ØnÀ“SdW …ÉHÕ°Àäa,Ùv¿€A’a ‚ÀȾÔʆº[W ˜¡… ‚!–W³¥¯ÍÒÜ°4kPÛ l8hØ°-9M4œ˜ÎlªäCÁ’Í·1~t¤Œ¹±Ì±%æ#¦1÷æâÕ ….,¤C½)IOÚ(•V‰š3­j¸Á¯2üt£E-ë=‘:D;þòì™criôñµ×†pñú|Ýk`_Ƴ>ö‹j ¢[÷äÔÜž°ùJlhG{Úps4²³Ý!e—Ú'ÎæªÃnck»ÜZD·Éòí“Ô@î~7¼ã-ïyÓ»Þö¾7¾ã]só;C_àÀ.ð¼àøÂpð…3|àzè7Ä#þ0I¼â/Å/®ñ£'ãÿ8È›ãñ“¼ä±¹ÉS®rÍ |å.9^Zó™Ó¼*2¯9Îs“›ë¼ç>ïÎσ.tšð|èFÇyÑ®ô—'}éN7yÓŸ.õ‹ûe+QŸ:ÖÍ=Ú¬sæÛí:Ø]þõ°“½äc/;Ú‡ã±|³½ínþ;Üá <ýßH;ÞA„¿Š»ï~7Û¼DHöæ½ðšÙ;ðB±‰ ¦MñŒ?ŸãiÚ"^â)ñŽþléã#&Ü÷Ç~ã,çc¯Ä»òtýí1mW۳Ѕ24[~`¶¢Í ²?þWh¯6?æÞm» öK™i@š Ÿ¨þàåŠüígEù®ECÄiÎ<Ö¢ à4æwkP¼M¨ÿ®+T&3 Np~÷˜~q9¡)MjZ›Úä¦7É_8Ó[]ŽNi÷% Ux_ µ5±”8…û­_ûíÞIMJ™T  -ì•-tÂzÙÕ‡Á”LþÑ]ÝTIé”O]N›Áž¾ M0 (À둺î•]—[€å¥M-`B[‰ n™—¢—^õÚý=ŸÛ†Á Î~` Ô€ ‘Ôn1¡é™—j½•„ž'´!aˆày‰LÙÖm¹{yž-˜iÅaFaìMaOÁIaBöiaóñ :]Š5`Ûp â`ˆÙ•l¥×z•{]N|¹ T\öBPá!æÑ`ˆ…añp¢ûi‡™†µÁØ´^Åо”!jX‰’Š ‹Ÿ‰Lâæ1 ÆY ÕY ©× šªP0ÞYP½Yœ‰b U¡ÌP-Áþ5 a4ñÙ.1æÙžõÙŸ¹Y ;%ÜtîÑb$Ú¢áÙáßãùlZíyZñQ…$’cÍ™#:Îcæ´ZÚ¼ÚJ¹£M\AÃõ£?úãÀcËÈ#=ä9ŠãsØ„Ⱥ $¬¤AFd¸!¤MðÜBÞNíäFC:$«@¤D~$QdMXd[tO¡ÆFr¤§A¨¡K¾$LƤLÎ$MÖ¤MÞ$NJ“>ÖÄEήiUÕEJªä¦Œ„Q%R&¥RfÄNÒDOòD±‘PD¥º¥UvI2W%]R&õR'}R()™R1ð’*a+Á’,Ñ[äÚUÂà;¢D˜\KCô$?ùþ“?­‘@QB‰er=WDAT)5—@ å[^\v‰KS]"ÄS%„TUaFØs%ØVä„&\òÅU2<%-"*ßbÝÛ¾ àŠ[§ù_±(¦µmE®¬æn.çv®ç~®…rgäZ.é¾ æÊjÊÜãvÝè–®ë¢lã¢n™ÂÄêrä$îæ®îî.ïª!&Änµ†ÜÖµDíf] @ Êh Å ¯ò6oó&ïóF ¤LÇ\ŒÊT/öNoÅLïôVoÄd¯ÅhoøŽ¯ôZŒÄà€œÀ¼rœg¯ßvNñúJƒÊåûÎMü‚†D›þî/ÿö¯ÿþ¯¯¹èLÿŠ¤vÕoËÜïg´îë’ ($ÀmÚÂw"ðÂxÆüó‘þZå}L6µM‘ê`[0mhÕEÈÛ"žÏ–ŽMÀ|·¶T ›p³`°ïgJ<ȃ¬0ÙØÞ 9°´jœi$@ŸkÝ0ç' w c>„_ c‚HiË¢ð}l1Dñw.Ùêú *ÙœÀjóðC±XÝ «Ç€¤ð3DždqÕuñ‡ ŸlJkåb5MÓ¿Ž9ßþ ò5*Êתò*ÓšÍÚ0·±üFqS1Ñî%ƒI'kñwîñKت2­™±òÔ¹:an¥k²š ³:k ­ å´`]91&ÊÛ&¿DÛ1‹²¿ñJ²þ£2,ØP墡϶ÖÏ첫!,aÆ2,_r.3¨&¿FËG0ã11s³Ÿˆ)ÿ•ÈÏ2¯²¬ûy,ÂÖ–ÂV³wÝ26gó§ìr(ç3.S1lä±0oò/s3/Kl+¸¶”*ll;CóÈÞQÀÂÍÉZ2'Û³.s10á±Ó±8ç±Fo´w–sO¬]Õm3C{¬†I°‰ÙB,ZŽÕÒsE[4«t¦²‡)×@ø¡AëY@€ØÚS£4v­4~­6¢í&îÙ˜´Lß4M×ôbB5zˆ4Út0:‚ÂÌ™Ùä- ×sT3 xz1wXu 75¡ÑÙ>‡õžì~ðfð)ûÙ2æè/VÓã5Ï´[C \kÓYµ½n^Sõ^‹õŒüõY;_[v£ÌÈíö.dGvM¶Áb36—ôufàl6gw¶g6h‡¶h6i—¶gW¶eÏf¿Ój§¶€,]k»ögÄvýжl³lß6€.o÷¶oÿ6èÊF@;c++-annotations-10.5.0/html/threading/compile.gif0000644000175000017500000002543412635354026020532 0ustar frankfrankGIF89a '÷      #$ & !!!"""$$$%%%&&&'''!&,#(/((()))+++,,,---...%*1/5>000111222333555888;;;<<<===???:BNAAABBBFFFKKKLLLMMMNNNFO]GP^PPPRRRSSSVVVYYYZZZ\\\]]]___MWgR\m]j|bbbdddeeeiiikkkmmmrrrtttzzz{{{iwŒo~”p~•u„›………ˆˆˆŠŠŠ‹‹‹ŽŽŽ•••–––™™™€‘«Œžº¡¡¡£££¦¦¦©©©«««­­­±±±···¸¸¸¾¾¾˜¬Ê˜­Ë£¹Ù¯ÆéÇÇÇÌÌÌÍÍÍ×××ØØØÜÜÜæææèèèìììùùù!ù!ÿ ICCRGBG1012ÿ mntrRGB XYZ acspAPPLöÕÓ, descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desÿc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ ÿ„¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-ÿ8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ùÿ  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Úÿ*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+ÿ4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÿÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ ÿkÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·ÿh·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿ, 'þ! H° Áƒ*\È°¡Ã‡#JœH±¢Å‹ Ùȱ£Ç CŠI²¤É“(Sª\ÉòãŒ0cÊœI³¦Í›8s"ð¨§ÏŸ@ƒ J´¨Ñ£H“*]Ê´©Ó DtJJµªÕ«X'ò|ʵ«×¯`Ê5«Ù³hÓª]KpëØ·pãÊk´,Û»xóêÝ«Ð-Ý¿€ Fj—¯áÈçô;¸±ãÇp +žL¹²å3kÞÜTòåÏ C_@3çÓ¨S?ò,ºµë×0IË.ÈX¬"°ŠæÌQ­4‘nÞIYÃN¼xFÙÈ!Õ{FX@L˜Gú'úô£Âk׋¼»÷ïàÃþ‹O¾¼yñzž6º-ÔÐnæÒ¯=_þÐìÛó¯ "xå\Íq`ôÙWT’Õß‚xñÇàBÞµ¥ÔTˆÄ#nhgüsƇx„hðÞ#†pø!†üÔˆTœ±!Q†ÔXcO-ŠÁ„<H'¦¨‡hž‡D ¨$’Jö4fÄ`F‰D:ù#4ÚX_‚?á÷à˜R9H¦A³´\{[ÅÇ¡O6ÒH"fÄwFA"øH”†8Tnô¤'PÄ° <è#TP!hŒB,´§ú”ª«àZÔꪥe¤”1ÄÞ#¶F[‚ÒºE%†þ¤ç öšz†[»ânO¢N o|Ð9+ÆÖB»ë¿Üv»Z¸×4®eáù7±„KYd»÷6[¢[pèF?¹C±B%ë“ʈÞ6°³c+¬A.Ìp¶&û$ªÃGìsl¢™YîÅÇõ•”ï°ñ•Ü¾üñOJ û“"³6,£bôd#*öF̺‚­¬tzlU6´ÙR½(¾§~ûóÛ=P¹Ñ­fR&Ÿ!Æþ{Íèa z¨âß(B§cSC×?Í¡Á‡T0kºL\Ácz3Qs12¤Š‰\!Á„ >‡á*6’¥µfüADç†#î8ä’wë6ܸ·›Ý%7÷Ц97dœÜ“¦ò¬Ùéº~•°G¨ì§s •Öšúˆ^ý*XeÓà¶Å°¡L²Z[‘­8ÕŸ"TÀgS g¼Ÿp5–škO¥JV©Þg¨x-ê˜úÓ¤êk*¾¢‰: “וÜp!3á-\Çh >À&vXéJa »2&Øô+2 êd½z?Ë6]êªbµCâ5¡z}þ£RæÕ“^ÑìiNe •Á'¥áöW" ’ã€Ò½® åM·ÍVÉ”Æ!Þ.Õ'Š°Ð<›’ˆxNW(Å…+ønk3ïù–J‰ˆR(_3Å×í¨³cµe¶­0k=‰Ô?5 ˆ³±jz×ÕC¨Íj@y“}í[ÎÚ†l@Ž£g#æ€LŸ¸aQöÞ¢ „9l(ÿ5n€Á7`ž ÍÀ)u*}Ç{EóÞ$¶ â+»X„+lmu`ÚY7t=Á_DêŒ+[¹Åí欋Ñì<[; ô ;Æ•öfc_©±òIºz2åGTYR3Ê#TAiDª;‘µ¸½95UþšïZbKÄ|(^Ši+—â ë KŽ(%æ»#•ªHÈ@èBúЈN´¢ÍèF;úÑ~tFCaÐ….Ãp7çYŽ¥¸ndž ´gV¡’‹><5’F¸úÕ°Žµ¬gMëZÛúָε®wÍ$Øzdˆõ¦éhL¤èq¦raÄjó'ê£0p8|vþÔ –RÏ$‘ØbôZÍën{ûÛàw­}]ë=”AØh¢¢Cqhû1Ú“öuåbm™`{‘¨V5A¸-î~ûûßÿ&7­n"¦oÔL½crï8ªðƒû¸Ä'Nñ[ |Ö‡õ°Y‘8›EÅ ùSþ|ÃÑäúfuÅWÎò‰_\ÖõÆ¥hÊö¹;¿+¯a@.òž+…äÁyηÈȉñ»åHO:¯_똻zæHL¤ŸU­óÃðÜçX'ñ~<~£+ýë`—5ÓaCœ†R·9ÊG™õ¶{è©zE¼öº}춆ú)¹¨v9r+Ww»à{¶õ›ÐÝîˆg9Þk­w:\ß)¯Làßv¸óåð‰Ï¼ÄOëÆ£„kÿÌä)uËïóšO½¸9?kÏKqè 7åß­¢‘–Øþö¸Ï½îwÏ{¼D?¤Ñ@Ì®úâ÷›õ²†º›—Ï|œÈæØBŒOýn#ÿìÍϾöeþòät?ï¾øÇÝmåoÿüæ=x4(üðïuùÑO7ǹûÏ7@àðþøÃÿúW˜Wq`(°{à øj(sG%.°ü×€èjøtعg¨—â·Œ`~x‚Vd!(‚ÔÇzŠ€}(ƒ«4w,ˆœ(ƒ2¸ƒ)†+XƒªÇzdȃF؃ñƒ@¨y$h‚Gø„F¥‚KèM…VÈP>8…ñ‡|†°x…`H^Y¨…ãw}#Åa˜†N4†dX}U¨†pH1l؆ÆG‚‡xØAsH‡A¨k‰ïÕê7ˆ„Xˆ†xˆþ„Èi{ȇL¨k€†à„Û'vP‰–x‰˜˜‰š¸‰œØ‰žø‰ Š¢¨‰_`p‚ŒX‡»¶áÕ^P°‹²8‹´X‹¶x‹¸˜‹º¸‹¼Ø‹µh¦ø6¨˜Š}Èkw(¯è‹Ê¸ŒÌØŒÎØ‹ÀxŠñ8DRÖxؘڸÜØÞøàŽA°âÇÉøŒê¸ŽìØŽ³˜‡1{¸“Žîxø˜¸?Còèfö¨9îÈ>ãÿh^I ÙÊhƒ ‰W éy‘¿Œý8‘ !‘S‘’ ‘ã‘1h’à’"¹’I’á‚’Iþ>*É’4‰.I@1i„3Y“<¹Ž7¹A9©“ ©R°“¼¨J °Hvàvà?ðyˆX•Vy•X™•Z¹•\Ù•[9?–?pË(–Qù‹7p–¾(‚ðŽ7Œ_JÉw  •Ò”;h”ºø7€‹aùJP‹?Œ„à„ÐŽdy‹^p—¾ø“)¨—(È—¹˜·h™½8mI‹…™‚ –µØ˜x’ƒ” ˜j‰”^ ‹ù# aù±hJ•m ‹_`´©J0¯(P9›µùmp^àm–ˆ¹”R ¼™˜wp#pœm©š¬YI›?þ ‰™‹9ƒ¥ipçwš—y–^p‰Ù@–~ ‹qùŠ„0MÙéH#Ð… 7°™)q¹”òYôY— v  °˜–°8… Rp•x˜èYÙ˜_`ê)›Þ9• “áù‘똂 —±¨Q‰™R0…`Д„°™ØÉ¡…Ÿ· ‹Ù¢Žé¢0Ú–Á ‹Ù–_0—–ù£%z£jp›¢‰£ Ú¡§¢!š’#•m‹‰w‰™ÿY7^ £‚0²X¥²˜£.‹]ú¥@ª–<º”jà`¹¦°H¦³¸¤ š¶ø¥Qº*äi‹© £þ¢‰™‚‹j0p£Rp£@ê˜8šŒgŠ¨Šª¤lú¢Øy·Y¤g¹¥²h§˜y‹zŠH|Ú§gò§±8–LZwŽ*bŠ™çY£›‰¢-Š§.z¥fê˜1 ‹¶ú£ùÉ¢­Úšæy–­ê¨šªxš‘Ojªé¦}¨Š£·y¤8:˜5º¨w ‹w€­O ¤ ªª³8¦’º£Éè ú£öùŠmJ ŠbŠ£û ‹M ªËJ‹£ºW¥ê¬­… oé›±H° §ú–JД¬ê›°ImФ³x#Ó)•Ø¥J ÛŠ®?˜–o™ª Ûœ ›Uúšw@?þ7pZ± úp²N*Œ±¥Y°³<Û³>û³@´B;´D[´F{´H›°I‹è¯Ê°´ˆŸ¹x¥ój‹Tk‹WŠ÷:’Z’±)Ęz$8OÛ“¬Š¬ë¬+™¯o¶cK¶Ýf¶}‘}P‹¶·«2*’n›bp·™W¶g‹·îø¦ÔÉ’}+g ¸ˆ'¸®H¸ë“_[’!¶ŒkwŽ‹Œ‘»¹Í˜¸rV¹—Û¸sû*Ìw·œ‹·žÛ‹º`—¹u»|¦{º=™ºÀº¬v®;€±+»5I»Äd»·{w£û¸¼[¼¢:¹/ ¼Á›t¹ûº i¼Ð‹¯È‹“ÂD–þ»¼H×¼qcb»½é»Û±P³q½Ø«xë¹Þë½à CZ!û÷‚å»rÚKÝ›¾N9½4;Að¿7¿èW¿öËëë·‡ (ÀþFÀ;ñ¼l¼ L•²q€% }ìÀ«gkàj€°"\â1‰£xÂ(̉kÂ,Ü™XŠÛÇ¿WPÌÁlk(=€< ìçAû C^9ÄD¼•1\.äkÃ×m2°¿üÚ‘êöÄ‘ÄJ||ç[GÏꬑ'Å'U¼yW\E\¬m>4Æ AÅ_ nó+w}ºw*dÆ ÆiìmkÄPøDpÇs¼Ä¼F·Ä¶½þylÇV(Ç{¼ku !yÌw‰<„\ȹFÀ‚¼È ÙÈŽlqa¬;’œÉAÉ•L~} ÈÎË‘‘“œÜɳɤ“l¬ÉQʦk¨üÄ«ÌÊáʯ쀗ìpm¬>p&ɶ|Ëò÷É̯g£|‚¿|˱œÊmÜ‘ÇÜiÒ<ÍÔ\ÍÖ,Í•6iæÇY¬ÉÅüÌ´,zöÎ/ÎáL½Þ|Ϊ\7jhÎê\îœ~ñüÎç7ÏC5Ëô”ö [´—Ïò<}Ö<û<´7ÐW8EnüíKÎ}Çø¶jQLšþýq<Í*HE¤äÔ¤ôzC÷ÔPwhÐ0ÑÿÜqZ…-.HÓEõÕ¥©Ö1ÔZñf`-žo†vÒnMÅ”@ïSJ¥¤EE÷gSGÕu}×'FØMÑI=nLÒù–ÑT4ÖÍp†½½@vT÷¬‹-Òo<Ù‹qΣ,tÐE™ÍÔqÍÙGÝÎerN­Ë¢ýئ=uqÄÖ¨]½t=‘¬ÔImÓ¨Û÷еÝÙã¼|P*È+@|ÝÔÐÃBDtÜR †´þmÛÎ'‡º Ý’-ÝU“ÒØ-1žÛëóÜß}^©íÏÓ]ÞÞS­Þ”ëÞðM€61Ø߉,‘²Çim߯…ßb ¶?½ßï\Ü5—¿iÄ.àêœÛ nÖžûšÞü퀇É;hÇ«lA–m=§VÕ5¤ÑÎÎÕ­&:-ˆWÎEôÆ}ýá*®Ü§âÃÜ ® þ*š­n®ÈRÙ0NáhÑHø٭׎”ãZôÒ-Ýã>¾s3¾O­×饾ÚÕ>ÜÎ<ÐݾíwÞ츭W0-êâ®Ð÷lî•nÝé>ߧ>ÇÜàáÎÊõž÷nÞïîí?Þï'.Ïû~Þþ~ìžïsðú®Úà8;æ€nð ¿ÝæìçàLêÿ¡Ëîèñ6^ÄÿñV©Ðö<Ýïþì]ÍJX©î»žÖ‹^ò™ð¾þè.Ÿ¼ámÃóAÎñ/ÞéW¾ÞñoäÐ ô<(é—>áDÎe"é‘>ófœô' žµ õˆ^rî~ë«õôê1ŒÞ\?JC”}T”â¼ë ,7b¯óQ(@hÏ|c¥à>îfîöíórŸÎ=íä>ìb÷Ao×Xç¿|ŸðÑ>ø„/ćïÖ(æôúìÁæjtº>ò°•@Ž?ùaŸø(Úšt~[øíù^/Ë¢LÞŸ¿>µô,`®ÿú°û²?û´_û¶ïúÈ‘·¿û¼ßû¾¿õÜË£ÄÝ2~&-àÂÈÿ‰.@ÐÉþÿü'l¨s¸ÞÓÏ > »‚j€{½ÒO+Íè'ÔÚ†™ŸÙº‚Ð}ñj¿ßþYDå³îq£Þçf‘þ§  ±éûþðú $‚ D˜PáB† @âÆ)^ĘÑ"à vô’ B%MžD™RåJ–-MN`ÇåLš5m–´ RçNž=5JœèSèЊEšbЃG•>%ySêÔ”vPÅšueΧ]ŸZÈ¡CìX²eÍ–í( =r¸uû¶G\¸9ÞÞ­K¯Ý¼{÷¦E!rƒÞ¸sÄаV‚áº~Ã%|—±ä¾Žñn ˆ"†]Ãogôþ@a`Ãg»|Žlù±dÇ«]óÜÃ@T­µgJ±›*W¯½‡R9\øpâÅ‹:Ç€ÄÈ;7]útâsrˆÜBýPš"k`¢]üxòÑ·Pœ1g¼ž-~’ë¡"Ñ€˜òõíKÏA[÷~“„øÿw‰7ßÜ ¸û¦;c9dp:ëD:éôC¶Ö¯A ˃¢ê°/ø.÷6D1ºô°E[@320Eá²0À€mdpŽ ¬/ ¸€ xDR¸J¯>äÒРHùèK2Åü^Ä2KÝbœ±K‡jD’ @¬Ò¾Cã>C 240ËÔð¼‡rPþ¯¼4$ðACVÔ2PA¥âÒKCz“Çœè³<±C1>mPN‡>,Ž,˜@‚³J(O €ƒRû®4UUU*ôPW JÔÆ@Ê0U¼:® )»Zw=nÉKëOÂá„åu<@WµI/~@Ö¶V_=4ÖbM­ãG4§ÅÖ׆èÄvZTkSãqÅõBÜùâªfµzZ/¥íÎGs—WKj²ÞZµ­˜ ¹ã† ̵ͪ“îX—Pw†^}‘<Ó£4¦T[†¸¥¸Ñok³J¦B¬ú"7ƒK„Ù„mj—aÎň3Òµå2ïeh2e®rc­:&€KþRC )¤ðïc%–mã)&(© %L9à¼(׎£hãdVU†–eœ{´Vbb¿Þæ…ò%[Q³â¹/.É %ü{ºB&©r¥P7`¨ÕDŠì°C¼ Ñ[ë”Ræº7¯Ó®ïeŒ&†ø§Zj }̦›EðTk›ß¿ ¡øçìÁêæ¿’P{&«]!êfÀBL OLÊ e8õ”Ï‚‘ [F(wCñ´/!™ã¡vŽ·3 Âg%¹Á Šf‡;(/n¸á Âqƒ¿™Ä #xžhÀ·ÑЋ_ã ’ßq<’»ðÌ( þxkŒŽü¦¢?Ü yüñƒçÝÀ „¸Ã¼ …øgŠà&ð;Œ¡s^"Ù HB |‚RHF¡0ð†h¤ˆáX"m£4ŽDK–¤y“Ê+YXÞäi“6Det|§Ã\F§”b/…þ3ÄY³&⃡ʒÙIa”¥0ÛhÊ›538ª4f6§À…,Ó'ž´à.'gÍáL˜ol&1µ¹ÎÛqS!Þì 8#˜>z‘ó†ø¥ANiMl²S›¸k'ãiÏà<°žöÌgA‚™N ú“åš@y"ÏŠó";´¦9õYM~6Ô¡ÿtç;•BQøTlM(AZ+tö©Ÿ%D•9ÒàŒ :6Ž°tJ‹8=Íép,J‘‰µ¦?EªO•*£Þ3©A]ê!4Z|5ÕªO=êpU§rõªÃô(L‹)S†It'š‰AZÕºV¶¶Õ­ou«à:WºÒU'uÅk^Û*þW½ö®ñk`ç Á6%«XYHÖ…™5¤ qìc}YÉ…²DI¬bÁÇXw]¶²ž­lR@ÚŒ¶'™Õ¬â8 -Óº³µ¤íÉka‹ÙŠµ©=Ùj_UÛÜñv¶ñío9Ò¥Ûâv]ºuUpg*\)—¹q.EŠk\d!÷PÑíìs„]í „¸Ôͦu‡2ƒäÁd oA†ÌÀŽ€Â rG— ŽÈCzÏ«_ôæ0 Ýí wµ+`†|€jFp‚¼`7ØÁ†p„%<á‹×'=èÃ{5¼awØÃæ&ü‘Ç°Ä'f.†?¼b¸·D1RD,ÜþÇØÆI9D‹u¬c̯ÆÝý1láyc"«lÇG^q{[dŸ™´Cfr”µ$WyÃE¹®”K«å‹@™Ë_öŠŠ­leÈÖ0Ë`Öš+âd5£Ãs•_ü[&·Í]¾ó;Ùœg.S9ÎGĸ[>;dÏŸ-t¢‡òç#/Ba„t¤%=iJWÚÒ—ÆtK|hE9ÇŒÞñR4ÙéëfÚÔ§FµI½jˆÔ-.³—Y=kZךk®Ž3œ[¬dèrÚÖ¿v°‚_þ’÷½ñ…Â{É›lG´÷¾ù-ïzí'H@Ø×Æv¶µ½mnwÛÛßw¸Å½]_ÛÜ綬ѽnvì·Û(î~r¹á=ÏÌF¾é­çŽô[ÝKÙwÀ—LgüÝ߈¼ C†ÿDà/+À½ ƒO\ÓgŠ½«pˆC<ãéwÅAÞqÈR<áMaøȃbï#üß$‡9%òƒ[<æ2'ñÊ%>q}œç+·ÈQ"Bñ›}¸OxÐOÎó›ODég:Ð8t¢¼áFÇúšYÞr}ã›ã|vºÉqŽtG]“)ÿzÖÕÞnª{—ædŸzÔËÜëµ×Ýî:ÙúØ]÷ŸÏîw|à9’”W½ð{G9Î_.xÆð½F»¨Éî”­§ý·;c++-annotations-10.5.0/html/threading/sorting.gif0000644000175000017500000002020112635354026020552 0ustar frankfrankGIF89a ö      #$ &!!!"""$$$%%%'''!&,#(/)))+++,,,---%*1',4/5>111666===8?J:BNELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-ÿ8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ùÿ  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Úÿ*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+ÿ4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÿÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ ÿkÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·ÿh·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿ, þ€f‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢ž‹¥¥£ª«¬­®¯°±²³´®©‰·f¹µ¼½¾¿ÀÁÂ󦻅ÈÆÄÌÍÎÏÐÑÒœ¨ÆՂ׺¦¨É†ÈÓàáâãä培·ÖØØۇ˃ßæòóôõöÍñê„ñÚÞï÷ HÓ®TËÐqó毠Ç# D¯[¿ì’a”ȱ£Ç½(®K˜Q—»}Aª\ɲ¥Át·),©q¡Ë›8sêd•r§ÏŸ@ƒâê)´¨Ñ£+m"]Ê´©Ó§P£æä'µªÕ«µ¨båIt«× Z¿†j'¶¬Äj ­©…©ÔìX·þp¤©O-MDLÈØË·¯ß¿€ L¸°áÈeÖø‘Ô›ãòͽ½û÷›F~ ¼óݹÖßOm¶¶…²á‡{ðh qò•Foöå&Þmúñ'á%DàfHZ‚¤-8<Ó©'à„$nR!…j¨âŠšq8š‡x¥%£}Ü´Uâ•œhÉu,ö¸¢‹¢Áˆã-ñèã‘þšD6ù‘‘HFéž’ 1éä•A)å–ÙQù™•X† Z)ri&p^z¦˜lÒSM9@AÆ™tþ–fgk¶©g9hP@EtQç ¢ÝÉYž{&êZŒ6êè£F iFÌI襛º¢ŠvºÜd¨4À GŠé©-‚FƬ¶º…ŽyÚi¬æ¡2–¢ª«’cáë¯Fä é°:Ê­¯ÔX¦®—jª§É{#²Ñ-Ëì Î–í)Ò–H­yÖ^Kg¶ÛòÖ-‰ß¢¥¸„’›îIçJø®-á²Ë¥»™Ì/VúòT¯½Râ Ù¾ûõ»ÊºŸ)0…ì  ßë]¾ þ—g°*GðÄWüÜÅ£d¬1’ ïè1t ‹"òÈ>–œãÉ?ü/Ë?rÌðŒÂìUÊcÍL³†.O"éG!ˆðÂÑH'­ôÒL7íôÓPG-õÔT3AA<ƒ²òÏ*-ô£ ¥pEd—möÙh§­öÚl·íöÛpǶXË̵ÄÇ<£Œ‰-÷߀.øàrÓMPÖç$áêâŒ7îøãG.ùä”WÞ¸ –ÃJ1JÊ ÎŒß„‡.ú褣mø@ž“Bìꬷîúë°Ã®ÉF6Ö”:- —®ûî¼·}úD:g…ËG¹÷nüñºÿÐíÁ;’ºÒüôÔ®ü˜Íc ó›H_ý÷þà«}ý=Ügoîöźâ}øì‡?¾=å›WH郲~ûøOÿ~=ñËÏÐ/õëÄýòG@ÞíÏMþKÖÃjg¿±ðÇ;à<ú—Àð€ƒy„ 'AyPб ¡GHšphã@‹¸ÁŠ®ƒæø E*Ã~epzWB Ç0m_Ðaþ`ȧèÐp‚¼¡àšƒ H MPx€À]AB"ªˆ?"’C†û8âD8%® ÀÙ„Eñqp1hãÚ®ðFöy1…F#êˆbÆ¿Å`‡dk‚MWG¹Å±mtbÝÌ£Ç,]£†TÚz(¨Q¸‚ bþÀ0”­‡<èdÙ4iH ‹S”@ 7I¶D’ ”¢ b ÀÀ@–îŽâ£Ù7Þ1ðe„ Oþq˜ ÂÐH„5ÚÀ“¬ ^ð²ò T$^HWVš;Ä&xÀ„ì—áÐå§xÙËÞ5aØÀÃðDQšQÄdÙ8IOT3 tü$pÏ0™ûìfëùÏ€"Ó“\¤ºØÙHŽ *@›PH„Zs‡ý£H±ÀQ³TŸmeC*Ò\²£¤CçóHшXn¾Œ*·HÈ„†§gC©5Û(Ôc´Š@ *LG'Ói¨ÓA5}ˆ „9þº: A•X°§R}šUaÒQC]ãšÈ®ö´wM•ÆSie‚¶®Àom+\åêVºÖ•®qÅ«\óº×¾ò•¯sÕë]k×¾–°=laWÐÂ:°f¹éÛQ0¤ 1PAC=jP@ª ˜­T£^àÉ/h L€Á …’í³½ÂK—Öh¬ÕF¸Û–ȵ‚²HÖmNücä†à³Ê„'~* 4³¸ÀÄ¢'± œV›e¨À¹W¨® jÜÌ  áÀx#z8š."·º¹\à[ªŽ½` j6þž-¿kÛï÷j Û6¾ñ=Ò|ëëÂþŽÀÏ00#œà-X,¿u°ƒ!ü0÷*‚®Ùqz‹aûjøÄkã0><œ‡h«¡o‰QLc·©˜~ï‹-c×øÇs“¨¼c]ø+roLŒ¸È"žŒ‘lb%£˜É“a1"\ åÙ+I¶r…l‹F ]†ñq¦ æ*‹yÃdnE¬Ja‚R¥Ù@_ÞJ˜ßì¾8óÄ@\ݹ=¼õ1ŸkŒea¬•X°À›ð€ÈàÐ]êñŒÍh?Ã]`TFL#HÓTæt§ÛÛŒˆªƒ.t®L-/A¸Æµ ^=ÂìYÕúó4P€:þ›ŠÖ™ñæt2‚f;ûÙÐŽ¶´§MíjC[H€µ·Íín{{‰ lîä™O• Y¼å .—ûÔk^¶žôÁîf¸ûݵ^ ‰o6oz§'ÿ&2¾·sn¡íI$Î!OÀ'ñˆoüâùÅWÞñ’w<ã-ÏyÌsžò}è;Ïù x¾ñŠ§üìŒE«Á#°æ=Ÿ÷´`û6¹þ,´w;¢>¡Û¿½÷Òò½¢„nÛË%%Ы ñQ7äQ â—¼é|‡|CÒ§áò átDgÑ—ÉÖy¨l*9:ÿŠ#ü}ãç5»L¸ùY¿q«Ü¾2P}ÿ?®¯þ,~öÜ·n÷¡Ñöçqµ'uì÷~a„ðw¼p øõÖ}ßç "Boù×þGYW!|Ó|S—|QÁ¹„cGç<ú‚ç@vÕþ'xø0/0CE¢‚ÈKé#€óÓ‚,˜ƒ: CÈ/ßâƒÙà2±IX#kq(ø¹WìD- ø í—uA#L!3…TX…Ç@h‚ä—\˜^¨2`„mh;#â€#˜úG†ÕÑ|o E„lè^Þgd"ºa‡òw0y(vfÑ?é¶Ø ¨…í'ˆÔwˆc(7x>êr‚Ow¡‰ÑlA‚xH‰Ñò—ˆ‰Z3Sk˜Š¤è<–(g!C|Wf­Xvô÷…j…RX‹p7…{؇¼ˆŠ¾(¿ˆ#ÅŒ ˆŒÇ¨=z´ŒèbΈÑ8}ê6¾pŠ¤€ŒÂèrþÖxƒ×£n¶1QÉòÚ8<ó7Žähfh‚3aòŽ¢ˆ1çøƒ€çd˜ø‡i~á! ¸‹õØ€÷ÈŒÉ!ëäû§B‹ÙqW ­g'Ø€P¨X~¬Ø«({ HˆhˆX† Œ UFŽçÐ ûÈgˆpŠX’é(ƒä7ÂñX‚ô“&IŒ¹7“1s@yu 1”(”Ea”#©‘JéMÙ“ù”ðC„M)•NÙ-7‡ÜÇ“VùzDè]YaéAÏÈ•@g[e “c /[Ij)“N•–%¹–K)ŽrÁ“P™t™/ทه— é„5'ÔÞù½†•ŠéœÉ™›Ø9žQiœ3(˜œižyiõ¨ž¦Øœ‡(Ÿ×¹~å©ö¹f˜îi|øÉžÿùšc º9 ð¹G|( Šƒ»GŸ Ú– ™Ÿ¤8–û™‘ ZŸ7q¡4I¡yÈ¡WéŸoXšlB¢ˆ(¢m¢cbrÖ¨¢þêס/Šu1Š¢3  Âc£7Š–ª£QÕ›.j"‘GlT¤Fz¤Hš¤Jº¤LŠ¤=P¤P¤;ФTZ¥Vš¤T¤‹b AšŒ†0H(Æó¤JaÀå`t´(: \Ú£¦'VOKªTKµAiú5sHŒÆi¢j¥eŠ§'†°`4–§/±¦§ž~j[êô-‚ªa= h0É´¨$;*¡ ù¦Jv*ÿtbŒš‰ŽÚ %Ъ­Ú®êª°«±:«´*«¸Z¶ª«·Ê«»š«½:« PÃJ«°Z ¿ú«½úª¹º«Åú¬´ ÐJ¬ÅJ¬­Z­þÀz«°ª¬hÓ*­Ö«à®Øª¬¼Š­äz­ÑÊ«Ëj®`®­Ú‘P©Vª¥@¦(–ªŽ†pR0°;°[°{°›° [°E@ +卿;±{°§%P±»±k°%@©V¨`NœêT±aÛ±*»² ”`)˲2;³ëwˆ±4›³4Û «d©p¦¦¯T,þª³H»².; ›´N»±›8û´T+±;¯Vö¯öcDK>P˜ 1[µbk°Að²a;¶h°6{S›¶n °W ôªa„ª¨5ÖµkZ°IpRÀo[þµeË´g¸Uµ7k¸o·¢je—ÚLw–GË·E0I ˜›¹š»¹œÛ¹žû¹‹´ƒ+ 0[°^º¨›ºªë:»¶†Ð¶§«º²;»™ËºN˸Ž0·ùƒ^jãþĵ’[¸n6=V º[¸SP@Q ³ˆË¶›¼4O‹» »oÃ-eDà_€³Eót6Þ ¼E"¼T¼:;º‘д ½ù#½9뺅жQP@î›´<‹µ¢ÃQcƒߎm``p^ÚÔ_7à¿h¼;¼Èc¾9‹¾ ¾˾øS¿3Û¼¯û¼ô;½=:tä@õô½nó¶t6"¼hx›·ä›? þL³üŒÁÑÛºŽÐ¶Ü>¬³ÔËÖû6\6´Ä¥TZ:DK.õ§%_ Ka€)0\JÌįd•V²tµôLŸd¡DijTKºsÂg‘Âø³Â3Û€†¼œ³¿0ܾŒ¿œIdóÁaÐZd³Y$NäÄØôNp`ðK°P=È‚ü@ELž„Fjô—*ËtJÎNôt©}ÆL° |ŸÌ²¡Ì£\°5Ì>7̲þðK4¼ÆI›Ã‹°ÃnCG­%]eL HB5L#ìMé¼RªU6(ÌaÀR#ÅYš<¾ \¾Æ; ϼ¾Ø\Á§°Ñ>Ó¼³®£-%R ÌÃtT*E³lUë¼FZ§úÎcµCIe6ç\:ÇܘÉÌ>˼²Í¼ûÁý,³Õ<×\ÊÙ, ÜŒH ]6YV­Ñλ\EYUP= bÅU1íÎwJ8->!­²#­%Ê6̼ÿ ° >=³%àÒ¬ÔG¥]* Ëô,>}Ëk9mM6@6uOð|Ç P³eÌ›<°lçr>çt^çv~çxžçz¾çvΔpÎç‚î: ƒ~èˆ^çàèŽþè~çÝJØkÎæY©ŸZ/]éÇÓæýÑ¥ŸºéœÞ;žž~ žé„ ê£܈³ª¨Žª¾êÝ/9þêq벞ÕÇ ¶¸žës#³Øë$ÒWpìÈžìʾìÌÞìÎþìÈÐíÒ>íÔÎì[ĉgHì%’ÜÞíÞþíàîâ>îä^îæ~îèžîã®íìÞîîþîðïò>ïô^ïö~ïøžïÁwêúÃŽí.Øï7úµ1)’ µž.˜~ð`Hs¨1Ꭰ¡ÈðúYíè’¯‘ñL¸ñoñ¾H_˜_ûïùñ Ÿ¢ë&€y,¯B.Ïï)™!iòù€PÉ3Œbóù)´ô;_‹S˜ØòÙ‰9ô)š˜þÑó8™“¤;c++-annotations-10.5.0/html/classtemplates/0000755000175000017500000000000012635354026017462 5ustar frankfrankc++-annotations-10.5.0/html/classtemplates/notfn.gif0000644000175000017500000002443412635354026021304 0ustar frankfrankGIF89aÎëö    """%%)""-3.316 !!!###&&&'&'#(/+*+,,,---///%33/5>(88-??000434555777;;;=D=DLULUNWNW1DD:BN=UU>WW[f\fjwkwp}@@@AAAGGGFO]PPPRRR^^^R\mIff]j|Uww```jijpppuuuvvvyˆzˆiwŒ„“ˆ™‰™Ÿ—ª™ª›¯¯¦»¨»bˆˆgu„›j““n™™u¢¢zªª}¯¯¶Ì·ÌÅÝÆÝÔîÖîãÿåÿ€€€™™™€‘«Œžº†»»   ¥¤¥°°°»»»˜¬Ê£¹Ù’ÌÌ”ÎΟÝݯÆé«îî·ÿÿÀÀÀÐÐÐáàáððð!ù!ÿ ICCRGBG1012ÿ mntrRGB XYZ acspAPPLöÕÓ, descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desÿc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ ÿ„¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-ÿ8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ùÿ  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Úÿ*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+ÿ4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÿÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ ÿkÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·ÿh·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿ,Îëþ€I‚ƒ„…†IH‰Š‹ŒŽ‡’†•ƒ–™š“‚› ¡¢š˜£¦§¨©ª«¬¡¥Ž‚GGF³¶µ¶´¹»¼½¾¿Àº¹¸·ÁÆÇÈÉʳÄÌ»ÍËÑÒÓÔÕÖ×ØÙÚÛÆ~àáâãäåæçèéêëìíîïðñòóôõö÷øùúû÷;ßü H° Áƒ*èo¡Ã‡#JœH±bDÿ,jÜȱ£Ç éa I²¤É“(Sâk¨²¥Ë—0cN)³¦Í›8sªc©³§ÏŸ@Aò J´¨Ñ£‡"]Ê´©SrJŸJJ5gÔªX³j%yµ£š8`ÊK¶¬Ù³hÓª5ûf«Û·þâºrŒƒ§®Ý»xóêÝË·¯ß¿{ãÀ¼UîFº€+^̸¯`©Öˆ¸±å˘ó>ŽÌ¹éd‹•3Û¥DFѨõnîÌÚè犡ñA»öˆÓ|GÌ ’%µo»«[ ÿùšbì»·ñ°P7¾YF¤¦3ç7ðá؉g yÜ.“ºËÁWß;;5“ ÖëÏÎ^fñ‰Ýñ†÷þ€Žü Fò=›ÒqÑA=Àwx´!Ciû%ð€~ ŽÐƒ„öý7 ‘ØzíuØÒ{Åw×|u1Q_^å5‡žrÒáDö•GÇß…!3jˆ‡ 24÷Ômèá/‘ˆv‘þØWŠ.®ÈF‹)†‡!^7N 1¶¨‡Dv)Ôv !y%`Lá$”-†Çd]7ÁÜ•Ï­ —^Ö¹‘‘‰©Ü›~•¹bhŽi¥]Uò¹\urþE§ŒN„çCz*ÉFöɦeŠLº'Ž ôP—}7Òq`]6§¥¦ªÑ£‰ù2Œ7ã%Ùuµ‘@ øßsÈzm<ð`Aä÷]1a…·®ˆªªÔJÄêBzfVkz–-Zí·]«P¶Ü–«(¸è*$nBäšë®jéÆkкµûî½êÉ«/C`~d/¾ïz»ïÀðÐ{п›+0Á ¯c°A'Ìí þWlÎÃE,ZÏIœ¯Å »ƒ1Ao¬eòÉgœqòÊj…ì²ÃýfÖË4¯3V3׬³µ7W•óÎ@/4rN?mô¼=SUôÑL'•ôTK7-u>CãõÔXÓSõMWgíõ;[ÛÔõ×dïô´Tc—­v9a×”öÚpƒÓ¶LoǽöÜ1ÕmwÙx»äC`õQÄÞ„Ë}vSE˜&Q8á}·ô† ˜ Å7¹J}è`D&d¾÷æ*éÇ>ˆn7é)j¨7ë(íÁƒ |È7í(… î»žÜ¿KLŽ_'ëG”!ýôÔWoýõØg¯}öPL±ý÷þà[GóÎw }ø觯þúìg?~ù^žßþüô×?ÿûð)¿ýü÷ï?õøËŸ‡ö÷¿ê}¡ˆ‚ö¢Pé0Ü^œ€½ °=Œ`ÆP2Dá ÙkÆ°Á~PƒÙƒV@ÂêYð‚ÙÉ úÆÐ@í9aÛÃA ¦wÃþÑP}8ÀøÈG¸=° e¾À\MdX~„Õ«ËÄí݇lâË€€0LXÜ ¥WÃ&jÑzU¨á nÅ-š± $ Z8½JpG,‹òŽàøñ€ ¤  HàˆL¤"ÉÈF:ò‘l$‰’Á*T5X„þè@_P °N¢±XÁ .™ÉM’Ó³d*oàO–! +€¥%1©IS~J¸ADIJ!þò“ ´ä jàÊ2@ ŒÒ³cž¼ÉjZóšØÌf"-GÈnz{,ÙXÎ ¤ÈŒÒs¤7(Š\µwE顳 ê”Þ ©WOéÝ€“U€%±˜Ï " _è¢<ÙéN{vŠáKéÂI>¤G8$ó®‘G“&å< ½Œh²¤‘z÷ h:ÚD|a¡ôÄbJzO†q¯´'UŠO–J¦N`é\:ÐêQ€]ˆ ‰%º ¤IÕŽ=t°þQc  Š_Ü)M} €*À4{ýœ©NùyÓyòT¬T„€Q牮6°ŸÓ;j£z>`D}øTÍ)0à[÷Î1s¢†oÚüæ8ϹÎwÎóžûü›p€p‚„àçH÷ùÇã!.5jðqªžm‚üÒXϺַÎõ²ˆìºØÁ2âyˆ«ˆTyª<~Y˜áíp»ÜçN÷ºÛýîxÏ»Þ÷Î÷¾ûþ]ï6˜¬À‚¿þðsW±È$aÑæîRÌ—›·#þò˜Ï¼æ7Ÿy)(à¼8à¼èë®øv¬ë ê=JÏ?z£6úØ9¥8:Tš‘LIÈw{êY–‹h`ÐŒ÷Ÿ}X¦¿H…Y‰¡§9w) dš¦¡ç¥B¸ˆ ª•„x{j©§ýY˜d™¡™' sJ–|z§x‡¦~Ú¦u¨t£qñš=êD`¤£xŠ;‚=:£@úÇ™œEʉe(’™:£NÚPŠ£KêØ9©X©3Ú—ªã©Èqç„6Жqš‹gÚ«‰úv.`o—ÇXwoš¦» wIh«$*Œ[woÙ§Ê …`à¡£'¨þÒ wÑj¨w‡¨ÓºwŒšx)£‘Z£” /«˜©åZƒBP’DÚªFê$Ù’˜LOšª)i¥°ºŽþ:Š/8ªz ²Ø³úzx:w8”è­Þš­f@…‰h8`Š*wÇê§Éʦ{ %úvfúŸÑŠ­;™rú±Û²Ýê«ßªw Zf©QÚ‚:©Éꚯ¼Y³,˜Ùˆ›òª’3 [pƒ xóÚ¤ÖÈŠšz£y°Bƒ¹¹ŽQ;Ž9ûªˆ®³È¥¶˜§Y­ù ±.+±d),`«y¨Š¬"›²`+wÜŸ„º¬)ûv ±ˆ‡­q+„IÈ­ŸYþ¶«·ÎúŸvç¨á€"àH AY’‰´DБ"‰’‹k‹ë«¥+¸” CÚw°”!²˜Àu°"0“»¨«¹3à¸ØŽ©Š“;œu¹1@”‹›‘N+ž^[žŒX­_ÚVɱ&[ h)L¸…‰¼oW­;¸ k¼`ÐVk{z  ˜w»ž‡wO€»w¾ù©¾o÷.½ {²ß[ áK¢k+½oû«yw¾½ø¢ãúšéÀœ‚»‹´I;À+˜¡Øµ±€æ‰où€mÅ.À‡ ’è–9`n‰Álì–jÛ–ÅH—8¬Ù¿þûÁ+j‡tÁpÁl#ÃÉ‹Ì`8ÌK0ʱQù€3\ÃÅØŸýÛVê©Ä û¥m)™+,ÂtiÃ*Ä:\½=ü¥kÉÂE<ÅG|wˆ¹wˆk8å‰|Æg<‡‹Æ,˜Š¤»¥ ,ÒGèÛ 1ëwd Â³w¿€W¾Bwý›Ä„{w|,}OzLzÿ[Æ×褎ì¤ñÊ£ Él\É–œ°‘‡ÊLJLx{ðÛˆ7ÅšwdÀ… ÊÂx•§¬È3ËÈ­8É”¬‚°l¯–\ËŒÉm'ÇÌG0‰V ,0ʨüw¸wV¹ÊÃlb€Ì¬,2jËÐÍÑŒËþ¡ÉÊç„AôŒ•ÜÌ̓œÌQØÍÝüÍp'ÎÞlxc|,ÍìÜη<¼àÏò<ÌéüÌî|Ïø,†Ô\Ö<ÏþüÏÌWÏë<†]àD`ÀoxœNzŠhlМ϶¼ÏV§Ë]ÑM{íÊ*¸ãhÐÛ(’¤H›‘,À ÑÐ,ÑÑϽÒ,}xh¥Ø-éB@B†Ì©¹é7^pÓSkÐ ]Ó5]‚'ø…WP¹ ¨Ó&]Ë( bmR¢-]ÕV}¸‹ ÓÓ¨w`žH›I©ª[ËÓzŽuÀ¡HH{“ž(ÓçX‡ -‚ÌÙÔlüÔ‘‡`†{Õ|mþÕ/=hŠc½Ó¹©´bÖè¸W@{ÞIØ; ¢H <‘ H×N ÏÎúÉ}ÝÙ+ý×â°WP‡`MØÚÈÔ˨m¤o– «¢x“ÔxŠW@/x’DŠÚ˜}Æv ;ȇžÜU Úá°y0[À†È’‚MixÜ¥˜†6:Ž¸œ`HaØPD@_Ø»D0n°º«[Ö ƒB»Û¼­ÙZ)Üî}ÑÄýnríy 6¨Ü-hßÑ\ßo¬ÞÜÛü°ƒOÀ²ï]àñß~`Ær(‘\ߤÑüàþƾ “hà~àI€‚>Ò>â×Xáúþ0O°6ÈÞâú—Î<0Ð$>ãÎÞº.žã˜ÎÚ4þãumãý©ãDn<À± äJ‡&ž¿MàEåËwä}ÞK~åú,äÀ-å\>åÀVŽåb¾‚MŽ;h½]žæµGå0=Ùcþæ)Xæ÷‡8 8jžç¢Çæ´J ç€.«B.„è熎y|îãËèŒÇ:Õ‡éˆn1®ÑóÚèo.ç&éœÎy‰^ܺ˜çšk~ê“>=ê0(á£.æ¥^m¨>ëèüåýê€ëÌéXÌ´>ÏŸ.߸èº.*mSHÎu‡ÍÉl….ìþ >ìÄ>èøˆ{½w‰¦É,‰ÂìÞЮàÒëÔž|Ý>wõˆÇ_ ÎËxíÁýíáNêã^{ÿȶì¾wüøϹáîÞŠH‰Æýþîvï&Š—Ž©—˜•šé‡€)˜ÆÚ–o—®Ð Å z•,°¦”im…féhùˆQiüÉy©¹šh«ì ã2î’Ž|Ž2 ´,©S›Š“=Ô6-’4}ó1m’[À’"ðÅÇNÈ(Ú¡Šzž k¢}¸¡FwÊžR X¡ÁŒÁûù¶qiuÌõøh­bê–½ï*¨ÖzÀÑç»^­³Ë½Ö-Èœ_í‰[ÝÕ’ ð8(ðLÿþ«|ê·P¸Z˜Í»¨aÛ±|¸¢kŠ½ˆÏÙ˜G–`ÀâÃmëm®‚ÑYÔnP÷kÙ—Ïö;-ØIY÷vÿŽxOïßj«ÑÚ¬¢Ÿ¿/[wb;w¸ª«¨¬ÂªÌÅ ²Á,{ß×dÙzÔ­zù™Ÿù„퉣žÿùÂǘ‡­¤O~ï¦m«¿v—¡ û°‚[±«—wé–Žxw\à¹/‚Ú† ¼ÐzÀ’yP’=_á¯Ú­þÛÍíßþÇÜ'hþÆüžüp[·}åÎø€`eF€Cˆ˜H¨pˆ Eh%(I‰(Æb%†H¶i69¨(:JúiYŠšªºÊºªç+;þK[«Pëw¤ÇÛëû ,!ÓÆ(q3”MÊB,¡GTº}ë ÖÉYQŠ¼‹7¯Þc$çú•–n*r‚%Úh‘ ÁKf÷6ƒ£‘(¦f(S~rºÂœ þ[üë§.­{K›>ݱ/èÕ£«u~]Øæ×V“r’éGŠ ‹ÇÖ¬ØØ­(2ìá?ÿåËî±.nPëa®7OçyU³¾˜¸v‰[­‘‰`á‰),f‹cƒ·51¼—˜ß¿¢Ü¿¢§#ÒåJiüzðëÏ{E ÃlD4·—DäŒu×­–]|¤ÜD!…’­Rá.ÜtáDd<ÙšIHb‰ŠçW}²FÌ ýGÌ[ðâb‚3£è‘w€Ôƒ¿(ØàƒFFhb’J.É$E(Î¥b,, ãDh!Äs.º!BäxED`aåøq‡‚êqc•hžù£š$þ,ØÅŒøå!DYªIDÞÈË^"¸#›n੧jÎÐe—Dô0 WÌ(迈P¤‘عÖd§ž~Úé“'E©Ë17žÊ‹€y¸EŸ[pqc«zÜ! Bʦ²ÒÊ‹­w¸H°³ÎÃt¶êÚ§møc/;ÖCwk,ƒ*û\ŸDè‡ /[|Ù  Å8¨é\H‚Šnºêr&ªI¤N) ª¹Î+ ¥ŠÞhâZ/¡©ò"BWÌ ([\AAs7 ѶÏ})$/lË`'Lｊö¹ªgÛç¿|•Ëڹ람rʨ´[Ò»¦Š,¯€W„ìðúõ8¯˜þk3þˆ¬Å3LÇ_ óBÄŒóR‡ÓéèKÑGçŠ-‘ÍÍ<«]\š)É™¬rØb¯ËòEÈidL‹4u¨ý¶Û«2keyÌðmÜ[÷7Ú‡â-Dßl톋8?C€ø >+ÛDøø‹Åº#⊫ÝÜ mÒ–nѬ/wwíµ¹œB¶„zc¯Îº„eKã2uÃàºì¶ó‚çÓÆ[:`§‹‘Pë¯ÝëÑÄ~{0º'/û¡ÉðÞ;4çÞD|õÖ f<4g+Ç|÷Þs}ôÎL¯ÏõæŸßJö%7Ú÷î¿?®ø'»!úöß?ŠúÎ ÿý‡/¿Öˆ‚&ø+ þô—þ þùoÞ`Wt:B*#2 [‡@[°Ï>wÈ?x;>P$yp º ª0e¤EìVÂ:G„<—º±Â²®…tÙàŠÂ%à –††<—MtˆD±ñPÈ#˜Ÿx"Ê|I¬"Ê–‹íµiA‚¢="EñQÑŠdDCãC)ñ‹l\F£w. ¨¥ŒtlÒ‘'®6ê‘oì]„p`ƒ䤎„4ѵhŸlíq‘|¡ï¡‰BJ2IwLc©òÐ-FjÒ},Ø& JøTm›,å/:éµO†r•°%÷LiJT’L•¬¬%öæ“"K –Œ”e¹hiËþ`: —P²¤¨Ìd*s™Ìl¦3Ÿ ÍhJsšÔ¬f31àÈhS˜ÜL1GeÉlŠsœä„c »‰Îˆ¸²œìl§;!tÎtÊSë|§=ï‰ÏiÄsžüÌß7ÝÎ| t #Üf?ùYO‚*t¡p€C шJt¢­¨E/ŠÑŒjt£í¨G? ÒFôŸ%A$COŠÒ”ªt¥,} ©Z Ó˜Êt¦4%èKkŠÓœêt§<-fO Ô  µ¦7ªQŠÔ¤º4 JmªSŸ Õh˜4ªT­ªU“ZÔ«ju«\miV» Ö°Šõ_«YÏŠÖÒ•5­lm«[/²Ö·Êu®n+]ïŠW°þN5¯|í+Xíê×À v¨€¬a‹Ó[ð@Œm,cëXÇBV“le)YÌ^V²‘Ýg? ÚЊv´¤-­iO‹ÚÔªvµ¬m­k_ ÛØÊv¶´­íhk[Ù6v²—e€~ Üà w¸Ä-®q‹Üä*w¹Ìm®sŸ ÝèJwºÔ­®u¯‹Ýìj»è®w¿ ÞðŠw¼ä-¯yÏ‹Þôªw½ìm¯{ß ßøÊw¾ô­¯}ï‹ßüêw¿üí¯ÿ à xÀ.°Œà+xÁ n°ƒ áKx®°…/Œá kxÃî°‡? â‹xÄ$.±‰OŒâ«xÅ,n±‹_ ãËlxÆ4®±oŒãëxÇ<î± ä yÈD.²‘Œä$+yÉLn²“Ÿ å(KyÊT®²•¯Œå,kyË\î²—¿ æ0‹yÌd.³™ÏŒæ4«yÍln³›ß ç8ËyÎt®³ïŒç<ëyÏ|÷;c++-annotations-10.5.0/html/classtemplates/converting.gif0000644000175000017500000004104312635354026022331 0ustar frankfrankGIF89aÙT÷  """-333 !!!"""#"####&&&#(/)()***.../5>444555767878999;:;;;;>>>=D>>A@?@DDIILUUU:@@:AA:BN[fffjwwwA@ABABBBBEDEEEEFFFGFG@KLFHL@LLJIJKJKLKLFO]EVWEWXORXQPQXWX_^_X\cR\mKabKbcMefPlnPno]j|VwyVyz`eoihignxiozmtyˆbo‚iwŒqx…ˆˆ‰‰ˆ™™™—ªªª¦»»»[‚„[……azƒu„›aa‘c‘”f˜›f›œk£¦l¦§q®±q²³v¹¼w½¾¶ÌÌÌÅÝÝÝÞÞÔîîîãÿÿÿ{ÄÇ|ÅÉ|ÉÉ‚Œœ‹–§€‘«Œžº“Ÿ³œ©¾˜¬Ê˜­Ë¥³É­¼Ô£¹ÙÏÓ‚ÔÔ†ÚÞ¯Æé¶Æà‡àà!ùž!ÿ ICCRGBG1012ÿ mntrRGB XYZ acspAPPLöÕÓ, descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desÿc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ ÿ„¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-ÿ8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ùÿ  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Úÿ*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+ÿ4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÿÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ ÿkÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·ÿh·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿ,ÙTþL€  Áƒ($ˆ°¡Ã‡6˜Hq¡Å0jÌÈq£ÇŽ ?Š Ir¤É’OªD9Ò“Ë—0cÊœI³¦Í›8sêÜɳ§ÏŸ@ƒ z`¨Ñ£H“*]º³(S£.>¸˜`AU«U¯*´º+W¯Z³vÝzñ+Ù±bÁ¢5›ö,Ø­\áfÕê5.]¹uç¢]8µlX¶€ÿ ^K¶­aÀ<]̸±ãÅN÷2Ar2.q 0hl*Úž?ôÙaÒœ~Sï¹d س n²÷04!9®3 ­F8B è1,Ø[Lºç0Át¡óDŽÐ¸D Eh‚ ^R)È` þ7Ìa d¢íÉ@MhÁ <ø‚%zb 2(B^°ÃjÏ=ü¡KjPƒ$¦° MTaè‰#2¡,ßX ƒ–Ñ{:è¢Áç’±ðÉHÈG"™DŽaM8艄 §óD Dç’EzÂ{‰Td#]B™Ò‡.)B „zB Žd¡'bð’PÚ‹›Äã(KyÃMzo1ü¤÷¤0ÄOVÒ.Ø[$ „¢ñõñ—7ú#ÓP8È+^Б- c#• †Há™1]29ËYÞÒÚƒe)ñÆÂf>S Ñü¤öDùHOxó™2È +±ËKZБ‚tI<õÓË=óž+þfôãHK^± R˜‚#Á'š31àæ)aBЄZ²š7¼æ+c9 J¡’´|¨_‚ÑZ„œ+];oIHI²ó‰ å%…ðÉÒÌÑMKŽAâLDÙÏ~>Ѧõ\@“œ®¢²|‰÷Ü8I[ꔧ+$©UG…y¾‡ëÔæ gyÅ~ÂR™ô\iK·Á—úé1. ã'±Gºf¶0¤R ã"ÓZÔ`•­&ý¨R§ú’*u §¥[J×:ºd¯}gÛIÕ—„Tž*„O=oÃÕÆbHŸ˜‘R‚€DM‚O/¸¬ ˜ ЀF³ jü¬XcPƒ àq ¢%b À§ƒ*Ö ³XlþÞˆƒª²ŒauI t„ꕱŠ˜ßé¸Û!ø³™tæ'_„ËÂV¤ôÄZàI"¡ ‰ešëØîBö2’åQq]sji‹Ím-ÓÚdÞ^dg4^ÚL!’Ì£È$+ßÞô×2áµÚ(VÚÐö›æIo‰ œ¤ðÅÎ+`§ñgd2v9 `´ñc*laû„°?/Ð04 €ìˆØ?%ž†K¤Û¤,Ö€„{ã˜?`1FÃâWçÅ!ñN°Ê*xëå “uúäËHÁ·³™q„Šlä™$ ÈJ– ’fœ€±dJþŒ9Õáð°;gšÉæš°.)nÎ.lÌ ƒ™&\n0uÆ œÅHõ)%‰ _¢gœ€n…u®I•ƒ²hÜh™AôLRÌe#‡ÐO)óL¨@Ñ9+%ÑþÊ£?韀ÁÔv>¯ƒø¼ .k82ñ0—AíÕNå¾Ì ÝšÄ\òЇS&ð4{Xe6!‹Æ£K0ÛÛ6N‰st ^ø‚XzTÜh&‘=“Û¹]cc(íQÊ ™L vè¶íÃXö°‡ã”ɼ]á€NP‚xšÈ4J€ëAóØ(‡¶¸ËkÓ–7’ŽÔKZE“^rœyõžrþÍ:X—€QœÓ^'_?éÊ’ëv˜ì«"‰Ì½-’â¦5ƒ˜““.ùáC94Q9xN9Cº…΄¦À€T”›3éõvú%¯YqŸ>2–k-+Ôùrr:RªEgIQýÄRÎOÿf·)Üo7'>wxÝŽ"ô²0æÅlåÊ^CJê/¨Õ½V7w|s-ªTñþT &Zð…ÿèás.²·ß$îÏáõRD-“C¯š…;µ‰(©ÀaÔ6^Ûžå%=zØš¾„ð(§BÅý^Ò¯Çô©w\){˜„>zmÏá_  ¥î}uÁ¾eØRnüšÊï:P%Ir’ŸT†êôDógþJRÀ_ý%ÑìSoY}GºÀ“. ?xuþ4ËÛóÎѼR8¿ÂÁÉ1°«lu{G™1–ùgZ¨WZE[×&€e´Z¸¥YÉ:fÔYu$C€oe[£Ä[Q¶Eiä ÐåÓ…=ÌEGT„€ÿçÐEGGÔ¨}ÌŘüVy=W|s×còcæ~5Ê!IA6˜—vƒ:h4SA¸sì‡ ÃwyGøUIø4ÁG„3èbÆ…ýƒ÷Ñ„ï÷„¾†…2„;W„3ÁƒÉრ†L¸„Â…;è…·¢†a8…cX…;Vƒr¸…l†d(føiW˜‡í!†íg‡?‡‡þ‚(Zhb} ‰’8‰”X‰–x‰˜˜‰˜d¶Ö‰žø‰ Š9öM¤XŠ¦xŠ¨˜Šª¸Š¬ØŠ®XŠžBˆL؈0‘p¶x‹¸˜‹º¸‹¼Ø‹¾ø‹¢ŒÂ8Œ¦k6:ȘŒÊ¸ŒÌØŒÎøŒÐÒ©³—$‹8n8{^[r?"‹mH‹è†G„ìŽ>’ŠHŽãaŽFŽé¡Ž2F‡…Øð˜ß‹Ý˜…î(ù¨û(âȇA!èA2ÂŽƒøß@¡ãÁ&R²ò!‘?A‘âa‘>Ö9xX" )|ö8‹$‰ˆ2r’7(’[þ‘p¸.Jâ’;—’㸒Hø#6ù40Ɉ: …<‹8iøX’Ò“k(ƒGÉ’&¢”mX”)“Vè”&ÉLÉI#ù'éAù…>•aø“ÚH•w¸“cI”Yy[)!]ù)fÙŽa‡IB–)•`Ù”j9#x™…sùuI“I‚~¹’ˆgˆ”ˆùÉ ‰™’9™”Y™“Èo¹xFÇ8žù™ šž™:¢©ŒTšÏD@¥Õ™Íhn@¢—#†´Y›¶y›¸™›º¹›¼Ù›¾ù›Ài› ™¹ I:œœÊ¹œÌÙœÎùœÐÒ9ÔYÖyØ™Éþ‰M@˜LQÁžâ9žäYžÂ‰™ŠÉÈ©ìÙžîùžðŸÙÉ8ñ•³ižø™Ÿú9žÃÙ Véë)Ÿ: Z JŸ7ј›·Ÿ Ú Z›ýéÅ©Çé šœ•Ðp¡Ò™¡Ê¡ÕY Úé¡ì‰ K"›þñ *º¢ä¡ž0¡@’Z ‘PU¢ÐY£7úž`£U0g ×y2 :Z¢­ :,Ú¤NÊ›. £õ)£Ê – ¢z;úœWz¡ZŸ_Ê ’ÀY` Õ9 ša:ŸI ö™¢ú¹803ðð›k@§3Ð?0OšŸQšž;¡:þÉÙgP k꜆ʞÑ™¨í™¨Tp¨8¦“Pi:&:Þ¹ øi€~j8ðÀù3€†ð à§ZžúŸ=œt LP‡* _pQ@œ QbÐ4àb &ŽÀ t _À4‘œaÚ£g”JÏŠ«czR@©ÏY ¼zX*¦»º«Òº£Ôj­Òúaਜp_ ‰ê+`¦’á*¦Q€©+Ю7+਒I ºÊ«¾j¥b°«I°¥àz⪩múošdùI§¶¹¦ú›¨Z›Ð±¯ÊŸè)«Ë Ž@b µœp£’€µ[ªœ‰ú´‘À²“`¥,³G¶àº£G¬œ •@´d+¤½µÌÙ£_À¶Ï¹©4±¤?ˆŸƒm›yú`ªoà3°!‹«ªðˆ0¸…[›?€=à´–;¹ˆÐàª*«}„šµ”ê-pª«®a¦5š²ÞºÉš¨–@, ´?›º«ë­ÉY°_0®ËÙ-Ðœ´Kûµ {µÉËœ_»‘à, ºÕz¨kÚº_þ`¥× ½Òk­ŽP^ÛµËY _pЩ·3q±d†ŸowŠ›‹»¾´I¸m`~úðrº´ù¾¹ý‹©Š¹†Àë¹ û ¢+”C²¦+­Q  "Úº;úºœ²¾¦’ª{»°û®,  ¼…ZwK¼àû®c`¼Éé˶2œxû½Ëù´’À«LÁ,ŒÃœP ,` *Â=l Õ»ÂT«´å[±Ò©LjžëÛ¾ºIÿÛ¸ñËdÀ±  ¿µiÅþKµÙ!û„+²MºÀb‰:Uª²œÐV˼;êº;êÆœà¼?, C,¦ üÀpLþ•Ð®[¨XK¯Z{¯W»œt€ÈÉi¼fjÈË)KðÆÞ+Ç@Ì QУ…ZÉ^›—ÄájÂÍi¾]‚¢kžð¸¹ù| ÆŒÀñ ˬŠ¬ü®Ü¹Àk¿oÐËoÀ,ªÆv qmL©–@ k 0;Ç\Ç×*Qk¯1<¼!|ÌÉ,¤ÐIÄQp½VJ8k¥ÑŒµ¨û®z¯gð¡{ ÉÒZE[Ƽ̗LQ`Ìî¼²’ Ä”¦â›É,¤¬¤PÜ·øÙ=`›ð©ì§ðûʶ‰ÅdœÐ´ü¿_ ƒ° 0²Z²£ ëy:€©bšQ0\0 ‘ Ð þ¬5ÐâKZI ÌŠ¯Q` Q b°ÈùL˜Z°ýúØ,C]°I@Ò¿.ÓÂÊÓt`­b°¡O}c°´‘5`£ó<®’ÐAmÒQ ®*ý¡–Àã: ^ÂBÚ5Яa°ÒA<ÔÔùÏnjÊé‹ŸÀb¿?@Æ´é× M¹°<§€ Ø?àÅ]À{mwú8`Á¬Ñ ||U ŸvŒ£˜Ù J×Ð ¢Ÿ0Ð8Àkª£­¸?p¸œûÀtÊ=`¨ÝªdP¸8°×Àˆ‹wjÅT¬À’½ÆA1£îyÙš½ÜÌ Ÿœ(v  þj¿ŒÑÖÂL˜ÄŸð°KÛÜàÞsíÄžÀ·Ÿ}Ý轟٠2HÜâýÞðÍ¡Ï]ÞÑjé}ßø¹Þ›ÓÞ•ßþýßò9ßæ}Žø]à$ ‚ªî à ÞàÕ)àõÍ'`àœú=Aüíà¾áþLÞâPZÜÃtýÍœ$ºÜ•@ÑÚœ¢Œ¡El HÜâ(þ­1Þ®"¾ã¸yá'”áÏy¤îy©6ú½U ×…ª®ÌÇÍ S ÄÏ) >jäHþÆJN¯œÌœBÞœ=j£b0È*àžMà×=d¹¸ ̵YÑ^œÞ>Htwâ–üž‘ÐÀ/žÁË) þßýÉÓù´wžçÊ-¦}N·Îù¥– 5çí™ã°±Ÿ¡­±±<ÃM›ƒ‹›³¼Ê’Ž›yJ§|ªæúùæÃäÏ ©ìyå•åz^¦.¨®êƒ.­nè+°¼ñ)æ:¾Ÿë›À”®›fŒ›°×¹‰Å˜žª«ÚªÄà&»3š°æ:­¸zågÀòú®ì ÍÌëÉÒú¡Û:·Y+b°2¬Àº£ Ëùlî»* ÛÝý,­ÚNν»«Þ~³bÀ5@îQ@É9 åšîó®°t[ xüÆ“*±ëZíä*ðyëáî©ûɹªŠ¹¾ŽÆ ËŲê$®Ý&®œ,ë´Ã¦©KþµE*¦Ô|äX;.^ðR`¦–PEÛBz³t‹èMû«ÔŒó3¿ÖIðîAÜ-N³L[´eûí7£!ÿ«XËóqkÄÂRû³E: \k¥G0¶e]åÛéácâ J¸_ÌÛ›Û±?Ð= ¸‡À¡]¹ØšÛœÛ¸† Ê‘[§uo¹?÷ßãÏÞq®œPȆn¥‹Ü»µ®ø¶¾œ6/ ßl¯Û{¨nlÁoLÍ,ù»?1½›_ùÌüƆÍ ?½ïšt`¨ã¾œµ µÈ«œšúÎéèµÑ ¸ˆà-ÀlÀŒ;Ûý±†`Ú Ù;Àª ü¼œ¿þшʴÀÊ_ÀhøʾÑ? êº_žø1<ÃT+þ\NH̶<<Á"*úQkê_šþ%uçÁ=¼þÿÃî£ðïÃÕ[ÉIÌ:,8qr”$‰#Ng¢HŠ±ÒAŠ= ñ”QãF%pRäH’"K B™RåJ–-gô@4Ê6~ÜäðÑM”o ü1ÑšŸ+ƒ"ªyóGÎȬùÁ`ÍJ2? “2)N-K”Kò@X²eÃ~5K#ÅF-*6¬ÂIR Kœ"¹­H‡îA½ußZ¢Ñ( [o9U9sðL\¸œ­0¼ØqaÕ9Y‚ÑH Û†+þf,ùqä¸:¿•¬ò¤u#¤XÐ’iËo/ž]V·î“-}ÿNIÔÐ6@=¼AþfÐή> ]ÊòèãÉ—Ê gUiràPœzrå¾Ñî;ýú³ì9®=hI†˜øAFˆÿL£ƒ-Æð礵ÊÄ !±øh #>I305É£ï2Ð.CPA»Âðë­0d0ð2" ´dÁÏk ÂúJüÐÂԋ˼1h¿ƒZ³¤¬ì6°zé¡g¾úã'~…ì·Ožûß½×¾{ñ¿?|òÏ7ß|Þ1GvðÜM¢=~ù»”÷÷;º?ÿ´¤ ‹ öõÏßëØ‘ùÐs¶Ûýþ8@ŽäSK VÐÀû•àÌHà ¸Á·!P7 ¬ Eè‰Ä ,ÀkÂ5'@> /„a e8CÖІ4ÜÀn8ÃìЇ?„aýTèAzm ¿£BI¦ ½‘p,tâýRàAÔ ŠaáûˆxÅzáwI„Ç?.. ŠeÔ²˜‘" hÉa·E8öè{$ÉMXÇ1¹„šxàö!©0˜/…#ð’¸H†)‹’l+ä±XHE6PŽ£ëä%Ã"à…o$R8A* ‚üO”f9ã+ñUHC†…–Ÿ!.JYŽD‚¥lAþ"ƒP^/Ó5eÖ+´ÔXR@KARR—Olæ²XЂè%3$ÉÀ€Ç„lžÅåd5kIcÒR“‡¼¦Ýx‰NOPÚ£^ &É)𮤧I,Pô¼@x $5­9D‚® ücmÙÐöQ=P§J¢NDž µ(zXP–u†”#Ì4iYÀÑAºŽ£%­c<Ù6O‚¶€¤)ýÑ9q:j>À§[+JpLQÊÔk4 ¨MÉSœ¢t§aq¡Y˜úG£J ©ôTêDŸšAn5$Q½iQAêÕ’d,S5©SÉ*°.õ•UÚUÑiV’´‘¬±\«FÚªþÕKÂÕŒyÍ#Y†z×–#{=ë[ÇjXŽÐjh )^‹Ø*6‘Œý&YìêUµbÖ”% dáè×{ɵœŽåé]»jXЦV¬—õìFP+ÑR´³˜m-m-+BÓfs¶!©mC%›×Üw·ìm3 ’àô¶Œ-.sKÁä*s¹in@‡»Öèbwº ¬n/¯»‘ìÒ󹬥âw^YŽW#(gW;Ùô¾–·±•-IÙ{ÅóÒWª)¥FG8üjĽ9€GŸº]²v—¼/…p„%—^­3 ñìÉ%´ÌDösÂôŒèE3pÐ=ª4-çHCÍ˸Í4/ížPçoÓeí´ÚìhYŽša…6sª]÷iè–:®¬!Ý`KzÕ¶¾®ÑìÜúĈ~gÂh^%Ã6¤ÆÆqƒ“ µIo•Õê ±am‘̹™>Åͯ›}_“r;³Ò6§¸©Üè€þš$ÞV&¸w´lÿ®ÛÙµqŸÑ9E¹d¾q·¹;mªÛ¤ÂÞ¶£ï^ÊûϾ¶}ÿí8*ôÓâÇxÆ5¾qŽwÜãyÈE>raºÇáʶs(àoêjN š€yÌe>sš×Üæ7ÇyÎu¾sž÷¼çb:9µØëûµÀŠ°æþ5ǽÜçO‡zÔ¥>uªk蟵K®wÝë_{ØÅ>v²—Ýìg;ì–¾L—WÝío‡{Üq~õtqëhÇ{Þõ¾w½«Ý sºÜ?xÂÿüKA/¸Ýù¾xÆ7>ï~¿7Û_xÊWžòtç÷ŸwB ›}ÚG·vX¶þÝò§G=Ü1,zðîb‚ d?{bñlè¼Î†Ùû„=ß!OnÂMþéyЮ‡?¼ùXÀówžèc¡ qPDê£>&¬çTëd¯}"à®áó‹·î½ûDÂ~ð?ú¿ßËø<ÇÄ´ýLh!UÏ¿ýÓLð?ž‹,À.ˆìÓ>Ÿã¾pS¼±c®? Œ?¾K¿¯c?®4¿ùSºú«—ûÛ9哹9ø?ª3Á˜CAD@˜k9h@Ä—î;©jË×#» ì:8ø`¸Ü¿ä:AÈ HB®Ë@ H„ $8?Þþ"ŒÂð8Â$üLÜ;᣿ÈóÌ9Eh=¨¹$HÁ>x‚+È°ƒ<@L˜9EX6¤9ê‹8Ô9¤ÃÔ„8€˜ãÃ>Ð7 Äh棹ø¿=˜‹%èLP<ÔC™ëƒpÆ™khÔ˜ ÄkÌ>Dôƒ<Ø?„FMF˜û€9,À$h¾LðFM¬ÁºÓ<³ÅòþƒÂò;E( B°K?6Ã(ì4` p€ZìºC@òãÅ„tƒ[4E,d¼á›¸âƒºndÀšÃ;Gr¼‚œëIšÃ„9Xr|ArT‚9ȃ8Ð?@’„GÈÄ=€Æ8A´¼Md½ïóÇ^ Å€ŒÂŒB¥ì:ÙëHÊPÔEñó½‰ä:7耨E ˆE8Ë \<Žl¹¦ƒºxôƒšëƒë›ƒ’<Ę´¹xdDš[Ë8˜ƒ0I™‹ƒ“$Çi¬K—Œ¹=@$؃8x‚>@Ì>XÉÂ#J_‹À²ûǦ E¦,ȯK?BxH€ EŠ€1ülj<6¨ÊÐ#Kð2½§ãþ/àÆ>øƒÐÃn¤F¸´9$è‚ÕlÍ×|ÉCä˼$GolÜœ¹»Äƒ˜ÁÆô4£„L¤ÔÌåtƒTt©l?&Ô=Ѿ ôE(¼È¬$? xÅÎ<ÃC°=8ð1Ü»Ò\¯Óô¹?ˆ= Æ8ؼtG·<À˜[Ëm”¹?@P>$Å„LàÒ.¸Ëÿ³ƒ)íþü€,ЂæÓqdÌ}äD u¼ ýÀ?»!u½"}:LPL¹Ë„CÁ˜£ÄµÔRÝéÊrºYýÓCQà;„%<;ös?ø£T„ÍÁc};”¹'xUMX>šû{ЩCS$ÀŠuTLƒÔŽØ×I5UÙó:4P?³³ÎlÙu-K¤<¡ÔEØMš»ÙžÛKŸËƒFµÙ«mÁcXå¹|íœ#SBˆü:+$BB§•B* ÃôÓH%ÜÂ]ô„$;—#˜}»@¤FµDÃÌÄ+è‚.X›Ä9„Gÿ+À­­ÄKÌD™SÃÄ>EìC›DAì( ÃÁË…ÃþšÅWM¼s¥Ôñ د»ÅDÈÅòë€Q¬ÎXœEˆ|ÝØÝÅ^´U Æa4;¿%Àu»E„¹'ÐÃzl>LÈGÄåÍ­­Gþ„MèµÇlÆÀÄ:ÄØ|¬¹ptG G$0G™sC-йC]×A[P2Õñ3X®“È^´N…dH‡dÛø=B§…]Œ¼Â¥;á]!âu;çýƒÚtÇŸ¬ÆÿËZÉÝÚ<ÈMj²­¹1É"I5aSJ¯K^ôÌ^?¥tB2?åL„‰TƒÑD;Þ%@èZ‰½Ø˜3â¼Ìù„àFÌã=ì‚'Èܘ£MnLË?hFľڪ5L90]š“æB2~=aÌìÜßåôdÙãdNæNÄÌðlÝÿÕáôäaÂë€DLÐL|P›MAFÀLÐ΄ÍåˆuЮՂ˜ÓOP`w”OMbM`-€&}ºJæÇf¥UA°ÍU$ÙµQ=E…ÑòÜæ}]ÝÅ5ÑS;9ƦUª—ŽéŽ9i싶itÅi«ÒižÞiŸ.J‘ ê`ê¸*j£†i¤6W ^êgmê¿‚g¨ÖꞮ蟮éªîÖ«.­§Þjq•êU]°fêT&Ò¬.k¨>ë Mkµ¦U±þ1²~ëdkõENº^ëc”VÉËëÁÞë)áÜ* Rìņ¡x¡Äfìȶ!¶T·ì˜.ì´³€€°¨bmþ˾ìÎl}Ýì÷"€ÏÁ$¹Öví׆íØnm19éÓΈBRmd´m“²äÃö*ƒê(ŠíÇÙí­ªíÓn§òZ(Ý.nŠêmÛN(P8¯ndiî§:îͦ¦ê¾ÕÕ¾îrzîÍ>uj)tânÒùî”Ên5{&jBéÑòîôV¦ð¶³—"¨ó6 ùæíiƯ6r'ŸŠ/zÂo×Ñï¢ïÍŽ8ªŠï¥õ6¸û^p§¤ð€pÝ‘p‚rð~îÏð?¢po¨ ?©¨ ‡¸éfT§§OñÜlï%ǯç#ÇÏ&¿q§nçq.²ñØÂñ˜ò!þ"7r "æVrço‡p(ò:bò/sr¡Ññ ºrY*r-—qvýòEÊrPó¨-s3Ÿòïp+_ó+:óZKóŽóC s4ó¿s4šsfÛs2ïs?oó¯sUt,§i@#:W!KtE÷j@k±J·ôKÇôL?&ãtß™žOõPõQ'uèAL€K÷©UgõVwõW‡õØ€Ú€?ô[KrQ©Ý€¤[˜lƦ€X'ö¡åª[w¢.÷„-·›]× ån*ßFvÀtŠrö´èõóâi§ìLÝ©k—*f_/içv»Qvq÷p/ @w×{ïrr>o(uþG±vÏTr‡÷x¯öyGY×öwÏ÷{9÷oïwÐv|xÏõK¢÷³0xüÚö„×w5©†ß‘‡­ˆ—ø…xœ²xfÅ,ßøzéø”úø„ö´ø´xòv¢–÷ª’7©“w ”¬•w ˆ°B<3°~7öÒúyý‘ùŠ_›·¨KÖ •Ó ø r—_¦ ¿©Ÿ¢·(šw­ŒÇyØù˜¢e§z×{öx-Çzk?úƒ¿ørMz:´( Ѐµ©û»ozHº¼÷£ФHŒ€"(üŒH•£P¨ßûH:Á(| @ü÷§?þ<|Âo¢pü¨üŒø|Ëo)ü²O‹´ç÷Sÿ÷¶7 M’nO(«%Ú_3{¯ÛΈ7ŠTM:µ¡¼§ð¨Ð(È÷„0©%…)þ Ò$ç?v±_³ó(àWÈO|Oz…‡órÒzÝ‚x„ßú“š¶iºm_÷„lg#é~¡¹oöïM‚|æ?þó€/Èo#’ÿûˆž , Â%<•8Á…Ntè âÅ5rìèñ#È G’,i²£Ä“*W²ly’…KcÒ¬i“f‰7?ÎDiQC‰‹8Pd QGOèìHô@Ÿ§Ôø åƒ6åþ¸u«'9=‚ÅxUãW‹f¦èºó£È·rÑέk×#LšïòíK²Ä‚»4|Ü:³§PŽ‰_™Ø«Ã´V­¦„¸•1ÙÈb–ú0"ZÍ2)§ð;0®é˜)MKiíú5ìزgÓž£IíÚ-‚äîíû7ðØTøŽ½+àÚ… "µŒþüú÷óïïÿ?€ 8 R_$  —Àqž$° PA)¤r)\øœ{ <@wváƒq‘è †uÀ €(¡Š~8P&F˜âsþxøbQ°W Dð`„=¢¸WX À¡`ð¹$__ô8%•UZy%–ùxWqNzÉÒY_ÒÔR5)æIPò%e–mºù&œni`hÚIR˜wª¤¡FZùõžždÁÇfœ…zè•sÖÕe z2ö“Žô€B™¨¤ Š(§zÊŸ¢sÕ™)©¥Ši¦jÞE¨§ŒØáǧø¹ k¬U†*£¦êºë¥¼ªj«ùɱÅbH•z(!€ÃK,²T*ˬ}zë…ŒÔ ê¼zû­]¨Júk]Áâwl'~°PŸ´R‰µþ¡ëG ìº;%¼ø ÛI&^ì í¶Zçþ¸Ì’¸’;—¹÷éQŸºün¼ý=œn½éNŒoÅì[ v,0—¾U]](û¥²F/Dêe /Þ™p  ËÕp~ÛçYèÁB˦ ö²…Hw’¯,݉²™èGï}íqêõý|.ìqÿçé÷}L>ÄEŸ¾ê£m‡rìp»}™Ø±®ïÔLJÜY.mƘM^€•î­dz-Q ž –2p‚‹Ûmò½ªµrã³\üÄw.,(Á bŸ¾>X¾÷Ù‡X%ô äx—.lý¯>|P‚n';?ðÐKT·h’à,ЀÀå„erÈ„F Äç1‰KDQi)”ÆCÜ!âY^pÁ)¨A r²xQB b„†XD‰¤1ÕñÐ   ŒcLIÓ¨‘::‘&Û»Sk²Áµþ@îSa¡ÖÁúÀ‹ûs\û`È®òÍï>•¼¤Ø @H-|ÿË„d§ãݤn` a¨çó”‡+T9"UPƒ‘ÀÕ2O{)™Â´Ç\Ò24iÊVò¤Ë‰ ¦, æi®3ËϼåvJ$M ±I†R„àCæv`B~¹jÿ‚˜D¾ŒiÒcY°¡êÄYÑå+•Úz±¾Ùºzìb¤ÌÄâ–‰âa‰•6I^Lò¦å$!òIÏZ¦b„N9fJ&”ãK‰64H 5Ã4Q‡Ê²¤}‚HÒQÁÝÄšhÂfL´É3l`ÇÛ.U>³•o›š-Åò ºð3-a©|ù¤’³žÕV͹̚E3 KuåÔdù$lv 6…Ëæ ?€s «4¯ÖµËJv+‘­iI Ú4…6É¡d@FŒ/?— ÿ£‡¶Am›³tÇÜ éqÓ¶þFS§ýòé’„ú?hƒœOß7,xÁ ,¸äÖz‡4¥u³kpËOå -ðuÐj?³ƒY‡ö´®1›i-[ä¦ýŸ(ǧȷ>w_rÝ—]“¤×þ!­  5Í xKçÇöµºtQxõ.8¯¶Ÿð¡ítðKðXGÉ×ÍÚZ¶£õŸÑ-ñ^·"vïÆ9@Ë¡Yηü¸ÊY?e*^j"\’¦N±%ô‡Ü+îÄsîX5³¦S©Ì„ø·ÃjëãOÛWªC9tÌáü›Ú$YÈrÌuÓ“$g~øs+â:ÿºxuÅÛ?]uµê¼poî«“0LþeÌÙ&n>Ò}œù'ŸÞ‰hϽë™;à[ÊóùxÊ_ñ¨@‘ettœ¢Ów@ç¹gTî”Úu×$8ù%Or–Óž{ßô NˆÓiÊ?½JÔMJ]ûéZ­Vb¡§<ëi…¡áöAݳѪšjë¦ñŠ*O©ª{¬Âʨ>~ÍÍŒúé§~ðQzò‰/[(›«¡Ôÿ~H¬¿&ì“ûÒ?ú_,þU•¿ýr«uúã?M±³Þýö'÷Ódnù£^õ\ªÿýà¸ÁÿŸÿÑ  êGþ™Îà×à¢Ào‡^ f n o4BàôI ¨€ þ:àþ•`Ή ®  ’…éµ`Î!ÀúÁ > jš ÒÍ ¶ ÷í Äå òø Ú V¶R’`&á¦áA1a ž R™þÖòß^á™U!Nhaü¡ ªF¢_–¡Žá“ á÷!z‹æÍNßΡΠ¢›æ¡ á!ÚÚþ¡¤Há5 â×É$@"&¢"6b#.¢"Bâ#N"$.¢$Vb$:"&2â„Lˆ‚h"%NÈ&^b(nb)’b%¢b)®b'ª¢%†â)Nb'‰®@.æ¢.î"/î" @/£0êÈ/ã/â"0£2.#36£ 3>#4Fc. @@;c++-annotations-10.5.0/html/functiontemplates/0000755000175000017500000000000012635354026020202 5ustar frankfrankc++-annotations-10.5.0/html/functiontemplates/selection.gif0000644000175000017500000004337612635354026022673 0ustar frankfrankGIF89a|Ã÷Î    "" "2   """ #'#(/3"!3'&(+0+-1.05.38/5?222333346888;>_16T86_?=g*)!C)Tp+D"2D,-S)6D22F92E<*]2%m$1d #z#9u&aIreat65:@9P„øý몾øy˜ „¾äŽ›<ðè%ð²ù¨¹X;V³]%«Eœ¥Z.ååµX¯È.›ìk Ëöì.»Âk é1Y°B:+z>jkçή@Ǻ€b™@©KÇb1Z^›+9dÉ»<-¥ŸªY˜ ˆòîò ÄÒü@^ŸH=VEši«—ì§P|J5¦c2í4þÔjż•Èp© @Ø— Ä£»Ll¯Åba|¸Æbq,å»T'(øqðŸÁé®ÛnÕ HªÍ«®»3c~{6sÍ`ëW„½<Êèš\î’¸½‹CJî¸âËè iýèçaÖ´ B¯Vÿ“ÏëJ4@?¥Œ×[•C³9!iKkÔ%Ò–¹¼ŒkZþôÔÙp"¸«Í‹‚i‘Þô¶µ³pM@u‹W›Æô Ìp,ØR¼ht–†™%•T{võ)$Ưr…#KͪÈÅüIlrë²lRH˜ºe€sI#ÀȦF8¡¬RÊÔþ0Õ?² ƒµ«ß‡>á½+âÍ] €ö y™ÖMf…f`2H3úµJWe£±j¨öµçŒ1œ×§Ê‡©ñ%‘Žuº“àв«—eí]N¨â÷”T3ZJé?¨„®Æ( OÕ’—ª±Õ§ÒÕ1]:âáŽÛ®Ó™LI¬ÒW¼vÅÆ]’%Š[¼”¤Ž” ®ÑŠnÜc2=Î8N –œ:a/hܱɘíþɦñYTB3ˆ©Le¥ØFµ(q‰Î¸ÉÌBÌoJò,öjd:wqHjrT| (UÓ(e©q´hDÓ™©º…”-–ÄÊ4Ù¨ æÑ£gaf.©$[šDprB(—‰KgN a²ifRjLî)l½ ¨MI‰Ìg®¯˜=!YºÄNu«XERR[ES²Á'=‹¤7ѧ~4j5üç§@U¥zS?I <½²ÒµŒ-lýœ¨I!:*’*i¯„êϬi·¾B3Sí#V˜; ¹îƨU#VEÏÒ*Æ–…©g-kCIÑ‹¶…ªÓë”á~M¦IwacבŠWµ`±È¥—Àþ«þ P$œ8¬òc‡6›Ê±= Ÿ€BAº Ýäb‹jwÁZ¼y«C§-˜Ë•º®ER¡›‡¹ÕS¾Unq †øéWJt˜µ!ja ›5‰å«Öä¬VU…Yùús£ïk\@+´™UèB‡ çBLñ…å*…lú1‹@8ÙWv´€bx >R‡©à- xKb¨ 6°ÌUâÃaKW¸*p‰ xÁ Î\òJZÌÁÓ•¦·#) ¸4]Û͉ ” 'àl¹ÍµÙsov$é¢EWÍ,’a”ÎO l4®l9C]Ô@6T ‹ôTdOÊv·D6rþVÕêÝÌ ¯Ü–ÏÂ_mÍìZxVŒzgb]¶`‰p[ €d¼ª„qà´ îa6gh@ÒèÆ;.K¿ íbHÁØÁ6‹—£>4èÑÁæÑ8ÞÌž³ºâánK§u†oˆ7¶Ñ¯x‡3Š»b8L^ÀÓ\ñ„âWIX¤ÍRgTÝ9ÏÈv˨cÒçd;»o]vTŸ}™bÇrÚÔÎöÇ¢•fk[ÛËöʱ¿ÍkÿhÜä~v¸_âít;{Ý\A·»ábîÉ{Þx†wKÚï|sû0÷î÷Zê#l üZúf ¿®¢„g%à §ó¿kðˆoÈá*Y¸Å„q¦@|ãc!¸ þ+òút%/9zN>“—\äf"¹ÊW>qš¤|æáa¹L\r˜s‡ç8¿ŽÎKró '¨æ„ºÅ}ÏèÈ*D.} ‘š硓¤èFŽÕ_¢ôˆ3ÝY2wL.+£ao&\dMöÖïböá'ìo™zº×Þ’®»æEr|Í×)M&çkàFºL°ž›°@~¯AûÜo»(ï®Ù»ÌàÎ$nÆOý¦;HŸ+=Þð‹G¨ã™ùS!”zЉk%K_uÆÄómaYk\™y×wåÞ˜GŽPÑDy‰ŸõÊ‘îÂHå…L]d^óê%0fÂqx/´¨4Ç/ar󪈕þ£ùÀ¥¬WŒìÞ}•Ü{÷¢Î»ÎV#y/÷^1Çts‡Š°Ã–΋mxË©ÇòÕG+ƒGãCîU\"”5áÇe:†Â59N}HÂ0É$<¢!»ã&  9ñ ÷MÓG}Àf}"–}3gËa{ñVq˜/"ø<•#Ä£& 4,Ì?5)þÒ·Ã&F;i÷í'm©' þTJ«4>¨aû§;…FåÁU5ÒQ ‚,&¸om7%5ÕTxC<uï%cS2T#ý÷!“e6hÃAØ>G'z$‡XøgBYX=ô ?T5ZØcŽäDÚU6Ñ"7b±@ñå?xIï'ñg_þXèEÏ„?ŒbMíƒ5N8ÆEu·A0˜˜‰š¸‰œØ‰˜X Š¢8Š¤Š P…éSn5¦´GÄ’.P†‘³„ÌMˆ.Æ”A¨˜^S¨ç§$¬ôiéÔŠåU548!_»âwž‚xô¶¾@ Ò8ÔXÖxÔøp…‡¸Šœ•T²X\|r8ÞxKá”øE¥ØŽîøŽ¡è‰(°‹Cu…ò‡…uˆá؈B…ø%ŽEŽÈÑ™€Óx|§gJ2Pá¤YŽÄ]ëT`”\YUOûTqO Ö‘ù‘ ’©A¨ŠÄ…Jeh’ø3Nÿ‰m&$ Dþ{šÒ‹+ñ}–b’‘ÈY/Ž’IHÕVæX@Ø"Y”Fù‘ J©‰Q0ŠI`L‚… %•]•YLÂdVòÕƒX@’ÏqL§““©4VSÙO26¡Ä*·èHx…~6‚ˆ˜Y–õSaÂ’¬@9/1¹†"9˜Ó¸ ðx˜Q€‰@QiHž‘ŨJŠ•–K¨•b‘’åF“Ûò•X1z‚" -†`ÈE–pF[¹TEú·dü7Cd€/I3¶C‚¼(—šr…cùšp¨’a¢–«b‹Ye7‹È}šéqmŒúu–u©W5TR¹Œi•™¾È™Æ©(Æ8¢›cþb¦'·0Áö3cwc‚¶bÓIJka‘kpb!öÒ6RH›d¢$¡ù £‰›Nèct¢šùåe›€ZÇéZü[a3„ßeeXæ!¹…$»å)²5fêŒ>Xœ E4á™Y7›Ôa“iÑiªV\æ¹ ßÙJ!Raã™!EVk•ƒžò&h‡Ã6X‚l¸ãaà.Â2úìi3[R¡†¢&†¤Ž2PzÒ!®æ0r/;Ê]Ù¤À¡-·j#z"ú¥0¦;祆r€È‘¥vÂ¥gJ¦þ&Ÿpzqfʦ5á¦vŠ¦sÊ,uzuöø§þàQ~)q§µ¢¦¸¡§_Á§0¨„ZI:c©C5©.©‘±b~úŒš[ ––Êq˜•:ªa¨ÆÑ©øö©›)ª¨êªº§«Rª,¡©ßæª â¨\Ǫ¶z«r¬…Š«©A¬Ø2°Š¬ß1«Q«ÌšÆj~Àên¼º¡Ë­Z7­”1¨ÚZ¦=Š¬×ªY­ßÚΚÐz®9VUæJnãê«™Z­2ÒƒÙöU;)™ªÜÊëÊ®r®Ä¯Ùšiâ­xœe*Ù¥é:뻩cqÆ·c:—îʬ[®­1vûê @”Iò€:¬pQ@V-"þ›ø¦°¬ÈŒ—*°ÁÚ±Õ)¹$-¦0K>¬ú°¡q‰s—€3—ð®·¡2#2l6³›m¹yJ®7»‡†&™£%Ä ªƒF SXB[eã8,†)úB{X’µâòvÙ·.p’8“sKg«'ºY0¡41'¢K(iG2Š GÂHáñ4Uسh2²´¼á§=s„éUz(ó‡k³ʪ=K"ö%Nís‹H¸4_‚·¾“4iT"c“CÔbzR!‘ó%c3@€5¿¥A›Ë3ŠªlýJ«{ë)dU!¢Ò&ZTdGƒ!îâ¶b1,ݵûR‹_¶W&gmrQRZ¥Ðþ»µ]» Œ¢/o›½ºI#œ¤+WÊ$»;ÖB2èb§C¶ØÇ*âr!–Á¾ÇÖG###³“L“bõr/Êu!†#/γ}¾÷pòZw˜ë- »úÁ–ÐRìÀ`O¶¨+ŠŒ”é)ÞâSUŽW©¬’*&”h¡ÆoÊŸ0XRŒ` C<‡´@BDt3UÍ¿a*f/ÙÅCPÐÕ6³²ã’!uƒ3O5ô²bºDÕŒ"? ÊèZ¾êj×x\aSB½(>œF²³ ­U/íÐÇÃçÜÀRØ ]ØDºµG‚ɺóÌÂJÊ×ôíiX©­Šª\}•do6e¬œYq†ZÎ¥ *g?µÌÚë²Nݧ»­#Ý颸”ußÈÖ€ãË:ò-!³a¼,‰Æ`‹¶k‰diŠ&cêI¤™ 7¤V?*aBZaÖî©£¨Ý™}¬ŸÑüÒÍÓÁŠÝ q&p¹qþ¨HûãýÔáÎð¯Nî*PžÝ/§Kþ«SΣA¾å3¹ßÃitY>¯^¦^æðÜ_ÖB¢d:æ ŒædåRîåFþºªmn^Ðp¢þ%Œá{ŽRU~äMžmyîãnÈ]~è¢èv>èÔVèæwÁ1é”^é–΂‘芞ævæèÏé)¤1ê¤^ꦮ Ùhsé¬Þꮎ™ÏâšÞ¿Wë¶îe§žëº¾ëR‘êÆæéÎê·>ìÄ^ìÆ~ìê©ÂŽìÌÞìÎþìÍÎ =0íÔ^íÖ~íØžíÚ¾íÜÞíÞþíØî¼€ËÐ^îæ~îèžîê^T=¾îîþîðïòÞìT;ïö~ïøžïúÎ)í¾ïþþïðߨ_ðð?ïõžð ßðÿð¢×ï?ñ_ñ¿sñ¿ñßñ¯êñ ò"¿ñ ?þò&ò(ð%Ÿò,ßò.Ÿî+ÿò2?ó4oë1_ó8Ÿó:Ïï;ßó>ÿóìôB?ôDo§_ôHŸôCóJßôN/ôLÿôR?õ4õTõXoòVŸõ\ßõ¿õ^öbŸð`?öföþ^öh¿ölïjßöp÷Ðþör_÷v?ìt÷zðÉ@˜~ÿ÷Ö˜ ‡9ø„Š‰¹”ˆŸøšèGù‘{Ïò}ø’ï÷…_ùðˆŠŸùˆ?ßùžÿù ` š_úžhù¨_Š›0ù×8ô‚Éú°O¡ú´Š˜oú¸Ÿ‰œú¼ßû½¹üCPûµ ±üÒèëoìUàûÎþÿü™”ÂoúH@ü´üÈŸ Ë¿ýuR€ýÖ¨ýÜ?þäosCPþèŸþ!zþêßþî_Gìÿþò?ÿLQñOÿøŸÿ5yÿúßÿþoª1ÄÙ@‚ D˜PáB† >„QâDŠ-^ĘQãFŽ=~RäH’«,™RåJ–-]¾„SæLš5Už´™SçNž=}þT¨GœCEšTéR¦MiuUêTªU­^… ëV®]½~‹TkX²eÍžE›öáXµmݾ…×([¹uíÞÅ›W#]½}ýþ—o`Â… Ž:ñbÆÇTüXòdÊ•)F¶œYóæɘ9þZ¯gÑ¥MŸ.KõjÖ­ªv[öì¡PÒÆ[·MR·ó"\øpâÅGž\ùræÍ?‡=¸¯•Ò­_Çž]ûvëÉV ù^üxòåÍŸGŸ^ýúò!>°‡_þüõ¼Döp’_ÿ~þýýÿ0@$°@D0A'Šb%„0B '¤°Â9 e%vá°C?1DG$±DOD1EWdq'2 ©‡g¤±FoÄ‘ÅOTiÃ2H!‡|QÃ!D2I%C,2Æ%Ÿ„2Êw4RJ+¯ÄòÃ&Sò1K/¿TrËd³L3¤²Ç3×d³E1Iê²M9çdþFȤ3Ï<ÓäRO?ç|s¤8ÿ$Ì@9³PE³ä³¤A…ÊCCz4RK‘œT£D/åtÈFáì4T"ítTTSÌ4£MO=3*òSAY¥Š 05U*¥µWu½hUx€ÀØcqõ•FP0 VûÌ3—"*à ‚ Š8Ò fC–#^›ÑÖo; ·"aKà½íð“sÉ]”\¤­rNW¹åŠyQý×Òt5×Lk±Õ–_!áuà‰Ö%]ÞýV—€éSV‘ 6Tâs¹øÄüFd\RA¥sßýí6äE–b‘]&7ww¢65¦4O<þŽÅOî ]ryÀ ’i.æ‹8þÒÛ‰9™Æ‘E,Ý“;’ù×y@¶Pv©äV ø¹lh˜z]®ÍVißÆ6騻ˆ©?â"À&vì]80 Ù±+yÀ¹+1Öî]Š@âŸq¥›pvÉÅ;|»X¿§v"m "—[ÇiK¥r½±Î{êJHK~.–µàÖµ'\l²Í¦Ói‹ öòç¶w¹ÙÄ¡w)úhÇ™dšPáêºÄ¬9|ý’+á×Û".ùr 8Ôe[òŸ÷P—ÍàÞc'֥ﶉ…â“J^íò¶‹¸Ý àwœ·€à.( n|nûþäV¾ÿ¹-[ À÷øí™._rBÚÚîå¡÷¹M~‚V/q/.mlºð׳·=…Éiz!^–Tw<áíX«#ì"7;bëv5Ì]äÇ»°x€Ú¢jt=à€»¨ÀͲ歱á5¼"ˆ¬Ø¡Kèìu?™ÂJH±=ëvºÈ"È6è¢h¹hŠ`Ðà(7È­1Œd$ßWÄ3Ä0KºpBá’µÁ/~,ŽsüA4EΉŠbž^8?^ÉU»ûPã÷€ù@„$,Ý"é¶b‚,”d7R=1ÑDƒ©VÂÄ)kY!ZŸ‡Fw¼ ´qzÌÚbþY ¹ùË–È’%‡~V„5"røóP/“©Èññ#•ôã 5±]FÓ—Ô¤&Ó7FoÁRO“”6­ô¶Âå²³c()OqÞm”Ï|b$ƒ§JM-1` Sÿì™H¥…3DáüY&Xº¬ùë^Ø +Ýø!@Žkc²:MzžÈš»R”¿ ˜P.” K;)æJ(ÐT^Nc7!ùMy4™“[9™Ë}ÞÇŸ"’_o  …#2*ˆdÊ!i:s¢†t(.ׯöA/D(4€PÇÍ™r´Eíˆ:£ÄÁPiK…"MSjUεCAõ:#"V,¡±$í^ÁÙþÑdÎs–ý!}jµ‹]"Y¡l¨&V4SD+«)ÁxH¿öµo߃*[ó:PgÖÑÝ;—MKVqå 4¤»Þ©Òx®U”º_Û Ë¾®I®¡ë’¤Š;¡µ©•5+JÛúC¸ž“Ÿªú©ˆÕÌ’}·sU*x‰©~ÈUžüÄ'¢:8Nz°ócè¼^'TŠmÔíë=PÝ12~@ø®W-¨&:‚»„ù”ÙÝøÅשp¬îk9äÜÀîb¹q=.H3vOaª«½ã+`ì)–‹‡Eð`[D¸2é‰3@¶è!kÎoÉû(F—;óº¨uØ»Õæî—»þÀæònÈr¢»™»êþ,[«EŒ§Ú¹Oþò|©5§kEξ¶áç` -²Ú³N¨ •U„ȾëÃ=¥¯œäÅ6·²¬š„/x`Þø¹:°q5,¤×c_"íFr{g¥¢ÌKnSæE,fjéÅ¿£rY½uå,ÛsË]vÑ—ë$O‘·¯|¶Rž †é}ÂÒF§kTg9SúG¹Ø–>í,j|…™Õ)Bõµü j”½ZGŸžô‚tݳ1wµµu4‘=ó™×MKpXƒ ëTÏ:×cZ6¹†‘bG›Ö³²v‰Ž-½d[„•Ù^Ô´ŸnZÝö!Õ&÷šš îþGé>Õ'ŽÐîålÞ¦"»³Š*ôÛßÿþ7ºï &"x`CÂÁ¾p†7Üá WÀÀCõ‰<ÜâÇø( ñN%ÀÉyÈ#—q‡#@àÇ’¹òm”‹ùtµnù˺­‘!œ<æQRùAX~ó3‰{x<—¹JjtEåÜ ;R“EÝõÒ±9Â[ôLt0©“Èçᘇ”¹\:èZšyF†þõ?½ H’DŸåKÒP¯º×:ýrl‹(ÈØ;*ôèv²ß-ì»Õ W:¯7+êû{̼$Qæ=E¹x;Ü6w—jév@htôù¾û]è1Ü;ƒ}ÅøRëþ:K¤’úÒwë±>DW‡!‰,ŒÆ$‰–ìfOHàÙU:ÎÓ õ×Vâé]Ÿ\ÉJtß؈.Á/bÒhy pÂÓºë›ÕïIÏ~ÊoÝG Ø7ºZ’T/w9kÛ‡Ú™çàÁßMt¤CôDLr±ÆJ–±@¡tÌi®˜·zdQ–Þ1"‘Ê  Ó:²Èbœc %Ì)fÙ16ó(äë-1–¬Ê@eäP('˜1¹Q1l Á~@ä¹,À‘¿2b¿\´òÉ?‹ @Ù´‰12°õj?æ ÁTÁ ”kñ´ÆR$[!ž:¿Ï;‘é ›é—^{Bôiþ™™—Á½P¿Â0·¢  ¨Ÿûá)*"%û ®œù¡¬¦oÉš»«ZŸŸ¹ï3¼›B£ºÃªbPhA% 5i—Þ*õ9 ¤a¯¤ÑPp—K0€ä‰C¡ûá*/D0t£‹ÒÑŸü¡B= 5d”—"¶‘Äg™ªU¡(C0*ð ’—{±ëA?Šè>)Aû?fɉò›+óüÊéÊÚñ!ѦJX1¥Q›B,³Æñ@cQÆó´)œn¼*¸yž(Ã!sÉŸ¬FÍ1œÌ? t‘_tõË®5|* /΢ÁþÙ»Ò¹D},™ëy$¦r¶-â.J&†Q£»i#…<¯þÁBŒ<å±À>J¤šïó,Éú/õA-§‚Ã~0K ¯ãyÔB#jÈQÒ…O(+=R¤˜œI4I~¤˜ r¶²G‰Æ…¬D‚”Cû" ·Ñ¯?¬0€Ì"Û3Å1¬Ež›9DJÐÒSäC;”<ä®÷ê®}ÜG­ 1«\¤Ÿdõ£îH’,JË(œÌ£‘,I¼º;\ê(F¢ªcbüÇ¡œØ£$¬9 ë“=&´˜R¤×9ž¶®ëɶÌɼÊ"(૬µ„¹‘ÉìL¢ÄD¹‘— Â³tÂþô¤Ñ´Ë7zò•ú!ÄtÊŠiKI„ «”ÈæK‰’H†„°CâË—4K°›³jò¡Í¬KYºž¸Ì¨"ÿ˶”Ì•:MƒN‰ÂÎd)ËÁÌÈkÂ@ËÉ–Ó?1@š*EjÎÊlËOHNÈ4%wyÇËÊrOÛÙLjºÏJÈOö,÷ !_LÍqLÖdÎy©%eA&qIàŠÉ쒢ЪÌ«ÌÞ¼Àô­6N -NŸæÛ±©Þ½|Ø„x]œsÍÐÉOcÛ=·W[Ö»”Â-ˆÃí¼3qÝ?1,…ñ´‹D‘XS5Q±_‡°9=É/°iPÐ-ºömÿýß2 à?)›û›V‘m‹·ïT0>£Z¦Yu! f ¾à¨Qá£kጡ‚Ê‹a ~a…`á¾’ Öáž›aWëaC¹áÜkà ¶š!æB#6“nˆ"Vþbá_‚Èá'$v†÷¥â¹V¶,>=+6\'öb‘±b,cï¤á3®âUcI)ã6n5@ƒã5æ]à;Æã<Öã=æã>öã?ä@æã A6äCFäDþc(cuäG†äH–äI¦äJ¶äKÆäIö„LæäN¶d(àbŽÀO&åR6åSFåTVå"ãþ% bPÉÐ) åZ¶å[Æå\Öå]æå^öå_æ[N/Xƒ`6æcöåV.ˆ)@æfvægÖe=€æi¦æc¦Þ}åXÞ¯ˆƒ3P†mN‰EÈ ßð Xg¯P†3ðæs q¶ rî sfg®P†0 ƒyþ w® xæ yÆg¬ø{þgÐgÊàç­ð綊WøUPè(èÉ8h¬H臦 Uhh‹Æˆˆ–Œ‰¾ŠŠÖh©°ƒ/ø…®Ž~ ¶ 6i§ ƒ0(é–Ž”v •® ––i¦2øæœvšn ›¦ œöé¤Hçu.ê…jÆê© ê¤> e 9€j…XêÅhj©xꪊ€¾g®.ˆe¸jÄÈê¨Øj°Š_ø‚S@ë(†±>Œ²vŠ³nëŸÀh‡Fë·çl®ë¦8…/x…¼†kÃ릠ë¾ö‰—ŽéªÖëwækÄÖé0èi¨nì}~lÈVŠ£žì¢®lƒ¾lÌ6êþ3ˆ™^†b …Xˆ…E@„Á.ŒÂfŠÃmžðj|.í[@íEX>àÜFí[(†eÐ ×^ ØŽíh; Ú¾íÜÆÞŽZ(†c8 áV â.n¸kÓPîÔfnç†néž êN ë¾îœÀèÀ®Œf(†b@íFX?hîE@íïžgñF ò.o›PlÄPoöŽ÷†ïÕž„X…è6iû> üÎïšxiaЋþnï÷Æ'ðõæj7 _ð™Ðì·XoYˆ…Ip /ðbm  ßp™8j²øðWm<ðƒEh„ 7ñGq¡Pñ aèªxqG§qÔ^ïfàñÜûþì$7ŠãVŠc0mò¯ñX8r&çÒ%Çr¡h…Œî (?mîƃݮò+ßrîÓò3 Œn™óåsçömàVóŽÈñ Øñ:g ;€é’(í0Çí8—ïX˜s=/‰;Š<7t•ØoØnÜÖm9ÿíE Dÿ E§ô’PçÍnˆGïîA§ïL¯ K÷ Lu‘èpƒðt>ˆïù6ðS÷ Rï S‡u,`ƒ‡oï~õZ7 Yç Z÷uŠ€ðÿñDÐJ(pðö¦ööfGˆbð _„/ñ‚`h¼–vgOón§ˆ ñk·ñ‡Ènp_Šg׉h×sqŸò"ÏvŒàóÅþF÷£P÷œ`÷ ww"/ób@òhôzÿõoÏô7r~7r‰nætÿ‰{·‰|Oê7s2Oø·‰Twx €øšø‡¦ø@ßíA/ô¡¨gªÞxŽ'x´þs8ùÞžô¨˜í”õ•oéUyBy®Pk¶¦yžèxšøxÐXõVî^?‹sÿùœú™zÉ(z^göºøkz_ú™hz™xz v —zÃø«—‰¬‰­·‹®pr_vÊØé†û– {˜0{´@{kÇv  {—ˆû—˜û®÷´¿ûo ©í½¯t›·‹}§òrç™G|–è{—ø{£`ü"·r…·hµFîþÈ_‰Éo‰Ê× ƒñÆÏ|Œ/j¥÷|’}–}—ùEˆó~Gý¾>ïÕ?tÅ?ŠØt˜§ó{ÜÿˆÖ_‰×Lj–¯xIÿ}=i·~šÓ}˜Àyå7!¹ëÇþì×þíçþ €-Ø‚èþñ'ÿò7ÿóGÿôWÿõgÿöwÿȉþ‘ˆzPGúÖ‚*p‰d 7á…10ƒýR,hð „ 2lèð!Ĉ'R¬(ÐÆŒ7rìèñ#È"=S4ò¤ÈeÅnÅŠµhž^äˆ?P¹`r%š;løæ&wîrl…þæèè•Þ7¨+üIÅŸä² (Nä¢K®7 {ìÏ®þ“…"Þ>fîçí>÷Tòp%€¾=ñ^‰øNÀp |Âè‹ß;ð»À  ;ñ@ÜÍ'ü¼ÒLOÿeõ¾s=·Uô³ÜŠ`P$  \ûà]€xÌ{Š  âU ÜE°Á„|úãŸNXô?ʬGtÛ'8`À|r&ÜEãwÁö±oaÔ…€Ð@@!a@á ɦ”¬­ÐIôÎ çö‰ó`ƒçCâ.t‘A2l‡Ës]&¸„A¡‡’CáNÈã­&é‰Ø‰bß @Dù­®‹õÛ…½ØE×9¡Ž8ð0<ýíO‰J¹ÛØBÁþñkø Â`B,j‚y4#v¿…=pŠ„ü!Y¥DÉ×idÕæ˜:@nL{ Ëa&#‰I<ºN‚ ë#â÷I4òäc¤Ì‘)­ƒJª5¬A¸À>P–vŒótQ„ `Quø$(¡‚&éýFÁ¬Î0§6Mó†8ô^ÀŠ€&ì#2‹¸¼ô©Ož «€=wJ¦ô¬›.ú¦s‰͢=‹„ä¥OTèÏ.2GhÎœLl"Ô'L\h‡Úœ‡Bte»ŸAºO§Ä!R%‘FƒÃÑŽ¦Œr4diE}‚È“b(¥ÀY)Ksª²˜Ê4 ¦¢éŽ:#œê´þ¨œéS| Ô" FD5*T-ÆÓŸüWKuMóÔ¨r5bSýI?¯* ¬úf«]=+þúeùI¬û!knÌŠÖ¹ªõ'u«}àj¹Îõ¬uý ¤ÖˆW÷èµ6|Õ¤ ïh´\Àw}uR§2ÓÁ¶§°©9ì.œ ·JL”h €{Ô·(ƒ £l},‹šÃªnT…kE{±¿E©¨=jOsØM³G¢Ni[ÛÚÝV=¹5ÍaûX´\ز·~ì¨ps¡âⶩ/âë'²§>@¡ƒ gÂ*!ÃJA|\Øß8¸KäB†ô¬D ógÄi NsNïùôh?íªï~þ½c`÷è…ñ²s‚ “fà’7´èJ—YÔõÎqK“Üç*W“~ìc.ñ ò)–|D_,3 D!ŠÅ°†Ï‡À†U8¼•Sgí—A ‡Äȃ .š{3å®Æu]4á[RøÂEN˜êL*y!tmÁ×b-š±Å ¢Â*?+÷‘E¸¦&Á¼ãȦE:‚ýq›‚Œ¢![˜Èm~³CJË=^Ù±Y,¦Œ}XåçfÃ[监 ;ümWp|¦™Í2Y4û&¡asžÍå:ZYÏtÆ£bÛwG+ë·Ï SÜJh.vzÌ„Y£›ãhÏ@ÚÓ’>ò.ä[gZzþ]˜IÌé=7 ³«èÊfÇE±mªS³êδºHlñ¤MâKÓúÉ0ve°çì°JOŽ~||.ª¨ÌYçÌØÇ&n²s³ìÈ´úÅüÄ' ½QCû€¶d¦µ=b$nÔî£.–½Ø¶øc+€ÀKäÑ kºM³nÈðÕ âS°ý.^ÆÿZ¼wÛëx>àrÊ8y—°|\_1^œìlx‰ñ>N[Æí¬ž ¢¯¯™¹•2šˆ+[Í%¬l–s†qûkAWŠB‰^š‰?éIG°#ݶ§/q:RŸºÑIdõ¤ç™Zfñ¡žh¹¨ñëž¡þºcÆ.[Ɯş¥Ñ¸~Hƹ@a‘ܯNѵËås}÷{“/x‘zÙ‡Ÿ Ü£øÅ7OïL‰ÞãyÆLžò›³.¥'ÌéQ/EÂÆÇ­‡Ðß;ôñ¾÷¾ï rÀ-œà÷Æ?þ½2@ÔéÌ·'ËëÙÔ‹Yp¢yØÀ†2Ô¡ÎOÔ¢Ÿ?–èG‰Ó¯~ZЂB8‚½@†3„Š9h s@ÅÙ.¥ŒQŠ¿,äבùuBõÝ@ Ü@!p‚ûÁH´Â”ö•Áø£8^ÿAÅÿ•2ô 'tB/0OÈþÔ߬Bþ š¨IŽ_î5Kr‚#‚úåÁÎB2…2´B8  Á8 @\ ¦ ̃-p#Ð` Ø 'à`Yü*dˆÁ ~ß—°U~Ê † *!!¨!0'Ø‚1Ì…2¬Bˆöa[‰ím!Q\ zœŸõ©_!¡FÆ/ÜŠA¬6I`É¡®ŠùQß®_û½_mÃ*Ì‚ Â:Iø¢OÐanàà& u¼B>`÷iIiý”&'–F ~¢‚ ª‡üÑŸöÝ_  ®â®taŽÄà Öà æà€0 B öHUÙ/n¢þ/’È.¡0>a/Œˆ–`ž`.Â6£‰<ãƒDc¶À–áæÈö`¡Ž(‹zc/戦ßúéá9ZIþa ¢„Ä!< 8¶G"¢6¢ÒI®á:^b†˜Ù?âD+…'r (" #^J>j z߈dâCVE@Ç+Rd,c¬@¢$j_%2¤ÌGŽDDŠ02¡âà,F )ã)JÈ.¾¤3ÄäFD#M#ÚÔ¢ ⟃¼ŒO’DH6†8Š¡=&’1>`H7ú$ùÍ#F%M]£Fj£€ ÝRnÕ ä"²Ÿ(¢V:ú î‡?þc„Md†âE&[FVþá>Ú‡ÙŒå³4%SŒä\~ I^BNb[¶GÛñ¥FÍä4Ú¤’"rGžª)¦_â„P6f5>$JNâJ~‡á¥Þ<%9r%_fÄTn_U^‡Rbåef„VÖ£9žæHå-"¥s`žkú„YÒ#ZÖ%mî#;ÇU®¢˜ÈeE¦ep.…Wf# þëÁã‰fEÊbsŽE:æ°¤g¼å®c6á0ÞdvºÅ]¢ ¦FbR§!(áPRãy:Fa.¤ixdxîiÎgh@¦)Nfdìè4#PŽegª¤%ò!ÿ!çkò§\¤&2>Æ6ycf§mÚnÆqö_…òçp®ã;þÊÅt†gƒ:¨c<§F§\€gëu¨‰fD}þ`wÆEIñãè¹è‹nDzæeZàg‹–hŽ†F¦ä&hY¤¢!âh~„n_÷Ù(Qôdæ)é’‚JÖ_%ncST ¶ •V©H@èj>ņÞ—‚imΟ B©Nhažé|VÁÖ©Þ)ž’ÀdÁtAžþ) ª¨@ ª¡*¢&ª¢.*@ÀéyVÁ°¥Vª¥^*¦fª¦n*§vª§~*¨†ª¨Ž*©²B <*¢é\Hj©¶ª«¾*¬Æª¬’ê©ê¤f'«Îª®î*¯öª¯Ö*SÄÀ +±«±+²&«þ².+³6+²Â@ 8«´N+µV+³ò‚ƒæª¯n+·v«·^*°.… H¹–«¹ž+º¦«º®+»¶«»¾+¼Æ«¼Î+½J˜I¤Nê·î+¿ö««†«RŒk½,Á¬Á,ÂÎë½f«¾ú«Ã>,ÄZ*À…À&¬Å^,ÆflÆ.,jkÄvꈀXÀȺÁǦ,¨N,QT¬Æ¾,ÌƬ̚+ÇÆiêì¦.Tª)˜¬à,Ðf*Ë…ËάÑ-ÒÒkÍækÐæìÎò,,€Ã¶Á4-§íOmÒn-×v­½â+®Þ¬ÕVªÎ^ªuë˜+”˜B*X@ÕŽ­Ð:þ…Öz­ÝÞ­Æ.mØÊí¥–-ÔJm¥º”, ”+˜ ,€(ÈZÀͦ‚ îÄm)ˆì´å¢@Ô’lÜò­©Ò-Þ†®è^¬Þ6§Çò­ß®€áR*涮@*PjÔªÁ´Á@릂 ¥šÂˆ@¥Fí¤B)L*t®çR*ÖúDÝŽ.ôF¯»–npž®Üê,Éúììþ.´¥v/ív.ïú.+(¨­ë‚/+$¯Ù*ïò6oO<¯ôÎ/ý’+õÒ¦õŽ­ß–‚,@ë²BÀà’¬°ïú*¯ùRªX€¥¦¯¯ûz.üò„üÖ/$ØÀÑþâ€ppýžëýžfþZmêšÂÈ’íÓfj³‚ߦð÷ ï·ïòJ,èÞm;À 8€ØÀ»â-‡°ƒ­éŠíõ®0+˜ìöªÁùjj /à.p?pøÒp 3ï {-$€“ë1»q‹10_–pÓ¦® Ên ¯øN.¥š/ú°úÆqSðw-GB¹B‚«+×k àÀ#r¹2-Ãf1— ·qÛîüì ³äZÀöŽïï*®›­ gqïÄÏì —ë üð Ãk$8€"§+$0À,Ûë+Ó/¥­ÎPçê¬Èp˜ìþȪÁöÐàÂíöRê&‹¯­É³÷RªÎZ€`27Å)ˬ € ¬2º ‚; <Â"‹q ¬À ز¹F‚ è°;³0;ß²$@B*Ûó .ÿÁ 8:—+9ïð9ßí./e/×ð43OpÇj)ëD7Çl-à$œk @Aÿ¬r!ã r$¸³$DÂF“k*w4àó¹Æ4Í‚³ ÂG;@¹~tH´Ý.´O6ôDsêõ«VtN\tÌF4¬@Gç3øs¹Nµý‚° Gµ½¹j°AS5M¯kX_uM“« S5¹Zµ×õK µQ³þ°D¿u©"5N(õÌ®³Fr 4;³sX“q÷u;ƒpK£ëX§ëa32ïµ÷õao-[¤[Ë5¥ò/ óÿRö\÷qè†ñàòº’1#›ëc§µL“ö-+66ÞFöCN¶fǶ¬Ò5JصƮ@AW5"‡±V‹0óvºz1bŸ¶n—u:ƒ1ôvkqõ"±l?7¯ÒöIØvÆÀg2´² 7owº~sn·X§¶wwiÿ4sã¯sC7{S4go-$´$óã2Gç3\wI[7  ˜5À  à:?5»"øq/¸}w4$ä7z?r{Oø¬J÷HP7ÆþÆ39±Z“k |ðSÿA$=´ˆãr_·o˲ 4õ@ûs‰´‡ƒø ÄøZ§7 ¯7…y¨Z¸H`x#/¹Ìºö?¶‘G¹ s3“W¹è:9Båo¬æ·5ç÷ªð{¥JòÅ‹>اn×}Ðó´û<ð¼ä.âƒ>¦æî¢;lìg„mò’ã€íK‚J¿,÷ûñîKvïïªùó®3Ü6n®_¶ðb®{/ö’¬üï´ °á¾¼«ä.@(a5p‰Ô,9Xª–°2µ@€ˆ%¦²Z‚þ"cGA†鱄3“'Q¦T¹ò¤ I/aƔə7qæÔ¹“'LH lê´gÑ›4‰UÚ)–O¡F•:•jU«W±fÕº•kוUÞŒ;–lY³cßÀ˜€³bQ„};WlI¯*]e€ÁŠA#Ùp°èKH,Ø°A€ƒA/­hïPIð}3ðàÂ0ÿ &à@$É}W’y˜¯_@+ àå Ä6p0ÐÌY0a›{Qã8fྉ#A–L™ñŠÍJ›Þ•>zuë×±OK—{wï¦ê¸DÄ÷Œo˜7o·z^£–‹`a¸/L¾Òýþ‚lk ¿@F‹o¾Òê“d ‘$Ú^‚/' %‘°¿˜î˯À—"!Nɤ°BÀ`!¹HVp 9IúûOÖŠ.»i¬ÑÆq4i;õxì1$7h ôJùÎ ”°@.çb:÷Š¢Ða d²‰êðÀ 9´BI¦l²+ûó1,w¢ÐK ‰âL`Dµe‚/LŸü{ÉM¿,JÆ TÐAÝ‘ÉC{l¨"%–ÏHhÑ&¯ƒ²' 7ìò@)!ÜsÍ—2u€ùd`Nû’ºIÍ6ûüTëL¾P%q€=ûÜ“)§íÕ×_ÍÊÐI‰-ÖXcþœÎRžÔ„Cg)äÒSVís¶ÚÚ$#àTÓLÊU:qåVUYƒÀÚ—$ &]yú3Øwá·×a­×Þ{)µnÙnc õÁM“ÊM]4öwÔ˜YŽà ½¥V\>a"ÀœDœ•´˜lbèx•×ãA¾Ž^|I.ÙdV’•n_¡’ºsÌ9%Œä³i×ýÒåË®´öÁrS•ÍšxÊç‚÷fHòÜXã]CnÚ駯ùä©©F4å»Vžð\-雘àÎV¤y`®ôAj£²ÂsÇŘ€@ùC·¢Ý„„m‡ÍÌõÙÁOdAEÙÝÉ]¨Oj©«nÜñî®ö*kœþúsÀ†mìí³K‡°s@µÌ€‘ÀÆæìÌ7˜$ó‹…3ù¬ í˜0 t˜Ñ ¨Ê©¸ÓEé‘Êø#¹Ê/„tgKÑÐQg1t¢ÛíXñë±——ñǹﾮJ— _ÄðÉ/ßüóÑç8ûõÙÿu{ïáeðÓg¹þûñÏ_Ê­oßÿÿiô>ù Ðq‘ëÊäÒ7¾ý- ÔÉáA Þe%°à1˜A nƒôàABŽ„%4¡M@¿ý)ÏvÎqà aè@N†5´á †Àî‡=¬D!P:ôᑸщMtâŸRL‘ŠU´â±˜E-n‘‹]ôâÁF1ŽÑ èјF5â0 ;c++-annotations-10.5.0/html/polymorphism/0000755000175000017500000000000012635354026017200 5ustar frankfrankc++-annotations-10.5.0/html/polymorphism/caumon.gif0000644000175000017500000000422312635354026021152 0ustar frankfrankGIF89aÂú€ÿÿÿ!ù,ÂúÿŒ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçôºýŽÏë÷ü¾ÿ(8HXhxˆ˜¨¸ÈØèø)9IYiy‰™©¹ÉÙéù *:JZjzŠê°ÊÚêú +;K[k;›škpÆ«ûá[& \¼@<†l¼ æÌ ý5[Ý…m}ª½Õ½Mú%J~u^î™^Å®¾é>ÿŽ9eO_‰ÿ´Ÿ/ÙŸ €þ< ëÇÁ‚Œ6C¶J!CT#"°hÀÕÅVÿ"œÈmÆŒÂ`‘ÔøU U4‰°¤/ŒizdÙ’ÐK˜gªŒ‰RÎœ‚^´Éñ¤Ež!†dôèI’Gk:möTTÔT»ÚLÙUhVs"*ý 3¨Ø±ŸvªMÉkiÒ©+Ù¶íewÞ¼œ® ñË×àáí-\ï0bKƒ%.¾ÔØGäÇm&ó°LY f›3+Næ™Rg£Cƒ6SÚô³ÏªÞz ;¶ìÙ©/оM»µ*ÖCj3ð­ ¸ áˆ_ÔÝÀø å˜cE~Œ÷_ÇÐÖÉ5…óÝ’¯Ïñ3ìñb®j›æ—9öñ=p®ÿM4gĶŸˆ§2|U¤×Cÿ|¿zßeD]YúEG ]Ju”]L@õ–2–§AIÜÅçS‚ñ=Ç¡νÂÞe÷½Õ†Zxâ졨À„Ö­–‹–È!D=ô¡@ŽÈÔ‰@ÉT߀°8_‹FÂc‡3úXã‹ …[”Ræ8ålNδ!“¶uX¤“Yf ’Gb…¢Œ\Ö%™ŽWœY+2Iä1*W|^>é>Ý„‡Ë@â¨Z;îÒ¦gÝ×~6¸aP‚ŽIt68hßØD¢–frkJp©}I~ æ=h(¨ITJ¨¸Š¬wr¶e`²šp+©¤ÕÊW®$ø*fìë’¤„uG¨­Uÿ.ˬ•H4 -€CV «lR«²–b›m{¼r«‰µª‚k˜¶­6•* úx&¹Ã} ‚´W¾;oˆÄÚ%n¼éj¹n¿AJ5U~†j¢»-ä«oºs•ibŠóëiÁÁ¬¼ ƒXo¢ ÂENœKâ91Å÷­-õšÙ$qI¬‹"«k±©n6Ì°–Œ>dÁ ƒ|ïXËœª  ¸ðœö½.¤/Wl.”ìfÊòÒ¸ÆܼLè,u¬TGœu$?_صA[Û¶ØM[¶#_s¶k%/ûmÛÔö,·>usK÷Ýÿè=7ßÕåí·Ú#øà‹^ÇÛŠ/îì«9!îäAH.å+ÿX~¶?˜3íxK›k-¸ç{|¾él˜Žfç ¡þ«Ù«îúD¬‹;Cè1Ž;Üd7ô8Û§}¬Èìh '©ð×õ¾ûïJ<ðH.Ÿˆñœ&¿©óˆH?ŒïÕC}óÜGJ}ôÞÏú<ùÝ‹>ćþzúà[öd¬Ÿ½ûÅ¢žÚ‹ÿ÷úÛ_ù)Ï|:­¨“ñE­€Ü!Àí°BFÑ‹¢@]ðaCÔƒRç¿fdU3ZZ0†)íï|íË_Œ˜òœQ%†kqaû7Áž*)ßi èÇ;.‚UñÓŸ|’®0~# †–ÿX…s!¼a «h ÿeÈ+2‹ kˆE QƒäÉ Q’D%^0,ßu!ꃭ[#TšØFꑉcÜãÿlA<¯vâßhEÙ-ñad£ §H1^1‡\0$óúèÄREÒ‘˜ÌcÈ< ³N’}Š´#:)BQB²‘wTeý6ÙÊI"Ò¨L¤í’“»\F©–3ÐåmâVH^jÁ’Â,™ALõ <Æd%2—‰…dÞ`m¦\†4IÉ^63›Û¸æåæ“h.g›³ì¦8UÖœs¢³šPRg(·åÊ]Xœ|¢É³ô´0±]ì¢æ1­éN›)­LX²yP`ÌÇK–,z¡jhqÿ)øô ©z1øÓ™Ýg¦õ¦”5j%¾lÉdóÈ$aÃB5SÖâ…Q h£øŠi&Ô§9jì¢ÍèK‹©oVÒ¦?MÙ"TZöÔCI¥—iš ª…’4 ýçÁÈé3¢:ªòÁjV¸zÊ¥‚Î[AÕ*ÔÄ:²Ì=¬V`ëUÕº˜Û•t®·0ë¯è ›Ö€¡$ëSa×Ié°~µà_õpÔq–±^}k/ó™Î2H‚Õ^jØ̶3 ­£>wö$ËV³¼+dùõ¹P¶žÿêbƒ†DÿHÌU—…gaKÇ#ȶԵ…Øsh(uéK´EÕiUÑ«­ó¶¥ÿ5­Tá´°%‰‡-}–W\§=7É­HcՅד9ÏF/EÙ´lD>— ]ŒœwÛЩn· -ûØʈ‹¡ ’éNÂå(37˨~áL.‹ÚXÀÞË\ Ê@D‹¢ƒG2Ñ#ŠçžxBcýÛUØQCÛâ…FÕå’VÁÆ^9«a..ªža!0‘H;øÒÀ=µýi‚‹Ú¢ØFñµq9¢‹'¬Bks±ì…" ÿ5C{˜ÂA¾ñ4›b¾Â]n™\µï^ÊEÞ°‹©Ì ªÖÀMq_Cã—ÊRdó¾Fåd–Ÿó•ûéŸ)‚±tx} —ñPÛ¬úZ†Sjj½4Ds¶Ð†4£}E‹LÒU}tXméqŒ6ÓT賧™ÅéP‹zÔ¤.µ©OêT«zÕ¬nµ«_ ëXËzÖ´®µ­oë\ëz׼ ì` {ØÄ.¶±ìd+{ÙÌn¶³Ÿ í=;c++-annotations-10.5.0/html/polymorphism/ambiguity.gif0000644000175000017500000000247112635354026021665 0ustar frankfrankGIF89aÈ›‘ÀÀÀ€€€ÿÿÿ!ù,È›ÿœ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó BÔªõŠÍj·Ü.ä ‹Çd*¸ŒN—Ïê¶;{ÈçôºýŽÏë÷ró‡ (8HXhxˆ˜¨èçAÅ)Ùظˆ™©‰YÉñ8 :Ù¹q¹yŠªIªñ¹'p÷jK7++Ú'p¶(`ÈÛ[è œ*¸šÑªW;—Ü7zPŒaŠy.(«¡ò\.»3©KIM%<ý¥]O«US•ÐЕؗ1ÁÒ‹L«±¿¨¦-‰“'_tz£qíJ+ßQeŠ•’-\n°ÚjÒt"|¶äw‡yæóvŠäl¤OÆùŒzÜf†£K»¾¹ºfçÔ´ëz»]l§³kÓý sîá Oû>>s·ÙÖÄ_wð&ºt6Ò«£¡n={ìÚ»k¢\Š‚ðâ/oàì¶K%;í³ßûÎé.NK°ðþºï)O ^Þ<£ñn­^úì¯6}óΟb¼PÈ35ÖD`QAÂ9ŸýVÛËEÑÒ¾BЀåB oº1½°`-slW¾½L6tôV˜šº&…†!jdXFƆŸÁ!itX*Ñ QX¤¢9„¸$*q‰Ll¢ŸÅ(JqŠT¬¢¯ˆÅ, jq‹\ì¢W;c++-annotations-10.5.0/html/polymorphism/implementation.gif0000644000175000017500000001537212635354026022724 0ustar frankfrankGIF89a‘êõ8  """###'''))),,,222333444777888;;;<<<@@@DDDKKKMMMRRRSSSUUUXXXZZZ^^^fffgggppptttwww€€€ˆˆˆ™™™ššš£££§§§ªªª´´´»»»ÀÀÀÌÌÌÑÑÑÝÝÝîîîÿÿÿ!ù,‘êþÀšpH,ȤrÉl:ŸÐ¨tJ­Z¯Ø¬v{y¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡t/+/¢§¨+-©”-± +^"c´k1" +±À±·¸º`¹­r f¼n¶b°Ës+'3½Ès-"13¼ÇÏb"¦k¿ 1+êê¬ÄbÇÙn'Õdçmâ_¿ås×fœ(6ï a4,³õ¢D 0+¼}K!âÝŠc”Èå £ÄMܾĠxâc®%þÉ›ÌHç]ãÇRDÆ#zI÷åÅþ ›ijÌõ¢Å?/’–( ¦åŒWZí¹ôhŒ6Á`=ñÕ‹•^¶aU @„µ8k¶ÃNe¾P¡E…²ö>f 9ãköÊ  ¡|ÇbÀ5‹ö„kg ö €)Åq5Ì­+O_ ÂŒk «Â‰€^Â)¼Kàòâƒ3D(³…Mv ÷RCxL vYÜOé “Kv¹²©iU@ø-·; ¬{jÙ‹†˜—øŠ`>CA‰ÔØJHº—€+¤Å¨ÐµÕs/z½o>}FgÖ±Å7Ú‹>ÔöÑ"yW^tÊõX^ˆç Ì¥€_€µàƒÊpƬÀ8ÇþP‚:+Äg 6ýLH@|Ái—¤”€œ}åìGË1´£N·|UAJ’u÷Ý èß„÷i¥!aüG"’ç)Hâ4yy^Y؉òULbm8L‡U f//–Èâs(bvجõ×sØLHåŒ ˆ9¦(@—^©HÌaeZIá úœ Ì5Lš9â‰h“‹ÒÔ¡.úhKn­,—ÐB£q8ãCa™à‡çðÔÜí… ª_¼H‹¯ÒHbQ}½³Ö“©hj‘H*‘ êCÀ2ÆÖ¡¢V,?Qúšà¢.Š4©•¦Æ 2-Ð)/&à«Ù"F ¯ÞlSxþ¦ˆõËU¯ZãHؼx_z#y²±r†^f 2ûYÈu-¬k BÖ‰·Æ&9!¹3@Ìl/è"¼h@~ý˜'yÈz1¬½æµb0uÕr,KÒ²,1 =Õì @ ÙSŸlza(\·½Ë '¦¥ËÌìóŠ­ˆ'†Ìœ›Í)¬@@,óÖBWo|GSÈ}éÉM£µÁŒé€w²DÖ_ï)2ʬ‰J:3PÊpbrœ  ¥/5˜Î Ó¡±¨D'JÑŠö“ ê4(ú …r˜¥ <-JÒ’š4Õ¨8éþ’P,4ƒ •àCeÑ“Úô¦üL©JóÈQOxô—©0kŠÓ¢ÞT§@<Á+˜Ñ ªK¥¢2hƒÈ„0ˆ`VKØÓNüTƒ ¥©H‰jÔ²’©.´Ë9©xVð¥Œ*XyW<àð”Á úˆA¹^®¤Á9)xDЪ\eiGÊ ²¢73«d+ŠV-ð#Ý ÁOÞàäìa)(Ú–ö§½ì×úÀDð´Lm;e ØÎ^u³†%aW9ñÕ †u¨cìd‡ûÏÊ–P©„ÁVqàÚ2QEI#!ƒ <`‚‰<Á @ YçJp‘(XŠCYþÚ`¹8Xä")AE¢d°%x€ü–úI»‚öœêï«  ÒàAsŒ’¥¶€òÝ@s#È^ n¶Üm9]ÚØB–¸ÎiASƒRvwµ]* º{Í–´8@hUÛ‚Ûâ@.No¥AwÖåzzNc6ª€u- dЂ|ÒÇ>–qA€b“(^°^+HƒŒž½ ”°&z‹Á˜÷Âs= *Êþa üÖ4 Ï?Ù®’Sc¸¾Åíà´ûÜ,/(Þ@œ·ÛÙ ~ÒµVͪ IèÔïÎp¼+Xs§J|ÆSÅ´³oýâ ÜÑÉ%€ç"ÜÖ^% Õ+0©Ùþ\Y%+Pìy\{–z¯žuÒ 0PdVip]ÜàæVwxÙÓ;õ¦§X»Î^í®ZÝÁÝêg®hoÐT~ x|zñ‹0d)á[ ~ò~Lí28ÃÌyÞn0ç|¸;§à¼O(I“kÐ2øy%Yl··¾ÒD}iY?AÚgÐöÕ *I»àwûƒóB9 õ…m…-PSYÐòd뽉KÓL•Áœ«ç?/Ùкð;-a 2ýËÑwÓf8B4Õœj ¨@?:†®†ôqŒŒ:0‡R§Úyœs²Þ7^à~X¥ÐED‡·!2Õàþ! ""3'åv ¿P5êpd°yÔs•vsCjÿgTxXH€Y”€ÅG Ÿ¡v"%£ÓnH-(0b ØÕ‚Ý·aüg‚b„‚_Ð5'ä6H!7óÛò Æ×ùwæiÚç<(‚>S%„V$„> å@1æ"}‹B!c(¼0 ¨â ó…Ö0…`¥ƒ6‚WhS#Ø^[È…Tä…Í1/3dƒ.CJÌ' Ã`pcƒ7¸Zøi;X‡Eu‡z§‡_ćd€8jpe@+h€ƒèˆsÈJœ”‡ÎEŠ”E– žH‚ ¸NÜàLÝ”M²ÈMÌ4‹±þH‹ÝôLÌ$YˆAxŠW”Š°ŠxØŠH‡XR’˜b¦ŒM$Œ@Œ“X…˜ŒvØ‹À֌θDÐèÒ˜^rèŠÖxTØ(oÚ¸IÔð£×î6Ž'µŒíˆŽS¤ŽŒÀŽáxŒðåøVçøA‚a2t¤WäÇDSÖe~µA·_&d‹€}TøeV¸µŒ¿˜A2@ˆEkuaA¸VAvJ<’›víL1FZ+És.iAIWc,XÂw øhŒ#e‘Ù¢÷·\F¦qÂtU¦'A°EiEy{")S+™[&&”ôYãåv?§Z¯Õ{8@"‘Šð(Tþs¨“gÅ“ß—A* zs¶pûÙÕdX‡ÝUpiUŠT½§Z7°p9cç%SÆ4cÚU*@Yµ—w©Y'@?øåvpUç¦Hxæ˜TX‹`Záå^Ȥ ??§X†¿aèÇ Àˆ]–9)–µŒTo†æVÍEkfçK2°`XyY{ pt WÇ\xÆ:˜'GtÆ Ag’ùãÇ\)¹›SÙYnu(†W…ÆT¥•vº•&ÖsžÅ£'ÉŠÔ–²IQ¤^ê%ŸŒæ^ƒFŸÚk³vL40“éej€L.¦Z/…ogþ~´hƒ™šò6”Ä4ŸhG L‰h2æj(@rÞAt¹` çb™TVéAór"»q¢(š¢)Ú¢.ú¢+ú¢-£@£ fëYŒí)Žï9›Pf ¤f®éZ§TÃv[Òi c4'AÒ&Iù]œ·õ¤n%Èdu/6ePu¤¿zžéU Ô™Dž#´IУüôT÷ôpè[°IVlªa>iA¶­×lƒe½w¥ ú¥¨uY;椇g g”Îyn§Uz¨š™ àŸDç§P¹¡«µT0ÐvsÖk­Es§é èkZ§ÿ§9:Y¦ªOËHd¾x þcÇ&ÚÕNx O- •¦]LWuJ…u[å«Š´T{yeáEbxÛÐ{‚•HTú@Çêl% Y…Õ*Ðt8öf·U«V×cK§Hn•­(­gt•¦`nu¦‰þ…•fš¦¤Úªý§#ê8I§ô:fdù‰+„¥ Dl${%RhYi1F°2õz"Õ’„•"™zÄdÙVž ûšO¨š}«êž{Oy§Z´—KC"7B6°\g™X¥ö±o g©†ŸÀ4§ÈH¯!ÛF °gQÚBN¶²êCóRª.›pš`ýc•`É£E›³ôŒóZ´Fëš´´ú(µò(²ODþj*µS›ª éë²N»µ{3^k¯$dµ±ù±Yk¶U´I €‹Ôt‹µH·Üd·¹x‹ÕôL깶b늺˜‹w{·zk‹ÒT¸xk¸°øM¥µpÛC›$Šœt¯‡¸ÇH¹”dŠó¹L$HšKH`«m˜»J¡;Hœ ¹ž»ºÆhFɺ°[µ˜kF»¶»AVK»ª{»ž›»eôº¼¼cÕFÀ+¼Æ»NÄ»»ÇK¾KFµ»¼ÆÛ¼cT¼Ð˻҄Ê[½Àx½”½ÚK‰Ü FÏû½¶¾•è½ä „æëEÔ›¾«»¾]4¾îû¾³[Fò;¿2Ô ´¿þ³¿\Ô¾ø C {þºîc¹¸[¿d$ÀlY0·èÁÀó·#À[t¿ ìB\™ßHºÉ›Á:´ÁˆÐÁÃËF Â+$‡ ‘"dÁZtÂ(œB*l$ܺö‹¾1 S«9a£[ÂkÄÀ9|B3\5¼£gÃAL“-…ÀäÂYÄI\ž5i Eܱh„ÄQ¼•;¼eTû¿ <½8œÅصřPÅ6×FX,ÆÞFƘÀÂ!äÄX”Æj¬šSŒ`x-@nv`ÆÈkÂa<ÇÎÅÆiðE¨y›q°_,FP Èt¼;pÒ@(A+/P#ïàqÀÇîèÇŽÜBy1€)òð †R˜Á‹£n‰,»þüÉ),ÈgðÞp/ƒ"aË1Šçœ ÇÁøÇ€l…A·< a}"›ÜÅÌVÔÈ°¬ÃuL_ñ'nQÊÈÜ +±IÍÜÃ6ì¼Â<Çên_à Ú )ÿðÍ€‹Æã¬Æê(_a(ßñubaé}pðË‹Fr<Íò&ËùP` š‚4,à !ã1 zrÈkЯLÐBlÐo%AíÉ}ÑÕ< n¬ÈýÑRÜRàlĺkÒ‰Ñ"ÝÊ^\Ò,BCL½F=ÓÒ’0Ò®ìÑ:MÓ.ÝÓ0ýÌ-¾ñ,Æ5=7­FÒÔ;Òï ÔPmxC­ŠþÎ|¹2]Õ£ÊÓXÒV|FO Õ±´Kf}Öh}Ö°ÀÄyÔçËÕklÀïÖgLÕp VQ[´j[Án;IÅ›t±R»±| Ïw­š-«×E­Õv}Ø•×.KØ-Ü×]4ÖA=´iË GºÙœ}¤*@Ùü×QØ«Øì³ÕŽýV¤P‘Õá”Ó:ݵƒ½ØádÙ:Ù³M×qÛ3ØEûT° ÛpdÛ½-×sÍ…¼ÍÒlÜêÃÖ%ÚIŒz=ÝÔ]ÝÖ}ÝݳDÜ©MÖÐÝÝ€ýÝàÄÜ=ÞÊ-ÞæÃåÞÜìmÑëýÞ°ìÞò Ëñ]ßÃŒÞø=¿ô½ßs|ßþ]þER™Fýàþ¢úÖþH§&³­†j žjÙujþà^ážáŠä°!´ï”’â¨&áÞàô á#.â(Ž¡v'§>¹Ì½>`»ÜÛc¸ãìcŠ>߃т>þã@äB>äDäW¶(PÔmpU«ôPP>åT^åV~åT.åX¾å\>å€ýªIú ÂK-^9€pMFTn:\m>Y( aÞYcžÁe7)’Ö¶û¶þ}ç€pæ—{³­êçû è è Lè¦jèøè~àÓæ8è^[¶~ÕÃHÛþÚÄúº¯Ž^ßÞŠÎéŒ^§–ꘚþ.攎µs^Š/žêÞ¸êtÞêM !ë^é3nŠ|îé™Ø-—º.Õèä뎳äSç œŠ‚=݉ÑÞ‰´ë‹^é¯nàQ½¤°A*nhBÒ’Îy¶N¶Ù®íÝø Å`)P|É}S† CîÕÎŒçî¶énàë¾`­‘ÎÓW‡±(󢈚—ï üëÊÎì<¾ëCR °Fs3pNs ïË ì¥Î¦´éï²ÎîPÒ21§0ˆ ?‚ïHòØñŸüïòƒ!çÑ°Ê×—ï'ìð…ÞïÅî&) ã„:v&“*jPîó®.óŽLóþ'ÿ#ù<5B2‹Ò1.ϱmò=:òCßE_† MÊ &ehl0êaóÚ~r|°™I±Ç?è]þ÷€ø‚å ô.ëëèÚ›öÐøŽÿøù’?ù”_ù–Ÿ°†èˆ}íQ_÷]½Ä`_ÉôR?Ì‘>õ·žúä¼ú]©øìIêt/úÔlì?ú¯û¹¿X½¾ï}¾ù?ÔâK¤•"‰XƦU7ê| ÷¦/öïIöÀg—{ßЭZvžz¥§}…Nt²„E—ÊOCοynû¡ŸBª×kçDק¥º°%[_z[ZØqñd¹åßþNt)C@pTfEã™T.™Mg±@á¨Uëõ´¹n­2 ÉeóV‡3-·–N7«Š†›âNTÙæD†®åfcä¡Š†î¤¤¤JG…ÄêÄÀæªÅÆ处"åÔ§äa£µ…ªOæÁnïä”® f#ÑŠÄ%”*´ñ§…‚uãñŠbk#SNzz eèIF)û)i›Éû)ªZïÚ lM}]½Íœ|šà¡ójïªB«jü†ÇJT6ü‹V&MìI’AåF…‡6Æá Q±b•GõiaìH>W@¤úS¥B*€22ö‚GEÃx3«}±ygNþ;yöô©ß´,ñе3zÔh›ŸKyìÇ¥åH˜TZ<¬’ ÇXif Äç0žò{„BF'C§Â:Õc…¢¥²Rq°„#Ã-̨4iZ[ ‚„À‚\˜°aŃ 7F¼ØqâȈ+o(¹¢H9w6Ó†‚ Ñ£I—6}Z†‹/¸Òµt*,**¬nµ—@=Q°(pK }=Q:ÏÜ€Ab¬"öó—|dòå+Â)5(<å®Âer™Ï}é~¾ó;ërNH„Ê%zÅqsUÑrñ Œ­}%¯;Ž†&Òí Zä¡@ eŸ*zëµäTpÊ9*hˆ® þgHzp½™¬@ôDl'< á@aº86‘E5Ôë‹ê¨°ÅOªh >©í„T(cZèñG{2„†@À?XhŠáزJ¿ÂR¤„áNè$@ˆ¸q˱ k8˜6xH—Š4°J*Jx°­ûð»õ$…À ªï2oÏBÇxÑÎD· ¡Éçã†G늅&EÛâ$ÅTÓ¾¨¡¡6¸t‹IQ€ÀÐTSOÔN+AP.VTUODK½WrlÐ-×x†´Ó«^§Á“Ö=ÃcʦX·˜µØmZ\ ¤µhcÔ HkµEˆž›±OñzeöþÛóžÝÝtÕ]·T!(wDü41QráMÏ võÝ—ß~kz÷ÞîTP;í ø¨sý]˜á†µæïPðvâ0*6ãâ0#ã6®¸ãÅ9Ïy¡-ªc’9öVã\¬Á7œðÃüðÂÜñ°BÅ•"Ç!WØeMík±MHö #ÅÐbÎè!^t/lÌ£i+Ÿ$ãÛç.“/ÂX±+],t-w4À´½#¦@ôéèÉ!°éðôJdøþ¬!-]Œ?ˆ£ëò>|!ò‰ðYS)H÷ßtÈ`BU ˆ°‚LÌÀÂð ¶LHÌþ¤ð „Ctån‚h"3¤ A…%ž8EŠ+Т(PŸ¬_EF(ÈàŒ.é… Zˆ¡VÌ° n&|RãÈg]oÀ€#.\¶ÄRÆh‡„$~ˆä˜O˜PÀ)"¡Sú‘4WAä3^N±Þ™bJ’1P±•DÈ`S1Ø©†M€"QÕaÈ€U¸àÌQXg`Vp)™œ.!iMÁŽª¸’çfé‰ÁB¨S|¶i,¨z… K‰g$.È¥k1Ãkæp™¦0T@¢GäF–ÌJ!Œ"0+¦~°k§Ükcr&#—È(pêþ0Tè! ÄJDµˆ±”Õ^kD–«^Á‚ ¸ ‘h»…Q/u¸É9UGÀðË+=’ô^Ë*ál¥‚GC+ Aëé/þÒ0íÆö qð®E¢¯Ü¶LD@!o\Lá~ÀJ‘Û†‘®¡µFkòÌaÌ[ÅÉž>ª…·ÇB²§¦MT›ï»ÖôÏÇ°)¹ÆP¼Æ(`oÅÀEX48z oVE×3îÊÀ—~6e“»MľUÊvæºÌm­mfï½b ±â¥,„§°&dXɹQyz³Ú×µ> … Á4E‹Šåh&4Ú挿õ:ìˇø~¹—çM+Éþ 2>á´ÁQ ‘BÂC¨Ûz¼ Q3-þó_€`#QmÌKÀë].8] ×È<íö…V•´È—•Taœv ‘%¨<á­÷ ÁøÝilId);áOShèî¸i¤9+B÷A<—¢Ð²ô—³Z1Šp>c×–GŠ+]ÊÐÚÃ%wU kŠS댰§¾˜¦BÐãL¾ÇˆìÏ Ãª›?X€‚@Ž3+ÂdžIƒp‘|I¨äAðÂò¥—$È]ådPF4í™ÄÁÆ‚³¤u›ÇzdÊn¡¥K¤ARw÷´pÉRo™SbaiÐLÊŠð¨^EP–&‰„~N3²O¢’”)J{Be‹g™x[¼"a©…š8 ûÒ¥œëíû×h¥°zt…ÇÊÕ R$:-%B`ßBMJ·C‰3«è‹V¼@þ»ðí·ŠTP7å§ðjü EªWŒ:Uʨ;½¤^ƒ²'µBg¾ AZ´TT±,$gšç½"8ì>e Xˆ»¾íÖKÑLŠî2GüAB¨U#½IHáÁ-PºI‚EY{§uUĄ̊h¹V6{°¬ÄU24…&òX …ñwŒ#Ú¸\ƒÅZªf(*$Ø#TEåÂP§ÇL^s„–õ‹ÿI–E¾ˆìw¡U¬Hƃ…€Ä…ÄË<ñ^¨p·Ú™Ð8Tq’1Ä.YÅà™;¹¼º!T¥èP’QvAˆ.âS¨u‚W°’œõ@#MÃòâÆl&þ÷¡2ÑØÍTÜÁ⼨D ‹†}ô¤ÓÝG“®™àh=h‹¨ª…]+ iëªZ7ò4ìi*Õ2X¹±a¬NG6o…ã$ù°r[Ö|H«õ$Y6ô2òl« Ö !&°\j_×õLív·CÓ ¤*\$pÓeE›Œ ‡®ðð"»bTáè%äÃ@o ¶&¼…킧Öa鎴¼]´$˜Àáî{R¼¦†Ëâ6ZõÄ[r4½˜L ïS(:~q¯¦\ä#§¢äøä!÷UOG˜rs\ÕŽ'ä'9§j„M©9kn'ÆE!†AßLo’Ž™¨þ ½eMoOÔ›wrybØàyÌvÅ¥;<¿ºÚ…õ .qˆ"=_ˆ *s²›%@j…Œj|Ò™>ÝêkŸxõ4 VÃì}2]éÇ\´tŸèÅ2ü»5Ä‘µ¨ìÏ<¥ªWùãgã _E§»vyÀ+Æ6¿qó_âΈÁôÃ2ùNã5Oû%öÌI~-áz°¬%4 Qïý•ø¹˜Ïƒ1Iòz¾Lä(µ>ØáNâ»Ù/I>26ê` {mç¯ÚG’ëgÍüÈ>L&ɘŒºÓÏXÆ3̱{éÛª˜Ê3œMzaä„ë§#Ù€s×þ° kóezµ—þ1Ì÷ÿð6Ì0Íæ úvøh¬0iS‚ñX‘x­0{'¸‚Ö1õÇ‚0ƒ28ƒ4Xƒ6xƒ8˜ƒ:¸ƒ<؃>øƒ@„B8„DX„Fx„H˜„6(=nÕ„Nø„P…R8…TX…Vx…R¨„·€…\Ø…^ø…`†Tx Ê&‚fx†h˜†j¸†l؆m¨…¶à†r8‡tX‡vx‡*… ‚3|؇~ø‡€ˆ‚8ˆ„Xˆ†Ø‡‡µ€c‡ØˆŽøˆ‰’ˆˆyx ‚#x•¨ˆ¢P_òv‰“—‰^剚X œèn¢˜ §he©8Š¡PŠ¾¶Š¶‹¡Š¬Ø ®þ¨Š´x ²ØP»X‹›p‹Ö‹¦ Œ6—‹¾˜ À˜ZÄH Ëè2ÍxŒ”Œ³xU±hŒÅHШ ÒÈ‹ÖÈŒÝèŒß˜’°¿ôŒ¡`Ž‚Žâèä(sáxŽï˜Žñ¸ŽÐŽ×H†óH&êH‹`~³H"üxþŽØHù8&Y…p-Ó™ ‘'B‘É-É{ 9y‘„‘ò˜ºø‘A²‘ Ù"É)()&é"-™’z°’úø’˜“ÿ“2y4É6y :éP?¹“{ГI’Ã8””D9F)$LéQ¹SÙ”oð”'©”.‰”÷h•‘€•þ0©•“P•á!–^é”ËÅ\ék‰g `Y‘fÉ+s)”mù–™–åX—8Å—ÓA–x‰qi"€™…¹‡˜d0˜Âç—˜‰™ŠŒ¹”ŽÙz—Y–w9™|P™ª•™Š ™f!šœÙžy ¤)© «YšYpš9 š†)›ˆI›®ù° ­ù»Ù½y›T›v‰›9’Ài‰¿ÉË)w¶yœ[œùœ…Ðœ aÐÙÒI•ÔIع ß™H¥—îXœŸžÙ€žâiJäÙ•º žÄ¹žy|>ižžŸŸhŸòÙÛ©ø)ÿ‰ŠÝ¹ŸRПšŸ8þ  š# ª‡º ÚÙžÿ8¡¼‰¡¾©¡š ºú!ZúÙ¡gð¡µY¢HÁ¡ 1¢Ù‰¢Šá¢l £%©¢&º˜ê–ù‰‰6z£b£‘É¢{@£IÙ£> @ŠDšKÊ–GÊ“9‘BªM: UÊ™I:šSšW Fú¤¦¥¹¥xÐ¥ `¦™¥e¦bÀ¦I¦7ª¦dá¦`@§+ú¥`bjœ;š xš§¯¹§, §v`§š`¨M)§¬I¨u€¨7ɨª¨?á¨[@©ù§€z’ê–šº•™*›º¡˜:–Ú§¡z•‚Z“¥* Ÿjª­šªcþ³ªõ‰ ¦xª:ª!ñªVÀ«t«²úºÚ¢¸¾ ÇJÃêœÀÚ—Í:ϬK°¬×Y¬ýf­–ˆ­âI­÷¬›£­µà­âÈ­à ®3j®5*­üI«Gi«¯ˆ®ÀI®Ú ®ÃÄ£êÊòšžðʤûê¤÷ªùŠ ôúšýZšë®­þy°XÊ®Pé°eP°³É°ÿJ1›•k° ¢«˜ ‹ªÚ±)z±i²ïù±c@±ˆÀ²¬ˆ²#«°Á¨²x ³ +³ÊH³oi³ÙJ²‡à²†´šÈ³$Š³Óh²‚™±aé³A«³œ ´ŠH´áê´_µƒ`µZ(µ É´þÕIµ‡êµ‰ª´rÉµÞ ¶J¶Òªµé*²¸ˆ¶Áª¶Ej´j‰´'*¶„i¶•Š·—J·f·¥€µ$涋*¸©ê·þš²„Ë©z›’†k¥‹‹€ ‘‹„+ “{PöÊ·8JŸíʶ3›¸™Z¹^*·{ º€*ºgú¸Wp¹}ÀºEˆºç©º½*»¿ª¹›ë§¤[ž¶;°{Ÿ´K®;¤¿«¬vÛ˜¦ËœÃ+•É;®Åk™Ç+¼Ï[­Ñ{¤½û¦Ó[¦Ë‹™×§Íû™Û[¨Ùûhá{ŒÕû´ãÛÁK¥ç[‹å{§¹ëž»‹›Ý‹šë[4ß+°õ;Šíûµ÷KéË¥ù;´ó›ý;þÿ‹½œ«¬›ÜZ |µœµ <œž›³ ¼Ÿû;‘¸™¿ò˹{Á×*Â=ëÁH:ÁʹÁDpÀ(¨Â”‹ÂÐú¾JÂÛ ÃÜIÃmÀÂà‹ÃЙÁg+Ã:jÂa  ÄRÊÃÇéÃ@éÂ%†NüÄQèP<ÅQøBìÅGÅZ¼Å\ÜÅVœŸxÆb<Æd̆W¦eœÆj¼Æd| v4‰pÇ€` Çzì‡gÌ{¬Ç<Ȅ܇Fè^|ãj}ì2`µÈ\ $4EÄŽ¼ŽÂz“ì’Ã$ xÉx! œüë!`ÉŸlX®â$¶*ĵYKÑBÓJN¥¥;…³"zSV<ÑåÕàãÔFÐM­ä'›™M?ãí‡4gRã3»-K!q¿} Àìì‰@$´\àÔBçÂ-YR0> Ä€#rq.õ]Tù²þQ_®F2Ãl¶5cRÉAäœÑäg_PwuJgæ ¼–Vt ž ð‹°ÔÌ<ÒþšÑBD‘…P/óßBñ 5?YrDN¦ M2ê öÈÀå(¹ òõŽ+Á%}u7õ}JþdèJÐïµpÊ0ÿ˜~]í]€ÌX€EÏ#3š ÏóšuÝöÓ@^.5V !çR/àC£ål?+L>ßcMFrï†_±ÀC- ¯¼õàÖŠöšÊ,ŽIßU‡å¡×-FbTî~òƒ#g6$}¡P ”aèÕXðDÝ»qJ€žáÿ ¸Œø®ZÏ ž´C÷OíÄP'£FzMP_„öo86RX»óu²ÙGò'Õðà‹æ³Ö~å]µSFb_L5P ÕݧTVIãÕÝ]Qn ÿû‘ÀØ¥…OCŸ5ß3\Â/Ömbô„±Ê L‚“@ðr&ÒvþÚVd@hEã™TaBÅRVN®"k*,h„ðÈ*3#x øSR2Õº=—uûŸ×ïósþ0Pp°Ðð1Qq‘±Ñq0¥",åPA„pFDs“Å,)E¤¢â#Å“f3Õ)µ•%é£jÉ%´BÃDiÆDcÔEF“’Q¤àu)STÄØÈåCÔdU™†E¦¹BDبºUs™&³7Æn¦`ûQ}Fa•>^~ž¾Þþÿ¸ @$²_> .‚QNA…ܘZøbD‰)æK!¦¸?m”«øä:48 9ïÚ“+Y¶tùÒŒ,ýû3ƒË%þ˜;yqñ XÏu3ÄziR¥!w) i” ²–VU˜ €“V ™HÈlX±c5ànë¬4’u›ØT¨o¹£{oÞ°qÕxÜÓŒŸ¿z ×™q1 ´ÂØ\üräˆ,¸<(Åç0wŽ%ßeñá¬àÎx>x}ujvû |àŒG†W’—UsE%åCÛÚEˆêÞýxð:‘ȤÓs›Œˆ¹ÂWÊH«xZà)¾2·~=¸ÌÀ¯ñÐ’”¼v‰0L@W@Š;ó:Å·wú°¶‚¼KYþ}L^öÑçgÒØ¿ÔË,K¤Ëƒ< ìÁPªQ0 e¯4þ5ÜP¬¦ÔXîòœÑ"åÒã @©@Œ³²ÁoÃsŒC‘F#.Äk†Á¢ì,Ú ‘–…ÅDU Å)µ‘Ã6j|ò){é©æ=„X,®Ö¦4H„$£Ä\ø²¶\ E„^’T 3¡\b½9Ã:3 5×Ä“!˜\ %€Ô)à>C"®‚árÁ1YÌ"×, ÈnÜœ¢€JY@ÓÎ#d0ÔªFB‰ï(ýó6O\ä'T‘‚=Ed Lk„Œ–XóGž5A©%‹*ýfOB!ºfÍH5Ç 5ÐdÍWKU"”kMÝ $ù@“kåIþ%hud$…zu)>2|‹çšak%0D)q3÷ÜwOP ã`67§‚h©¸\jÔÖtV "’É(œšrEm¨R«Sx鸎³dc“r2Ù*Z¦U, @)§Ü$$9D1ä,ÝXh0Og9É3cÝbKÉ4Z&™B³6f!øÞ{ ®—ꪩ66j|•Iöáuœì)>‚â#°Ø†7…èȈS‹2! •h€ÛPQ³ðBì)*àí»$ƒ2†‡C IX5 ´,j€‡nJ»õ{HÇÚHCbo%éôÞqOòðƒÃyÒ3à5ý{¡QP?ª‰½'.þjV:¢à¬8Â,1B§ œkßØ)ö`à‚¶o=q¼€Îù–º‘àBt%@{à‹igÜ]Z¤‡ß±g¯}z†ú‘á07® —ógx*åÕݧaÔÓßéla?"fÐÆ•$Sß-"fHpœÜΑǹŽq*Ñß'+QE¯egqȨ$Fƒ‘ìêC¨Ãظ@31C Pi‚i0¶£ðåò›”Dp»nk.1ƒ7$Q«‘Ьp$4‚<·m\°ákGCàEÀÍs ‰ÃH¦½%Œ-x­¨!üÂÇ„IñÖ$”õÂ)ÀQ^äIÙŽp–"Xmdd´CYq½v|þEUi0S¥CB¨‘qÂHWÃ86«QBl´C•ò+¦‰1@,(@ù<ŠÍ4’`—ÀÆ#Ž³aãì …$1HL‚-x¿3˜rV‚tʈâÂ;²*Œ c#¤¹Ñ²'jœ<²À9†’9¬ƒ æ¶Ì#99ÝÑ„EÁ™Œd4Ÿ(È&aaCG&nYÂê@ð%Ú© .?röDi …س<åЀÁó‰Y´¦ îI ûÚXÔ 328ÈeùX`?1Ò#yÀ+Êc(mÚsè9»wJT'ySŽŠœ"È/ÐnMÄ@eUã”ùœóþ=~@éN⨅qn ­ñÕj•¸z5Q¯Á‰ý¢È,„Bÿ„Û´°)Øt8,£G­§8Á3ISx* ¶¸±°¡+…Œ]´ú íË_Oã4vÏÒµì¤Jpµ¶¢3kœâR‹A7²É{ÆF9"$›Æª 6ÁH èë[2á”Ðu58XÈ*bËHÖˆG–YlcÇ’Ê^V'‹T¡Äšb62D'hI ,pj–M’D£JûÕÒ½¶±•íliK[ ¶¹ÕínyÛÒîRíLÞ¬V\ã¹ÉUîr™Û\ç>ºÑ•ît©[]ë^7¹¿Õn<ˆ‹]ï~¼þáïxÉ[^óž·¹ÛU¯:òÖ[÷® À6°‚C®·%"·ðÛ_Dä  ­)Ò˜À ‚óáÍ´OÁ,¡Naa ç¡ÂùèÒg/’:˜¿±2<-ZfÄiÂ}¹RâØÅ1ä‹¢_ۑƉ◼¼0_'ÆA ksœ-&ÈE„šºA¯ê+õ{O’ "N`)™_£pˆ±Ì‡µ"Äjó˜9Pf3Ÿ¹Ì³˜ PµN«®Á¡òUd£wyÞ2Žñœ¢Õ À@p¼Ñ‰Vô¢Ýèœ`e†ꥀiÅ95sþ~VûìˆQý¸Å\î4üž#¸)0…vA£YÝjW¿Ò€@›³`iÑ FÓ)ì‡F­ˆl=&×#®†© èB¿ÙÉV6£[PYÓZ ¤˜¬U‚=™Êø¨×ƒp°EãØ ÀÀ½lsŸûÜÍ楧°ž;S»Û,ñ,¨³Í† "9Þ"þLTÀ”Ýø²[0 @{ ؾKµ+"ËzÿAua¸z‘#` «øÆ9®ì¬ûnB 5Ÿ½:“ñ=6P¡[&^Ú]Ž xÇi^sW»Ààœº5Ëó½“v¥ås%·IŽß ÿ¶ùÒ™~s°;1ô~þIËOR ©½©]xÏ·{«ha¼éa{£UÀLèð.ºPŒuj<32T廙O=ïyA 0@­¯ëZÔŒÂGmËá³.øŽ¸[ wÇ;çg? „Æø¤lxå/6Aæy¾vÊRGI¿ûãIŸ÷H¾ÓŽÈÄ[Š^׿ö#Eìi_{óJ½%µ8F_zßãýˆ¶Ô%ÂzÛù×^w“ß|ç/÷Ú½0‚ß_Ÿô' €TU_ã‡î½áÿøÉ_~ñû Ã~2ÿúÙß~÷»—™z»cUì`ÿ¤oAß“Úã{®±Ð¯;,œ‚mþæGÀþî/ÿðñZ@øÎâÝâÿJKïàçÇ ‘°"Ü8ÀC0û$¯ˆo *´.Ð2ð}6Ðóiú0 ÷DÇhíê@AKë€ÝÇë „f®pì\€ŠŠ%v³zpö^° ð¯…nª ³Ðñ ° º/X8€²ÂeÄÀ°‘‚P«dà;8`KoûŒP IoÚ¬&°œð² ° ¥—Ð¥|ŠNÀ…@îÚé>ŽÒ 1ï¸0+¼pð²ô›Ì‘ü—v (}ŠPàT@ïJ ô€õÖ†óîA +‘iþ ÏÐ)ÀúâÐÜN`óÎq SQïT€ÝÍpŠR0SÄŨÅèT  ñíOÀW­­±ñ¬ñЪqí@€ÈѲQ_À÷®Ì¾1Ñx‘[MÄ‘„15îãØÑ‚ñ÷– ѱQ •qùš‘þ¨ çdç§ùQ0@…€ Mí$o dPÑF „Ñ#©ê€_@Ö(-ÐƬ$Ñqû²€n)R ò¯/#Ï¢¿pi ypqç Wèçg—ÂíÁ±Í2ƒF`Ù $-ܦq&G±ñT`û `Ñþ¬±ïè±! >Žúí$©oÍ@@Ñ„O ©Oã~q€  J€Ñôñú\€Òþf!^‘±(‘{ò Ò0ç¤à%•­ïÔÑZ ØÖ0@Ñ–°&_@ø 3Ñ„//ó&-ÜîŽÒº²m33Ѷo!Ò2]/±ÿþŽ±S(³ ¥° !ħ  ™­,÷24Møz¯Í-ÜÍ_4“r2í+1ò4­ïòòÌúŽ+Ûq‘-6±»I l³«p“†RÓ‹èÆ9—mûÑMÌMøT@·SÑ$S?Ͳ8-:‰3Ý‘Õ"°þ^TóôÕ¾ûæ°½ ñ6ƒò"t ÒB‰rMQ§M;îì`Å "Ãm%KÚˆþðWu 1$ýä m!k5ôÞ‘Óoµ^PTV…J±OS€S¡LQêL{l0ôZJµãJ@´3¹²ÙT­#-/…±ÐÌÌxå1#m­ìÊlHÍÙòØñÑÌ[@Ã58KïX“•–õœš5MWZCEZñ®>uÑ`›._]ÑS2ýB5=yó_Ûc` ¶?Öb;.aïpaTK+`¡$qÖµé&2 ØñbOöÜ2vø•œüÕa}b_¶=ÈZÅN Ñì^QVg©‘Ò0ˆ»6ö )”Ge`GµTF¨fíÑ(•i›ÖiŸj£Vj§–j«Öj¯kþ³öjÍ­ÚLBeqÉe=ÖhídyäÔ&ŸOm×öÜRä!liilIëcQD*ÖK×VoÝV±v’ⶑæ´êvCFU“m =Š… àúY¶'2h;–nËöISm’qÏÐqÑMS}6Q€6…M‰u w@ó)—mqW*o®kÝ(IwM×Y»Fudœ"Ka–œñsÎM·‘7ñ0EF‚ÎíuQ*vn «£WŒ”÷²v7?Fhsó¶sSD7ŽÒ¾¶,l-·p™wCÄm4xw“ãp÷}w#öYÙBàr–sawþx©7~ {½H{)‹{Ûcv’Ò; XTÇwã\àì”ê¿îwBÕwycJ¸AÍ-zÏiz9Îáî'7 9¶aÉ–ƒ!k4.„§P‚9nûD÷‚QØ|Í4Qw[E–§X]‚¶æf×WƒËs‡Y8úPnð„‡fm.†É4‰ut‰/ׇ9Ä)XÙª¸qg˜ãâÓxí‡?u…µ¸‰7ÄqžwãÀØsŘãàøx¯X‡5x{ù7?œ"i£8|…WŽ'¸Íê‰Ï˜a‡uWÝÃqLô¥XMù‘ųŽ Y…™‰åO;ƒ;ŽŽ™éÈxLe(·tñXY<ÄþÆ‘ùå—éúŽ’ÌŽ™5‹×w‹Dúz!¹h%yã$“TÎ×’+7qy¤ Ž”æ>y7Íl˜–ãú.‡“9LùvQ¹±88Fâ}ÑÍ™/”ÇL#³ %!;Õ•RP­—–‹ù”yƒ­Ù?œâ{ýX€™iëUÖÆìU§@Ì2 ö…‘ø…x›UÙ:š •çØ—Sw€ƒ™i9  œAˆD:'_ºž³Yžó8—ýÛ©8¢{XìÚ¹œ¦4!jøí`DaZ8¡_Œ›Ów¤S¹¤÷w¢—îì¹0›%¢fjÀRؘ1Y59‘áþ—.œ#xì–°š¡:¾jœ:ž¹zž¥BN¥_Yœ¹ãXÚ€k¹_oy¬wú=ìÙªSZ‘ÕÚTU®­CZ§Åš¤é™‡ó¬óï–Ђ͸”ÁZ¤ýš§[<°àƒ=Ù®f„ÃÎ#g±!N±û7™²º›«³æ®šˆÇN‡®Sùµ™±¸¹6$AdÙ¼¶kÛ¶o·s[·w›·{Û·;'ïСWH¡[´C LV²÷Ö¹m/’{«[®ÿš¬dT˜yéF`;¼Ã[¼Ç›¼ËۼϽÓ[½×›½¡¸®;»ù §W[®‘»§WyEwV¿÷Ûæ.{þº5»ºÅöº;¾óìùÁ<«(pÝÚºY±\;5¸ ¶ÜÂ/\4Cµ¸çç¸#<¹wC˜ÃG|ąϨO—ºÑ˜±ú¾±C HÆc\ºß9Ź³§ša$5†:Æ{œ¿g<µkü’o<“ë;xÜÇ“e—ðˆ7ü}:|î>¼6øTÉ«|gµºÁU;ƒ<Ê[Ü:Äƽ­\̳ËiÀUœÈ£šË™ÌÇÜÍ ¶ÌƒüÌm¼‹|ű£Íß\Ï‘œ”ç|Èë\Íïü:°à›÷ÑÑ:Íå{³é›Ð»Ü±­ãÀÝÒ±oѳ\ÈŸºÑã:ÒÙ\´/]Ô³o²‡vÓÃþºÓ±{Í…#ÏGÝÕÏý¼0O}±SÀW]ÎòÛÂøÕ¯/ÎÁÉÝʵJÇG£ Â|¿%“»uñÑD\É]Y\À!\Ò ü=ûÂrà\ Âm®4¼8Æ¡ý‚}u†=Ÿ'Ý:œ¿]€"[ˆÅ}­)’, ÀÙǽŒ÷Ö9[БÙÚ݃ÝýKmŽ9s ÄØ¥]nœÅÕ9^|ì¾µÌ 3^yâ-K@Äéµâ™›â9`]ïѾu*™{àÍı[ѵâ-S-.gŽ‘=áóýÏ]Ö“×áíâ…C€zàøOÍ@Q‘?1 84Ç@/[R×þ[r$íýZÏŽÖŒ]õ7ñî ôˆ>Ô­9ÇœÒNÜÜQÝ…ÚË­ƒÂ ›ú¦‘Ûû­ÜB2é ÒܘE O N»²æË1&9 Z€5W¬ë5Ür‘ð»SåO ïún½S›ṫòìÁ&íEXÊU£ÒÃîìbµu­!gn3_OGŒ™[×ÔñÑ1¿~ûV’‚4 ¨¯sÌOû¿uÍûÝÓm½=Z]ì<Ò9 •«]»Ó#åt ×µõyDcÿ?tÑŒÒ6t s¿ßxÝÂý[ÓÓ_Õ?9ˆbÙÃ.>·ù©SN'óàmòý¡˜S‘ú“’ùÆ`þ%—ÙúŽ¼^Â!±h<"“Êå‘0Ñ¢Ò)µuÖ­´qÃâ1¹l>£ÓêtÖEÆj×ò9½n¿‡áf=¾ïÿ‡)´0*9¼0¸P©@¼”paœQ=v}9‰z:-m24ÂÆÊÎ"A¸ÍñyúþWµ½e #'ç—é*??k”Ðƶ0bús³¯uEe+\ÔÍФs›Kaá¢EœípÝ¢•â•º}ƒÒþÚÜï2׶(À;¥pX²R³ºSÂËÎx0/}GԂР½Tx€«^'Aµ†®ÝZU;Rß‹¨$õéæÙÏÔi÷¿aAáÄijE0‡KãÊh½&Èok³ ‚£8Å*^1‹[ìâÃ8Æ2VñuUjãã8Ç:Þ1{ìã9ÈBò"#9ÉJ^2“›ìcþ·yÜm‡«Œ—„¤æ‚X+=Ý‚9Ìb3™Ë|D§Î@¨ž•Û =€Á\ø-Žflç;ã9ÏzÞ3Ÿûìç?ÚÎ!ÀmèC#:Ñv®« Ø'_7C*Íø."þ] ‡,¶˜á ¤˜Hƒ >¢~ÏpÞM×õCu)l˜PÃÚ;”zÅÀ_V?íØŵeà…–Ä*ÖnÁ_pi.Øq˼žXt—CAP‚ÍÂ/ \4¼­ÔÎfX€·]Â[e¹Ó–ÓóZ£¡Ëèöv©zÊî¦9 7Nà˜ Û Â¼ö»Ku×~—¿v ½»dï,( ¼è[5À»5Ö†·ÐÞŒ¸ . 8ÆÚëžÃ©!~+:{¼…)€²I*nñÒ”; §Ò®C®'M»¼….øõ^¤}r¸ %OÁÆïì˜ÿÉŽ úg ¼— ß:p$¿>È&ùëâÙú×u,AT_ d^€4Gö¹_ãT€¤èuÖàþe„@A`uÉÀþõ¢0\ÅœÀëÂt\@@f(F¦€í­HÙ=Öd±` ºà   MÝM 5U \—ÿ! ˆ`j`–`ø  ^¢¨”¢à‘¤€“1a:áBaJáÙÖ „É€ ¤À‰Uð±Š@•¬à’a– ²l!Š­`#™aºáÂaÊáÒaÚáâaêáòaúáb â b!â!"b"*â"2b#:â#Bb$Jâ$Rb%Zâ%bb&jâ&Ž^;c++-annotations-10.5.0/html/polymorphism/internal.gif0000644000175000017500000000272712635354026021513 0ustar frankfrankGIF89aÈ›‘ÀÀÀ€€€ÿÿÿ!ù,È›ÿœ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó BÔªõŠÍj·Ü®÷ ‹Çd¨ŒN«×ì6ùl–ÊTøü¾¨ôøþ€ßè7'¸Q8u˜¡ˆèÄxQè&éÖ÷h9™™VçùdÉJñéØIxÊQÚ4ªÔ*±*š*õ»T{”ûpë:›ø»8‹©Y¬°[„ÜÐ[Ü|lÐl¼ 9|ýÓ‹ ­IW}‰ ¼¢}0®òxþ¼.þMSí>“.?Á\ÿ‡Co×ή‡>u(üí ·ß‹ ]ô„ÐÜ5n]Jô–­Á„ÿã=£È¥ã>Œí@nÉñ HLZº| 3¦Ì™2ï‘LhR Ê‹*úLH3¨Ð¡lR{ ©Ò¥L›:}ê”á¿”T%½ŠµhDGÛAý 6,©=«rš5-M£ 0‰} wìÖŸæ²T‹&Û<×âúýJâÊky ·Ü;ø¯â¦ë~f¸0bºñ[NÚX•]Â5;Ç v²Ù}OD=í7³¡Í=ëuU4Ï„¥Q35zîh “©¬} ûªì³¡âVzüö_Õ¼Y·ûý´VéEµÆvÞ¶oí¥¸« — —¹°ÇÏ¡W?Þ7z¡ÃGz5þ}l|*˜ßŠÇЛºkéÔù»ÿÔT{nÁWŸ|—`ºÍæeî¡õ[VöŸpØñ…`Êå݆ · qš‘áL õ÷Y…D ¨|2_X÷YC¢UìE§"Š+^˜Xɽè¡}!>Øàhw¨—zèéh"ÒçãmPY`iCnÄ ˆDÆY^,fx™b3‚S#—]†æ¤‘†)äNZ6Wæ>g¢§šlŠyeC7e¹¥œsfõå{wÆ5fùý hš|N9h›î6Þ“œ!ºc‹®Ù(ˆnö §¤­Q:T ´eê(¤oFªæG9aa©–«êô(Ÿ¦ZÒ«V´Ú§­¬Æz*~ŠÞPè<éÙ­å™Ñž#ÿzêC°2Ÿmö¦5Ìø‹Ã=ðsÌùN‹´Ëkw2Ô:lÛÛ}Ëü·ÆÚ nµß9þ0߉¾¸á;ÔÝ6µoÿK^¸ãG_ªkòvîù½"ç úŸ—.†æ†™ÌÖâ¶ëoëœx;zOîúݦ̻ζç~8í¾q{æ½Ï Dñ‘ ?ŠÜsË;ÁHWŒ5ôxèýµÇ(k­GÙ,(o-ðÙSMµÖÛ§þºÌ»Cþöcßtô[¢tùï¿ñÒ«k´¹öïœ?ÕáB|WÂHŽ†o}t Xئ–¾—]€nûüF7–BŒ|ð^sˆF÷-ídã‡A´ÕlŒj\Zßø¸8Æã æÛcØÚ‡@éa{ÐQyå”ÆX‘Hªà$‰P~É£•\²¸ƒ’QŽXbfU’¹åLš·%&°i¦”x–0¦‚^î&šzjèxƒÊ™æ›-N¤£{aÖ' ¶™¦&Hjø§¡•î馔µòÜ‘¢P(¢gâ!*–¤¢É(«‰¶[(j’‡¦“rZ¦ ©ÊÊÎ2#Ö!,®­*ú*~±úõ IÿÀÒ,²Çö©â±tbèÌfKë¨j.ÚhŠ–ö¥Í¶ÎjûlµàRº+ª|Ö4n°Í’ -¨ô®éh©*…moÂ>»ï¼ŸÎ‰Ã©&Ûe´¥yï’œëÁëÜ«®wkÓÂá6|æ \‡>p2Æž^špžœ.¯íJ2Å¿†Ø‹o«®Ç‘G³6ÃL­Ì8A0œ+³[qC{¨Äõ*‘´½E3}´„/wóÇWñ´[£«JÔD/`Ö'£ ¶Ò²H=UÝM…ÉË`ë„8UÁ0†&<\¼†W¹Ãz7”š[Ç»ºîx¡ "·r8<$&±‰ÂS¢ìèfÝANwûJÝs¥8@£Q‡MÜ!ïÂÈÅ ±z+ºâ ÅHÆ2–΂Á#³H«ìEâQ#t£õ˜¨G«Q±ôc! ÃÆÇABM††$äè©2z@ð‘ì"IÉJˆ‘˜Ì¤&7ÉÉNzò“  ¥(GIÊRšò”¨L¥*W©É;c++-annotations-10.5.0/html/inheritance/0000755000175000017500000000000012635354026016727 5ustar frankfrankc++-annotations-10.5.0/html/inheritance/hierarchy.gif0000644000175000017500000000274412635354026021403 0ustar frankfrankGIF89a,È‘ØØØÿÿÿ!ù,,Èÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçtiàŽÏë÷ü¾ÿXW&hxˆ˜xHHvð)9IYiy‰™YyÇ8æ¨ *:zÉÙöIªºÊ:izú•Ú:K ú Û%[»Ëy‹»¥Û;Lû œ%L¬¬j||•¼màÌ-mÙ\MuýíKÍn®->þ\~Þ®Žåí.½ ÿ$¯MÉ?\o¯ ¾Mý †ÚÇ `À% úz”R9<%¦Ú±•Â…ÿI„!»‹ CV4‰²äªx48òaJ”1%ÕTÉ,]Ë{Ia„¨gÍž4ƒ²b¹“ÈË~?ù¼ù4¡Î¤L–òkjS&Ô’DN¥ªÄªS¡diFÙõàW°HÄf GòlȸsÝZd+0í×&²˜±(ÄqD–<­²Ë˜¥j6r¹3&ÊŸi„®´RΨg‘VãtkWŽaë=ûm ¸sÝÍ[‘ðáÄÿQ<¹râÇÕ¼n®î9tnÒ§;«nöì°¶sïäý;¡ðâé/ï`¹úõìÛ»¿Ç üùôëÛ‡/¿v.ýÖøÿó¯ÅyaHN~B`< ®s`# Z!`GVa[vsánÖ 'Úña‚"#fp_Š‹4 b‹Æ±èbŒñÁ(cúÙhcz8ʨ£oÄÔ›o@²æã(CÙË‘Hî¢ä’ÅÜH¤“™4)¥`0Vé”Xj¤å–+uéec=†)æ•d æ™™™©æš ™•mŽ–朥Ôiç&xæIÛ˜|¦ÆæŸúì)èoªÛ›QÎ)'¢†*êhŸ‡FÚ¨£•"zi¡™ ºéŸòùiž¡”Ð?„jz*§©úTj’«jÒS¬3j1o™S+¬z’DP™êçQ‰4ë7¹ »¨2ÇÿŽöÑH?a”,¬¯ê RS]Û«I—-Ë ZÕF[&¤­–B±®+lµ™‹UQžMª¬·s;-©»BõëIïŠëÚºúÊÅî¹ðþ£ïVÑpëÏXøÊ»ï¡å«-\7íÓ“èÆ«’Á‡ÕkK³åÊÔ°§±µÿžœåŦ¥±²S{ë'ÄB ìÀ¬>[V»(s©r’oµüãËSR\—YO9.=w 2Í$k%0¿gtÍRG:×Ò¬‚\´³^뜲͵t•oÒ9ií©Ðg"ì%Û[º%ÜUÊ-%ÝNÚ½$ÞHê]$ß>ú-¤Úd§àa>â­)Žã¢9Þä˜I.åŒÿYnæi¾çóxîèíˆ~é¸Þ6êo«7ës»^7ìwËž7”;º¨ãí-æ®{Š¼÷nßïÀÓ'üðøåp"zΕ¨¼yÌ7/GòÐw8½=ÒWï!ö ]¯=ÜwïÅ÷à÷7~tÏ—†øè+¸~5ê·Oáùðg??.ï×/¢üøÇ¢ÿþ±<ÿ}€`à”¸þí‹S þØ8Ö‚“àü(9 ƒ“Ó`û8X9®„—!úH˜9–…›SáøXØ9‚†Ÿ“a÷àD$³Í€Ô!¹XãC4ñ°‡ñ2×·d–­¨ EA$ˆÆ°-ѽÁJÀÊ¢Ä)µR±‰ û×ĸÆ$j7|È™ƒ¦E& jãØĈ=Ùd_ÜYØÒ¸EŸ9…"^ó%…Ç Ð0tp¬Þ GWÈé²t‰„Þ"OȹŒÀ.‰×Ë` s˜Ä,¦1‰Ìd*s™Ìl¦3Ÿ ÍhJsšÔ¬¦5¯‰Ílj™;c++-annotations-10.5.0/html/first/0000755000175000017500000000000012635354026015565 5ustar frankfrankc++-annotations-10.5.0/html/first/datahiding.gif0000644000175000017500000001621712635354026020357 0ustar frankfrankGIF89ayô """222333777888;;;@@@DDDPPPUUUXXXfffqqqwwwˆˆˆŠŠŠ™™™£££ªªª»»»ÀÀÀÌÌÌÝÝÝîîîÿÿÿ!ù!þ4 Image generated by GPL Ghostscript (device=pnmraw) ,yþàdižhª®lë¾p,Ïtmßx®ïy¦À pH,ȤrÉl:ŸÐ¨tJ­Z¯X«å7Px¿à°xL.›Ïè´zÍn»ßð¸|N¯ÛáÀ-²éûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•y?|–›œžŸ ¡¢£¤˜{¥©ª«¬­®¯©§š°´µ¶·¸¹•²º½¾¿ÀÁ¥¼ÂÅÆÇÈÉÄÊÍÎÏСÌÑÔÕÖ׃ÓØÛÜÝÆÚÞáâã®àäçèé–æ~…‹ ¨“ðõ,h(0¼> f-Ò0à„{„¼z§.»>îú J¸€ öÌ›ôoÈ›þ2vR ˆã—Œ&¨ AD!‰(V¼uqK? ýÀì†yúˆý£ñÏR@:  ”a`Ÿ’¦f}º+ƨ4X¤ÁëÒŸB5qÌ0òOÕAX¶}‰²kŸ¨lw¾ê©òa=&¼ r5ˆ&w2ÿÚ3H€~kÒð°`¦†YªLÈÈ€ ÛÓ ØBI ÷{˜pPÅu}îÚÀ笕÷ÑÐ:w@ y !µm«DxZúaŸ Æ\ÆÁ0Å ¢oë]Å—"„Ë¡èZÀ¼ïL£r˜ŸGà-XÈ7°^úz‚¨0l@¸×Ïf8ÀO lþG„f`>•4@ü¥6O= `Ü=hAuù¡ˆUÅgAŒÕûõ7©7ÁˆÎu¢yƒAA‡|,È@ƒ  b’Ñ„üu’Dî˜E68@‚Û©ÒÝyŒT’K¾ùáÀ²]¶ ¤¥R~003ù1€9Á£E €Ù‡÷|çG –ôO‡ýh€J=V9GèUMÉOu#-¢P<§ã‚bpZ©)By ùU€øÉ!AiÐ¥D عAu°yYVIÊ•þ™­Äuå ?È6VR@ðå;‚‚úGb$t§¢_Áƒ“?÷<{kaµþþ¡@Ÿ›BÛUH_ªn0€BµŽkl“¼ÚŠi®ìÒõÒ¸$$E­¶õ” ¬Dã¶CQj y%+(´bµåo»– Û¨hÀïï°™h½%ˆéEs:‹’sÒÎûO\9wD„ÄÌ:íå};ìîÀlKjÍ"Q&<Œ«¡{Dìn—Ïé4‹ý;Ì;™Ò®Õ² €˜°<1Õ™I€^BàN[‹°œ:êîÇ0myÞl+£nòᱶ”šñÑV J®#± ›ZO غ.Á$‘É"êêÍ÷È4Vzî*06±Õê¯Ð›ŒôÀ-·-œî u–auæìmþlF`jÉDò2ð„VjGVøÒ«Gꧭ YëyçÀ< Ǧ҂pnÏ\â*0êß%ß1 5êeô ¶©Á˪D¦¯þŽ;!V§"äžH>mØ܃AC ‘îô]drûCgá¡À¦O6D%Týð[ ¹ßi›k&™J"nécmΩÝüøAIgU€iL¬ú “ªIßñæG2EKfɇO'* z&h_ãÂe›† |!!š¼²R~øÁ† Án‚¥µ€0e$5¹Û‚5 «)¿g€ª m»aQ0ùAlÑH#P” t±T"°þâ·¬F½ù+ £ˆŽø6ºE‡Q PªH¼çôË7œRÓì 9Ø# ¥!ÃòˆTFOÉÈFZ¤ŽŒ¤$u±ÈIZò’ƒ$&7ÉIBêÁ ¥(QÉQšò”PÑ$*WÉÊœ¨²•°\e)cIKIβ–­.qË]ª"s¾ìE/ƒI `Ãû;¥S¶‘™`Bé†å¼ <¯<ÛŽò“¹F5ͦn+ŸÅÀdôU¯šºlm×ð(@ƒ¬" NDž¶(¯'¡jxÃ10Cú«…p)u¹ïª¬¶á¹ðã!&-1ñ,P{2²·Pˆæˆhö* ¸p,Ü^ oP¡ co!âM¬éŠjñ—õö‡M‘–(¸Šmí욨"דÌWË—ý@6ê‚2“E&‹sEð§jÊ*àH\š`@zÈ6Ñ‘íz‚Xþ"ŸB$»mjUQœ;‡–(Ò‘çü›­%[]ô 'ºî6èZË~­*8 *@>‡Fˆu'0T/ð‡ÖÄ3Õ÷^½Ü8ßâÆ“Ò)©…'ÍKXÒ(: •e¤RPãDìoÅ滺¨²%¼H‚¹ŒhZ£ ¸‰bNŒpôÛÍžö²(Ïe€lKÛ†=¶ ûœïeŠ<ÃP^Z Ͷj}™pý™¨¾¥XDb*Ü—Kï'úùÍHh»âœ 8ÆqñïÁ_ÉÃC>q“Ü?9$4®òC¤¼å¦09Ì->ò™S‚å6ÄËsŽœó3?ϸ̃®þˆ=C?ºËk®ôŽ$½é„0:Ô'öô©‹éV7„ω.u«o=è]Ÿú×v¨½¦áÚ×Îv4 gm»Üi°OaœŠÉ‚Þ÷Î÷¾ûýïTHÔ1î>ŠzÄõˆO¼âÏøÆ¿!Î ¼(ê±ï¬ó,È|((oyEb~ðU—ìb:ŸùÏ#ôA=éO/xÖ9œ_=ë#z[Ä^öv7}14ŠÛãþò­ß}íkáûßûòÍàý'Šo|Jê>÷ Gó›ÌçCùž˜>õm|ÏGÿÚ¿•4,ˆŒ-Óú0ï~2°ß‰ð¦Áöä\¨ÞLˆ~#b]ú þ7Õ_úþïÃýIó Ñp äB€˜Ñ*‚¨LüzþW rCâXUQ£± @p¼á§³*±?6À Øá#è€è÷ ìÇ ÈRöñà1#¨¢*SR+ðUãZú‘$˜×!?RÁ"üQA">_ì•Mèzö'ªDúaØC*º*\–)ì£+b²ƒÖ¢]Þ¡C!£%XçKQ(|( 3XZó,a*jó„ItUú€ <’,±Á3/CE"Ã5‘v±/x|ÃG 3¸(_h}PSRš€ >¨3š“Â3?À*ÌRpåómþ¸Ko}¯'}UXO#g‡Ñ!21p?.±ò×O‘VWÔ0Ts†èc€Ö”Š×׈°ðˆå‰(ÑÙ¢‰†¦b<º2Aõ* ±=mR+O䞢0§ˆKÆ|«~­H]¯ÈŒ^;+bA2ºùò$?p2»‘øH,üÒòØ6äüXÜ4Ž0ˆŒ¯€:Q$Gv¤"aTdäGÏ!áÁòGËæD>!8l2{”F¹ˆÂd®€ÛW"é|q &y’Ú”’´’ÀÐ’.‰p´'“¿@“594úwŒ8é :¹“£@Œø“½”BéI7YŽÿwŽIÙ þD9’F© Hù”á“Õ7•¹P•V)t=IŽS(‡NÙ•µ”aÉ’cI–³‚• ’d/ñ«åak¯zJ±ê} z”µ* ù¹ÓZ€=§©MJ¡ØÚkÏJ•ÑŠNe Lú/ͺ~¸I§ß:ã*+åÚݺ•é*ëZ%í ïJ˜üi)Pº¯üJõ*…³yœŒ¤¦[°-0òé›çZ Á™œ1¯ ´ê æçö$xU+®LëžÚj±ÍÀ•J‹fÔ•µŠ@´á´`° ª.¦…€l4%NfGçqG0ÅcOu$ð=.Õ€d;ž[+«P‹¡ŒIV…U…),#0¦ûuXj4¸úg·å¸á\0¡0##E¡XßÑ“›f+˜ƒ ªŒ¹fkƒz„÷ã0ÀuCpˆÑ@Áå—1‘Ñ(ÙBl!¶e¸ÎŠ´ðʘöX˜XÜ%ç!1w]1X¼â<¤"˜è-ÃÉ»€²\« -yO~y"Ÿ¦ ÷…Y]z¼IVÖå`d…k ¹žk½ ë»æÚ±vùœ×þf‘ª ÙD®›:÷³¥íðB³û[«ÒùKlÌ»,Ì ¿î ¼øz˜k©BxÖ ðUÆ‚W¹X|jì|5¾¨_Ðu’ÁCEXüo « l¯ <±ˆðm{ó•¦ ÑÁ":v‹ñÆIZc ÄlmQÌVohoËjJ¡›˜1\²Phkwî‹M|™O´@·{U|Wì™Sœ´üÉj<{ÆTƬ9ÆÁËH1ûÆü:³Ÿ ˜£K«_{²w1ÇW)¿’‰³'K³ÿYÇ{Çx È*ÈóKȬLJ‰È}¬È kÈPi³…çÇ‘ÌÈ^éȹ É+É/þÉÇ›ŒÇ“àÉÜšÅQ+Êy‰É£©ÉèÊÉKÊ#kÊ„‹Ê¼ùÅ,ˤKË+§Êë@É“gÉÌËÊ­¬Ë— ÌœÉÊ Ì¯ŒÌ£ìË›ÇÌ Ë*ËÆ lÌŒ@Í‹ËvŒÍ•™½°'ÍÉ©Í«Ì7ëÊÓìÌ©LÌËŒÎã¬ÎµlΕìÎÂIÎC ͽ'Îõ Ï»ÌÎçìÍÙÌÏÇìÏ•ì§p|ÐÐmÏFпܩÑ=Ñ{gË™ÌÍׄÆ0 SªÑ­¦ÍÕêÄÖlICIÝ ¿™)}I+Í -/mI1½ 3í²'=¨=žø¼5=I7 9MAmKþ= º?­GIC} E=MíHOm Q-SÝHU] WYÍŸImÅK½_ a Æc]eH[M ]í k}Hm oÝ q=¡´T×Üp×gzÖC›Ö‰°·ÔÀ×<×€¼6à 8@phµÓ½€^Ñ€£lËø9Fg SQÒ=w؇0œ}ÀP ˜% „Qc*iÒ`ËD"xIÜ ³»Ã,Ï@¡ ‡ Y¾„PpdEÏÖÙ[I.ØÝ¡º­ ªí&œ­u6«Áie2AYÈbc,ûå£ ¬~a9þ$_0`/¤ pÚ† ax’!ãè Â_¢B6×Rþ‘}°;€Ž9šº¢CÁ^ ÂUV£ Ðe$³pײx†jòöUÅÃÜñŒÑ:GßaA©¼¦ä‹!âÿ{‚gg¦ ܆pµ¼½ý€3#…†2D_Ày>ß‚©øM ¹fMu¯»"ݳUõÅk!",o•Ø Á;‰-. ¡¥-"'ãÏLÐÌ;YBá/2V»E;>!¾|u¨tS©aºdwköÛ@áx Ø OTE[ÈÛå_} Þ«ã÷3èõK†^·]`¨õäò̼uå¥aS^*Ú]&x¡¸åÙwª4X02]¡ eŽ0«M ˜èþNFl^‰BFV Q!C¢õvUåñ=²É,áß’P ÓûVåÖÒá„g-á¾ä=⌎2cæ‘.æFÃX'ré’ÐéT[Â#' A`ÿDã]q8“57f 9e•ùçlO—Á'¦ðŠpK'ÎݨQõ=Ã8Þ"~¿ÓÅâó‚_¿>D%*)°î-Nì‘@Q>0Ü]ªK6 ‚ȶW!ê—ñXùËZ{âØø>DÇ5ÐþL”v$`!câ–j3¦¢|åŽ\£ë„ß^ˆkk8†'¡C'!Púzäù¹>šj2ÔM6š Ý°U'!J¾óæñQaþËîI5\\õ&V¢ŠSïZn-šJx†.™ À] %^ú¾¦âŠ|w+Új¯ðn¤ ò·ÚWÔŪé׶€ö¥ö-j³ÈÆS.ÝîôÊöòêÙ:Js z½ fß´x ¯µ†íвrøE;ø9«÷ä_¡$ö­Tø­Õù*ùšoÓœßù¶ôù OÕ¢?úüYú¦ÏÖ¨Ÿúð¹ú¬?¨®ÿúM ùxþ pO–{ŽÖ+9µ•v?„V¾m ¿o " ø—qg‰¬ÞИÉûãSt"ñ A"²TüÁƪn¨À‰+É "DÝu¦÷üüFÒþï‰0þ£¬ýa8”òÿËÇrߘ.þ ÿ ¸ý0Ìþ  l4EP`ä(Ói5nŠÅÏ\À5€ØH½Ú¨¢ 5ÅÑr ‚GÅj±ÌÛ5ph®L"u¤´È›ÅXm€rz1*ÚX¢çÜÆÖR@Õà̘ÓFâFD¤ ‹ ÌCMšÖÆZK¢†CË\ ¦@…΢MeÁØ£ ¨êæ«ÅÈDW@•êP ñ1r²r@Ÿp²ÂžÂ€×IÀàÒÖp%RÊ…€CïÀ!„Î7ÕLo°Äø^„ ‘´ /Ëá/ÀJ†£ì)È@F>vÞF¨þƒb¨ˆIuoC°.ŒA³×o xò ± À‚¶ÓA#Ae+BÂzià$!g.©,©¡¡º½ŠÈÜR’ÁÃ^¦,’aœ-Rš³×„#;¾Ô‘iØ°`›=ƒ(á’ *×æ\·¡À†íËÀ-É–5‰H‰Õ*PKœûìeÂpwƒƒ€ì© ,‚U Õä—‰<6ZVA箑¡YŽA„=Ší"Ò¡µ“.m$…Bo_€=^D­Aö{»6Ž( Â0"Õöm€–ÉïW7tV‰/µY±Ú·7wÖôÚÛØ ÷ë¤åt§YÑ؃ÁîWþØ¡«ÖYž!‘164X8OJ{l¡'œa³ÂQèí{C5GÄg 8x™ ÁX ¼d…+܇”múèjÙ €t6aÑp_åcÏYM˜iqùu•|À¦”fÜù¨YßžˆléÐ ’:¡Ç\34ÄÕrI"™c"ör߃Y2biI(‰Hy ÂWÌœ@™m ãfD”‚$*̵e”Î`y#C€Ô׋gÜTçxÁ*ç‹€ÎÈ4KÔy•œYîÖ ,?JºLè 9xäºåp½ VAcìÑa£ÇTÙélmj JZZ¡âi…*´àŠ¥–ÞŠ¥‚þ@P‘œ¬T•‰°˜Á•*q"=ÚARjâ„Ly„¸ ¢×Ëai"í8)N:.GÞéú‘ñõéÜŠ*›¸!£ D´ä'ó…¨R²f¾eã _†øÙÊ­*!&.¨ï¹‰è–ª¼¢Èg@æW‡hÒ¦w-bnádO¼AWbžÄbz7ˆàìÐcå®±Úà€Ó0>nÝI.Еf—¦EºäDtý}– "û|ö…9S7¨„!v—œƒàã`…B¿ªfå@ZÛXåoTÝÒ€ã6‡Aû»SÙbñ¦Yz•#Ø°rŸM£ö S§vÜþ_°@±^®STc$›]*<%·y-'tN|&uÙê(Ð{ö|±Ï8`P DÕ9ëâ=»ÐÑ­.FÍA ÍDôîtú¾Äq½ëu$=¾‹Á˜cØ—wKt&?B.[a<À—'ý¹ÜŒ÷f3(Ÿ¥Ä: ¨!Y€‰8é ŽÀé% ÈÎ<¤Ž³Žä&1²2ÐX¯ïãX”†Ò Œi:Ñò:O|³»`wÊB. X Xß1,¦þp¨ƒO@ÖŒÁŸV…e…E ¡18x·d °XOp¡,B±XŒ…¼@–ò€Úƒ°!«X¸‹)ïO„È â2>è#'Cˆ/ì!1X»,r±‹^ü"KÆ1’±ŒcÜ¢Ó¨Æ5ÎNŒl|#ãÈs MŽv¼£ ‚D<ò±D£)ÈA²k¤!©ÈE2²‘Ì £##)ÉIRò¬$&3©ÉMŠ‘œü$(CéHOŠ²”¦<¥+*°²•®|%,c)ËYÒ²–¶¼%.s©Ë]ò²—¾ü%0ƒ)Ìaö²R€:&2“©Ìe2³™Î|&4£)ÍiR³šÖ¼&6³©MhZ%Òø&8Ã)Îq’³œæ<':Ó©Îu²³î|'<ã)ÏyÒ³žö¤'B;c++-annotations-10.5.0/html/intro/0000755000175000017500000000000012635354026015571 5ustar frankfrankc++-annotations-10.5.0/html/intro/objects.gif0000644000175000017500000000341312635354026017712 0ustar frankfrankGIF89aÈ´‘ØØØ   ,È´ÿ”©Ëí£œ´Ú‹³Þ¼ûÏâH–扦êʶî Çòl"ôçúÎ÷¨í ‡Ä" hL*—L² J‡Ï©õŠu²Ü®WTýŠÇÉ0ùŒÞ™ÓìökíŽËKð¹Ý]¿ëÏkÿo±ÓXhÈ ø¶ubàø)9IYiy‰™ii¨ÅÉ( ):JZjêøÙ¹BxÚêú*šªšÂ k{k+{%ðS‹ ËËELµX*¼Ì<©› jL¢0"û‰¼˜ FŒL×=­Ü,Îü< Fw^“Î˽Ð^íξ½ú]>ž[~¯ þîið´œw–½m˜ðpx)œCˆ¥(¾â—N]@ÿí¤mDRÞÇxÑ<Þk(Ñ"%‰‘TƆqÛ¿- ÊL8r @z ešd1%¤B5"úð¡2£E%!UÊU£¤S“fŠI+cš_•˜2EÕT)X¡T­š;6ìÒ¦Gâ¤Õ וe£Zei÷ëס]ÑòÅ;lV=~Uûzu»6­_½g‹VE°˜(`MqUÍuVñb³“÷bŽš¸¬â«?÷+]˜î]Íœ[¦Ø9ñRÏ.–Äæ²S´øžâ ½×¢oÆREû%­ãvÝúZŠ«ÝRù»k©ìq²Ù­ºôA=S7wÞ zôص~œ‡ÞÝÈÌ¿»§,Ý`HsÓÚ?ÍGû÷ü»*ÿ·y_M<Ù I<ì×_‚Cý'ßMÞdT Av'ž‚ýUÖ ‚&ˆa"nÈ_‡‚|¢{"îAÈ!*bšB„­# -þÐÓ'Î(EYÔˆãr<óc»‰…ŽBNa¤Ô)F’H&Àd“D> e”rM™ãVúx#ˆl¹#–Qpó˜JŠù¤™\n¦š@v œn²‡f–sYç˜lÞI„“gòy¦œ^î h~¦Y¨ž‚.±h¢2j§£M@ª§¤“æ'¡–æ@i¦›2Šé¥Ÿ*Ñ©¨£Qê §¢ªª«öÙ*¨¯ÂÚhšÎªH­¬â*DŠ1þÚ•¾K,ÂRXb²Rÿû¢²É꺲΂-$NûÜ­œfÙ,¶V{·¨Uè-9ñý´6×á”M•ôLÇæµåÂôŸyešOA®×¾Ét;oˆ úã¯5ëÂËŽ1ÚpoI4ŽB.¶Æ„š¿êÍGßÂ!-eGß`ì Â!\zð®§s°‰åØo›I5Ì4³]J yçØ “á²3²©µhnÁ \q|½Æ´ÐpiK帶=5³ÑM §VÖàafœpPÛôn¼iÝuÌ[φl¥ ÏJ1+5×gWóqÇY½4]FC.Г6vàe»¦tÒµ6[Ó¶µÜ 7d3T¬Avó_½ÿ=&´P²¹ý¶Ö>¾aÄæ2¾28d*¬±v8¡¬­¼ùˆ¾ Å*ïRzåt±Å.Æý±‰õ²\ŸH/¼ÆÜÜ{s²Ÿ{¿¶“4_žðž¼>ËÏ”òy–©zîÇS_ý8}ázø­Œ/%òæ‡÷õå¯_Qûr [lýÀM£ýúK€nòóê°hý€Þ@ß„ xªT‘*V<Ø@²J‚„à1ÜÕÀPð‚Ìà£,Ø+-yðiÄ™t7ÂÁ ÐV)4!aÕB ¾ð1$á wUÖ097¬à9ÕCn°?ÜÔa˜C_Ì0„ITbeØÄïµá‰’:" £8½)ÿ€Vd"ɳDCm‘W]ãÁHEŸWeÔÏgÕF:‘ciüàU˜¿ýé±ýû×ÿØÁ½~{£@GH`ÔQQàK¤" y%õ9r\ÓÃ&I¯>z“™lº^Ôà]J’œ¼ÈïhÇ­Ün”,¥+(öŸÕ„d¬¼$ärñ±åq$•:Y-Aá1\ +¢ 4LVÉ&Cl *ÚÍò‚¹œÑmm23[å$· Ÿ¡0’|YáC¶ÐLœƒ›JÒ&s8-R‡ÔKÀÜv²s3x'âV’Ì0IÒ›é” g(7Ê¥“-EŒ9ššuþr™[Ë[^—7»AÔä33ûK_z%=iµÛÞÈO× 3¤Ë2TúZ)´»Çš‡cÛبÉlÊ”jÓÏIm9/ؽr`Ð%uPw:v•‡¤œ–NÏwJááΗ«\jéJ§e…_'#È:¨ã@Ô¥QéÊS<àq @,jWIK‚Ð2?¡‰Á@¢+¨ž£?˜…\çZS^f‘x LFùÚWäüõE€,¬BEXÃR“wDQ»PÈê!Ž’µÕa++ÃËbVšÝ¬óéY:u6´Y$m(kZÑ‚6µ.-kw§ØØÊv¶´­­mP;c++-annotations-10.5.0/html/annotations.gif0000644000175000017500000000772212635354026017472 0ustar frankfrankGIF89aà{ç!!!"""###%%%&&&+++,,,...///000222333444666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFHHHJJJKKKLLLMMMNNNPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸ººº»»»¼¼¼½½½¾¾¾¿¿¿ÁÁÁÂÂÂÃÃÃÅÅÅÆÆÆÇÇÇÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÒÒÒÓÓÓÔÔÔÚÚÚÜÜÜÝÝÝÞÞÞßßßâââåååëëëïïïüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ!ùÿ,à{þÿ H° Áƒ*\È°¡Ã‡#JœH±¢Å‹3jÜȱ£Ç CŠI²¤É“(Sª\ɲ¥Ë—0cÊœI³¦Í›8sêÜɳ§ÏŸ@ƒ J´¨Ñ£H“*]Ê´©Ó§P£JJµªÕ«X³jÝʵ«×¯`ÊK¶¬Ù³hÓª]˶­Û·pãÊK·®Ý»xóêÝË·¯ß¿€ L¸°áÈ+^̸±ãÇ#KžL¹²å˘3kÞ̹³çÏ C‹Mº4Ë à0uê×°W D-›«ëÚ†70`뚨wÃîûŸnÿìtÀ»øaæÎÇ Þ¼ÒªëØW)7¾{Ãõ‡´;þ†O©{€ÀJÛ§Žÿ¸aj‚襷<Þû_¥X±²_¯$GýïAב€)àTÌ%R‚éôÞ@ʇÒq¾Y‡Å'P„ ½§aF68RyÙ!‚p¸Qj*ô }ùIH^wæw¢AÊÉÖ¢{æí8Ñ{>zDày":U^¹ŠB«aw¡Œ(xß’ áP’.öH%ˆZžô¢@&"€w[r’vdw#”#òa,k"´A“evØ¥F@Ö‰}h¤›XJDb lª$eŒ åù¢xÞIt~*…ÿH꥖ZŸ•Â镕ꙣ\†jRj÷ÙQ[˜ ¹¦Ú@þ®âvP¬°¾&kB®¾:+sc‚ù­rwël¼§°µ «P®ÃD+±©5ë,°íM6d¦S.ê(F¤Štd,þÁWä´Â™gu©m0ç®å&‡noëËëkêê:sõ äß{ ºVnºÕâݾæÞËl äïÁðÚ[k»çÎ ï° ¼[”}™išqŽºíE݆tæ* –ر¾V^iG¯iæÊên¸²o-ÿS²Â¼®–æuªæ«/Æöe‡(w‡Ê³/ë ŸÐ[* a™ÔéŒ]Ï/Ûœ²Ì,kgsÕÇIý]o™¦±¨f~lQÈ m¼D*”#˜VN¹¤´ ʦêrÛ,§þpÞå‡ÝÉu¿©¦ÁWú=7Bo×8¸ÉH_ß‹#®wrqû=¹A â·xØ„=Ú.o«xú%«›ìé¯æµ]Ћ&®þâ‡f`ë¦:ˆû7ûù"’ñXûЉâ;†³oWÇ ãÀù`ž‹$úf ‰¢7»Îã›'þ®ç﫳þô½­—g¼´ïNvɶϦc™Þ۹ᖚoú ‚ß½ú ùzŠdsLô(’«á¼ÆMÇ2 ²Œ£Àá u ¤Û¥H>¶ån{óËÒøþ·Áþñ;åUýè÷A„X(|â»` U¨» ‚Ð…TaüÈ·ÁìÝFoÄ“ÌÄ°æ‹`þ L¾|˜®þh<üñ²‡ºÂp…*š¡7h ¶uR<ÈÎ*‘+7É°„PØÄ,J‘mûªW¥×˜ìYj=_²ˆqw‘ç͆7v虲â§~±ƒ4|â ³Hûl‡8KÍ¿ò!DÆpŽ€,dú)ÅìéËg–a[ þM?S;(õƒ½OŽr;Ö¥“˜¨^‘^  Á8EA~Бƒ¤¥³þe´ô4R—¤.K8ËH*¤:¤#2=v ©òp¥{æ~J$MhN•lä¤ÚžÙ MjЖÆ,¦ ‡IÅ®‡R'üÎû¾™»j¥’O,¤ðÀˆÈTjq–þq#+w‰ƒ*dzèE¾¥Ê˃Œ'áwK`>ÈvƒDÎ!{uÕò—T”h0kÉÂZ¶Oœí|•3+ñ¡eBF“Ù4˜P(?;b®zxÓŽô‰PŒ*¤ºY‹ê'»†~‡Oö ¤MsÇ¢:°?ÎÙiù‡Saöª ¨si`œôsŸ”ªµº7µùV«:YS_JÉÆË›@%a9¿öÔ¥•säÐQݦóyq¨x¦y¹.®þe“$ÞXÚR¬j«£1U"aõeŽÕye,ûE£öéT¯êL*üÚZ¦ËzP®!”¬öˆV!â=–_qBÕW1“2{Eí>)Íþªao‡Ø$pyô¬˜U"ÖÉ&8ÆÓp{[›áúj5Æ Ž„[¬Þè¬üÑÍUé¸ä«¸v‹®Uå¯+”¸ ìŽs‰åÅêâ ¼/Špƒªëli ÃÁJ[ØÁ”"C¬Ï¾€–ßñëWÍ!ˆÎ&`!øgv 0‚ŵ5útÊ¢Nn‹!§¥Œeé ×{16aØöï`ΡêA/ (ÍuïÀžL0Šõ–àmÞ-j+íc8æ^#êÌÄÔ«mŽýêIU.Ñ” ŒHI2 G³ÇA.ò(‰g¢Tò'M8Ö"I§éa“Ù“?Sšò*­Låð ™iiò4¡ áŸ-YÉI^Íþ…¬ƒ¡ù®"¶“¡±“üçòX q&(פgl‚ÉÏ}þ5Gùd?C•Ð ésÇÝfýðÙчFt¤!­E@[ºÐ”žëœº;ßWS Ž žËãP›z'£¦m©OÍj›4iµyµŒ[Mk l‘#·®µ®wÍë^ûú×À¶°‡MìbûØÈN¶²—Íìf;{WÄM%”g5dÚ`}¶{øß#l\ ,L‚£Fp+l‘ÎQ¹I"nmo¥IÊIåДf¡Y¿&Ì‘óöISF 9öÞ§Üí•4Ù,šo3¢ÉiãmÝ"ÉÈ´¬ÝÈWsÛ—ÁW)ˆ¼*EÅ•uþb=Ø€/èzKjßý.eƒ¬ú!•3ùÇ™r÷Tª"ì} ‹<Å<÷È”¾sz9Dr>s­ÔÜA7§ˆ7[rôŠ{5€VúC–^ô«4ýuIGÊÕ}Þ76âMæUÏËÖï•u"wÓúíˆvAEkZøJ ÝÚ£´›Ú{•µín÷½Ãýìo‡»Ãîî÷°dìýKz¿qP®—õûX=4ðkxmE6'^CôÍ~Á]•D¾T¢Žºh”,¾±mñÇÙÅ”Ç+›¥^õ—jö.ç ĆÿG•t¤ìn5+HÕ™0ÛªÞµjr´£4xí:«=}ÞŸ««B•šªþæ{uÿžNWNo¥àïÒª-ó=zöýaЃ¿ûø¾Çs²ÝÛ|Ko‹]ÂZ±Š½AWfÔOt–vp†#VŸ&9t’AÒ…qOv"ù—e£Ca’9BV31ò€–³*,FüGeã#uG>…!A5ìVe4]q+u"…x[erŠ2%2XA²¢Z«³‚ÎÒ‚”‚îW¦³Wyôf;XaØÇ:DhBH‚b‚e·sûóK¥!º¡D çpr|‡dÿd.S@È¢ZKÂ1##`MÈ:ìÕtp˜"Le5G*kV_#‡WvR¨;TÈPXˆåbôu;V'þ@è†XÅ>E’_ßæ†(2‰‡˜%•¨ˆS4O ‡‰ä#u†gƒ'øY‚h‰ˆ(_ÈÃ…‡ø?qeX}¥'toз$W2u(†žHŠ¦¸‹¬Ã*hHC$U1B‰|؇¬H6[XŠŸ¨Œ’…Þ's¶H‡¸Øi¢²38Mµø1·x‰º¸Œ¼x3ß²?‚hÄhŒBu̱qݸŽ¹è‚ÿ`UÁ¸Š°Ò‰í˜ Buì˜*¤$ùˆ‹åèw`JÄP:öæX#è"0ØÜ(Yþ¡Ž*$S˜5[ívŒ¼(YIqíhI‡÷fóu#yŠ YŒ¹5x?ñ‰þø’-²þ.žᆊYQÓhűLüAXFOw’ù‘F9.¸&êF”(™’ÁH‰[4H ¤T²&”Â6”oOÒ‹œ†×u~éAÞ”•ÛÕS¨Ó“SÉPgIåA'Zδ•ó˜“L9ñá/5çE^cò6’8lØQHScUžb\‰#ü_Ö^­³˜]ãaÉ%z€Ù€Ù—áõ—Ìå{Äq‘®Q!†;˜ù]w™gÁ-"X}ËG|[”[î畲ZOÈl–[é{¯I›á^û²°5~½™G‘›#éšÎÄbû!›±©*^s8±Éx!J"4mFR¼»¹œ^㛩Yb¶•“Öœ{öš‚†#û‡žu¦haVžS÷fòfQ¨Ãhèi”ŠFŸìyŸ ÄxŠµ8›ÄžæIž™öà9Mh1RG¡âÙ'óG  6磠è ËGw„rš¡H-–§X]¨¡¹7rÀ’œ ª¡rV:X¢*Š *Ú¢.ú¢0£2:£4Z£6z£8š£:º£<Ú£>ú£@¤B:¤DZ¤Fz¤Hš¤Jº¤LÚ¤Nú¤P¥R:¥Tú£;c++-annotations-10.5.0/html/advancedtemplates/0000755000175000017500000000000012635354026020122 5ustar frankfrankc++-annotations-10.5.0/html/advancedtemplates/multibase.gif0000644000175000017500000001461112635354026022601 0ustar frankfrankGIF89aÚ÷öJ          #$%&')*,,0"""+).;()>++333:7=K::DDDHEMR@DWGLYIIYLL]LRUUUWS\gXXfffealtdmto{wwwp{ƒww‚}‹ˆˆˆ‘††‘‹š™™™Ÿ™ªªªª¬¡±®§¹»»»¼µÈÈÃÃÌÌÌËÃØÝÝÝÙÑçîîîÿÿÿ!ùK,Ú÷þ€K‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£„ ¦§¨©ª«¬­®¯°±²¬¤¤³·¸¹º»¼§µ¿ÀÁ† $1ÆÇÈÉÊËÌÍÎÏÐÑÒÈ' Ÿ½ÙÚÛÜ­×ßàØ1Jäåæçèéêëìíîïðæ;ÖᚦHøùúûüýþÿ H° ?õ*œb\¼‡#JœXnÞÂK÷ jÜȱ£G‚/Š9Ì!Å“(SB´HRRÆ0cÊœ©/dË› ªÜɳgEz8½¤I´¨Ñ6ƒ*½¦Ó§Ó§Y.]4ô¨Õ«3“NÝ:ª)Ô¯`ÕIåz¨*Ö³h j%Ë–“×°þpÃŽm;ÈlÚ»xÒÝ»émÜ¿Nçîµ›·ðݵ|Gò ¸±JÁt 5„eÃh+Þ̈±ãÏ!·•0ˆ‰ù†œþçþCðµ~m¢ö #Wkˆ@õQÍœƒ—5™®Gs(”yQÎsr6Žû‚€IÖ¡ØÎE!H‘]¢h¶¤ú  _ ®ýÍFÀ¾ËHLÔðÁCDü£5ðÀŸ5ü&ÜT‡Ž 6˜€Ip9!”0¡!üàÔ&ñBrê!":ˆ˜„Q‚¡•Xz¬øˆB|Aà†Ä•Íû Ÿ ö!±Þ}9ÌþPƒŽFÎ0Ceø¡$“û?3¤ðY!èåpì0è 9%§btJ@ßõ€BEÈ°†ä¼ùaƒè$¡C Bœ#ăíÐç‚Ͻ CñœGŒòÕCô‘´éZÀ0ƒóQŠàSƒ¦&ˆ€O½Í*9(0 PiD"(på>ú‰JAo±ÁÜ—ÁyÖžäjƒ Jô ƒ²É– „Ø€"‡Bü ”PD+šÓà ãÑiŽ ²#¨9GT{-9Gì‚ ²£(WŒö³žíÕàä¤EÎàÚ|õÉ6©&¥>"Ðh—÷)¥¦ø 1ƒ"þä@e&Ppk><¤i‘ý ìfÂBG¬€Z«Ä²G„°rƒB¸lNBÈ€'tþàì2Hð‚tè!¢JŽ›! P^9ßU(n:ónU/?GÎ(‚”üV p‘î×±©H¡¯ ®"CŽú@§>ø‹Ä{Oö3„5(Àpj3Èè‘È#¿¨à9b–h„-OBËRWŽµÛ%]ì *çóÓ3K´¹F›óÂsèÚ²ëD=ÕÔû‰q¨nç×ï¿ñl)>žÒgŸ 3ú jFÌ°jj;éd–ºz0?5ü±ªrßÀ–¬¹å¨YΊ2Û¼æ³å–@'ô(C.9þI|;Ñä}9æé(¾»ð¶#úR¤ës¤ –º§no-0ì +<ùXMj æƒöÈmb£>xðŸŽ}ÌWÌû’ó E4î­, ëA…È¡> uÈq(+袧ƒ„QæóÓùg´Ayt6Oæäå"¾Ä/GÒGê` %#P€u°ãR§ì#6ÄÆ`HøïîƒÄÞÜgxa£••7Ü*¼’ ß"8š¿C@ É×HGMxê`Åø¡bÉ p\Ú9Š0!ÏYÇ:Ð)×9ÎE¡0@i”£;Þ§”Ê€:Ä‘( €½ŽU ¨_§îH.åM˜D àþS¶$îj7Êã”(pGèŠäâœWQäD{›(²,xœH+©á`@p}„Gû0‚_dn $ÊUI//Â…a`CbæšËcf°œ–ö¦Eœ±&6ÇYej~Üü¦:ݧËÈð’œð4Š9ÏYÍt®óžè &NÄÏ~ê…žŠa%>ª}Þ„ŸþL(æ Ж” ÷4¨CߩЊj„¡ ÉC!ªN‰’¡…'F3z‘r4Õ(ECÊR€Œ”¤ 1éI“R‘€´¥×|)Lë!Ó™N³£Y)N‡šî=õi\jZR¡u¨F=*Sì©þÔÏ05'N}jK£*Õ`$µª`¹jL³ªÕrµ«¿ø*X¡"Ö„Ü´¬i9+ZmAÕµþ¥­<%+\*×¹Š'Ø`KØÂö°ˆM¬bËØÆ:–°1*z@à‚ÊZö²˜Í¬f7ËÙÎzö³  ­h3;¿Â¯¨Mí)"€€ ô"œª•EÛÚê´¸P€Ü†âð­p‡ ‰;WÖ9®r—{ˆä2wÎ}®t•kÜé6"ºÖÍ®p««]C`·»à5íw»;Þðš­å•nzÏËÞrwºëm¯|Ißíw¾øk}Å{ßüúWªïµïÜÕó—ÀpœàþÃÔÀGݯƒ'Ì<gTÂÎðÈ0AkøÃ^òð—D âÇÂ^°‰W¬J‹Ä,Ž±b`¼ËøÆtqñ‰UŒãoØÆK²‡Ì!ßÄÈDN²RtÌ$+ùÉ8aòTœ å*·„ÊßÀ²•·,-ÿÂË\sB¤Üe‹ùÌ3³'ÔŒæ6gÙÌ#a³›ç 2_CÎtÎsg´‘€¶Õ…pZz.Ä¡ÍèTT³ m£eñCOZ²nìc7ÍéN{úÓÅ´[A@ ˜úÔ¨NµªWÍêV»úÕ°Žµ¬g ˆÍjµ«Oðê SÜ`¯uÁ­Ïœk]þó„×ð5°+*ìD—¢®Æë°‘ ‚_/;¡Ív¶ Ší” Û-Õ¾6¶§fnwû$ßîK¸ÅÝÏlkÛÜçç>×Ín‘’›ËðŽwTî- e×ÛÞÚÞ6´õÝ“tÛƒÞÿƦ»o‚'Šß^ExÂ1³ðD;Ï8ÈQçœÓœª„\ÞaGw¸Ó4ñœ,—¶öÄs ñ*;/pÅ‚„(d! Qn'6ø4Ó7¢ÉòPϲœ¼*ñ•ç¥âz~ùÉU¦4•MjbStÞ§9•ÃN(8ùúøä ªcçåxž E¾A¶<­E7úaÎþd¥éyÈR³zà,hIëÔ²¶´Å-iþ \2 Ø¿îu ‘}ñ Ûm‘ö ¡Wúx¼Úýô<»]päPË\f³gÉŒi5»YÎvÖ³ŸþƒcÐÀ£=¦¼ %C‰%Ô !”NJbmlƒXñ†öûð×îm„Ýàj]|’/s™CˆÃÞâ’&Fñ1rB{ÁÍYˆú¾—iòÜ¡¦ü¿¦ùHÁíþ‘ûùì(6ëᨠdØ ‰ý(¦ÎÆ©  ª’|·/W.ÒC&%DÖ“ÔzÏc}Þ>ât±Ô}ÞR‚¤'%ð.‰G~¯‡%¥Rø’{I@¯µR¬<9d6¾1´%VþRô7É”D<Ä&| h/ˆ”%wCyå7d44yT2€AG³AÒgsB×A†rí2F]×J×=å@w‚C2Px8o*—Húò6¾€ÿ„¨¡œ€¼SR$9À)5°*·374ÉC7`1wH5yL„JÁg” Ñ•2F˜…)–©ne8y> ’Ê´™,†™™™O¢9“7yX!˜¸¦•¥9tÕ™ª™§ib¤ùš?ኳWµYb·‰›Õ›–@“»y¬Il® œ!“˜@œÅyÇ)f¿‰›Ì‰©ùœ¡‰É©œðPÃyØ™ÂùaÓùšÞY ΞEå¶Üivº©žò4žVž¥yž”žò)žÚùžAŸ žû¹7JaÄ0 š  * -° ÍP ñ9 üp—V¡ZVj´Ö¡ú¡ ¢­fk˜bªhPº¢«P¢&þÊE±å ’Æ¢6Z .úfðg9Úfx† vÖ£[ö£;&¤%J¤if¤9Š¤mÁ¤JZbNºQú¤ 6¥Qf¥TZ¥<ÊLXš¥Pº¥/ê¥TÚ¥á@¦bºbfZg`z¦=š¦¤à¦lŠ¦pú s§r:buj§wz yª§,¤Aѧ~c‚ú…:¨„º¦WŠ¨Œê]‡Ú\Ú¨‰ZdŠ*©z©€j©qZ¨‘ª©>Æ[$Ѡ꩸¶¢Ð Ð7ª PÀ¢F¸ª²z[ôBY£u«¸š«ºº«¼JZ8ú\³¬·°(z%¡G÷«Ì,@ÌÚ¬Îú¬Ð­Ò:­ÔZ­Öz­þØê¬8€¬ùY¬ÆºvFèžþÙŠµú­äÄž*®ã:†Rã­æjœÜª\ö™™ø‰šïªpñz\óZ˜õÚœîz¯V®¶¯[Ù¯Ö °—¯ÄE°g°ß‰°†!°Æ°ç°èù¯›>F±úf±Ýš±Ç®ëzl o²Y²Âuq—“ËÑ·…(Ñp¬¨#·4#'Z·œ*+‹²1!± Æ|(ã|4w!â¤U"=g"?p,§ˆrå€Y% °D›`FËtfòtf²&mBur‚â‚u=«}ÒyÊ(è3.å"+r³¦I¬ýà/Lâ/ I)u@ö!þ|´Ó˜D!| ™ÃWRBJ”·‰{ÅgÈ—²"»0w´p—,Ëwu-Óòê²wÛÒ-]xt’u‚Svév¤?Pz2+?ÛvQ*ô7‘D¸ü“¾‘D¸a0`‡ýX<à:òÁ)@Â)FF—ùÇ)ü÷™ÿ€”»±ét¹)Ãy=Ð2/ãyszÅ2zi»ç€Fc¨ØU›,€×çà±Úú6ú09 <¦Á?­òCÀ7È03¸0S)Ð+ŃŒú 6"àKÆ  œ~½ë$yHc1h½a²tà#!‡}KÛAŒS}ÃA’}7‡~‡¾Üþ'·êðࢺï;»{&¿jSð#ë9D$U¼±A)ÀË)º³@*öÁ‡<`<ºÃ)ë'•( CøÀþ@ÅH<A’œ²ˆPl+C¸’•«t€J@= è9 ˜=Ûô=2äã¶d¼¬{Šqâ3=`·Á‰·h—º»T|6A’µ¡ÆÔˆ½Á$]‹`GXA岄ä„´´I …"d…%T‰”÷,[XÇLcB:ྚÉǸ2™®R ¬ÃˆĽKÌ÷Å R?ôÇw?r—IÔH_œþVÌÜ”™¼Ñ¬@è0E%æ%‰a„…Gs‰i’‰´‰Ô‰ÖŠ(ŠCÏëË…$|GÉq0ÌN¼¬”â1¸Ì¬:¼ ¸ ;(hIÆc;·Ét’)iÍ•\’¾D+[[“ý`¼<°IRàìWԨ˶4C‚’ï`Ò+»»öщP»öñS<ø°I»ËÅ„ìA—ÀèC®a:ò*M”‘ˆÃc¼>0ɲ#•" @Gí¸ùp0SÍ ,V«Âð€p¿.‘U±CÉaƒI3ÌGLJ¨ÄwÔI˜’1Žô#Ê,‚léDù×+ЬŽ 2wé@ýƒ§rþ|~y”YUÝU “ºÆÕ‹´úµ!L¢Esã0€ÔAm/—}Á=Ʊñ†Ø&«ØÀAÙC;ØRÅÙçæÙp²BëR¦}T¨Ýmª ´­M›a<²(1Û´ Úµ½¡L`±mº=ý ¯½SÁ“Ç]¼]Üå´Ü$•Ü‡ ÝØÜÎ]½›­®¸›W{ÝëIÝ %Ýv5ÜTaÝÞíÚ·½Ý°yZçýÝé­ÞûÖÏí]Úï ß>+ßóý¿=`â½Vä­¦ ¢>à^à J¢lßë]H,ú ¬³«ŽZªE¬—¶»eá~£ÞáÛ ª¯ŠZ¾Õ©¤þÊ&ž¤'N`)^c•ºâáÕâd‘©0N^/N\2^ã|zã%Îã:~^9NAþã!æã Fä_Ê\4Žäò5ä:ÊäjäçääPÞ7T> W^åV.åÆåZ>`Y¾ aþåaJ_^Næ6æ”°äh>aj^\gÞæöæ×çr>çv>ey~çn¾çGæç|Žç/FçP„Nè…~a€^¦‹žè–åˆîèÖè_Fé’þa9Îæ—>d-é›^`–Î žþéèê—0ꤞW~p.¬­þàšê«Ôá5¬€¡nëÂa ½:ìšµÄ~ì•eìÈ>ì¦ìÁbÞþù=Íîì$íÑÓNí/bí×þÙ®í»Ôí×ôíàTâŽä^îø}îh‘îêÞ®ì^îþîìïx1ïôþhö~ïà﬽ïïùNtŸ?ðÅí/ð6eÞŒýÔÍî ïðX•z‹ñ&зöñ·»+¸)0Ñ1*ðÑ·[L0€À ˜¸›")°µ‚»{÷KJ22ñûPñ?jô‘“»ÿ`ÌQò»ÁK7Ã;v€H5È»Ãį¢ÍO ½ ü™<@#FàHþ VÄ)<"‚) ’ó9/1¿¢’7+ƒayÔ‹Ôƒ½ À)/À DÀÌ{–áþ†oó‡ø÷<ÁNM5éøó<À¯a•ßïô^ö5|Å8LÐÄÃ[ÿó3ôCü)EŒ‘H¬ÄL<õO|*QlIÅ<Í •Y¬Í€+,Lý¡<Ýüˆü öcÿ Œ¯/Å—Ôž2DAmÈ›Á(¿ÈTbD²ñÈ‘ |…\ømúú(JÞl˜ÙÏûŠÿJ‚û\“5…<;ŒˆÌì¸ÌØÌ”q—)͵@¤Ô}úUâ¼ÎüoC—©Q7ô²?ûýFQÿìÐÚ/*€`‚„dâC83Hhh‚8Ȉ$Â38#˜è#2c`”˜h”“¢”XS‰`عŠªšHÉ ›þ¤ûÈà *JÊ ²Tl|Œœ¬¼ÌÜìü -=M]m}­½Í<œXˆ4œŠ”ÒhR nþ½ØX{K!iD!hĉ4s˜8´:TC©!HäãV,rf!T¸Êá;XéBâj…A9¤„ É0n$Kš<‰2¥Ê•,£ysäj¹Z"D˜‚‰$ˆÀ™TA£LPH!ˆ:HŒ5ZqU~H:šPÌá*†­”OÖ©^"T€ë"Œ¢ ˜æ¼R$±–tëÚ½‹7¯Þ—q-õý;ÈHÌAA‚ñWp'¯¢@Õq§Qûúˆ,y¤ÞÍœ;ý{þœ—¯äѤKÇ­a:QcÒ<à¦þ«´ìÙ´kÛ>&úµîݼ{ûû¶ðáÄ‹“Ìý;¹òåÌû7=ºôéÈ›[¿ŽýõóéÜ»{÷\=»øñä;mÿŽ>½ú“áË»¿üüúùôë?k?¿þÔòíûÿO~û H`\ýˆ`‚ÔP`ƒ:7—‚N€^¨ßnÈ!gbbyvHb‰,}bŠØhb‹.nƒ¢Š2Æá‹6Þ#@ìÈc>þdBId‘F‰d’JÉ"ŽN>‰Ì0RNIe•V^‰e–ZnÉe—^~ &—PŽIf7až‰fšj®É&˜e¾iW ;c++-annotations-10.5.0/html/sigfrank.shtml0000644000175000017500000000023712635354026017315 0ustar frankfrank

Frank B. Brokken (f.b.brokken@rug.nl)

c++-annotations-10.5.0/html/memory/0000755000175000017500000000000012635354026015746 5ustar frankfrankc++-annotations-10.5.0/html/memory/rightass.gif0000644000175000017500000001155712635354026020272 0ustar frankfrankGIF89a,‘ÁÁÁÿÿÿ!ù,,ÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦óˆJSMÀ…^[Û§÷ é"Ä–,–|0[·êg £ÓµYzÅŸïU}zšeW56è' 'x˜·x¦È¸ÇÆhGéÕUXwùÙ˜¨H¸Ê7ö:I ÈéØÊŠ*9·3YY›pI‡…GŠÚèûÛÖûúæ¸(VØ LÜ©Ú,«Ck;=‡{‘È»ùü79|<虪É^~ʉ¸$=]‹Œy­yjzþ8«üªÐ+Êí]=}?ص£díP®2òœ³Ç/ ¹Úê9«øÏ¡À‚ÿàºËeg/¿Œ•4‰ObGcâHbد¥Êu+="4ÅÆfz:ñë 4  ê4JÔIµ¤L×ül 5jT¤R«ZmGõªÖ­–jrý vIÖ°dËök6­Úh׺}›¢-ܹt?È­‹7o…»zûú-êõ¯àÁ€Ÿ>L˜/âÅn3~\Ö1äÉ\%SÍÐR—X&›yŸÍ5n¦"›êÕ¬[»~ ;¶k††ñš®#ší-]!ûYÜ]Û3€áÄ‹?Ž<¹òåÌ›;O~z_àºdrönõð]‰÷@T¦K!ïðšsî}Ž>½úõì£ûtßx÷9òtÌ“æ~gÄwñâÍ+ÿÜÏÀ^¨|$ ¶Ÿ5þm H A( ]ò9 …ᨠ~bˆtˆ’` JÈR…÷Ý–w¢à†–!b6¢Gâg_HŸŠòqÆâB©Mh߆ú7ÅIA“#òÒ$7N¹\ŽÓQGd¸ù¢‘ó‘ÚuÉðĉ‡'¥”Ã¥¹f›lR 'š´™™V˜¦}Ò] 3ÚRšm>ù&›xĉèšsv–˜6øùçhg.éæ …Ž˜h¦#.ʨúņ ˜Ši©iª)•V×)u—¤ k«BjÓ•­F8i¬º>7kdžÞZÔ>»Û\¯ ý ,®ÿË,rÆÖy•lÒÎÆ€,Ó^‹m¶ÚféY-¸-¶*„+n°&ÚZUu’{í¸´‚k¦ ¼q½;¾¼1/\:N]¿¼Ák(û׿mœÁ™¸ ±ŒT°KqÅ‹t1X†eÌPÄ(ä7Z³ªºË±ÆÕèÊ” ¨†aˆ<¥Ê³lrJ÷z¬Åº0ß(³gèÒ…§8›à°šÌmôÎrÞKsd|ÝsµQ×{žsH+ ÉSoõóÀ[ÛüqŽÇ9I蚨ž­¦“dgú5!M×Ù6™P½/t–šz÷¨”ê7$”½2Ý`ÂGê’gWŠ7¡§Fkß%>øÊŽG>ñ¾¯ÿî}饥Š:¨¦“wå> ®ßP%]¸Ú‡›M êI'ú¹è5ßL{Ø…U‹µˆ±;ÞèTÛ^»Ð¡P‘{ˆ»û*ñ^Ÿ“.âñÇ&ß2ó©I2ôbïíÁÁÏý½å¿­ÖjS.ðê ™ÂXym½wËOæ>5ð‡?xü ûîªþÈþ;Èñ/)ï tü×¢‘oã“Ÿ¹6¿õPÚƒ“Êêš²oƒÙ« ÏÈ;€!ð~¬›?h—ÎåÃ+aþªf·®ç‚*ô—'˜3½no2L Yh•*o„‡AP‡6¤¥ UO:áCHÀ§•ˆ'Á¡tT#ªÖÿå-sƒÞ4+Nñ†&lâ4g¨µQ½ç•e1qhܜٸ¿Šñ…q$žá4×Ä-2Ñ‹ Ì£ÔÞø0üÉ‘‡=lO!f:†‘‘,c™ G†å[U<¤"›7ÉEbòCxÔ˜§tJP"r‡£œ¡&»×IÉ!c TÍœj‰Ël½rz‘JY.G´_ ±1ì•×„YÌdуQ&ý’éÌhv…Šn¦©iÍlžšÚìf˜éÍpn›âô%2ωÎtªsìl§;ãáÎxÊsžô¬§= Ï{êsŸüì§?Û™Ï t -¨AWS΀3¡ ]&7 Q‡’3ÿ¢-ÝD+ê·õ5ÝQ%ÄòÐhº _cê¨,M R^”1H¢^õÐL?"óÆL“¡Vc ÒiH¹ðÓdY‡“Cü@Šá¼e 'êé1\ñTž^d#GXh«äÁHM$#åyH@ÜöTnPÄ[…‰9’`ÕNÝÆ¥ùš K¤ÈUZ0Ce=jLÞjW•B‘¥3b«9yúÕNrÕ“Â(lšZªj­A½ÕZ78²Þ©“U†W5âT¨Jv³‹EBZ…U¢¶õ¬Î³l(¼AÙÃÒ"±Ø¬EîŠR!|´eBVO° Á•‚Ñ3R™­^1º²x×¾®q¹×ã*\ºÿ]®s}ÖÜçJ¬Ó­nŸkÝìB7¹Ú•nq»›Ýï‚·ºâ¯w±kÞî–7½Ë]/{ëÞ÷7¾òÅ(}Ÿš×™÷¥†0µ_„·¯×¸ÞAqÙ­|¸–a ðNô ƒ‰é§‹­[92匕Ž^€é3áÐö?ù°°.Ä¥-õhxbëpÌlIëîÃýIq}V ’ƒlH@‚Ñ•%Ú ËxÆÖÙkÄ°.õÇK1Z±ŠýŠ›k Ϊ’Žl<¿ ËYæ(Š–œ¢&ƒÙÊA>±”ÁÜäû@w\öp‘aØæ%ùÌ\:en‚å(gÕÆãs’à\6Ö±Žlƒtñÿ³:(èDgƒqG>Í´ôã–ŽyK’NáRCÌ~™˜Íf´cß$ãCÇÔt ¡,–I—ùÿZ\,FÒé{§+Ø7)þ|ê^g·ÕľF¬#ºJpÏ]ì¨>ĶalLtÙþ®èoÇi蹎Òw ø¾'V¼£¦ãSyî±1ûÚξ¤çäNôk7[‹ggü ÷ê)øuj3ö®øT~ÙŠ6ý S/øÁsí´ïz[XìcSžsv„æ _jg’‘L·‘vB z½qfn7üá[/h¿{žìYÿãóimxZÇÞ‚3£Yòo?ò+æ;Ϋß6ÔGo¦ïûÜö\OƒÖ©?÷óß2`?ðÐUüÿ—?òäÖ×ìÁ¶~6“à™‡eQ3{ê‡tÈ\:gKøW8[ÿ×€§|¶ñréR3—®RrµÒ_zkqq"X‚£~û‚Á€l·‚ G±±K8ƒÔâ1˜@#Ø|×$5Èz>(3/X{WJ¨oCȃ$€ü烛biF…ŠbOx…8~¼';oÊQ€£Ä„)h9W}1Ô@h~uwjNa0ˆ…¸sÂòGØHv‡Ú“„À'}°§xN$9­s:è„Ès´yƦ‡j…†ByŽØ{v‡ƒöBˆË÷¹Çy‰X8c÷u_Xm‰8*½¦4cÿø"±JˆøˆˆˆSh¨‰=DŠ•GqH‡Ù—8wX(Û3{Èz¥·9}g)º(2±H‹;xŠlH~Œ8~ahh(‹‰ôŒ¹·„ÊX\ØnĨ…9XŒ{W…V؉TX…؇ÙH‚V÷o¼¸†çèŒÛXD—s7xs¬øŽð(ˆ DqxN³½•Nõe`-ç u‚YNIádÙM ©ÙÄ )M¹ôH‘i‘P©‘É‘ï4 ’!)’ ô‘#i’'‰’ñ‘+©Mé’À“1yUûØ^#æ'e‘“_J0“XRp6V¦¨‚y·ŽêÆ-˜0Õ²|0ÿåT¥•Pé7éYX(A.S±`V9ð“+”iM []YW*aTè'ê@Qå–^i“íóeZ•Xƒe3;UX^Xi™XcÅjz9 —ó+téVÜBYe©Zc [€‰Xwù4|X¥1˜|•<9‰˜)Xl™Q’y’yÅb•Õ~V™»u™Ðx–Y ¢YW‡å73šd š¬É§‰kž$Rùs…>L%œ±™S°ÙQUyZ¤©” â]aiMËùäÅ”ÏÙ’R}¡f4¹]Ú¹’ Õ‚×ɳðSoH\_ž·):Ü"ê à)NÌ/Àž·ežTñÿ Tõ98úÉ_÷‰ŸW¦ÉŸôÖXs ã—J d 9Ä ¸9çÙpP3ŸcDž^¡Ûåžùqÿ¹ŸØå¡è©  7!jÑV¡"º¡JE&ú@Ô š¡ÀU\.ÚŽ£ù9¢ý‰M6š ß•£Ÿw¡›Ê„å¤øxr=i[ÂæXqé£ó¸Wõ˜šûâ¤xu^² ÿ˜’|q]¢Uf4ö')Útˆnu º„;¿¾ËŽN †ø»‹ÎÛ·÷Ûy¢ú¿ÛC2âú£KŽÆøtx~ˆxªÇÀ[¨ÁÚÇÁâꬃ“˜¼ ˆZm0«{|yꛎ\|œwI±AJBªµ\À³xÁƲ›‹hÃh,óê³ÞFÄ<®sk5<¼Â [”?lÀÉë¯Ü¶{Ä7}Ü‹¾|¼×:£Ú¾g•G)Å‘¥¼œkŸš:‹÷‹Ò‡1ÌňÚÆü|Ò÷®cÌ+¥J¿·Ë*æ›…¾ñ©]H¡àب«ÇnŠ~jLÁ> ÈÚhbåÚHú[ì‹´ìjµ_›‘eˆ~hûÈåÿˆÛ›CÝ‹d »‡\ÖB8°‘ÂTì†èKÈjÈ6[³§LÆö(¾2hD^ñÉ,¥3øÁ… ÌÚÈ—[½ÜLJñò[½¶ €ª.)ŠÌU FÎÜÌ;L»¹|ͺü—›Û1Ï̬»­;¼–›—Þl”×”Íâ<Î8 ÀH¿½ëÃÅÜ‘ÔÈÍiƯëh8Íó |Bhσ ·ß{´—l5ù¼Í¥ÛÏQ¬„ö†Ž <µN\,Ñ{4¥Œ£òœ+áзj|=Ñ ½4ÜÌë¥åt‡n½¿0­í¿m¨$]Æ%‰ÎïÈ ¬¶üÓýÒ"í´Äì,ÌiüÍAÿŠD<©g®ßØŠnÜÔM$Ó ’ÈêÇ+‘Z–¶¾ü„,Ä©Hjq'tìz/\ÕºšÖr{ÒÏ|Ñ? ÅD™Òÿ ŠaœÉÃÂÒ•ü‰©ŠWý¬@=Ô^ͧjU ½²|mÃwÄÓNëŠbÉb ÒØhÔgl„õ+´«³D- Øx½Ø}o¬ÙB Á0 µÚ8Ù «€-ÝÙ«­Ö›ý׋mÑã©ÚÖ¸Ò­Û¼"Ú±Ít³×mÕÕß<×ݘ×z ª°=§µŒ§ÍÉÃ-zÅÍÑeí¬¯}×ƽcHÛ”ݵ`E’­m’\*Lúükýh^ÎMØ/w¸æÍ.©Þ/šÑH@ßDšÊÒ¶Ýp½Rùmß÷-QKZß9›ºïàÔ-ËÑUàý½Ã‚¹¹£Ú•àFáɬàÚžÖ\á…rïm;c++-annotations-10.5.0/html/memory/fswap2.gif0000644000175000017500000001514112635354026017641 0ustar frankfrankGIF89aÝ÷Ö           $"23""""!2233 """%%%)))+**/((---...4++222333777<66:99>>>???CgC66D44C;;D<<\==u66DUXfw.D.DDUUXX9DBffwwDDDHHHJJJKKKPLLSLLVOOPPPVSSUUUXQQXXX[[[]ZZ`HH`\\c\\DfDPwPVfc```fffhhhmkkmmmrlldwspppqppvvvwww†—¹ ¹ †'Ž..¦''Û Ëì ý þÌ??þ..ë<<þ>>¹N †~¿__ll‚}}Þ__þNNþ^^þnnþ~~ˆ™ª»ÌÝ2Ï!ßîÿ}»}ˆˆ™™ªª»»C¿¿ÌÌÝÝîîïïÿÿˆˆˆŸ‚‚’–––˜””™™™ŸŸŸ¡¿»µªªª±®®µ³³»»»¿¿¿ÌÑÈ™™ÿŸŸÌ¦¦Á¾¾ÿ¯¯ÿ¿¿ªÿªÀÀÀÌÌÌÏÏÏÐÎÎÓÑÑÝÝÝÿÏÏàßßÿßßÕÿöîîîðïïÿïïÿÿÿ!ù,Ýþ­ H° Ài€Ö(3È°¡Ã‡#JœH±¢Å‹3jÜȱ -1 ïröPŒ3@»:ª\ɲ¥Ë—0cR$ÆÚ´;&H2ÜUS¦ÏŸ@ƒ j‘æ@°%Ê´©Ó§P'.uÀ—5ek!Iêë‡ 1€®Š¹3vš5_HÄØBŠUkRk¶~˜J·®Ý»µú²µ&å´ §X¸ôïÛ5kúá‹š2À6Õ‹·²åË>òÈÄ®]‰þvéÚ¾˜] Zôâ°˜cËž­q©µÎz}é&¹ÔUo÷̽›¶ñãÈ ÚömË„òž§¦æ ÝyòëØÛ9ÍÄÛi„{þv·%¬bñÞ.ôugnö÷ð‰vý*Iû«?Ò*DûƒüU$€e°=¦ßB° S| 6èàƒF(g®Uhá…f¨á†vèá‡.8!ˆ$–hâ‰(j("Ebàâ‹0Æ(ãŒ4Öhã8æ¨cVýÔâŽ@)äDÒØ£E?©ä’L*y¤LI6)å”TÆø$‹.Š”â–\vYâ.^ ÓZziæ™h‚ÜE?Š)áJmç›/͉d˜tÖ‰§{æÉ’z“Wk¸ç'–kú$è„z¨D€"ú$X6ôh }B™)¥ÓXzéD‘‚Ú§2kúö©¨‰jš(©=šzjDþ¡BÚ'U°-ö*¬™Æd'­Šýp+D±âšê&(ã‹g¿–”똙k,²É6,°™:cH,d¬/ E;дV{m¶WéÖ­·Ö€ëÊxç,\iù‡®º*±ën±ðª…®@ô2d§¥Ó ¯Bûò»¬ž‰,ðBܯAv†vÀ<lpªºö)±M÷äðÁ‰í@IfñÃEŒÉ`ž»/ÊÙéÛ[ÎŒ„£ÑÂœ‘ÌH T³ 7Ÿ 2µ©úfÂb(CjZcÌlÑôÒ{«óÅWNãËŠB;pÖ[[\ÐÕé-ö·fÙöÙd“¬Û˜z}vÌkû[w×nº÷þ­mßÝtÞ-íýjßrϵœ~¿œ8Ú…SD!šƒÈõá|6>Ñã‘g¾áäe[.íâvW)ºŽy .«çÂŽ®:Ÿ£1误.»Œ¥Ã~§ëÊή;È„Ž(a/üðÄoüñÈ'¯|ð:ðn{ܾ£š…ÔWoýõØg¯ýöÜwO½ ÎãN·ø­§òÊù觯þúì·ïþûðŸÏEøÑ×û<㞢ÿþü÷ïÿÿ  ¨?+Ð#¦û‘ùâ÷>Tt Œ ç'7Ó…¬#?Ê7¨?Odä ûgÀ Â..Z üZ”  ­Hß*ÀA Úð}¬ùx¿‹…P€þ£È‚ Hp…Qð›ÀG8Âê°~¡{’2\ã2¢©‡axE+¸Àõ…¡†7 £úrØ:(rDP°;·DZA ¤…¬ @O(‘‰x$…ËÈÃDùF78á\ì®Ø¾U`_ô"ÅÈH2Fq«2 ¦±3f€Ÿ¸#)´€:j2"Üã#ÙÔ§5üæ,®S`üX€,¾" :Pä*‚gŠ2Ò†ŽŒÝ5ò¯ž*%§k£ÿ@8nÒÿㄲ…O‚rƒ¢ÔeÝ” K¦](Á*RQT(Ò©0E z`Ë[20—cëáézD*yÅM˜þ» >á t¢£þÀÁ<á NÂó™ÿ‹f:wع'ñ%+©¼æ*K€¬âÛLÅCy¾T´ÒœDçøv¹³=¥†£>Ü (H|‚ôôÄIç¸?;þ $< )µ$䣨"$ûVQSdó¡§èNñÊE £ç”©¢< `Þî¥úû 6!Ï“rVà1ïÙAgÂ4€Ýè4¥ÓT²‰Cjòñˆ:Æ.¶¢Ú|EZÔôq©ñÓ(ã@:Ó æJÙš°p=Nø¥ùœ')®pR—¶Ô«_ ¨R¡'RÕ*Q؉f7{­†rñ³®LßEµWTtñ|•ßiñê>½Rn©~ìþ™5œ!²´l–³.ÂêçhLþS‰íIáØ®B5²aÝëX“ÙÔôG …S%üŠ¾V4®u=_+` Öâp²+Zgfèºè¸%Ýß(ÀwR”þÖ¸‘`r_KÙˆ˜÷ñûbw_Á ¸’µ5dá½Û>×’P¼ïq9¹ ý$ÀõhÏ8ú3¾œïû*‘ûê”}_,¸° Cõ‹\ìAÊIàõØ‚DK0à.I@N’ÀVøD&±ÇÚ€“&Å°Á‹*¯K¡ñkE*XÑbs¾X´ïŒÏËÁQxÅ„…œa"¯³ÃSÆo“Çìb/ë­n æ²þšÁjæƒùÈÞòæLç:Ϲy&$èíŒÜºéyïÏ€ôŸÁ—g¾öë¾»›ÝüæÖ%Zv‹æ°”áüèÕE¶|]¥UwéúB¤p˜Óœ¨-Ä9ç.Ó õ¨W]ꢙ¯25œQý6W£NÏ’5'=/[ÓúWºå§ak_7ÚjPv3¯‘MÐCNÕ«u«q-©c§:ÚØÉ®÷línztï¯÷mÑ…»ÈÝ_¹«t›ÜëžR»£S(68`Hm±g/H©˜,âIžñ¡5P¡2Ê€@à‡¢ß’±¾0 Τç8šhÀU¹š¤ Á¾às±°Ñ£QSÌ`-P•SP `ú¾¢aþa¦ŠºQ¶!67± Z”þÍ€›üIʤèyç¢çñ¤ÑÏ17Êd ¸à—à¥/—î™ Î$0ˆ:¥C)6‘6¨qÑ (P½@™Rà¢1¢Hp±@¢c†l÷´€Ïu_A"û!¬°‘ ú&ÓÐ ¢ëéÑéF Àd ¨sŠ”¿ÐYÀAk“ /²šø­Qé/b&­®Z¾õ÷" sz“>Ù¯BD°mЧÞú»€m?°&°­Ø¢þ±Ò¬±c’û"¿àZƒÛ±®è± ’¹²ihY"±(k! Y9™þ²»²PhúèŽùŠü8³O(³6kŒb…278K_ƒâ³;8;Ë)ž"6A{‡H»¦½ö±GÂ*?ˆ7G熭ÒvT«‚¼r'ª´lˆq>³1¶Â6;ë,ÇbSµÖ`¶ÐâµPKÖ’‰åÂ-iÛ>3.Úb.u …í ïb ñ²·ïXY÷²€«/Šó¶@0³®ÀöµÛ¦0›µP¸1Œ»¡‚Kƒå¥ã¶&‹Y+s-ã¹U;2¢k2™;†3ã36S´²´üL@l½Ü.“TI9?†„Hþ2œZhŒ>jlŽT‡oL@ÄdLZ€Lþ£LÌYjvÇà+lžòK} ?¬äJ°$K´Äb!\È*HLTUõÄUê¥OütaY¬ÅÃHƒíÔGDœ>?ÅMÞ”>úNãÊc&Ê1{PhÊŠLRA–R+eÅX¬Â”|t\ˆ(µŒ>¬ÀPQ© QÙõ Zæä ªðÍàÎPàN ÇpÎè|ÎU@ÎæœÎî̽5uS %Éý#UT¥XW•U[õXu JÍÜ©¶™ü><åSqTC•Í¯pTH¥ ‹ðÐÑ=Ñ]Ñ`ÐIH4Ç…XvRŒE\Ÿ´ÌL$ ’PÒ&}Ò']þ–  .ýÒ.}+ÝÒ0­ ÃP þëW¯GËyåVpõPsuÆ„lÆ·äÍá|Ôã\ÎîŒÎë¬ÔK}΋¶–Å\ÖDϾeLÁ5\X,Ò# ‘ðÕ`ÖaMƒ0p hÖhe}Öj} ‹À™ð ÉxV²E[í>£õVÝ´Z‚|WK ÌÕÛæiá\îgè…êÅ^Qõ^ ÝÏyôÏ šà‹ 7=¿Ñ.2 ¹ͯ@]Úu]è“ZÛµ_3,ØAØëøN5 F af6 ®œÅ”mÆ€ q=×ÅøÀbö>úu>ýÕËB-`¾Üd¬M®¿OþµA6†c:VRt$G.òc%Õ^Ì|q–ÙšÓîËÓù"Fb&ÖE(Æ*ÖÜÎÝfÑ-Ä”hÂV†e¤e¯S±ì¿Üt-AJÆdƒœTý=óÁ3%ÙûÍA½áÙ›æ}àöÜ Î½ÅxÀ üá ~= <Àþ ÜràN‰LÁ,ÞâÄcÁý»à9û¾<#\>Þ$~:5nã1žâ Ùã0rã ñß'.Ýq#äVòã;껾¤Öä‘ãnÃñäPîí;Ø@ÞŽºfä½´2-2~Q¥À 9n€Ç‡Bæ]ÎôrWknîÛÀ­‚ þQ çÖðÔMÝÎO½ÔÀP Q 1ê'KK€NÞ ¡ H`QüºCCؽéœþ1"¶€åY®m¯mpÁ`âÂÝ¿À´'±à¢žå[ÞÚ±™àÎ>èOM  @p@ £äC.ål 9^Ó0= ð"Ðr  ¬ä\§éš@ßa ЯîmľÅÄøÛo­ÖÐì.#PÓ.äÕ^ë×Îàrg¼Œô^ï¿(ŒD>Êy¸ °X‹ð‹ín ‹ðî3ÞGœ¸Šd׊•Œäˆf Љ£hw¥8ÖŽí3µð và.à}dñþuïïS‡µˆâñÿt!ŽÒq(Š%Ÿ{'ß)ÏÊÀv ÿòÈçðj;~Wˆ6ó’˜àµîîûè*·ãò@Ï€JŸÓžgô@òHt9Ï;ÿZN7Põ4'ôèKÏüˆYŸy[Ïåð^ß|€ð|¨öb/sdŸ‹Þ á„iŸôðMð'8X÷ˆw÷ƒË18¦Võ}ÏòÍô=èôXø†ï‰1Ÿ¿I{ö¡ãø/rkOëmø,è´Iwù˜?õ×#TáTœ;žÿùyù£?ùX›´ªˆúe‡ø4¸…/ûYúÐ-ùOøõ¸Ïrº¿û™e¾_óWþü&Oû€oû$#[J˜ü ¿üÊ6ÕM…ЯuÒïöFè*zX´†ˆý ¯úuý-ƒ8Ìgøý»þψ“4÷èŸþù…–˜H.ïÿ!Mà@‚¿àËÚB† Å Tذᢅ‹4I|˜PâFŽ3–BRäH’%MžD™ReÈ-;fŒØQæLŽ0%N›FÓ#B]}þTèP¢5ÖtÙ‘¢5‹“ꜙqªU­^ÅšUëV®]©æxêô(T²HÇ–Ý  ¶mݾ…Wî\ºuÙîÛЦҊõæEË0#BÂ… FœXñbƈcŠ}¸ì^É_ÆœY3áÈ‚3þ\ÚÔrgɃ7ŸF½™´5ʕɶvm:õlÚŽ_~®Ø²ë†¶ý\øpâÅG^ÜÙí³¼i®ì;ùtêÕ­_nv5SÝ£þ5nñÉ—GŸ~2ùÐ~=7W_~Ôóâ¡ÏÇŸÿ~n¦îÍÃÏ/ÀøöC@ÀövC°Áë Ï@'\@þD{ïŽë6ä°C§ûÂÒðCODDöº{¯6_„³íÊ“-Fo|q»-ñGQ›Ñ¾‡$²1Y\Hº—d²Éß²ÃOI'§¤rC(7Ú‘B-·ä²K/9ÊòK1Ç$³LðÂ43M5×TM6ß„3NÝ”U³N;ïtŽN<÷ä³O‰ôô3PAã -“cE4QEe´QG…4RI'¥´RK/Å4SM7åtÑÐ5TQG%µTSOE5UUWeµUW_…5VYg¥µVS;c++-annotations-10.5.0/html/memory/badassign.gif0000644000175000017500000001201312635354026020365 0ustar frankfrankGIF89a,‘ÁÁÁÀÀÀÿÿÿ!ù,,ÿœ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó$ˆJSÀ…^[Û§÷ é"Ä–,–|0[·êg £ÓµYzÅŸïU}zšeW56è7 'x˜·x¦È¸ÇÆhGéÕUXwùÙ˜¨H¸Ê7ö:I ÈéØÊŠ*9W9‹tI‡…GŠÚÈÛÛ¶ûúæ¸(VØé+Ü©º,Kû<4g{‘¨»Ùü7\<虪©ì-~ʉˆ ndŒI­yjJþøž°=:ß­û{?ÿš.`i‡n•qÇlß»] “­§Œ¿z } ¼Øcš\ÿú õ"ö$=~" õ9UÅmõìa|i!.˜aàѼ9Ë™3œyú”³`çÏ¡D‹=Š4©Ò¥L›V2„F¨©N«Z ZªàÕ­\]sU ¾<¢è…Ú¯ìÙ˜6v}{DÚ¯¹ZÄugä\ÈÈδ;®àhì4Þ²¥S«âÀˆô[—ÕÁ”sˆU|9òßaÉä–¹ñ_É•KgÌš±ê¬¤¯«à3fÕ“MÛ^ñU³îË€Ãv=¯cÚÃß>.jç×€» .»sµ¹‘[oR{FöëÜoLò±½»øñäË›?Ï _ì©èÛ«7-èÔZ»?¿þýüûûÿÿ ~BÐWÆzÚÁ'8ÿ¼!%<a„NHa…^ˆa†nÈ¡…á½à^Ÿ}’]Á¸äAˆäŒö\fÿ€!@‡2ÎHc6Îø¡WòFœn‡õµ¢*6›Š¬åÞJ.Éd“„àp¢ÝÅb‘T¦%‹úùŒN~ f˜"ÉÂR"j]‚™Z¦i›NÄ(fvÖI&nYjÆ¥o»µæ'–Œñh¥t9¡* €5‹Òyg¤bæ©ç o¶çty‘ ž[Ò-â0ØIH'¤>X*ª§®*i«MRŠ0 ecƒË '*u|áh¢ª6ů©âáj±KŠ²éÿÅdvΙºjŒ©F«*´Æ^‹£%P¸÷ݤVËè´¥‹m¹c¶·T·é™Ë®±ÊRàºÉªû€µíÞæ»ì'o ôN`/¾3©o|Wök¼u Ìð—ÃKT€ßÇÅ¿LŒqÆoÌq®)È9UǪ òÈ(XŒ0žmWò$?Ì¥WÌÃÎz}ü.Ê43áñ='ë,´ûü3BâLðtŠ"íUËV_-qN:m“Ñ<‡¬p² 7Ìu ¢FÝÚ¨}t346ÃeÇ´òËvmÒÜNÇ=°ÞtwmÛk¼üvOhêá|×è·w >·à™4~ò†‰ÿ/îðKa yç^’J.°ãŽ‹*¤á†Ž9©0IÎÑÝCŽ¸°ÔÎ.­¯©?©¹çx¿®Î~ˆ“;¬ì¢“^úíR>¯ë^󾃀T|K{ô¬Úþ«ñ‹®®;ó˃è<5 ‡~ú´¢O¾õ×ç®<äésž§æc‹|Ú¬­þîÛON±Wï_ÿÅß¼>Ne¯^Ý‹ÉþÜU3~Ð~õcÞ~”vÀbõOP­c` æwªkì`Õ‘‰ÐiLšO(…Á ¤^%4!NPØBŽÐ…]Yáµ×@¾pm1$á çÁ >°†=äÜkA MÐYG„Z —Ä -hOlSãE ÿMq 6 Y¥»ãEq‹Jèb|®(5— èBŠKkaÆ0 Q~`³šû<Ôo{cr¿ ÎQ€Xƒ^í¤¼é™Ër‡eøH.‘²#Ö½ù[}‘Ž‘,ã$Å%¼Cö‘)gdÛ: E<‚²x¡DÝ"•â±8p“< £"ǘ»0M–T0åàx½,¢ # kÚÎp(HZFC˜¸ˆœÔÆK·ù2¶dæùV89*s BÔ aº No¡˜r gçÌ©Ãòélç®Ü ÏxÊsžÿ£§=ï‰Ï|êsŸüì§?ñg΀ t -¨AjÇ "t¡ m¨C ÑŒµ#ÿ¢­¨E/ŠQN4£í¨G?ÚÑŠt¤$-©IOŠÒ”Î$ªWH|¨+•Î7°:ÆKµiL Ê´™\9:âå¨QA QAÅ ‰€*!âÜ©ÙDTO/¶¤"÷XEZ,µ’“¸b¨ÅpÈVsêÔæ½HRí‹Y]BdäíSŸJ+DÎŽh†5p]"ëÓÂsäL!ÖÐK^êV¯Âª™ëëÚÒ3né¬ôÃëãÄÒž5«þà+& »¬éTP°T…¬`-ûV¥RÖ«Åìi…¤j82¨Ò I·€jT¤Æ•±¬mˆiÁU»¦Ã‘·ÕœÛN¸¹Þ¢C.Â-®q‹ÜäÞ*ÿòŸrã™›Ë>—<_ÄoÔάÅ, i‹Z½ÕéÒ„¸›*¯'¨´‰å…/{ùQpÄ[æ‡H¿ÁÊ3×Tœ)¥FºðµL•R3_íÞ—6AÅïÛ_lJ)¿¯Î{5Õ\ýö(Á?‰îjˆÔ›P¡×ÀzŽøKáäØ”¾2a«‡Äú¤â. 1ÐäâÒ4-Ž±oŒãáÊ NTÈ1wÌ—ò˜Æˆ-ÐnAêQ7X…ÍõW”}ï;µ|©ëÆéÍ@ûÞ£FÇ(`Yš`Jµ¦Eí§F§—¥€ò'ì1åRÛîrÑߪ÷ÍZˆ·šìô—!– ^éb’ä¥%͸ë@gd$Ó•Ëé™O†²ZÐ>VgJWôÎ[»Þ¶Ë×mµöØ.¦ZÓ-©¥×Çéiê»á}§ÚH»¿ûƾÙ5µyó»ßôø÷+¹yí ´bç’9êDvç œ„ 'Ï$~O‚È„$û0îOï•VÜæÆNC‘ƒÕ‰&߬ÃAnØ~Ã|æÓ,ɼ.D*JŽæ-oG[ÿ|oƒ«Î _9IÎòzÝ€BïÊY4ž#ýèß®tÓ-G‹×ÖÜçW¹v,G½n?ýh ¤Çµ0öz}QøN»ü¤Þq˜–ùÔto6ñìt¹a¯çá{F*äìs‹ò–æs;ÕÍ.wÄgÒw¦¦Ö*-ÉÇú‡pW|`¾Ñ¾>¯ÜŽ?w0 ïFl㧌[ïûÔÙ¾\|ÏtyŸ¢ÂA±y¥Waí;ú½]ëC›}ÅüÎBàCBó\Ø=ïçãû’Ÿ¾–§Oþ|Œ¯ÄF:ÿ®Ë?¥?˜IèK‘èί|!çuíà<ç:&¾å•wz«ìö7<¿ú“Wý_¦ÿý–a¿ãOÿÛŸúó‡ãøSÏÞ—Lø·A¿fxC€\×X´jh6û‡S ¨øxvßWhb”Dˆ|Âw½7ykä!¸„=ãüç~ÃW2wTw©¦j¥Ãz£$bÅ|ÈI6HHW£m”t*¾¶HEE')øG;øxàâJåÂâ'„³”€IRnGØy}Sè„8¸Lª$÷S¬õW~õ ßfµ¥‚)¡U¥ôSÐØU¥%‰ÄÖ6Su¡@X³Õ,A[ÙX7…æøU”Hb>UŽ•Z°PUïèY£YšäXWµŒæŽã¸X#·ŒÏ˜úèúØøX˜W\ “Z}ÕÙ¤¢PcáYZYv‘ÈÔôVñŽâÈY]•Žï˜‘I’€¤‘€¦€ÔØ¥4’UgÔHUÒÈZ匠¥ÆÅI““È% g¨l½8iÇH”Ei”GÉ“ì0hOµ/©ÿe0@i‡”aa˜æ‹NYP ‚X #ÂF~]^)` ò^u#–mµA+ÒQ"{–ægBäÅjv+/"a®$'6va{9 Má–oY€6%6_°bKÆ#ôe 6˜h˜ã–NzƘ?2i·Ò•`h'a^ŠÙ’Ã7a3È_É“‰ÖŽtv˜†q™Gâ`o™z™&¶¨áqKç¤)˜çµšŽVd|y]‰¹`g~Æp²¹NÄIyý£…‰UjQWï(Be r‰–¸™WkµEùC7Æ #ÚSˆ Ù“„½žm9žÜ™vž†øUÃs²ž‰Øž óžÌ9”=ÿV&ñéT;7tŸ¿õ‹¢yy»‰lôYŸ#ÁŠ‡ Š{‹f•K) mòdö ¡òhúÉ)Ê¡À¡ª¡*¢$ú¡& ¢ ¢#¢'Ú¢):+Š¢:£,ª¢"pl£A£'¶¶Z\Ö•<*3;j^9jº•y´¹67ê¢L £2ú¢4¥6£%:¥5Š¥Wª¥N*¥\:¢9šÞ”zæU(oÖ zEiÉ–i’‰™Jvê4UÚ¤rú¤Vê¥Yz§[J§]º§T ¥y ¨}Š¤9ãné©t@õ›lÉiÄ`]ƒjd·É¨mJhoj¨N󧂪§—ª©vŠ©º©sú©uÿÚ¤á§Ç2ƒa‹Æg<êi¹©}R™—‡¡œÂ©¡Ê§¶ê§µª« º«¢ê«·Ê©¤Z©¦j{¨g¹I™h"œÍb)¯f¤±Fj}¨¤ks¢RÀ¡ši­_z¸Š§ê­Üš©½z«Â:¬ŒÊŸ¹Ç¦Çz–Ê­o'lqk ¢‹PW®—¢Û*Êš¯à•âš«¼*°¿°Û­›J®>3«Ò€eykÞP`¹V&Ÿöqj ]Ú¯{üʯÄ0°Àú± ²®!k¢ ‹2 ÛKæ—'nYmÌZ±Úùù:+þʱa®ž °Û³%ë«`\*ˉíúsòz61ÿ³9b€³8‹미à¯Q0²W+²Yë³& ´W+´QWªG[Sõªža»V0)dßú³<˵lK²n‹µ5úµ¹2Ÿ/'sd[¶d‹}5¡¶mÛ·oû·qÛµZ{¥9¢ŸD»‹xK¨ÓzukªŒK;¸„ ·”;¹[K²†Ÿˆ›¸3f¶ƒ¡›8’Kºk{¹ƒ‹¹‚›¦ «uŸK¯âĹ1K~oç²ýA© :»¨XTŠ[´ATq…Xœ‹e2"õŽk·Ý•ÙP°‚#5ž±‹‚Æ+Y. ‡ÄH»Ì¨FÎ˲®ûÓ(oôb‰—¤cRèzžÒV“ª¾V(† õ¸¼¸»·Ã‰­Mÿ«¤Ö˜žë›¼7u¨ëF¾Vº~À€KºS4¼+Kt»žp¾ÅÈ´OÓ2Kzº•›º–;ÀÀzÍ[GÒĺÚÀÀìËÁgÛ¹³¤lÁ¦kÂ[›ÁüÁM#׿FµK ü ù¿ª4‹)Œº;ì¶+,ºôÊ¿ïk®Ã8€½w½¶+½#®Æ€ÂM,ÀNܱ8¿× I<¯Ö‡‡'ÇÂÞ›6.š­U› ü ךWP¬ºܧÕöÃò§ÅfÛÀ²zÄJk®]Ô¯~š±_zR{³ùÚ¯TkÆ'üÄÕšrœtUŒ4oŒ~ÒºÀœË|š­=ªÇ ÆÈüÇŽJˆ¼k½†ÜŸ2l3ñÿ›¿çKÈô@¥w<µy|Çua¥Û*µìÊ<üFS\ƒb›ÀžìŠ ¶kŒŸ*µ{ Æ7 Æ`£ÙúÊÌëk Ü©££|‡xÇKT¶›6ǬÃÆlÍßêGVÌƽ;oˆ\ȸ¬ÀÜ+dÕŒÆä\ºÙ ½ ÊÍã͇‡ÀºÌÅXbΗLÍNŒÎ ÏÆ8ákËÇôô©Í£KÏ×<Ï•|Ï®»Åú¼¸¾ýL¬¿ ¹,¿²L¿šÜÁ ‡uÛÎ7˜Ìå)nÌÌÑ ã¶Ñ³ Ñm Çm,ÑÏâÐÊ»Òñ,SÌûe1ÊÛ»¿WìrÝO\Óß;´ýÒAlEß › È}ëÿðÓï,æ›Ó‡½G]Ï•|Ƹ ”ñÑWØÒb«Óɇ¢8ÇsÆdå<Ðd-ÈÎ’¾*Ò#œÕ›ìÌE={mÍÊT Ȗ̵g6m­†-}ªâìÕY<¾¨Jpu £„]×U=Ðiçá<ÄXüÐÅjÑ·ˆvÌÖÒlµJØÅlÖ€ût*ý¾­›½­»\³Ñ š ÕjµÁLÉ¿¼ÚˆM×ÚÙ›hÙ’=¸ Ø-»àt¯Ãü´ûÚÛxÑÊSmÉ(737]¿¸Ýض]Ä· Ù”}Ú6zÇ4ëۛý,Ü®MÜ.Î+¹¶Ù#­Ì/ ]\³PKµ©¼¯u¬Ùœpê’×øërÉ Ê2Ü#ÞL±Á|ÊulµçÍÚmÆíÍØL«t;ýÝ|-W% Î~ŒR{Ø ¾Þ8l.ᄺYéÌÔĉàËËÓ|{­®m×·þ“Ná+Yà6³á(øÖ¹­×fQÐ îàÈ,Å»;âi]A î„)®Õ+ÎâBòâäЭ4µ¸ÝÜ­¹sìÀ:~ѹ;Ù-nà–8äÇÝÁž ;;½f$Pùéä)'Ëù¼Ï%Äæ9ÓV Ò¯Û8Ž”²*¦'®‚èy i.}oÎ×pÞ¸l.­t^‚[Ž?xžç( Ó|^~Z è@$];c++-annotations-10.5.0/html/memory/fswap.gif0000644000175000017500000000675612635354026017573 0ustar frankfrankGIF89aú™ô """&&&222333888DDDHHHUUUXXX\\\fffhhhpppwwwˆˆˆ™™™ªªª»»»ÌÌÌÝÝÝîîîÿÿÿ!ù,ú™þ $Ždiž%…­lë¾p¼¢tmªr®Ãv_ã» ÎG¼ŽÈ¤rÉTB„PYsJ]>£ØVuK½f³Ü°àýÆÈfp9íB³¡îw{-—Òåäx}¥ßŸïo}~/‚x€ƒ|‡iyŠf…ˆ‰’_“ˆ—Ž™–•{œj”¢0 XŒ¤¥sª«,§Q°ž¨›´±·³­®²B¾‹¹¿¶»®À;ÇÅ«É9©˜ÂÁË¥Ív¼¯ÑÈÄÐבÜÝÕ£àÙ:σápäÎêµÓ¢è„Û:"Ãݽ•žðAœ,4à' ;\P.(0ÈI„öQ¸o‡‚Tú×bbÅLÀP!@Árþaxd%D†´öE$!@ƒ‘ØvÀ!€6H5ojidA…" ŠÓÛ/µ’iðÝGeA ÓUYsˆÐõÜ×°A$,ŒŠr*D€ (ÈK·®Ý»s (!àAÈââL8ïÞ¾A.HhàOpáÇvõ&áëwŠl×¹ýu ˆgL@¡Z®³g" —ˆÞaA„ RLŸî‘ZÉj íSi”¢ Ñhá”Ëúþµx®šÊ÷0@<ÓV~ôkómt9ØÜ/„-$·&Q|òY„ÿþ&üøœ9,Ð@üŸÍU!ÁICépÁ@s5þ›))½0àG2H@rÑÇƃ,ýÒ›eh×{×X·Ä‚ò’Éü샞…ßh(UƒšcãA"ˆ2Fá<~p\‹9iÌŒØøèT繎;Lcdy5 ÉŒ’P†H¥9=R)N’÷<ùä–Yz©%ƒMr)%5Wòøɘ%®ÙešoR"fœg¾g”IΉg–tši¥œwþYg™Ê칦v³õð¥)ý$Zâ„4ê( ¶!é¤&ä!Ʀ•jÁ©l¶ñi¡z:ê¥Þ£êª¬¶êê«°Æ*무Öjë­¸æªë®¼öêë¯À+ì°Äkì±È&«ì²Ì6ëì³ÐF+í´ÔþVkíµØf«í¶Üvëí5[u*k KA;-+vü(@`,Á»~T €p Pn«á-´ÇqG(à_½ðƒ>Ú´Þ®á=¡'"­RÒÝx>§±Iz°°á݈r$`€¯ ³`@f0T`p) d†€ÅÃvÈ‚„ôî2 ù²°IÆ·¦¼Bv-\ûJA+-ôX@NC°ï D³P>"œD×O¯@äQð„"¬g6hC\Ôb[=6l­=-× _Ë÷ÈØ`i-wØ- Ý@Ì7Zpõ&Wë*tH^”´tTp.ŒT’‚pöÊ`ÀþŽS9Л(8è¶Â½+Ô@¹›È…n¹+ Bо²í=å° ÀX‡ûNÀ`€w1HxcìçæÎöʇ»on Ȼ£ŒhOel·‚ í<´w;‡×@ âc@þÁ.QD\aÑñãïæÒ æÏ'¶MücËå0п—‡,îó×€Àð#û#àËÌwÀóéfç@yž™™-_qÙÒä²< â@„Z(ßËHÂÀ¹”0ˆßú0`¼£D s«Ÿ †ÿ!%*>Ä@ÌL@ ¸Asø‘ä1'ÅiŠùTr»TÕ'.[_xF(—£6œþâé´XÀ%W` ûŒÆ´N¶›`f6ÀÐñ‹ø¡E¦ƒš”qj‰cWˆ1®PáÉYÐô "º €D I3Ÿ-¬gxÈí{‘G(WíÄ9¾Þ8$ ð¡H`Ìd(9ÅB®8Ê•Ð0°À…,æû% „9Ea–6˜¡„æ5¾­è '£T™¿‚ø>TV©'ÓAHƼᖄ]pÉË÷° ‚tCòx€“Ä‘èɾеÇCnÂ3lCS$´›zlXtÃö$è³ÈÕqµfÀ·´ƒ!@s#¢ \v…Öò ÉþÃH”EÜëc·˜$;fNŸ‰'ux¥ò´•mezÊ+Ã&€RPod¯iA÷ÄÖIR./<(P0ém¤F©‚'lRt¶Û¦ò>&ð@y3£ÎR©×Ô•E_Q^Æ Ç¢2ñX±<'ÒJÀ•Ô!ˆaYBÒt®ê mY%¿%+¸ê- áñOOùJX3/¯‡5ƒLV®3Z±°ÏŠ!ôȇPö Èd÷ ÙÎzö³  ­hGKÚÒšö´¨M­jWËÚÖºöµ°­lgKÛÚÚ6’ƒŒnwË[Èäõ¶±ú¦†KÜ}(¸¯Z¬²&à/äÎj1Ê ‰sþiå®eÍlº²ú§²Ž†]XQ ›ÊÂfw_Uf à¬ã½†ê˜Õ€ã¦·Êmsß«*è6KºôíFuuÝYœÝÃOàh÷ ¾A¸ë›“ ª§ªÂc#Œ*×îBÄû‹ OAMuבÜdvèÉ çI˜…$>a½š TÚ«âC±xH2Ž¯4„ù(O7ž’Œí»c?}¿,Òĉ[Lbì·È.NCd‡8È<ûm:¬¬ÄŠËºà1ÿ.c1ï€ÃT^1˜Ù°ä”—ÍXÆBŠÓlã5C¹É2€ñ¯,ÓùÊm²˜u g;¿ÀÇK‚(ÆþVcAçG³î¥Q„òYhí£}‰f’s ’æj¦a^¦AÒE¬$‘ñ žl£RWâ"öÌŸ¿0e·&qäŽoDÍi90EÒ1(Ên’2ëXÊ­c®xú¤ØX`0Û(÷¡©ÐñE»ntˆÏR¥oLx#s‡ÅÓ7­è°×Y@s/Ž 9´ì@-¼Á¶yx}Çô¶0’Ae³˜Æ†1BÐa&üe#ö¾‹–]0€ \ß?óeâ­ëysÆÁ"¨Mn“×p²AzyÀ˜Œ‡f4ô&DÈM0e´ÍäªáÞnäÊ %Ù Ó©Îsž=j6@9'—q¸ þíxØAwÎ$ÉDUü))oÓ[ÝŸJ\ͯR7ÃÏxU“<= ïö ¶Žû”Tì/¸\ø“V,Á+ê1Ú†€ÝÇ ­î^G0"ÐJ´»à@<×^/Aö(ð=ëRØn‰ê¡›ãÙ¡ý˜lØý®÷ž}DE/|˜]ôô(3‘[®ƒæ_i7½ècW¼çqlfßT2Ðv<½å {;š¯ó dn8×þö³¯|ï÷ûÇZ÷­o‡èsߤÑ¿O>B–üÒãÞø´G¾‘±/|póYÎ/s•¥¿ùÕkŒù<¡Æ¿}G›_ëèoñ¿Ïþ÷ÛžüðŠ¿ýwÏ}þß_ê¿"Ö ÿW\ÿ ~|0€ÄEx¼w8\šâaL0aözhù÷ èïe€°âùå_ È ‚±R‚­‚‚&è**¸*-¸‚.8‚®ð‚0x4Ø 7Xƒ$ÈE÷ÖƒºuY:X+fƒqÅ5rAx„H˜„J¸„LØ„Nø„N.µ*äb.è"ƒÆâ2}/ñ”jQ`/ø¢/®Ò/~0`TPNôã“,¥ó3Ó:€…i€1fwql sH,02!d2Í¢98.ƒL}&3xH+6Hí$ 䄘Oƒ•,ÌeWÓ¶4[=ýt4V7Rã|Y#6þ1^6[Ç7es6i#®è6¢(ŠscF#0xC »4Q#@QS‹s„†cRF(,Õe:49•CÙÑ5%ó8‘0ó9—g:”:úól®Óü=ºs†·#=µ3Žð;0U=ijƃ<1óBˆ%;äH=ÃsˆMC>Ú#·SÉ‚_ÎsA&Å>^PM”ƒ2ôc‡ß¤:M%3C>4@¨„NïÃKj¤)G8€N OxC?ßv,ë"Æ“OStm,ÄE%4‰!C,PCpCÖxç¶kDÅ“§ä‘øDyÇK´;Nœ$EüÈ?U´,Õ#þ•+Éc4^´”.pFq FÈmädQ¦tPNFtz$’®dPGby–ð“qå…½’-`<^³B,INr)‹,P‰š´ÅáI«3Ki‰d‰˜ uª42}8°” $J@ ”ôcÆòf+:OT–M#ryHÉt3dpŸS?áMr¤SÓ”9Hp)6âöÛ´r•šyQ,äät 䡉Å2gÆO?cRø¤–Z°O—èOɱ 5dÙ»áCÒi–IÄP7‚"%ÕÏi‰°‰ÅKå¹:~(,Ð!/H Ãkö#â3S(<€pxSž³ þè2ä± ?¥U„TeCD•T^µU+åT€a/çA=TÕW AÅT ê0ÙñTbå ùr Ç¨-l…7¶vE0DsB@W甑wõ†’ã„XGPfXZ¢Pø*‰uhv÷‹5KŽU£ cY "Y@ˆ™ÅCú-!;c++-annotations-10.5.0/html/modaye0000644000175000017500000000010512635354026015633 0ustar frankfrank c++-annotations-10.5.0/html/containers/0000755000175000017500000000000012635354026016603 5ustar frankfrankc++-annotations-10.5.0/html/containers/insertlist.gif0000644000175000017500000000430212635354026021471 0ustar frankfrankGIF89aõÉ‘°°°ÿÿÿ!ù,õÉÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçôºýŽÏë÷ü¾ÿ(8HXhxˆ˜¨¸ÈØèø)9IYiy‰™©¹àéyÀ9ªõÉ *Ššz€ªÀj›"kAKz  ÁJ» »šàüÊÒ+àË{Œª‹Ûüóɼ<|\{­jM­Ò Œ­+ì<Þ½­]=-+Þ*½ý®þ½N~¿c.Þ>ÿÝoŒX7Úê¹S¦/¡Â… ñ5b1¢B~Ü’Õ»ŠŒÿìÞÙèpÑG )š´—%º•'8úócdHA21è;5/ç¯iÖ2²4áÓ=e0jÎüc´‚¹B©õkÅì¦T9Iò©:á\¨XÇtµŠçk¼bÔKç,Z¦k ©m‹.M¹ÞÒ]c÷®:½Wùn8+1°àÁZ>Œxi¼ÄŒoõ›0€É”+[¾Œ9³æÍ”óRÀ9´èÑ™=g%:õ沦éJV ;vë cÛF={×íÝ¢YCŽl“·p͹™?n¹¸ƒÚÈ‘ûþý¸VóæÊ0Ÿ.¼ú)ìÇŸCWj}äuî·sŽE>{ˆóÇÒóöþ=kø¦­Üï6¿O•ýòëó×ÿß/[tñI ÓMÿ¨Zq¢‡`‚",Ø^ƒ©Á7à.ËM4ž„¡)ˆ¡†¸=Ø¡‡£QXá…‰‰8bcˆ¡ØaÁÆ↉•ØACƘˆ EˆciŸiÕŽ7ö8™v42¥ƒD^Æ¡CÙÕS/:¹$fFyŠJVÙYômÉ%Q‰VOöx%–¯ˆfeøY×f—òýÄÞ™8¦©æiqŠYÌž|Ι~â™'mƒö¹ç˜?—h¡5Ø#¡`r©h †6êè ²()mVº×¥qvš©4‡Æs*d2:j©2lŠb§°ŠjJºaêê ³z(kª´­ºœ¯¹"Ú*ª¸þºh°Çÿkl±ÝËV²p.Ëì,Ðu­uÀNëlµÏR‹-¸ÚJ»¸Þ’°«†±Y¶fn[n·ªªfº¶£eÂ&iéWö6ˆï—çrð/‚¼ð[Wªö«”ÂLð %­'ñD…zë¨C<ªãÇ 0C;Æìk[L±ÈB’ ¯§aŽ<î°*¤Àúâ:KRÆ‹s,“[opËý×¾ÿlk0JëŒq¦7ÏœåƒîžÃtM¸®xÕNM)±AÇÅ0Ñ[ïG¢ÔFËÛR¶¡fÍêØ?¦¼¶Ü¹Üʲ¬ÍuSݬÝ0û7ààÑ ÞV››÷àÜ Þw®€L9ÍÝÿTŽùÂŽ¿d枧í(½˜èmi¢7sº%¤G}Eê·¸NÉêM·NÕy]¤RÙEM8ÑSÀ.Oþü¹O¬Ï»îÇWq:ÒdS:0ecüìk®—<ç¾KÑüöËs¥»8¸Ôtùþ•}ãÞCѽNÑDU:øÚ÷Î0ÕÏ®9ÁéËnúî/ÕO?ë‘%|0iÜýJæ<à`IvÀsAó6>p~)ÞÅõ9ˆìos¥Èàƈ'´pL©Â+ȼt‚1[ ð|«Ùü¾Nï‹Qá ›"•¥ˆ'-ä Ó !C¡w¯’ß|ØÕCå©/üÅÁPhå`‰I\â «ˆÅgÿø0‹\Ôbïâ×Å0Ò€b,ã ÈhÆ4ñ‹0T£'¨Ä¾‘‹hœ£[²Å;ê]yÜc=820~¼‡¯¨©B’ãV£"ÇÁÈ®ñ‘¸ˆdÌHHIÔá@’1Éd%§4H v,”–k£'%ÁÉ/¤ò”•Xe\ÉJT^r °Œ%$jYŠYÚÒ¸ìßúv)]úŒÀŒD/±pÌb""™V`¦2Ý"LdFó™@œf3­IÍA8³L¤œQ-°™Í@l³6¸L9-sÎʤ“2ëœÌ9)ÄÈpªœ i'ì‰Ï˜SŸèäçŸGLy2‘žù4À> ÚO„ªÓŸìd(<jL‚*´ÿ¡u'C-ZÑ{^T£}(D‘Ê:e´ 8hIzÒ…fÔ£}ȶ ˜RŠÆ£3åhMIjN–¶4˜ä‚P†pŠR“ µŸ:Ýé@{"™U¥7ÝhA‹jÔC¬p0L]ªRƒŠU¦2œQ½C”’ ÔªfõªUõL<»Ê¼Ï4‘¦VeëXÝ*V³¢õ¨´ÉW=Š×‘浩 •ë\¥š¯íµ­6%ì:ýúWhÖh°o-lcÛ‰ØÄjÓ©0,cÅŠY9¡O²„0(,«×Ðòõ¦‘ål ) ÚѦvŸ¥5­<ûØË’u¶m­kû²3¸ÒÖ±™Õ-Mm{[=ÀÖ·¼ÝmX• Üà†µÅÿ%îqËÏä*×°}ns¯VéN7-”µ®we«ÝíR¥»¢]ml;ºXñîÁ³å=¯jÛ5@©w¹‹5oo±ëTÊw¾Ôeî}¿ÛÞ…Œ…Ïão†k\ÙB7´¥´½Š¹ÿ*¿¢Å܃Q™àgXµ ¾ð(È9a¿wÀPóp&îªá¿³ú51)`aß [5¾.þpˆoœâ³Ö8•uoŒ‰«ã¿á³>.òƒ,ä6üÇ+N0’“Œ#Ëø¼O†rº©"+kyË\î²—¿ æ0‹yÌd.³™Ï<Ï_x{äC3HAHFËͲä‰)ìü¢‚„cÏ*Ä¡÷Lç¹Ì~{ñÅ“Ph+ñyÄÐ ô‡WH) ÕS4F èè>T›ö¸ûDÂeH/g–nt¦Ç{iæ΄¬61JˆçSãVˆ­ŽÞÿ@Íhê¡0Ö²nE]>?÷ÄÐƈ ¨YÝëd+{ÙÌn¶³Ÿ íhK{ÚÔ®¶µ¯ílk{ÛÜ¿ îp‹{Üä.·¹Ïît«{Ýìn·»P;c++-annotations-10.5.0/html/containers/list.gif0000644000175000017500000000234312635354026020247 0ustar frankfrankGIF89aôd‘°°°ÿÿÿ!ù,ôdÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçôºýŽÏë÷ü¾ÿxðgxH8¸PXˆÐØxÀ¨i@‰bi‰¸‰§ø‰ùHù˜ Y:¹* ºÊèÉk'‹Zikºzë¨{ê›Jº«˜+kLG[¹Ì{ÛÚ»¬j{)È -¬«y¼Í–Lûkù,mÝ|9-]êÝîþÏ-/_oï~N¾›½ï<}~BÚµ}ÅZh›‡0=|ùÀ­+Çï@Õùƒq0¡Æÿ1xcðÌÚ¨ØÌ™,!ÐIW7ºT"Ù'e½ôUòô1gœŽ/{žÜ@³Ï CÉõéò¨ÁJÅ4EŠð)Ô€S«N´C*VYZ·Æô:µ+ØbÇþ)k–¨Ç{lÛºEKá­Ü¹Sѽ+—PÚZø 8°àÁ„ > ;~LX±Æ+[.,UòÞÅ/{þ @3Ê K7ýÉ´jÄ™7/%´:vd¤eËFí ¶íÕ­]§ê¼Û6—Òøm½¾U ºJylÑЋK¿LýùuÕ½›£ù­ÔvÓÙ«‰º¼2ëèw÷N1·ÌHí?£®[©¾çûóóëÿ·ü|$dôNtÿUÆ_;øX‚91Y€.D„ â5—…îa(—†§Ñ5aVø°çá_ÊDb‰'~“¢‡È…ÈT –8[øÍH£`+:’#f0 !£=êhcx<IdLFÒ‡d`/þˆvM&V$qSR©¤•W†å-jøäyW†yä˜]*ñ¥…d2if*[ry&iB¸¦SÖ‰#’xÆÓ›xÎÉàŸ~òy  º%¢mJ„¡ÿ)z'mƒ2Úè¤ÎY ¦”á¨~6ù©ž›Ñi}¡yj{ŽJ”¦¹J¬¬êPj{©æx+«Îš‰¬Ðµš(xôøº+¯“h$YÈÿ.éA­è…ì±|Yz# Ô&«l°7E+­ ÎŽÏ°‰(î˜ävË^~røÖºì¶ån^èrœ¹ ÙoµÍæ‹íOóþ׵ܦ+°yøj«’Á‹ü;Z½‘:2°ßn­Âû"¼mu â0¨Â¼(;å><ÉsçÖ±¨nb|‰¬Ÿ RʨJÊò«5Ó ó°݌’ËLùL\Î:÷Êó€@ƒLr\B¼ØÑ}ý3ÔA/}Õdï^­/EXoý+…\_ÍÕýˆ}F±f™MvhƒµvÚ´îTA%E4Úm»ÃÝ?„Ä ,sQà¿ámF±ýÆüZà¤XôÐUEu áFµäïЃ´CÔ ãUM`ÄI^†áùø½0&Yô·â–Cìùç !zß²×4v|c¯”zJ§ß Èë°c”lî´.í¼èÞÏ×áú†òç–Šy»98ÍÎ9; 2ÿã(U/8J4¥ N(¢HÜáÜ»æ}Mã cr©¿~Z2}ñ5àväõÿÀ p€, ˆÀ*p l ÁJp‚¬ /ˆÁ jpƒì ?Â;c++-annotations-10.5.0/html/containers/dellist.gif0000644000175000017500000000324312635354026020734 0ustar frankfrankGIF89aôd‘°°°ÿÿÿ!ù,ôdÿ”©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*cfóXJ§ÔªÇɈFÛíA«ðÄ(²ÅlMžêv‡ýðš»ân|¯æº¼¯ç6øæ„Fˆ˜eèð—×÷8É9é˜2g'Ɇ—؉a(è):šõeÉ™yʧw‰%I©Ê9JúZ›x‹ KÖ˜éKyÚZFü»z·«¼Ì|›«Ø-=M]m}˜{­½8,‹ì= [YŒ:ü‡]þlé²Ì´NüáNÜ ÌÊn’™~òoTÀÎf ôtBAcæ¾4º¯Àx¸Ð% qQFyÿÜhlô‘QGh T«XÊYHZ+Õ´ÔÊ#<}bž!8SÂK+;«ô¤òSDPr9ã7sè¥G¥0MòIÔ#S›RmZµHV"[­é*l±@Èzõa-Öµgs†ÜW”OqëN› Å®^fxÛÂ{ °àÁ„ >Œ8±à€ (ü˜päÁ“W™ñ'Åœ;{>¬ÙïßÍŸK›FúŒãYKvM¶eÙ˜a§®à´îÝn‹®Õ˜·ðξ'ˆim¹åÌ_'_Ü÷ð銋ÿœºöÁÖ#xiûyøåÎÉ'ÜBîí짿®±Í1íÛ¿g$~vþÚûW÷ÿ¿ìŸyÐݤˆ|õ±w|n`SÊn— )àé' 8!fé5ÈŃÚE¨`é,Ô‡‡ÔF†–§"€Hé$ÒHë™(Š!£J4gc‡ç±äBê÷ž;3î¨[7.’¼ÁEš…-Ò¶âîU“»A¹dQFj™$ 3ºH%™ÿ•ÉS_‚iZZ]úÄa‰l–FÖzf^xç”Ï©ç‘srææ›NDߟžÕY%…z≦xJÅY¨¡€ úæ|rJZ˜y©(§RÈ‘˜fJi©)ŽšX2zf«¬Vˆ(ª¨™Jë²Îº‡«‹îŠž˜·‚Vk­~þꞦ¼Z™è§”ÿÅJ,wÁÒ:,±ÌvŠì¦ÕzP³½>[j´¿N›l¸ÖRK¤¯Ú‚Êm¥ç¢[Ƶºz*®Dí®Û[º”z{+³ã*K.¿R‚Ûl ö.Eo½{øï»î’°´«K/¢û&ü*x ûp—øʪêªÇö›èÅùf¼äƨv\1¼_&2Ç$ßhò¨‡XšÁ#b%}¢Ç+€†²zÉRb8ü¸À+@2’)c#]¸E4ÐQt†Ã‚JäÃEJÖ,”¢\£7INå¤,å°èJŽðâ VÃã MÉ¿X Žºì¥/ Ì` s˜Ä,¦1‰Ìd*s™Ìl¦3Ÿ ÍhJó,¡œ™wîw7£ðršÜDƒ²¹BÕ‰S=Ý,§êQ§Âpa*6OM¢Äð4§=ßAÅS‚ãt  ,0Ç‚/º§Aí˜ÏTîó‡dŒ¡CÊO[tt¢¡"7ü@ËÈ¥¢!ë”…'QÙÉ”¢$¥á>/ùB‰J4Œˆ©J·YRc~ð…›,ãS)F@èA )…iL‰Ù'F^‘ C½"&œ˜Ç~ò©ÿéOŸ Õ¨JuªT­ªU¯ŠÕ¬ju«\íªW¿ Ö°Šu¬d¥A;c++-annotations-10.5.0/html/containers/queue.gif0000644000175000017500000000227712635354026020426 0ustar frankfrankGIF89aôd‘ààà°°°ÿÿÿ!ù,ôdÿœ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì6ZËçôºýŽÏë÷ü¾ÿè&8¨pˆ˜¨¸ÈØèø)9IYiy G¨Éfxéù *:Jz˜¹‰J&PÊÚêú Û(Jûµ‹›«»û8[û‹uË;L\Ìê œ%lÜìü‰¬<½Ä }í,MÍ]d ®»Ý]îó-ž®~lÞ~¾?Jî^?ƒ.Ÿ¯ßkßOƒ¿/ @zþ ¢(0¡>‚Š@¨0â:†ÏÒC¢Äÿà(n¸˜§" Jš<‰2¥J4r|yeK•4kž”)ò¡Í+G¸„ ÔN $y-94燢Gy&ð3¨Ô]O¡65ZUéÇ«N}Ný3#×Yµf`:¶gˆ¨`Ûº*ûmZ”pÍK³.¶nûÎó‰W­ÝƒSê]ÀׯbO‡¦;8…ÜÂ$^ŒyReËocHnóÝÎHf>ÝJôÉU#žãdÁÐ&N9& «íB¨ƒv×4îÜvǵÜD¶eå2¹F›3nÝrx÷†9'WÙèЇSa2ðÍœ² ~üjã%˜—7ï+þsèÜÍ{^}õu tbÁÿ¥ÓÝtø‘·ræ­Öœ|å§ÞïÕ†àƒñEØžö Xœ…—í'Îo¥á}ÖñZ~:Øàê¹—b…6Ø¢ éá‰ÜÁ†Gjv0âá"=*òc"A"2¤);úx$zèhc“éÝQãŒx"|ä¥È¢ŠëØ…0R˜Qˆ¥!‡/)Êb’¶Ý”TžH›„pjùàA~Y§Oõ±†W›&šg&GýÁ¢æŸ|Îå'—…@祜 F(MŒQéä| *z!›#²·a 1É¡Ý€¡‰XA}2zi£ï½¸œ¥ç7&ìéç©B¿…ša‡¦E]dVÅêA§µ.öÜ®c¹êk¦ÿ¹&ì°~Kj²€ÛA³Îº-µÒ.m°×~kÊ´šn+{m¶ã’»V·Þ¢[ë|Ær…¬¯ó^U,¼ñŠ¥-»[õû‘¾žÊ뮿ÿ® ‚µ Ê/ÂspoSò.¼Ÿ¥UodRº¹Å×Y¼1€s¡°ÇlpÉ&ç“1ʵ¨¼r<-»L Ì1§33Í©Ø|s89ëŒ Ï=‡tÊCKõsÑAí›Ò Íô0I;½tÔMMuÕV„uÖAC½u)³zíï­awÔ5Ù¿dw¶PªMuÈrÏMwÝv wÞzïÍwß~ÿ xà‚NxᆎxâŠ/ÎxãŽ?yäW˜zœäPAÚŽG •å—ä9 œ§ºžª¡K@›|+ʆ÷é £Šç„Uº^9}Žž7;íz¾"ršÃm£ª+ê~ÂèVʾ%ñ™/z;‚¿3>:ž*_»éÈ»GýZ°'¸j÷ÙŸŠêœs>¿øž,bù=bÌ“>>ùé¿üòÏOýößþúïÏÿþÿÀ p€, ÇP;c++-annotations-10.5.0/html/containers/stack/0000755000175000017500000000000012635354026017710 5ustar frankfrankc++-annotations-10.5.0/html/containers/stack/stack.gif0000644000175000017500000000360212635354026021505 0ustar frankfrankGIF89aôÈ‘àààØØØÿÿÿ!ù,ôÈÿœ©Ëí£œ´Ú‹³Þ¼û†âH–扦êʶî ÇòL×öçúÎ÷þ ‡Ä¢ñˆL*—̦ó J§ÔªõŠÍj·Ü®÷ ‹Çä²ùŒN«×ì¶û ËçôºýŽÏë÷ü¾ÿ((#pPhv8H–¸ÈhxÖ8UèøX9F©–‰¶‰ð p¹$jzzJʃÊÚê:jó*;K«êA‹›«ûiÄ+ `z ÌÜkpLñ, š¬`-±<ëœë( AaÝ̼ j, òýŠ-ŽÞ>^î›ÐÉÐ+Ù`LÜ1:žÞÿŽÞ|öôÝŠ÷Ož°r9Ð×ÍÀ‰¬‚)uñ™¿gÿ ÜØŽb*W+êã¨#Fs÷&‹ø@%IŠ•¨½<§qfFÍ ÄÉ•Å™×V ü 3äN^µþM2N¡6‡%Ü„Ù ªSw5­rS„ô×V¢(VÅÊ@+Ñ¥"+2„„vÚm“’u+/n¬œ=ÁRÑV²zì.dÚ3°ài~ùñ‰XXà¾φ š4£bºOêM`8³ÐÉnv>bxQàª?_„~‘rã|0^G=Yºle¶—‘Ë \÷ˆÞ£b‡,î3‰yíµ¦½ó¢²[F?1½Ù]^®Èîô¸há"Ào?œ›­ÐRÅ¥.Øæü¡AÞí¯©ë*¾ víÔ!ÿïë}¿¥ãz£ È ü™´[ÆeÃ^ER¬CžBXÃ…¦‚݆â¢Ü $M¨aˆß}8b†(nhbV+¾¸„Y’ÆŒ4r2Û=r;ò˜£?Bd‘F‰d’J.Éd“N> e”RNIe•V^‰e–ZnÉe—^~ f˜bŽIf™fž‰fšj®Éf›n¾ gœrÎIgvÞ‰gžzîÉgŸ~ª©X ‚Jh¡†Šh¢Š.Êh£Ž> i¤’NJi¥–Rúg¦šnÊi§ž~ j¨¢ŽJj©¦žŠjªª®Êj«®¾ k¬²ÎJk­¶ÞŠk®ºîÊk¯¾þ l°ÂKì-öxñAÿæ ¬²"4û´pHÛµ£ß1û»2ü#Ë_2ý'ÛŸ2þ+ëß2ÿ/cÿ»»ånzW`·W8 idà³×@ÚŽ€ˆC`!ø@ hƒ›ÿø·A ~PaÔJÐaOA z„ £áÂlØ0>¬ƒÇ»T 9x-¾°„Ñ¢¨Th$ †:\’—x'ÎAŠP¤©×Ä*ÿ¶/‹Iº¢{çÂ+yñ‹œb•ÆHÆæE1KhLãòÞÓ=5:锓£ã÷¼‰Ñkz¼£õ¬Æ(u£~ßå¼÷$²²x„Yô¤¤ÈÝ1²‘t•"YÆIRr‘YK¤î$©Éûå‘“süd&C)ÊÛUJ¸[%*ûÇE$µ‘‘³ìW,_F^r„¸dÝ ÏÈË^:/—À¼¥0-PKMó˜D&—ÉÌd֚ǔ&ºxÈÌgQ“ÖLc7±Í^~³ ãÔâ¥L(‡sfsìl§;ß ÏxÊsžô¬§=ï‰Ï|êsŸüì§?ÿ Ѐ t -¨AŠÐ„*t¡ õÒ9 шJtÿ¢­¨E/ŠÑŒ*¯¡í¨G? ÒŠt¤$-©IOŠÒ”ªt¥,m©K_ Ó˜Êt¦4­©MoŠÓœÊRoè|ßäbÖÓFÎ'¨›ô Qç÷Ó}õ Ú˜ŠŽ´6$%ìhpëÛ™ñ˜ _ö!«NuÂT¯*U¨6³S‰jX{´ÔÿU.­ ÌjjÇV›Q¬HPÍæÆ:E­ÆU—<õêð,¹§ºõ­–ìVõêW_îõ—®[ì ¿šXÖ9–°Ë›,1£cY&J.³š5,g‰¸¶ÏÖ±”,^àYº¡«9-j kZ= 㫦h+Z×þp6·Åmc‡‰‡Ù—¬¡\o©ý¹bSlR‡{B–”Dø™sµ:]P—ºCîYië–¼Ñ=eSUìb•¼á5¯Nß ßøÊw¾ô­¯}ï‹ßüêw¿üí¯ÿ à xÀ.°ƒU;c++-annotations-10.5.0/icmake/0000755000175000017500000000000012635354026014723 5ustar frankfrankc++-annotations-10.5.0/icmake/mark0000644000175000017500000000012212635354026015573 0ustar frankfrankvoid mark() { g_logMark = backtick("printf '%3d' " + (string)g_lognr++)[0]; } c++-annotations-10.5.0/icmake/loginstall0000644000175000017500000000155512635354026017024 0ustar frankfrank// source and dest, absolute or reachable from g_cwd, should exist. // files and links in source matching dest (if empty: all) are copied to dest // and are logged in g_log // Before they are logged, dest is created void logInstall(string src, string pattern, string dest) { list entries; int idx; chdir(g_cwd); md(dest); src += "/"; dest += "/"; entries = findAll("f", src, pattern); for (idx = listlen(entries); idx--; ) run("cp " + src + entries[idx] + " " + dest); chdir(dest); for (idx = listlen(entries); idx--; ) log(entries[idx]); chdir(g_cwd); entries = findAll("l", src, pattern); for (idx = listlen(entries); idx--; ) run("cp " CPOPTS " " + src + entries[idx] + " " + dest); chdir(dest); for (idx = listlen(entries); idx--; ) logLink(entries[idx]); } c++-annotations-10.5.0/icmake/logzip0000644000175000017500000000134512635354026016155 0ustar frankfrank// names may be a series of files in src, not a wildcard. // if it's empty then all files in src are used. // the files are gzipped and logged in dest. // src and dest do not have to end in / void logZip(string src, string names, string dest) { list files; int idx; string file; chdir(g_cwd); dest += "/"; md(dest); if (src != "") chdir(src); if (names == "") files = makelist("*"); else files = strtok(names, " "); for (idx = listlen(files); idx--; ) { file = files[idx]; run("gzip -n -9 < " + file + " > " + g_cwd + dest + file + ".gz"); } chdir(g_cwd + dest); for (idx = listlen(files); idx--; ) log(files[idx] + ".gz"); } c++-annotations-10.5.0/icmake/clean0000644000175000017500000000054612635354026015735 0ustar frankfrankstring remove1; string remove2; void setRemovals() { remove1 = "tmp ../sf/index.html ../sf/cppannotations"; remove2 = "o indexentry/o aux/o"; } void clean(int stop) { setRemovals(); run("rm -rf " + remove1); chdir("src/htmlindex"); run("rm -rf " + remove2); if (stop) exit(0); else chdir("../../"); } c++-annotations-10.5.0/icmake/zips0000644000175000017500000000237512635354026015642 0ustar frankfrankvoid zip(string dst, string src) { system("zip -r cppannotations/zips/" + dst + " cppannotations/" + src); } void zips() { system("mkdir -p tmp/docs/zips"); system("rm -f tmp/docs/zips/*"); system("ln -sf tmp/docs cppannotations"); system("cp README single/legal.shtml cppannotations/txt"); zip("cplusplus.txt.zip", "txt/*"); system("cp README single/legal.shtml cppannotations/latex"); zip("cplusplus.ps.zip", "latex/*.ps"); zip("cplusplus.ps.zip", "latex/legal.shtml"); zip("cplusplus.ps.zip", "latex/README"); zip("cplusplus.pdf.zip", "latex/*.pdf"); zip("cplusplus.pdf.zip", "latex/legal.shtml"); zip("cplusplus.pdf.zip", "latex/README"); system("ln -s ../../../contrib tmp/docs/html/contrib"); system("cp README cppannotations/html"); zip("cplusplus.html.zip", "html/* -x *.svn*"); system("rm tmp/docs/html/contrib"); system("ln -sf ../../yo tmp/docs/yo"); system("ln -sf ../contrib yo/contrib"); system("cp single/legal.shtml changelog README yo"); zip("cplusplus.yo.zip", "yo/* -x *.svn*"); system("rm yo/contrib yo/legal.shtml yo/changelog yo/README"); system("rm tmp/docs/yo "); system("rm cppannotations"); exit(0); } c++-annotations-10.5.0/icmake/readlog0000644000175000017500000000023212635354026016260 0ustar frankfrankvoid readlog() { list line; while (line = fgets(g_logPath, line)) g_log += strtok(line[0], "\n"); // add logfile entries w/o \n } c++-annotations-10.5.0/icmake/findall0000644000175000017500000000107412635354026016261 0ustar frankfrank// assuming we're in g_cwd, all entries of type 'type' matching source/pattern // are returned w/o final \n list findAll(string type, string source, string pattern) { string cmd; list entries; list ret; int idx; chdir(source); cmd = "find ./ -mindepth 1 -maxdepth 1 -type " + type; if (pattern != "") pattern = "-name '" + pattern + "'"; entries = backtick(cmd + " " + pattern + " -printf \"%f\\n\""); for (idx = listlen(entries); idx--; ) ret += (list)cutEoln(entries[idx]); chdir(g_cwd); return ret; } c++-annotations-10.5.0/icmake/distclean0000644000175000017500000000114612635354026016616 0ustar frankfrankvoid distclean() { list extensions; int idx; clean(0); run("rm -f script.log yo/legal.shtml latex/legal.shtml html/legal.shtml"); run("rm -f html/cplusplus*.html"); run("rm -f html/target.shtml html/contents.html html/index.html"); run("rm -f html/cppindex.html html/cplusplus.index zip/cplusplus.*.zip"); extensions = strtok("aux dvi idx ilg ind latex log out pdf ps toc", " "); for(idx = listlen(extensions); idx--; ) run("rm -f latex/cplusplus*." + extensions[idx]); run("rm -rf src/*/*/o src/*/o"); run("rm -rf zip/cplusplus.txt"); exit(0); } c++-annotations-10.5.0/icmake/man0000644000175000017500000000061412635354026015422 0ustar frankfrankvoid man() { md("tmp/man tmp/manhtml"); if ("man/c++-annotations.yo" younger "tmp/man/c++-annotations.7") { chdir("man"); system("yodl2man -o ../tmp/man/c++-annotations.7 c++-annotations"); system("yodl2html -o ../tmp/manhtml/c++-annotations-man.html " "c++-annotations"); chdir(g_cwd); } } c++-annotations-10.5.0/icmake/cuteoln0000644000175000017500000000023312635354026016315 0ustar frankfrankstring cutEoln(string text) { int len; len = strlen(text) - 1; if (text[len] == "\n") text = substr(text, 0, len); return text; } c++-annotations-10.5.0/icmake/uninstall0000644000175000017500000000144012635354026016656 0ustar frankfrankvoid uninstall() { string key; int idx; int nDirs; list entry; list dirs; string dir; if (g_logPath == "") // do not store uninstall info { printf(LOGENV " environment variable not available\n"); exit(0); } readlog(); for (idx = listlen(g_log); idx--; ) { entry = strtok(g_log[idx], " "); if (entry[1] == "dir") { dir = entry[2]; dirs += (list)dir; chdir(dir); } else if (entry[1] == "file") remove(entry); else if (entry[1] == "link") run("rm " + entry[2]); } for (idx = 0, nDirs = listlen(dirs); idx != nDirs; ++idx) removeDir(dirs[idx]); run("rm " + g_logPath); exit(0); } c++-annotations-10.5.0/icmake/writelog0000644000175000017500000000034112635354026016500 0ustar frankfrankvoid writeLog() { int idx; if (g_logPath != "") // do not store uninstall info { for (idx = listlen(g_log); idx--; ) fprintf(g_logPath, g_log[idx], "\n"); } exit(0); } c++-annotations-10.5.0/icmake/loglink0000644000175000017500000000012112635354026016277 0ustar frankfrankvoid logLink(string file) { g_log += (list)(g_logMark + " link " + file); } c++-annotations-10.5.0/icmake/examples0000644000175000017500000000341312635354026016465 0ustar frankfrankvoid tryCompile(string source) { string obj; obj = change_ext(source, "o"); if (obj newer source) return; if (strfind("koenig4.cc" "personconstr.cc" "stringsmove.cc" "binarystring.cc" "stringconversionerror.cc" "binaryambigu.cc" "binary1.cc" "virtconsorg.cc" "refwrap.cc" "ambiguous2.cc" "ambiguous.cc" "buffer.cc" "perfect.cc" "basename1.cc" , source) != -1) return; system("g++ --std=c++0x -c " + source); } void compile(string dir) { list sources; int idx; chdir(dir); printf(dir, "\n"); sources = makelist("*.cc"); for (idx = listlen(sources); idx--; ) tryCompile(sources[idx]); } void examples() { list dirs; int idx; string cwd; cwd = chdir("yo"); dirs = strtok( "intro/examples:first/examples:namespaces/examples:" "string/examples:iostreams/examples:iostreams/cc:" "classes/examples:memory/examples:exceptions/examples:" "overloading/examples:containers/examples:" "containers/queue:containers/set:inheritance/examples:" "polymorphism/examples:pointermembers/examples:nested/examples:" "stl/examples:generic/examples:functiontemplates/examples:" "classtemplates/examples:advancedtemplates/examples:" "concrete/examples:concrete/examples/monitor" , ":"); for (idx = listlen(dirs); idx--; ) { compile(dirs[idx]); chdir(cwd); } system(P_NOCHECK, "find ./ -type f -name *.o -delete"); exit(0); } c++-annotations-10.5.0/icmake/removedir0000644000175000017500000000137112635354026016644 0ustar frankfrankvoid removeDir(string dir) { list parts; int idx; int dirIdx; list entries; int warn = 1; if (!exists(dir)) // directory was already removed return; parts = findAll("d", dir, ""); // if there are still subdirs if (listlen(parts) != 0) // then remove at some later stage return; chdir(dir); parts = strtok(dir, "/"); for (idx = listlen(parts); idx--; ) { entries = backtick("ls -A"); if (listlen(entries) != 0) { if (warn) printf("not removing non-empty dir ", dir, "\n"); return; } warn = 0; chdir(".."); run("rmdir " + parts[idx]); } } c++-annotations-10.5.0/icmake/github0000644000175000017500000000027012635354026016127 0ustar frankfrankvoid github() { run("cp -r yo/version.yo tmp/manhtml/c++-annotations-man.html " "tmp/docs/zips ../../wip"); run("cp changelog ../../wip/changelog.txt"); exit(0); } c++-annotations-10.5.0/icmake/md0000644000175000017500000000153112635354026015246 0ustar frankfrank// md: target should be a series of blank-delimited directories to be created // If an element is a whildcard, the directory will always be created, // using mkdir -p. // // uses: run() // if the target directory does not exist it is created and its realpath is // logged. string g_lastLogged; void md(string target) { int idx; list paths; string dir; if (!exists(target)) run("mkdir -p " + target); else if (((int)stat(target)[0] & S_IFDIR) == 0) { printf(target + " exists, but is not a directory\n"); exit(1); } if (g_installing) { target = cutEoln(backtick("realpath " + target)[0]); if (target != g_lastLogged) { g_lastLogged = target; mark(); g_log += (list)(g_logMark + " dir " + target); } } } c++-annotations-10.5.0/icmake/log0000644000175000017500000000014212635354026015424 0ustar frankfrankvoid log(string file) { g_log += (list)(g_logMark + " file " + md5sum(file) + " " + file); } c++-annotations-10.5.0/icmake/remove0000644000175000017500000000042012635354026016137 0ustar frankfrankvoid remove(list entry) { int equal; string file; file = entry[3]; if (!exists(file)) return; equal = md5sum(file) == entry[2]; if (equal) run("rm " + file); else printf("not removing modified file ", file, "\n"); } c++-annotations-10.5.0/icmake/latex0000644000175000017500000000043212635354026015762 0ustar frankfrankvoid latex() { md("tmp/docs/latex"); system("rm -f tmp/cplusplus*-stamp tmp/_cplusplus*-stamp tmp/dvi*-stamp " "tmp/docs/latex/cplusplus*"); latexdoc("", 0); latexdoc("us", 0); printf("the log files are in tmp/docs/latex\n"); exit(0); } c++-annotations-10.5.0/icmake/run0000644000175000017500000000015112635354026015447 0ustar frankfrankvoid run(string cmd) { if (g_echo == OFF) cmd += "> /dev/null 2>&1"; system(0, cmd); } c++-annotations-10.5.0/icmake/programs0000644000175000017500000000167712635354026016513 0ustar frankfrankvoid programs(int docs) { md("tmp/bin"); if (docs) { if (!exists("tmp/bin/htmlindex")) { chdir("src/htmlindex"); run("./build"); chdir("../../"); } if (!exists("tmp/bin/rmindexlines")) run(GPP " " CPPOPT " -o tmp/bin/rmindexlines src/rmindexlines/rmindexlines.cc -s"); return; } if (!exists("tmp/bin/paren")) run(GPP " " CPPOPT " -o tmp/bin/paren src/paren/paren.cc -L" LPATH " -l" BOBCAT " -s"); if (!exists("tmp/bin/trim")) run(GPP " " CPPOPT " -o tmp/bin/trim src/trim/trim.cc -s"); if (!exists("tmp/bin/verbnrs")) run(GPP " " CPPOPT " -o tmp/bin/verbnrs src/verbnrs.cc -s"); if (!exists("tmp/bin/tab")) { chdir("src/tab"); run(GCC " " COPT " -o ../../tmp/bin/tab *.c -lfl -s"); chdir("../../"); } } c++-annotations-10.5.0/icmake/md5sum0000644000175000017500000000015212635354026016056 0ustar frankfrankstring md5sum(string file) { return substr(strtok(backtick("md5sum " + file)[0], " \t")[0], 0, 5); } c++-annotations-10.5.0/icmake/pre0000644000175000017500000000051012635354026015430 0ustar frankfrankvoid pre() { string files; programs(0); files = stringlist("", "yo", "*.yo"); cleanup("paren", files); files = stringlist("", "yo", "*.cc") + stringlist("", "yo", "*.h") + stringlist("", "yo", "*.ih"); cleanup("tab", files); cleanup("trim", files); exit(0); } c++-annotations-10.5.0/icmake/install0000644000175000017500000000221712635354026016316 0ustar frankfrankvoid install(string base) { g_installing = 1; #ifdef DOC logZip("", "README README.papersize COPYING README.legalese changelog", base + DOC); logZip("tmp/docs/txt", "cplusplus.txt", base + DOC); logZip_r("tmp/docs", "html", "cplusplus.html.zip", base + DOC); logZip_r("tmp/docs/latex", "cplusplus*.ps", "cplusplus.ps.zip", base + DOC); logZip_r("tmp/docs/latex", "cplusplus*.pdf", "cplusplus.pdf.zip", base + DOC); logZip_r("tmp/docs/latex", "* -x cplusplus*.pdf -x cplusplus*ps", "cplusplus.latex.zip", base + DOC); #ifdef MAN logZip("tmp/manhtml", "c++-annotations-man.html", base + DOC); #endif logInstall("contributions", "*.zip", base + DOC "/contrib"); logZip("contributions", "GGD.algorithm " "chist.html chist.pdf chist.ps " "java_cpp_keywords.html", base + DOC "/contrib"); #endif #ifdef MAN logZip("tmp/man", "c++-annotations.7", base + MAN "/man7"); #endif printf("\n Installation completed\n"); writeLog(); } c++-annotations-10.5.0/icmake/logzipr0000644000175000017500000000071612635354026016340 0ustar frankfrank// names may be a series of files or directories in src that are zipped into // dest/zip. dest/zip is logged. // src and dest do not have to end in / void logZip_r(string src, string names, string zip, string dest) { list files; int idx; string file; chdir(g_cwd); dest += "/"; md(dest); if (src != "") chdir(src); backtick("zip -r " + g_cwd + dest + zip + " " + names); chdir(g_cwd + dest); log(zip); } c++-annotations-10.5.0/icmake/backtick0000644000175000017500000000016012635354026016416 0ustar frankfranklist backtick(string arg) { list ret; echo(OFF); ret = `arg`; echo(g_echo); return ret; } c++-annotations-10.5.0/icmake/verify0000644000175000017500000000057112635354026016155 0ustar frankfrankvoid verifyrun(string file) { printf("\n" "checking tmp/docs/latex/" + file + ":\n"); system(P_NOCHECK, "grep -i \"overfull\\|undefined\" " + file + " | " "fgrep -v polymorphism/undefined"); } void verify() { chdir("tmp/docs/latex"); verifyrun("cplusplus.log"); verifyrun("cplusplusus.log"); exit(0); } c++-annotations-10.5.0/icmake/docs0000644000175000017500000001325712635354026015606 0ustar frankfrankstring stringlist(string path, string subdir, string pattern) { list lst; string entry; int idx; string ret; path += subdir + "/"; chdir(subdir); lst = makelist(O_SUBDIR, "*"); for (idx = listlen(lst); idx--; ) ret += stringlist(path, element(idx, lst), pattern); lst = makelist(pattern); for (idx = listlen(lst); idx--; ) ret += path + element(idx, lst) + " "; chdir(".."); return ret; } void cleanup(string task, string files) { list filelist; int idx; filelist = strtok(files, " "); for (idx = listlen(filelist); idx--; ) system("tmp/bin/" + task + " -q " + element(idx, filelist)); } void txtdoc() { if (!exists("tmp/docs/txt/cplusplus.txt")) { md("tmp/docs/txt"); chdir("yo"); system("yodl2txt --no-warnings " "-o ../tmp/docs/txt/cplusplus.txt -l3 cplusplus"); chdir(".."); } } void htmldoc() { list htmlList; int idx; string html; md("tmp/docs/html"); // cp necessary files for HTML if (!exists("tmp/docs/html/annotations.gif")) system("cp -r html/* tmp/docs/html"); // convert .yo to .html if (!exists("tmp/docs/html/cplusplus.html")) { chdir("yo"); system("yodl2html --no-warnings -l3 cplusplus "); system("mv *.html ../tmp/docs/html"); system("cp cplusplus.css ../tmp/docs/html"); chdir(".."); } chdir("tmp/docs/html"); // index.html is the file holding the // c++-annotations-10.5.0/single/target.shtml0000644000175000017500000000431012635354026017310 0ustar frankfrank C++ Annotations

Table of contents:

Contents

Title Page

  1. All Chapters
  2. C++ Intro
  3. A First Impression
  4. Name Spaces
  5. Strings
  6. IOStreams
  7. Classes
  8. Static Data And Functions
  9. Memory Management
  10. Exceptions
  11. Operator Overloading
  12. Abstract Containers
  13. Inheritance
  14. Polymorphism
  15. Friends
  16. Pointers to Members
  17. Nested Classes
  18. Standard Template Library
  19. Generic Algorithms
  20. Multi Threading
  21. Function Templates
  22. Class Templates
  23. Advanced Template Use
  24. Examples

Index

Index:

c++-annotations-10.5.0/src/0000755000175000017500000000000012635354026014261 5ustar frankfrankc++-annotations-10.5.0/src/verbnrs.cc0000644000175000017500000000325412635354026016255 0ustar frankfrank#include #include #include #include using namespace std; // first argument: file to process, 2nd argument (optional): indentation (by // default 1, which is also the minimum indentation that is used.) int main(int argc, char **argv) { string line; bool empty = true; ifstream in(argv[1]); while (getline(in, line)) // find the first non-empty line { if (line.find_first_not_of(" \t") != string::npos) // non-empty line { empty = false; // avoid doubly checking `line' break; } } if (empty) // nothing but emptyness... return 0; size_t indent = 0; if (argc > 2) indent = stoul(argv[2]); size_t lineNr = 0; size_t nEmpty = 0; // counts empty lines cout << "\n" "verb(" << setw(indent) << ' ' << setw(2) << ++lineNr << ' ' << line; // show the 1st line while (getline(in, line)) // read the rest of the file { if (line.find_first_not_of(" \t") == string::npos) // empty line { ++nEmpty; // count it continue; // proceed with the next line } if (lineNr != 0) cout << '\n'; for (size_t nr = 0; nr != nEmpty; ++nr) // 'for': # iterations known cout << setw(indent) << ' ' << setw(2) << ++lineNr << '\n'; nEmpty = 0; // reset the counter cout << setw(indent) << ' ' << setw(2) << ++lineNr << ' ' << line; // show the line } cout << ")\n"; } c++-annotations-10.5.0/src/htmlindex/0000755000175000017500000000000012636515512016255 5ustar frankfrankc++-annotations-10.5.0/src/htmlindex/build0000755000175000017500000001463512635354026017313 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/htmlindex #include "../../compilers.im" string CLASSES; void setClasses() { CLASSES += " aux indexentry"; } #define ECHO_REQUEST ON // Extra libraries required. Remove lib and .a from the library names. // E.g., #define LIBS "m Xt" to link libm.a and libXt.a explicitly // Specify libs from the most specific to the most general one. #define LIBS ${BOBCAT} // Extra library-paths required. // E.g., #define LIBPATH "/some/path /some/other/path" to search these paths // apart from the default paths #define LIBPATH ${LPATH} // DO NOT ALTER THINGS BELOW THIS LINE string // contain options for libs, // extra libs, e.g., "-lrss -licce" libpath, // extra lib-paths, eg, "-L../rss" lopt, libxxxa; // expanded lib-name string ofiles, // wildcards for o-files sources, // sources to be used wild, // wildcard of extension current; // contains name of current dir. list objfiles(list files) { string file, objfile; int i; for (i = 0; i < listlen(files); i++) { file = element(i, files); // determine element of the list objfile = "./o/" + change_ext(file, "o"); // make obj-filename if (objfile younger file) // objfile is younger { files -= (list)file; // remove the file from the list i--; // reduce i to test the next } } return (files); } list altered(list files, string target) { int i; string file; for (i = 0; i < listlen(files); i++) // try all elements of the list { file = element(i, files); // use element i of the list if (file older target) // a file is older than the target { files -= (list)file; // remove the file from the list i--; // reduce i to inspect the next } // file of the list } return (files); // return the new list } list file_list(string type, string library) { list files; files = makelist(type); // make all files of certain type files = objfiles(files); // remove if younger .obj exist return (files); } void link(string library, string exe) { exec(GPP, "-o", exe, ofiles, libs, "-L.", libpath, lopt ); } void c_compile(list cfiles) { string nextfile; int i; if (!exists("o")) system("mkdir o"); if (listlen(cfiles)) // files to compile ? { printf(current, "\n"); // compile all files separately for (i = 0; nextfile = element(i, cfiles); i++) { exec(GPP, "-c -o o/" + change_ext(nextfile, "o") + " " CPPOPT + " " + nextfile); } } } void updatelib(string library) { list arlist, objlist; string to, from; objlist = makelist("*.o"); if (!listlen(objlist)) return; printf("\n"); exec("ar", "rvs", library, "*.o"); exec("rm", "*.o"); printf("\n"); } void prefix_class(string class_id) { list o_files; string o_file; int i; o_files = makelist("*.o"); for (i = 0; o_file = element(i, o_files); i++) exec("mv", o_file, class_id + o_file); } void std_cpp(string library) { list cfiles; cfiles = file_list(wild, library); // make list of all cpp-files c_compile(cfiles); // compile cpp-files } void cpp_make(string mainfile, string library, string exe) { int n, index; list classes; string cwd; setClasses(); // remaining classes cwd = chdir("."); ofiles = "o/*.o"; // std set of o-files classes = strtok(CLASSES, " "); // list of classes if (n = listlen(classes)) ofiles += " */o/*.o"; // set ofiles for no LIBRARY use wild = sources; // make library name libxxxa = chdir(".") + "lib" + library + ".a"; // first process all classes for (index = 0; index < n; index++) { current = element(index, classes); // next class to process chdir(current); // change to directory current = "subdir " + current; std_cpp (libxxxa); // compile all files chdir( cwd); // go back to parent dir } current = "auxiliary " + wild + " files"; std_cpp (libxxxa); // compile all files in current dir for (index = 0; index < n; index++) { current = element(index, classes); // determine class name chdir( current); // chdir to a class directory. chdir(cwd); // go back to parent dir } current = ""; // no class anymore if (mainfile != "") // mainfile -> do link link(library, exe); } void setlibs() { int n, index; list cut; cut = strtok(LIBS, " "); // cut op libraries n = listlen(cut); for (index = 0; index < n; index++) libs += " -l" + element(index, cut); cut = strtok(LIBPATH, " "); // cut up the paths n = listlen(cut); for (index = 0; index < n; index++) libpath += " -L" + element(index, cut); } void main() { echo(ECHO_REQUEST); sources = "*.cc"; setlibs(); lopt = "-s"; system("mkdir -p ../../tmp/bin"); // make destination if it doesn't // already exist cpp_make ( "htmlindex.cc", // program source "htmlindex", // program library "../../tmp/bin/htmlindex" // binary program ); } c++-annotations-10.5.0/src/htmlindex/man/0000755000175000017500000000000012635354026017030 5ustar frankfrankc++-annotations-10.5.0/src/htmlindex/man/htmlindex.yo0000644000175000017500000000531212635354026021376 0ustar frankfrankCOMMENT( Leave a definition of a label empty if not used. E.g., if you don't have other programs related to this one, use: SUBST(@SEEALSO) () Use bf() for items that should appear literally in commands, etc. use em() for formal names, that should be replaced by actual values in real life. ) SUBST(@SECTION) (1) SUBST(@DATE) (2003) SUBST(@AUTHOR) (Frank B. Brokken (bf(f.b.brokken@rc.rug.nl)).) SUBST(@ORGANIZATION) (Computing Center, University of Groningen.) SUBST(@PROGRAM) (htmlindex) SUBST(@PROJECT) (C++ Annotations Software) SUBST(@DISTRIBUTION) (htmlindex-X.YY.tar.gz) SUBST(@SHORTDESC) (Create html index from Yodl index entries) SUBST(@SYNOPSYS)( @PROGRAM < indexpage > outputpage ) SUBST(@OPTIONS)( startit() it() tt(indexpage): file obtained from Yodl-html pages containing lines like verb( ) which can be created from Yold-macros like COMMENT(Make sure a blank is written behind the backslashes in the following verb()-block.) verb( NEWCOUNTER(htmlAnchor) def(hix)(1)(\ IFDEF(html)\ (label(an+USECOUNTER(htmlAnchor))\ htmlcommand( )\ )\ (IFDEF(latex)\ (latexcommand(\index{)ARG1+latexcommand(}))\ ()\ )) ) using lines like: verb( hix(http://www.xs4all.nl/.../yodl/) ) it() tt(outputpage): indexfile written as a html-page to the standard output, as a two-column table, sorted, clickable entry file, referring back to labels defined in the pages where the index entries were found. E.g., the table contains entries like verb( http://www.xs4all.nl/.../yodl/ 4  ) endit() ) SUBST(@DESCRIPTION)( See the description of the options. The conversion of index entries in the html file to labels within files may be performed by a simple script, like: verb( #!/bin/sh cd ../html for x in `ls cplusplus[0-9][0-9].html` ; do grep -v '^ ${x}2 mv ${x}2 $x done ) ) SUBST(@FILES)(-) SUBST(@SEEALSO)(-) SUBST(@DIAGNOSTICS)(-) SUBST(@BUGS) (No Documented Bugs.) SUBST(@COPYRIGHT)( This is free software, distributed under the terms of the GNU General Public License. ) COMMENT(Do not modify from here) INCLUDEFILE(/usr/local/share/makemanpage/executables.1/pagedef.yo) c++-annotations-10.5.0/src/htmlindex/htmlindex.h0000644000175000017500000000275312635354026020431 0ustar frankfrank// htmlindex.h #ifndef _H_htmlindex_ #define _H_htmlindex_ #include #include #include #include #include #include #include #include #include using namespace FBB; using namespace std; void usage(string const &basename); void getKeys(); void head(); void display(unsigned idx); void tail(); extern char indexSection, version[], year[]; extern int returnValue; extern string lastFilename; extern vector filenameVector; extern HashString // hash_map indexHash; typedef HashString::iterator // hash_map::iterator hash_iterator; class IndexEntry { public: IndexEntry(string const &key, unsigned filenameIndex, unsigned labelNr); void push_back(unsigned filenameIndex, unsigned labelNr) { labels.push_back(pair(filenameIndex, labelNr)); } bool operator<(IndexEntry const &other) const; string const &getKey() { return key; } char firstChar() { return uppercaseKey[0]; } void showRefs(); private: string uppercaseKey, key; vector > labels; }; extern vector indexVector; #endif c++-annotations-10.5.0/src/htmlindex/version.cc0000644000175000017500000000011712635354026020250 0ustar frankfrank#include "htmlindex.h" char version[] = "1.13", year[] = "2001-2014"; c++-annotations-10.5.0/src/htmlindex/indexentry/0000755000175000017500000000000012636515512020446 5ustar frankfrankc++-annotations-10.5.0/src/htmlindex/indexentry/operatorless.cc0000644000175000017500000000065412635354026023504 0ustar frankfrank#include "../htmlindex.h" bool IndexEntry::operator<(IndexEntry const &other) const { if (isalnum(uppercaseKey[0]) && !isalnum(other.uppercaseKey[0])) return false; // alphanumeric entries after special chars if (!isalnum(uppercaseKey[0]) && isalnum(other.uppercaseKey[0])) return true; // special chars before alphanumeric entries return uppercaseKey < other.uppercaseKey; } c++-annotations-10.5.0/src/htmlindex/indexentry/showrefs.cc0000644000175000017500000000062312635354026022616 0ustar frankfrank#include "../htmlindex.h" void IndexEntry::showRefs() { for ( vector >::iterator it = labels.begin(); it != labels.end(); it++ ) cout << " second << " target=info>" << it->second << " \n"; } c++-annotations-10.5.0/src/htmlindex/indexentry/indexentry.cc0000644000175000017500000000056412635354026023153 0ustar frankfrank#include "../htmlindex.h" IndexEntry::IndexEntry(string const &keystring, unsigned filenameIndex, unsigned labelNr) : key(keystring) { for (string::iterator it = key.begin(); it != key.end(); it++) if (*it != ' ') uppercaseKey += toupper(*it); labels.push_back(pair(filenameIndex, labelNr)); } c++-annotations-10.5.0/src/htmlindex/indexentry/indexentry.h0000644000175000017500000000000012635354026022776 0ustar frankfrankc++-annotations-10.5.0/src/htmlindex/aux/0000755000175000017500000000000012636515512017052 5ustar frankfrankc++-annotations-10.5.0/src/htmlindex/aux/usage.cc0000644000175000017500000000113012635354026020460 0ustar frankfrank#include "../htmlindex.h" void usage(string const &basename) { cout << "\n" << basename << " by Frank B. Brokken (f.b.brokken@rug.nl)\n" "\n" "C++ Annotations html index page builder, V. " << version << endl << "Copyright (c) 2001-2006 Frank B. Brokken. GPL.\n" "\n" "Usage: " << basename << " < indexpage > outputpage\n" "Where:\n" " indexpage: file containing `' index entries\n" " outputpage: file to write the index page to (e.g., " "cplusplusidx.html)\n" << endl; exit(1); } c++-annotations-10.5.0/src/htmlindex/aux/display.cc0000644000175000017500000000106212635354026021025 0ustar frankfrank#include "../htmlindex.h" void display(unsigned idx) { IndexEntry &ie = indexVector[idx]; if (ie.firstChar() > indexSection && isalnum(ie.firstChar())) { indexSection = ie.firstChar(); cout << "  

" << indexSection << "

\n" "\n" "\n"; } cout << " " << ie.getKey() << " \n" << " \n"; ie.showRefs(); cout << " \n"; } c++-annotations-10.5.0/src/htmlindex/aux/getkeys.cc0000644000175000017500000000456112635354026021042 0ustar frankfrank#include "../htmlindex.h" void getKeys() { string line; Pattern pattern("([^:]+):"); unsigned filenameIndex = 0; while (getline(cin, line)) { try { pattern.match(line); } catch (...) { cerr << "Invalid entry at line `" << line << "'\n"; returnValue = 1; continue; } Pattern::Position pos = pattern.position(3); if (pos.first == pos.second) { cerr << "Missing key at line `" << line << "'\n"; returnValue = 1; continue; } string filename = pattern[1], key = pattern[3]; unsigned labelNr = atoi(pattern[2].c_str()); if (filename != lastFilename) { filenameIndex = filenameVector.size(); filenameVector.push_back(filename); lastFilename = filename; cerr << "File " << filename << " at " << filenameIndex << endl; } /* hash indexHash contains the key and an idx in `index' where IndexEntry objects are stored. vector index; IndexEntry: contains the key (and for comparisons speedup the lowercase key, and vector of unsigned label numbers. First hash (and index) are filled. */ hash_iterator it = indexHash.find(key); if (it != indexHash.end()) // key already available { //cerr << "duplicate key: " << key; indexVector[it->second].push_back(filenameIndex, labelNr); } else { // new key: add to the hashtable //cerr << "new key: " << key; indexHash.insert ( //hash_map::value_type HashString::value_type ( key, indexVector.size() ) ); //cerr << "..."; // and add to the `index' vector indexVector.push_back(IndexEntry(key, filenameIndex, labelNr)); } //cerr << " inserted\n"; } } c++-annotations-10.5.0/src/htmlindex/aux/tail.cc0000644000175000017500000000015012635354026020306 0ustar frankfrank#include "../htmlindex.h" void tail() { cout << "\n" "\n" "\n" "\n"; } c++-annotations-10.5.0/src/htmlindex/aux/head.cc0000644000175000017500000000042612635354026020264 0ustar frankfrank#include "../htmlindex.h" void head() { cout << "\n" "\n" "C++ Annotations HTML Index \n" "\n" "\n" "\n" "\n" "

Index

\n" "\n" "\n" "\n"; } c++-annotations-10.5.0/src/htmlindex/htmlindex.cc0000644000175000017500000000245012635354026020561 0ustar frankfrank/* htmlindex.cc */ #include "htmlindex.h" HashString indexHash; vector indexVector; vector filenameVector; string lastFilename; char indexSection = 'A' - 1; int returnValue = 0; int main(int argc, char **argv) { Arg::initialize("", argc, argv); Arg &arg(Arg::instance()); if (isatty(STDIN_FILENO)) usage(arg.basename()); getKeys(); sort(indexVector.begin(), indexVector.end()); head(); unsigned n = indexVector.size(), halfway = (n + 1) / 2; cout << "\n" << // left column done "\n"; // right column done tail(); return returnValue; } c++-annotations-10.5.0/src/tabs/0000755000175000017500000000000012635354026015212 5ustar frankfrankc++-annotations-10.5.0/src/tabs/main.cc0000644000175000017500000000046412635354026016451 0ustar frankfrank#include "main.ih" int main(int argc, char **argv) try { if (not arguments(argc, argv)) return 0; argv += optind; argc -= optind; Tabber tabber; if (argv[0][0] == '-') tabber.run(); if (not process(argv, tabber)) return 1; } catch (...) { return 1; } c++-annotations-10.5.0/src/tabs/usage.cc0000644000175000017500000000212612635354026016626 0ustar frankfrank// usage.cc #include "main.ih" void usage(std::string const &progname) { cout << '\n' << progname << " by " << Icmbuild::author << "\n" << progname << " V" << Icmbuild::version << " " << Icmbuild::years << "\n" "Copyright (c) GPL " << Icmbuild::years << ". All rights reserved.\n" "\n" "Usage: %s [-d | -e | -snnn | -cnnn]* file(s)\n" "Where:\n" " -c - entab at / detab to multiples of nnn columns " "(default: 8)\n" " -d - tabs in file(s) are removed (detab)\n" " (default action)\n" " -e - spaces in file(s) are changed into tabs (entab)\n" " -q - quiet: less output than otherwise\n" " -s - entab/detab a minimum number of nnn spaces " "(default: 4)\n" " file(s) - file(s) to entab/detab (are overwritten)\n" " use - to filter stdin to stdout\n" " non-regular files (e.g. symbolic links) are " "skipped.\n" "\n"; } c++-annotations-10.5.0/src/tabs/normalfile.cc0000644000175000017500000000040712635354026017652 0ustar frankfrank#include "main.ih" bool normalFile(char const *fileName) { struct stat fileInfo; if (lstat(fileName, &fileInfo)) { cout << "Can't stat `" << fileName << "': skipping\n"; return false; } return S_ISREG(fileInfo.st_mode); } c++-annotations-10.5.0/src/tabs/process.cc0000644000175000017500000000101512635354026017174 0ustar frankfrank#include "main.ih" bool process(char **argv, Tabber &tabber) { char tempfile[] = "tab.tmp"; for (; *argv; ++argv) { if (not normalFile(*argv)) continue; if (!g_quiet) cout << "processing `" << *argv << "'\n"; unlink(tempfile); if (rename(*argv, tempfile)) { cout << "can't rename `" << *argv << "'\n"; return false; } tabber.run(tempfile, *argv); } unlink(tempfile); return true; } c++-annotations-10.5.0/src/tabs/tabber/0000755000175000017500000000000012635354026016451 5ustar frankfrankc++-annotations-10.5.0/src/tabs/tabber/tabber.ih0000644000175000017500000000017712635354026020237 0ustar frankfrank#include "tabber.h" #include #include #include #include "../globals.h" using namespace std; c++-annotations-10.5.0/src/tabs/tabber/space.cc0000644000175000017500000000102512635354026020051 0ustar frankfrank#include "tabber.ih" void Tabber::space() { ++d_nSpaces; if (d_column % g_tabWidth != 0) // not at a tab-position return; if (d_nSpaces < g_minSpaces) // to few spaces to write a tab { d_out << setw(d_nSpaces) << ' '; // write blanks up to the tab-pos d_nSpaces = 0; } else // enough spaces to write a tab { d_nSpaces -= g_minSpaces; // remove #spaces converted to \t d_out.put('\t'); } } c++-annotations-10.5.0/src/tabs/tabber/incColumn.cc0000644000175000017500000000013412635354026020705 0ustar frankfrank#include "tabber.ih" bool Tabber::tabColumn() { return ++d_column % g_tabWidth == 0; } c++-annotations-10.5.0/src/tabs/tabber/entab.cc0000644000175000017500000000152612635354026020055 0ustar frankfrank#include "tabber.ih" void Tabber::entab() { char ch; while (d_in.get(ch)) { switch (ch) { case ' ': ++d_nSpaces; // got a space if (tabColumn()) // we're at a tab column { if (d_nSpaces < g_minSpaces) outSpaces(); else { d_nSpaces = 0; d_out.put('\t'); } } break; case '\n': case '\t': outSpaces(); d_out.put(ch); d_column = 0; break; default: outSpaces(); d_out.put(ch); ++d_column; break; } } } c++-annotations-10.5.0/src/tabs/tabber/run.cc0000644000175000017500000000017412635354026017566 0ustar frankfrank#include "tabber.ih" void Tabber::run() { d_column = 0; if (g_entab) entab(); else detab(); } c++-annotations-10.5.0/src/tabs/tabber/detab.cc0000644000175000017500000000154412635354026020043 0ustar frankfrank#include "tabber.ih" // d_column is the # of characters so far in the actual field of g_tabWidth // characters. void Tabber::detab() { char ch; while (d_in.get(ch)) { switch (ch) { case '\n': d_column = 0; // no characters in the current field, // since after this we're on the next line break; case '\t': d_out << setw(g_tabWidth - d_column) << ' '; d_column = 0; // no chars in the current field, as we // just filled it up by blanks continue; // process the next character default: d_column = (d_column + 1) % g_tabWidth; break; } d_out.put(ch); // write ordinary char. } } c++-annotations-10.5.0/src/tabs/tabber/frame0000644000175000017500000000004312635354026017463 0ustar frankfrank#include "tabber.ih" Tabber:: { } c++-annotations-10.5.0/src/tabs/tabber/tabber1.cc0000644000175000017500000000013312635354026020275 0ustar frankfrank#include "tabber.ih" Tabber::Tabber() : d_in(cin.rdbuf()), d_out(cout.rdbuf()) {} c++-annotations-10.5.0/src/tabs/tabber/outspaces.cc0000644000175000017500000000020712635354026020765 0ustar frankfrank#include "tabber.ih" void Tabber::outSpaces() { if (d_nSpaces != 0) d_out << setw(d_nSpaces) << ' '; d_nSpaces = 0; } c++-annotations-10.5.0/src/tabs/tabber/tab.cc0000644000175000017500000000005512635354026017526 0ustar frankfrank#include "tabber.ih" void Tabber::tab() { } c++-annotations-10.5.0/src/tabs/tabber/tabber.h0000644000175000017500000000075412635354026020067 0ustar frankfrank#ifndef INCLUDED_TABBER_ #define INCLUDED_TABBER_ #include #include class Tabber { std::istream d_in; std::ostream d_out; size_t d_nSpaces = 0; size_t d_column = 0; public: Tabber(); void run(); void run(char const *inName, char const *outName); private: void detab(); void entab(); bool tabColumn(); void outSpaces(); void space(); void tab(); }; #endif c++-annotations-10.5.0/src/tabs/tabber/run2.cc0000644000175000017500000000031712635354026017647 0ustar frankfrank#include "tabber.ih" void Tabber::run(char const *inName, char const *outName) { ifstream in(inName); ofstream out(outName); d_in.rdbuf(in.rdbuf()); d_out.rdbuf(out.rdbuf()); run(); } c++-annotations-10.5.0/src/tabs/globals.h0000644000175000017500000000026512635354026017011 0ustar frankfrank#ifndef INCLUDED_GLOBALS_H_ #define INCLUDED_GLOBALS_H_ #include extern size_t g_minSpaces; extern size_t g_tabWidth; extern bool g_entab; extern bool g_quiet; #endif c++-annotations-10.5.0/src/tabs/data.cc0000644000175000017500000000016012635354026016427 0ustar frankfrank#include "main.ih" bool g_entab = false; bool g_quiet = false; size_t g_minSpaces = 4; size_t g_tabWidth = 8; c++-annotations-10.5.0/src/tabs/version.cc0000644000175000017500000000056312635354026017212 0ustar frankfrank// version.cc #include "main.ih" #include "icmconf" #ifdef USE_VERSION #include "VERSION" #endif #ifndef AUTHOR #define AUTHOR "" #endif #ifndef VERSION #define VERSION "0.00.00" #endif #ifndef YEARS #define YEARS "2012" #endif namespace Icmbuild { char version[] = VERSION; char years[] = YEARS; char author[] = AUTHOR; } c++-annotations-10.5.0/src/tabs/main.ih0000644000175000017500000000071512635354026016463 0ustar frankfrank#include #include #include #include #include #include #include "globals.h" #include "tabber/tabber.h" namespace Icmbuild { extern char version[]; extern char years[]; extern char author[]; }; bool arguments(int argc, char **argv); void usage(std::string const &progname); bool normalFile(char const *fileName); bool process(char **argv, Tabber &tabber); using namespace std; c++-annotations-10.5.0/src/tabs/arguments.cc0000644000175000017500000000140012635354026017521 0ustar frankfrank#include "main.ih" bool arguments(int argc, char **argv) { if (argc == 1) { string progname(argv[0]); size_t pos = progname.find_last_of('/'); if (pos != string::npos) progname.erase(0, pos + 1); usage(progname); return false; } while (true) { switch (getopt(argc, argv, "c:des:q")) { case 'e': g_entab = true; break; case 's': g_minSpaces = stoul(optarg); break; case 'c': g_tabWidth = stoul(optarg); break; case 'q': g_quiet = true; break; default: return true; } } } c++-annotations-10.5.0/src/tabs/VERSION0000644000175000017500000000015312635354026016261 0ustar frankfrank#define AUTHOR "Frank B. Brokken (f.b.brokken@rug.nl)" #define VERSION "2.00.00" #define YEARS "1999-2014" c++-annotations-10.5.0/src/tabs/CLASSES0000644000175000017500000000000712635354026016227 0ustar frankfranktabber c++-annotations-10.5.0/src/tabs/icmconf0000644000175000017500000000161412635354026016555 0ustar frankfrank#define ADD_LIBRARIES "" #define ADD_LIBRARY_PATHS "" //#define CLS #define CXX "g++" #define CXXFLAGS " --std=c++0x -Wall -g -O2" //#define CFLAGS " -Wall -g -O2" #define LDFLAGS "" //#define LIBRARY "modules" #define MAIN "main.cc" #define OBJ_EXT ".o" #define PARSER_DIR "" //#define PARSFILES "" #define PARSFLAGS "" #define PARSGEN "" #define PARSOUT "" #define PARSSPEC "" //#define REFRESH #define SCANNER_DIR "" //#define SCANFILES "" #define SCANFLAGS "" #define SCANGEN "" #define SCANOUT "" #define SCANSPEC "" #define SHAREDREQ "" #define SOURCES "*.cc" #define TMP_DIR "tmp" #define USE_ECHO ON #define USE_VERSION #define DEFCOM "program" c++-annotations-10.5.0/src/keywordsort.cc0000644000175000017500000000306012635354026017163 0ustar frankfrank// use -lbobcat to link #include #include #include #include #include #include #include #include #include using namespace std; using namespace FBB; string keywords = "alignas " "alignof and compl explicit new requires typedef and_eq concept extern not " "bool delete if private switch void break do inline protected template " "volatile " "case double int public this wchar_t catch dynamic_cast long register throw " "decltype friend or static_cast using bitor default goto or_eq struct " "virtual " "nullptr sizeof union axiom continue for operator static unsigned bitand " "short typeid asm const false not_eq signed typename auto const_cast float " "try xor_eq constexpr import export " "while char else mutable reinterpret_cast true xor class enum namespace " "char16_t char32_t noexcept static_assert thread_local " "return" ; struct Support: public TableSupport { void vline(size_t col) const { if (col > 0) out() << ' '; } }; int main() { set keyword; istringstream in(keywords); copy(istream_iterator(in), istream_iterator(), inserter(keyword, keyword.begin())); Support support; support << 0; for (size_t col = 0; col != 6; ++col) support << 1; Table table(support, 6, Table::COLUMNWISE); table.fill(keyword.begin(), keyword.end()); for(size_t col = 0; col != 6; ++col) table << Align(col, std::left); cout << table << '\n'; } c++-annotations-10.5.0/src/paren/0000755000175000017500000000000012635354026015366 5ustar frankfrankc++-annotations-10.5.0/src/paren/paren.cc0000644000175000017500000000531312635354026017004 0ustar frankfrank// paren.cc #include #include #include #include #include using namespace std; using namespace FBB; bool hdr = false; bool verbose; string version("2.00"); string years("1999-2006"); void header(char const *fn) { if (hdr) return; hdr = true; if (verbose) cout << "PROCESSING " << fn << endl; } void usage(string const &prog) { cout << "\n" << prog << " by Frank B. Brokken (f.b.brokken@rug.nl)\n" "Copyright " << years << " (c) GPL, V " << version << ".\n" "\n" "Usage: " << prog << " [-v] file(s)\n" "Where:\n" " -h: print this help-info\n" " -q: quiet: less output than otherwise\n" " -v: show the version\n" " file(s): file(s) to check for unbalanced parentheses.\n" " (A simple algorithm is used, in which all \n" " characters are treated equal).\n" "\n"; } int main(int argc, char **argv) try { Arg &arg = Arg::initialize("hqv", argc, argv); arg.versionHelp(usage, version.c_str(), 1); verbose = !arg.option('q'); bool ok = true; for (size_t idx = arg.nArgs(); idx--; ) { ifstream in(arg[idx]); if (!in) { cout << "Can't read " << arg[idx] << endl; ok = false; continue; } hdr = false; stack linenr; unsigned line = 0; string text; while (getline(in, text)) { ++line; for ( string::iterator pos = text.begin(); pos != text.end(); ++pos ) { switch (*pos) { case '(': linenr.push(line); break; case ')': if (linenr.empty()) { header(argv[idx]); cout << "\tExtra closepar in line " << line << endl; ok = false; break; } linenr.pop(); break; } } } while (!linenr.empty()) { header(argv[idx]); cout << "\tUnbalanced openpar in line " << linenr.top() << endl; linenr.pop(); ok = false; } } return ok ? 0 : 1; } catch(exception const &e) { cout << e.what() << endl; return 1; } catch(...) { return 1; } c++-annotations-10.5.0/src/tab/0000755000175000017500000000000012635354026015027 5ustar frankfrankc++-annotations-10.5.0/src/tab/tab.c0000644000175000017500000001036612635354026015747 0ustar frankfrank/* TAB.C 92 11 24 Ported for Unix KK 94 04 06 Port and maintenance for ELF: FBB 96/08/xx Skipping symbolic links: FBB 2001/07/22 Repairing EOF swallow: FBB 2001/09/09 */ #ifdef MSDOS #if !defined(M_I86SM) #error SMALL memory model expected #endif #endif #include #include #include #ifndef MSDOS #include #include #include #endif extern int yylex (void); extern char *fname (char *); extern FILE *yyin, *yyout; extern int column, nspaces; int quiet = 0, entab = 0, minspaces = 4, tabpos = 8; char version[] = "1.41", tempfile[] = "tab.tmp"; int main(int argc, char **argv) { int piping = 0; char *progname; struct stat fileinfo; progname = fname(argv[0]); while (argc > 1 && *argv[1] == '-') { switch (argv[1][1]) { case 'd': entab = 0; break; case 'e': entab = 1; break; case 's': if (!(minspaces = atoi(argv [1] + 2))) { printf("%s: missing or illegal space count at -s, " "assuming 4\n", progname); minspaces = 4; } break; case 'c': if (!(tabpos = atoi(argv [1] + 2))) { printf("%s: missing or illegal column count at -c, " "assuming 8\n", progname); tabpos = 8; } break; case 'q': quiet = 1; break; default: if (!argv[1][1]) { piping = 1; break; } printf("%s: unknown flag '-%c,' ignored\n", progname, *(*argv + 1)); break; } argv++; argc--; } if (argc == 1 && !piping) /* error */ { printf("\nTAB Entabber/Detabber V%s\n" "Copyright (c) GPL 1989-2006. All rights reserved.\n" "\n" "%s by Frank B. Brokken (f.b.brokken@rc.rug.nl).\n" "\n" "Usage: %s [-d | -e | -snnn | -cnnn]* file(s)\n" "where:\n" " -c - entab at / detab to multiples of nnn columns " "(default: 8)\n" " -d - tabs in file(s) are removed (detab)\n" " (default action)\n" " -e - spaces in file(s) are changed into tabs (entab)\n" " -q - quiet: less output than otherwise\n" " -s - entab/detab a minimum number of nnn spaces " "(default: 4)\n" " file(s) - file(s) to entab/detab (are overwritten)\n" " use - to filter stdin to stdout\n" " non-regular files (e.g. symbolic links) are " "skipped.\n" "\n" , version, progname, progname); return (1); } if (piping) { yyin = stdin; yyout = stdout; yylex(); return (0); } for (++argv; *argv; ++argv) { if (lstat(*argv, &fileinfo)) { printf("Can't stat %s: skipping\n", *argv); continue; } if (!S_ISREG(fileinfo.st_mode)) /* not a regular file */ continue; /* skip it silently */ if (!quiet) printf("processing %s\n", *argv); unlink(tempfile); if (rename(*argv, tempfile)) { printf("%s: can't rename %s\n", progname, *argv); return (1); } if ( !(yyin = fopen(tempfile, "r")) || !(yyout = fopen(*argv, "w")) ) { printf ("%s: cannot open in- or output file\n", progname); return (1); } yylex(); fclose (yyin); fclose (yyout); } unlink(tempfile); return (0); } c++-annotations-10.5.0/src/tab/fname.c0000644000175000017500000000042512635354026016262 0ustar frankfrank#include #ifdef MSDOS #define SEP '\\' #else #define SEP '/' #endif char *fname(char *prog) { register char *cp; if ( (cp = strrchr(prog, SEP)) ) cp++; else cp = prog; # ifdef MSDOS *strstr (cp, ".EXE") = '\0'; # endif return (cp); } c++-annotations-10.5.0/src/tab/flex.c0000644000175000017500000013710612635354026016141 0ustar frankfrank#define YY_NO_INPUT #line 2 "flex.c" #line 4 "flex.c" #define YY_INT_ALIGNED short int /* A lexical scanner generated by flex. yyunput not compiled: by Frank */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 #define YY_FLEX_SUBMINOR_VERSION 33 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ #include #include #include #include /* end standard C headers. */ /* flex integer type definitions */ #ifndef FLEXINT_H #define FLEXINT_H /* C99 systems have . Non-C99 systems may or may not. */ #if __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #endif #include typedef int8_t flex_int8_t; typedef uint8_t flex_uint8_t; typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; #endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN #define INT8_MIN (-128) #endif #ifndef INT16_MIN #define INT16_MIN (-32767-1) #endif #ifndef INT32_MIN #define INT32_MIN (-2147483647-1) #endif #ifndef INT8_MAX #define INT8_MAX (127) #endif #ifndef INT16_MAX #define INT16_MAX (32767) #endif #ifndef INT32_MAX #define INT32_MAX (2147483647) #endif #ifndef UINT8_MAX #define UINT8_MAX (255U) #endif #ifndef UINT16_MAX #define UINT16_MAX (65535U) #endif #ifndef UINT32_MAX #define UINT32_MAX (4294967295U) #endif #endif /* ! FLEXINT_H */ #ifdef __cplusplus /* The "const" storage-class-modifier is valid. */ #define YY_USE_CONST #else /* ! __cplusplus */ #if __STDC__ #define YY_USE_CONST #endif /* __STDC__ */ #endif /* ! __cplusplus */ #ifdef YY_USE_CONST #define yyconst const #else #define yyconst #endif /* Returned upon end-of-file. */ #define YY_NULL 0 /* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index. If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */ #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN (yy_start) = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START (((yy_start) - 1) / 2) #define YYSTATE YY_START /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ #define YY_NEW_FILE yyrestart(yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #define YY_BUF_SIZE 16384 #endif /* The state buf must be large enough to hold one state per character in the main buffer. */ #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif extern int yyleng; extern FILE *yyin, *yyout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 #define YY_LESS_LINENO(n) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) /* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want * flex-generated scanners to compile on their own). */ #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef unsigned int yy_size_t; #endif #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { FILE *yy_input_file; char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ /* Size of input buffer in bytes, not including room for EOB * characters. */ yy_size_t yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int yy_is_our_buffer; /* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int yy_is_interactive; /* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int yy_at_bol; int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ /* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer; int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ /* Stack of input buffers. */ static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */ #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = (char *) 0; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ /* Flag which is used to allow yywrap()'s to do buffer switches * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; void yyrestart (FILE *input_file ); void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); void yy_delete_buffer (YY_BUFFER_STATE b ); void yy_flush_buffer (YY_BUFFER_STATE b ); void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); void yypop_buffer_state (void ); static void yyensure_buffer_stack (void ); static void yy_load_buffer_state (void ); static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); void *yyalloc (yy_size_t ); void *yyrealloc (void *,yy_size_t ); void yyfree (void * ); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer(yyin,YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer(yyin,YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) typedef unsigned char YY_CHAR; FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; typedef int yy_state_type; extern int yylineno; int yylineno = 1; extern char *yytext; #define yytext_ptr yytext static yy_state_type yy_get_previous_state (void ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); static int yy_get_next_buffer (void ); static void yy_fatal_error (yyconst char msg[] ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ yyleng = (size_t) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; #define YY_NUM_RULES 5 #define YY_END_OF_BUFFER 6 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; }; static yyconst flex_int16_t yy_accept[9] = { 0, 0, 0, 6, 4, 2, 3, 1, 0 } ; static yyconst flex_int32_t yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; static yyconst flex_int32_t yy_meta[5] = { 0, 1, 1, 1, 1 } ; static yyconst flex_int16_t yy_base[9] = { 0, 0, 0, 5, 6, 6, 6, 6, 6 } ; static yyconst flex_int16_t yy_def[9] = { 0, 8, 1, 8, 8, 8, 8, 8, 0 } ; static yyconst flex_int16_t yy_nxt[11] = { 0, 4, 5, 6, 7, 8, 3, 8, 8, 8, 8 } ; static yyconst flex_int16_t yy_chk[11] = { 0, 1, 1, 1, 1, 3, 8, 8, 8, 8, 8 } ; static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; extern int yy_flex_debug; int yy_flex_debug = 0; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT reject_used_but_not_detected #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "rules.lex" #line 2 "rules.lex" int column = 0, nspaces = 0; FILE *yyout; extern int entab, minspaces, tabpos; void process_spaces() { register int ntabs; if (nspaces >= minspaces) if ( (ntabs = column / tabpos - (column - nspaces) / tabpos) ) { nspaces = column % tabpos; for (; ntabs; ntabs--) fputc('\t', yyout); /* put out a tab char */ } while (nspaces--) fputc(' ', yyout); nspaces = 0; } #line 482 "flex.c" #define INITIAL 0 #ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ #include #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif static int yy_init_globals (void ); /* Macros after this point can all be overridden by user definitions in * section 1. */ #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus extern "C" int yywrap (void ); #else extern int yywrap (void ); #endif #endif #if 0 static void yyunput (int c,char *buf_ptr ); #endif #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * ); #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void ); #else static int input (void ); #endif #endif /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #define YY_READ_BUF_SIZE 8192 #endif /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result". */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \ } \ errno=0; \ clearerr(yyin); \ } \ }\ \ #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */ #ifndef yyterminate #define yyterminate() return YY_NULL #endif /* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif /* Report a fatal error. */ #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) #endif /* end tables serialization structures and prototypes */ /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 extern int yylex (void); #define YY_DECL int yylex (void) #endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif /* Code executed at the end of each rule. */ #ifndef YY_BREAK #define YY_BREAK break; #endif #define YY_RULE_SETUP \ YY_USER_ACTION /** The main scanner function which does all the work. */ YY_DECL { register yy_state_type yy_current_state; register char *yy_cp, *yy_bp; register int yy_act; #line 32 "rules.lex" #line 637 "flex.c" if ( !(yy_init) ) { (yy_init) = 1; #ifdef YY_USER_INIT YY_USER_INIT; #endif if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ if ( ! yyin ) yyin = stdin; if ( ! yyout ) yyout = stdout; if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin,YY_BUF_SIZE ); } yy_load_buffer_state( ); } while ( 1 ) /* loops until end-of-file is reached */ { yy_cp = (yy_c_buf_p); /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp; yy_current_state = (yy_start); yy_match: do { register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 6 ); yy_find_action: yy_act = yy_accept[yy_current_state]; if ( yy_act == 0 ) { /* have to back up */ yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); yy_act = yy_accept[yy_current_state]; } YY_DO_BEFORE_ACTION; do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = (yy_hold_char); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); goto yy_find_action; case 1: YY_RULE_SETUP #line 33 "rules.lex" { column++; nspaces++; if (!entab) /* write blank if detab */ fputc(' ', yyout); } YY_BREAK case 2: YY_RULE_SETUP #line 41 "rules.lex" { if (entab) { process_spaces(); fputc('\t', yyout); } else { do fputc(' ', yyout); while (++column % tabpos); } column = 0; /* as we are at a tab-position */ } YY_BREAK case 3: /* rule 3 can match eol */ YY_RULE_SETUP #line 56 "rules.lex" { fputc(yytext[0], yyout); column = nspaces = 0; /* process spaces are ignored */ } YY_BREAK case 4: YY_RULE_SETUP #line 61 "rules.lex" { if (entab) process_spaces(); column++; fputc(yytext[0], yyout); } YY_BREAK case 5: YY_RULE_SETUP #line 67 "rules.lex" ECHO; YY_BREAK #line 773 "flex.c" case YY_STATE_EOF(INITIAL): yyterminate(); case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; /* Undo the effects of YY_DO_BEFORE_ACTION. */ *yy_cp = (yy_hold_char); YY_RESTORE_YY_MORE_OFFSET if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } /* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) { /* This was really a NUL. */ yy_state_type yy_next_state; (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */ yy_next_state = yy_try_NUL_trans( yy_current_state ); yy_bp = (yytext_ptr) + YY_MORE_ADJ; if ( yy_next_state ) { /* Consume the NUL. */ yy_cp = ++(yy_c_buf_p); yy_current_state = yy_next_state; goto yy_match; } else { yy_cp = (yy_c_buf_p); goto yy_find_action; } } else switch ( yy_get_next_buffer( ) ) { case EOB_ACT_END_OF_FILE: { (yy_did_buffer_switch_on_eof) = 0; if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned. */ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; yy_act = YY_STATE_EOF(YY_START); goto do_action; } else { if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( ); yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_match; case EOB_ACT_LAST_MATCH: (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; yy_current_state = yy_get_previous_state( ); yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_find_action; } break; } default: YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ static int yy_get_next_buffer (void) { register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; register char *source = (yytext_ptr); register int number_to_move, i; int ret_val; if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; } else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } } /* Try to read more data. */ /* First move last chars to start of buffer. */ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; else { int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ YY_BUFFER_STATE b = YY_CURRENT_BUFFER; int yy_c_buf_p_offset = (int) ((yy_c_buf_p) - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; else b->yy_buf_size *= 2; b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); } else /* Can't grow it, we don't own it. */ b->yy_ch_buf = 0; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE; /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), (size_t) num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } if ( (yy_n_chars) == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; yyrestart(yyin ); } else { ret_val = EOB_ACT_LAST_MATCH; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; (yy_n_chars) += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; return ret_val; } /* yy_get_previous_state - get the state just before the EOB char was reached */ static yy_state_type yy_get_previous_state (void) { register yy_state_type yy_current_state; register char *yy_cp; yy_current_state = (yy_start); for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; } return yy_current_state; } /* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) { register int yy_is_jam; register char *yy_cp = (yy_c_buf_p); register YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_is_jam = (yy_current_state == 8); return yy_is_jam ? 0 : yy_current_state; } #if 0 static void yyunput (int c, register char * yy_bp ) { register char *yy_cp; yy_cp = (yy_c_buf_p); /* undo effects of setting up yytext */ *yy_cp = (yy_hold_char); if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ register int number_to_move = (yy_n_chars) + 2; register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; register char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) *--dest = *--source; yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); } *--yy_cp = (char) c; (yytext_ptr) = yy_bp; (yy_hold_char) = *yy_cp; (yy_c_buf_p) = yy_cp; } #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void) #else static int input (void) #endif { int c; *(yy_c_buf_p) = (yy_hold_char); if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) /* This was really a NUL. */ *(yy_c_buf_p) = '\0'; else { /* need more input */ int offset = (yy_c_buf_p) - (yytext_ptr); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */ /* Reset buffer status. */ yyrestart(yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { if ( yywrap( ) ) return EOF; if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; #ifdef __cplusplus return yyinput(); #else return input(); #endif } case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + offset; break; } } } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); return c; } #endif /* ifndef YY_NO_INPUT */ /** Immediately switch to a different input stream. * @param input_file A readable stream. * * @note This function does not reset the start condition to @c INITIAL . */ void yyrestart (FILE * input_file ) { if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin,YY_BUF_SIZE ); } yy_init_buffer(YY_CURRENT_BUFFER,input_file ); yy_load_buffer_state( ); } /** Switch to a different input buffer. * @param new_buffer The new input buffer. * */ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) { /* TODO. We should be able to replace this entire function body * with * yypop_buffer_state(); * yypush_buffer_state(new_buffer); */ yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } YY_CURRENT_BUFFER_LVALUE = new_buffer; yy_load_buffer_state( ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } static void yy_load_buffer_state (void) { (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; (yy_hold_char) = *(yy_c_buf_p); } /** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * * @return the allocated buffer state. */ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) { YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; yy_init_buffer(b,file ); return b; } /** Destroy the buffer. * @param b a buffer created with yy_create_buffer() * */ void yy_delete_buffer (YY_BUFFER_STATE b ) { if ( ! b ) return; if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) yyfree((void *) b->yy_ch_buf ); yyfree((void *) b ); } #ifndef __cplusplus extern int isatty (int ); #endif /* __cplusplus */ /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a yyrestart() or at EOF. */ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) { int oerrno = errno; yy_flush_buffer(b ); b->yy_input_file = file; b->yy_fill_buffer = 1; /* If b is the current buffer, then yy_init_buffer was _probably_ * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ b->yy_bs_lineno = 1; b->yy_bs_column = 0; } b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; errno = oerrno; } /** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * */ void yy_flush_buffer (YY_BUFFER_STATE b ) { if ( ! b ) return; b->yy_n_chars = 0; /* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; b->yy_buf_pos = &b->yy_ch_buf[0]; b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) yy_load_buffer_state( ); } /** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * */ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) { if (new_buffer == NULL) return; yyensure_buffer_stack(); /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } /* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * */ void yypop_buffer_state (void) { if (!YY_CURRENT_BUFFER) return; yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ static void yyensure_buffer_stack (void) { int num_to_alloc; if (!(yy_buffer_stack)) { /* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ num_to_alloc = 1; (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; (yy_buffer_stack_top) = 0; return; } if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; } } /** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer * * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0; b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; yy_switch_to_buffer(b ); return b; } /** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) { return yy_scan_bytes(yystr,strlen(yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param bytes the byte buffer to scan * @param len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; buf = (char *) yyalloc(n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; b = yy_scan_buffer(buf,n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->yy_is_our_buffer = 1; return b; } #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif static void yy_fatal_error (yyconst char* msg ) { (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* Redefine yyless() so it works in section 3 code. */ #undef yyless #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = (yy_hold_char); \ (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 ) /* Accessor methods (get/set functions) to struct members. */ /** Get the current line number. * */ int yyget_lineno (void) { return yylineno; } /** Get the input stream. * */ FILE *yyget_in (void) { return yyin; } /** Get the output stream. * */ FILE *yyget_out (void) { return yyout; } /** Get the length of the current token. * */ int yyget_leng (void) { return yyleng; } /** Get the current token. * */ char *yyget_text (void) { return yytext; } /** Set the current line number. * @param line_number * */ void yyset_lineno (int line_number ) { yylineno = line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param in_str A readable stream. * * @see yy_switch_to_buffer */ void yyset_in (FILE * in_str ) { yyin = in_str ; } void yyset_out (FILE * out_str ) { yyout = out_str ; } int yyget_debug (void) { return yy_flex_debug; } void yyset_debug (int bdebug ) { yy_flex_debug = bdebug ; } static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = 0; (yy_buffer_stack_top) = 0; (yy_buffer_stack_max) = 0; (yy_c_buf_p) = (char *) 0; (yy_init) = 0; (yy_start) = 0; /* Defined in main.c */ #ifdef YY_STDINIT yyin = stdin; yyout = stdout; #else yyin = (FILE *) 0; yyout = (FILE *) 0; #endif /* For future reference: Set errno on error, since we are called by * yylex_init() */ return 0; } /* yylex_destroy is for both reentrant and non-reentrant scanners. */ int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(); } /* Destroy the stack itself. */ yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time * yylex() is called, initialization will occur. */ yy_init_globals( ); return 0; } /* * Internal utility routines. */ #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) { register int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s ) { register int n; for ( n = 0; s[n]; ++n ) ; return n; } #endif void *yyalloc (yy_size_t size ) { return (void *) malloc( size ); } void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return (void *) realloc( (char *) ptr, size ); } void yyfree (void * ptr ) { free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" #line 67 "rules.lex" c++-annotations-10.5.0/src/rmindexlines/0000755000175000017500000000000012635354026016762 5ustar frankfrankc++-annotations-10.5.0/src/rmindexlines/rmindexlines.cc0000644000175000017500000000110112635354026021763 0ustar frankfrank#include #include using namespace std; int main() { string line1; string line2; getline(cin, line1); // initialization: pick up line 1 // which is never a \n while (getline(cin, line2)) { cout << line1; if (line2.find(" #include #include #include #include #include using namespace std; bool silent; namespace std { istream &operator>>(istream &in, string &line) { return getline(in, line); } } class NonEmpty { public: bool operator()(string const &str) const { return str.find_first_not_of(" \t") != string::npos; } }; class Trimmer { ostream &d_out; public: Trimmer(ostream &out) : d_out(out) {} void operator()(string const &str) const { // find last non ws string::size_type idx = str.find_last_not_of(" \t"); if (idx == string::npos) // no non-ws char: print empty line d_out << endl; else if (idx + 1 == str.length()) // no trailing ws d_out << str << endl; else // \ requires 1 space d_out << str.substr(0, idx + 1) << endl; } }; void trim(char const *name = 0) { ifstream in; istream *ip; vector vs; if (!name) ip = &cin; else { if (!silent) cout << "trimming `" << name << "'\n"; in.open(name); if (!in) { cout << "no such file `" << name << "': skipped.\n"; return; } ip = ∈ } copy(istream_iterator(*ip), istream_iterator(), back_inserter(vs)); vector::reverse_iterator it = find_if(vs.rbegin(), vs.rend(), NonEmpty()); ofstream out; ostream *op; if (!name) op = &cout; else { in.close(); out.open(name); op = &out; } for_each(vs.begin(), vector::iterator(&*(it - 1)), Trimmer(*op)); } int main(int argc, char **argv) { if (argc == 1) trim(); else { if (argc > 1) silent = string("-q") == argv[1]; for (int idx = 1 + silent; idx < argc; idx++) trim(argv[idx]); } } c++-annotations-10.5.0/yo/0000755000175000017500000000000012636513761014125 5ustar frankfrankc++-annotations-10.5.0/yo/functiontemplates.yo0000644000175000017500000000625612635354026020247 0ustar frankfrankCOMMENT(The Template Concept) includefile(functiontemplates/intro) lsect(TEMPFUNDEF)(Defining function templates) includefile(functiontemplates/definitions) subsect(Considerations regarding template parameters) includefile(functiontemplates/considerations) subsect(Late-specified return type) includefile(functiontemplates/alternate) lsect(REFWRAP)(Passing arguments by reference (reference wrappers)) includefile(functiontemplates/referencewrappers) sect(Using local and unnamed types as template arguments) includefile(functiontemplates/local) lsect(TEMPFUNARGS)(Template parameter deduction) includefile(functiontemplates/argumentdeduction) subsect(Lvalue transformations) includefile(functiontemplates/lvalue) subsect(Qualification transformations) includefile(functiontemplates/qualifications) subsect(Transformation to a base class) includefile(functiontemplates/baseclass) lsubsect(PARDEDUCT)(The template parameter deduction algorithm) includefile(functiontemplates/algorithm) lsubsect(CONTRACTIONS)(Template type contractions) includefile(functiontemplates/contractions) lsect(TEMPFUNDECL)(Declaring function templates) includefile(functiontemplates/declarations) lsubsect(TEMPFUNEXDEC)(Instantiation declarations) includefile(functiontemplates/instantdecl) lsect(TEMPFUNINST)(Instantiating function templates) includefile(functiontemplates/instantiations) subsect(Instantiations: no `code bloat') includefile(functiontemplates/nocodebloat) lsect(TEMPFUNEXPLICIT)(Using explicit template types) includefile(functiontemplates/explicit) sect(Overloading function templates) includefile(functiontemplates/overloading) subsect(An example using overloaded function templates) includefile(functiontemplates/example) subsect(Ambiguities when overloading function templates) includefile(functiontemplates/ambiguities) subsect(Declaring overloaded function templates) includefile(functiontemplates/declaring) lsect(SPECIALIZING)(Specializing templates for deviating types) includefile(functiontemplates/specialization) subsect(Avoiding too many specializations) includefile(functiontemplates/avoiding) subsect(Declaring specializations) includefile(functiontemplates/declaringspec) subsect(Complications when using the insertion operator) includefile(functiontemplates/insertion) lsect(STATICASSERT)(Static assertions) includefile(functiontemplates/staticassertions) sect(Numeric limits) includefile(functiontemplates/limits) sect(Polymorphous wrappers for function objects) includefile(functiontemplates/polymorphouswrappers) lsect(NAMERESFUN)(Compiling template definitions and instantiations) includefile(functiontemplates/nameresolution) lsect(FUNCTIONSELECTION)(The function selection mechanism) includefile(functiontemplates/selection) sect(Determining the template type parameters) includefile(functiontemplates/determining) sect(SFINAE: Substitution Failure Is Not An Error) includefile(functiontemplates/sfinae) sect(Summary of the template declaration syntax) includefile(functiontemplates/summary) sect(C++14: variable templates) includefile(functiontemplates/variables.yo) c++-annotations-10.5.0/yo/pointermembers/0000755000175000017500000000000012635354026017154 5ustar frankfrankc++-annotations-10.5.0/yo/pointermembers/fig/0000755000175000017500000000000012635354026017721 5ustar frankfrankc++-annotations-10.5.0/yo/pointermembers/fig/personfig.fig0000644000175000017500000000157712635354026022416 0ustar frankfrank#FIG 2.1 80 2 2 2 0 1 -1 0 0 0 0.000 0 0 0 89 59 89 14 14 14 14 59 89 59 9999 9999 2 2 0 1 -1 0 0 0 0.000 0 0 0 71 35 71 20 29 20 29 35 71 35 9999 9999 2 1 0 1 -1 0 0 0 0.000 -1 1 0 0 0 1.000 4.000 8.000 71 26 104 26 104 68 50 68 50 77 9999 9999 2 2 0 1 -1 0 0 0 0.000 0 0 0 77 128 77 77 29 77 29 128 77 128 9999 9999 2 2 0 1 -1 0 0 0 0.000 0 0 0 77 203 77 155 29 155 29 203 77 203 9999 9999 2 1 1 1 -1 0 0 0 4.000 -1 0 0 29 125 29 158 9999 9999 2 1 1 1 -1 0 0 0 4.000 -1 0 0 77 125 77 158 9999 9999 2 1 0 1 -1 0 0 0 0.000 -1 0 0 29 101 77 101 9999 9999 2 1 0 1 -1 0 0 0 0.000 -1 0 0 29 179 77 179 9999 9999 4 0 0 12 0 -1 0 0.00000 4 15 12 44 29 pp 4 0 0 12 0 -1 0 0.00000 4 15 35 32 92 Person 4 0 0 10 0 -1 0 0.00000 4 13 5 68 98 0 4 0 0 12 0 -1 0 0.00000 4 15 35 32 116 Person 4 0 0 10 0 -1 0 0.00000 4 13 5 68 122 1 4 0 0 12 0 -1 0 0.00000 4 15 71 17 53 Person_dbase c++-annotations-10.5.0/yo/pointermembers/example.yo0000644000175000017500000000340212635354026021157 0ustar frankfrankKnowing how pointers to variables and objects are used does not intuitively lead to the concept of em(pointers to members) hi(pointer to member). Even if the return types and parameter types of member functions are taken into account, surprises can easily be encountered. For example, consider the following class: verb( class String { char const *(*d_sp)() const; public: char const *get() const; }; ) For this class, it is not possible to let tt(char const *(*d_sp)() const) point to the tt(String::get) member function as tt(d_sp) cannot be given the address of the member function tt(get). One of the reasons why this doesn't work is that the variable tt(d_sp) has hi(scope: global)i(global scope) (it is a pointer to em(a) function, not a pointer to a function within tt(String)), while the member function tt(get) is defined within the tt(String) class, and thus has tt(class scope). The fact that tt(d_sp) is a data member of the class tt(String) is irrelevant here. According to tt(d_sp)'s definition, it points to a function living somewhere em(outside) of the class. Consequently, to define a pointer to a member (either data or function, but usually a function) of a class, the scope of the pointer must indicate hi(scope: class)i(class scope). Doing so, a pointer to the member tt(String::get) is defined like this: verb( char const *(String::*d_sp)() const; ) So, by prefixing the tt(*d_sp) pointer data member by tt(String::), it is defined as a pointer in the context of the class tt(String). According to its definition it is em(a pointer to a function in the class tt(String), not expecting arguments, not modifying its object's data, and returning a pointer to constant characters). c++-annotations-10.5.0/yo/pointermembers/extra.10000644000175000017500000002111112635354026020355 0ustar frankfrankCOMMENT( class Let's assume that a database is created in which information about persons is stored. Name, street names, city names, house numbers, birthdays, etc. are collected in objects of the class tt(Person), which are, in turn, stored in a class tt(PersonDbase). Partial interfaces of these classes could be designed as follows: verb( class Date; class Person() { public: ... char const *get_name() const; Date const &birthdate() const; private: ... }; class Person_dbase { public: enum Listtype { list_by_name, list_by_birthday, }; void list(Listtype type); private: Person *pp; // pointer to the info size_t n; // number of persons stored. }; ) The organization of tt(Person) and tt(Person_dbase) is pictured in fig(PersonFig): Within a tt(Person_dbase) object the tt(Person) objects are stored. They can be reached via the pointer variable tt(Person *pp). figure(ptrmembers/fig/personfig) (Person_dbase objects: Persons reached via Person *pp) (PersonFig) We would like to develop the function tt(Person_dbase::list()) in such a way that it lists the contents of the database sorted according to a selected field of a tt(Person) object. So, when tt(list()) is called to list the database sorted by em(names), the database of tt(Person) objects is first sorted by names, and is then listed. Alternatively, when tt(list()) is called to list the database sorted by em(birthdates), the database of tt(Person) objects is first sorted by birthdates, and is then listed. In this situation, the function tt(qsort()) is most likely called to do the actual sorting of the tt(Person) objects+footnote( In the current implementation tt(pp) points to an array of tt(Person) objects. In this implementation, the function tt(qsort()) will have to copy the actual tt(Person) objects again and again, which may be rather inefficient when the tt(Person) objects become large. Under an alternative implementation, in which the tt(Person) objects are reached through pointers, the efficiency of the tt(qsort()) function will be improved. In that case, the datamember tt(pp) will have to be declared as tt(Person **pp).). This function requires a pointer to a compare function, comparing two elements of the array to be sorted. The prototype of this compare function is center(tt(int (*)(void const *, void const *))) However, when used with tt(Person) objects, the prototype of the tt(compare()) function should be center(tt(int (*)(Person const *, Person const *))) Somewhere a typecast will be required: either when calling tt(qsort()), or within the tt( compare()) functions themselves. We will use the typecast when calling tt(qsort()), using the following typedef to reduce the verbosity of the typecasts (a em(pointer to an integer function requiring two void pointers)): center(tt(typedef int (*pif2vp)(void const *, void const *))) Next, the function tt(list()) could be developed according to the following setup: verb( void Person_dbase::list(Listtype type) { switch (type) { case list_by_name: qsort(pp, n, sizeof(Person), (pif2vp)cmpname); break; case list_by_birthday: qsort(pp, n, sizeof(Person), (pif2vp)cmpdate); break; } // list the sorted Person-database } ) There are several reasons why this setup is not particularly desirable: startit() it() Although the example only shows two list-alternatives (sort by name and sort by birthday), a real-life implementation will have many more ways to list the information. This will soon result in a very long function tt(list()) which will be hard to maintain and will look inaccessible due to its length. it() Every time a new way to list the data in the database, the function tt(list()) will have to be expanded, by offering an extra tt(case) label for every new way to list the data. it() Much of the code in the function tt(list()) will be repeated within the function, showing only some small differences. endit() Much of the complexity of tt(list()) function could be reduced by defining em(pointers) to the compare-functions, storing these pointers in an array. Since this array will be common to all tt(Person_dbase) objects, it should be defined as a static array, containing the pointers to the compare-functions. Before actually constructing this array, note that this approach requires the definition of as many compare functions as there are elements in the tt(Listtype) enum. So, to list the information sorted by name a function tt(cmpname()) is used, comparing the names stored in two tt(Person) objects, while a function tt(cmpcity()), is used to compare cities. Somehow this seems to be redundant as well: we would like to use one function to compare strings, whatever their meanings. Comparable considerations hold true for other fields of information. The compare functions, however, receive pointers to tt(Person) objects. Therefore, the data-members of the tt(Person) objects to which these pointers point can be accessed using the access-member functions of the tt(Person) class. So, the compare functions can access these data-members as well, using the pointers to the tt(Person) objects. Now note that the access member functions that are used within a particular compare function can be em(hard-coded), by plainly mentioning the accessors to be used, and they can be selected indirectly, by using em(pointers) to the accessors to be used. This latter solution allows us to em(merge) compare functions that use the same implementations, but use different accessors: By setting a pointer to the appropriate accessor function just before the compare function is called, one single compare function can be used to compare many different kinds of data stored inside tt(Person) objects. The compare functions themselves are used within the context of the tt(Person_dbase) class, where they are passed to the tt(qsort()) function. The tt(qsort()) function, however, is a global function. Consequently, the compare functions can't be ordinary member functions of the class tt(Person_dbase), but they must be static members of that class, so they can be passed to the tt(qsort()) function. Summarizing what we've got so far, we see that the problem has been broken down as follows: startit() it() The tt(switch) construction in the tt(list()) function should be replaced by a call to a function using a pointer to a function. it() The actual function to be used is determined by the value of the selector, which is given to tt(list()) when it's called. it() The tt(compare()) functions may be further abstracted by combining those comparing the same types. it() When tt(compare()) functions are combined, the access member function of the tt(Person) objects to be used will also be found via an array containing pointers to the access member functions of tt(Person) objects. it() The tt(compare()) functions are part of the tt( Person_dbase) class, but it must also be possible to give their addresses as arguments to tt(qsort()). Hence, these functions must be defined as static functions of the class tt(Person_dbase). endit() From this analysis the essential characteristics of the proposed implementation emerge. For every type of listing, as produced by the function tt(list()), the following is required: startit() it() The access member function of the tt(Person) class to be used. it() The tt(compare()) function to be used. The tt(compare()) functions will be em(static functions) of the class tt(Person_dbase), so that they can be passed over to tt(qsort()) endit() This information does not depend on a particular tt(Person_dbase) object, but is common to all of these objects. Hence it will be stored compile-time in a tt(static Person_dbase) kind of array. How will the tt(compare()) functions know which element of this array to use? The requested index is passed to the tt(list()) member function as a tt(Listtype) value. The tt(list()) function can then save this information in a tt(static Person_dbase::Listtype) variable for the tt(compare()) functions to use. We've analyzed enough. Let's build it this way. COMMENT ENDS) c++-annotations-10.5.0/yo/pointermembers/intro.yo0000644000175000017500000000312012635354026020654 0ustar frankfrankClasses having tt(pointer data members) have been discussed in detail in chapter ref(MEMORY). Classes defining pointer data-members deserve some special attention, as they usually require the definitions of copy constructors, overloaded assignment operators and destructors Situations exist where we do not need a pointer to an object but rather a i(pointer to members) of a class. Pointers to members can profitably be used to configure the behavior of objects of classes. Depending on which member a pointer to a member points to objects will show certain behavior. Although pointers to members have their use, polymorphism can frequently be used to realize comparable behavior. Consider a class having a member tt(process) performing one of a series of alternate behaviors. Instead of selecting the behavior of choice at object construction time the class could use the interface of some (abstract) base class, passing an object of some derived class to its constructor and could thus configure its behavior. This allows for easy, extensible and flexible configuration, but access to the class's data members would be less flexible and would possibly require the use of `friend' declarations. In such cases pointers to members may actually be preferred as this allows for (somewhat less flexible) configuration as well as direct access to a class's data members. So the choice apparently is between on the one hand ease of configuration and on the other hand ease of access to a class's data members. In this chapter we'll concentrate on pointers to members, investigating what these pointers have to offer. c++-annotations-10.5.0/yo/pointermembers/examples/0000755000175000017500000000000012636507651020777 5ustar frankfrankc++-annotations-10.5.0/yo/pointermembers/examples/pointermembers.cc0000644000175000017500000000050712636507652024344 0ustar frankfrank#include #include using namespace std; class X { public: void fun() { cout << "hello\n"; } void (X::*fp)(); string X::*sp, str; }; int main() { X x; x.fp = &X::fun; (x.*(x.fp))(); x.sp = &X::str; x.*(x.sp) = "hello world"; cout << x.str; } c++-annotations-10.5.0/yo/pointermembers/examples/union.cc0000644000175000017500000000113712636507652022441 0ustar frankfrank #include #include #include class X { public: void fun(); std::string d_str; }; inline void X::fun() { std::cout << "hello\n"; } using namespace std; int main() { union { void (X::*f)(); unsigned char *cp; } u = { &X::fun }; cout.fill('0'); cout << hex; for (unsigned idx = sizeof(void (X::*)()); idx-- > 0; ) cout << setw(2) << static_cast(u.cp[idx]); cout << '\n'; } c++-annotations-10.5.0/yo/pointermembers/examples/initializing.cc0000644000175000017500000000104212636507652023776 0ustar frankfrank #include class PointerDemo { public: size_t d_value; size_t get() const; }; inline size_t PointerDemo::get() const { return d_value; } int main() { // initialization size_t (PointerDemo::*getPtr)() const = &PointerDemo::get; size_t PointerDemo::*valuePtr = &PointerDemo::d_value; getPtr = &PointerDemo::get; // assignment valuePtr = &PointerDemo::d_value; } c++-annotations-10.5.0/yo/pointermembers/examples/casestring.OBS0000644000175000017500000000066112635354026023504 0ustar frankfrank#include "casestring.h" string caseString::*caseString::stringMember[] = { &caseString::original, &caseString::lower, &caseString::upper, }; int main() { caseString hello("Hello World"); cout << hello << '\n'; hello.setMode(caseString::LOWER); cout << hello << '\n'; hello.setMode(caseString::UPPER); cout << hello << '\n'; hello.setMode(caseString::ORIGINAL); cout << hello << '\n'; } c++-annotations-10.5.0/yo/pointermembers/examples/using.cc0000644000175000017500000000160412636507652022435 0ustar frankfrank #include class PointerDemo { public: size_t d_value; size_t get() const; }; inline size_t PointerDemo::get() const { return d_value; } using namespace std; int main() { // initialization size_t (PointerDemo::*getPtr)() const = &PointerDemo::get; size_t PointerDemo::*valuePtr = &PointerDemo::d_value; PointerDemo object; // (1) (see text) PointerDemo *ptr = &object; object.*valuePtr = 12345; // (2) cout << object.*valuePtr << '\n' << object.d_value << '\n'; ptr->*valuePtr = 54321; // (3) cout << object.d_value << '\n' << (object.*getPtr)() << '\n' << // (4) (ptr->*getPtr)() << '\n'; } c++-annotations-10.5.0/yo/pointermembers/examples/pointerdata.cc0000644000175000017500000000102712636507652023621 0ustar frankfrank #include class PointerData { public: PointerData() { infoPtr = &PointerData::allInfo; } std::string show() { return (this->*infoPtr)(4); } private: std::string allInfo(int i) { return "hello"; } std::string (PointerData::*infoPtr)(int); }; int main() { PointerData pd; pd.show(); } c++-annotations-10.5.0/yo/pointermembers/examples/size.cc0000644000175000017500000000151312636507652022261 0ustar frankfrank #include #include class X { public: void fun(); std::string d_str; }; inline void X::fun() { std::cout << "hello\n"; } using namespace std; int main() { cout << "size of pointer to data-member: " << sizeof(&X::d_str) << "\n" "size of pointer to member function: " << sizeof(&X::fun) << "\n" "size of pointer to non-member data: " << sizeof(char *) << "\n" "size of pointer to free function: " << sizeof(&printf) << '\n'; } /* generated output (on 32-bit architectures): size of pointer to data-member: 4 size of pointer to member function: 8 size of pointer to non-member data: 4 size of pointer to free function: 4 */ c++-annotations-10.5.0/yo/pointermembers/examples/casestring.h.OBS0000644000175000017500000000234012635354026023726 0ustar frankfrank #include #include class caseString { friend ostream &operator<<(ostream &ostr, caseString const &str) { return ostr << str.operator string(); } public: enum Mode { ORIGINAL, LOWER, UPPER, }; caseString(char const *text) : mode(ORIGINAL), original(text), stringPtr(&caseString::original) { for (unsigned idx = 0; idx < original.length(); ++idx) { upper += toupper(text[idx]); lower += tolower(text[idx]); } } void setMode(int mode) { stringPtr = stringMember[mode]; } operator string() const { return this->*stringPtr; } private: Mode mode; string caseString::*stringPtr, original, lower, upper; static string caseString::*stringMember[]; }; c++-annotations-10.5.0/yo/pointermembers/sizes.yo0000644000175000017500000000157212635354026020667 0ustar frankfrankAn interesting characteristic of pointers to members is that their sizes hi(size: of pointers to members)hi(pointer to members: size of) differ from those of `normal' pointers. Consider the following little program: verbinclude(-a examples/size.cc) On a 32-bit architecture a pointer to a member function requires eight bytes, whereas other kind of pointers require four bytes (Using Gnu's g++ compiler). Pointer sizes are hardly ever explicitly used, but their sizes may cause confusion in statements like: verb( printf("%p", &X::fun); ) Of course, tt(printf) is likely not the right tool to produce the value of these bf(C++) specific pointers. The values of these pointers can be inserted into streams when a tt(union), reinterpreting the 8-byte pointers as a series of size_t tt(char) values, is used: verbinclude(-a examples/union.cc) c++-annotations-10.5.0/yo/pointermembers/using.yo0000644000175000017500000001332212635354026020653 0ustar frankfrankUsing pointers to members to call a member function requires the existence of an object of the class of the members to which the pointer to member refers to. With pointers operating at global scope, the dereferencing operator tt(*) is used. With pointers to objects the i(field selector) operator operating on pointers (ti(->)) or the field selector operating operating on objects (tt(.)) can be used to select appropriate members. To use a pointer to member in combination with an object the i(pointer to member field selector) (ti(.*)) must be specified. To use a pointer to a member via a pointer to an object the `pointer to member field selector through a pointer to an object' (ti(->*)) must be specified. These two operators combine the notions of a field selection (the tt(.) and tt(->) parts) to reach the appropriate field in an object and of dereferencing: a dereference operation is used to reach the function or variable the pointer to member points to. Using the example from the previous section, let's see how we can use pointers to member functions and pointers to data members: verbinclude(-a examples/using.cc) We note: itemization( it() At (1) a tt(PointerDemo) object and a pointer to such an object is defined. it() At (2) we specify an object (and hence the tt(.*) operator) to reach the member tt(valuePtr) points to. This member is given a value. it() At (3) the same member is assigned another value, but this time using the pointer to a tt(PointerDemo) object. Hence we use the tt(->*) operator. it() At (4) the tt(.*) and tt(->*) are used once again, this time to call a function through a pointer to member. As the function argument list has a higher priority than the pointer to member field selector operator, the latter em(must) be protected by parentheses. ) Pointers to members can be used profitably in situations where a class has a member that behaves differently depending on a configuration setting. Consider once again the class tt(Person) from section ref(ASSIGNMENT). tt(Person) defines data members holding a person's name, address and phone number. Assume we want to construct a tt(Person) database of employees. The employee database can be queried, but depending on the kind of person querying the database either the name, the name and phone number or all stored information about the person is made available. This implies that a member function like tt(address) must return something like `tt()' in cases where the person querying the database is not allowed to see the person's address, and the actual address in other cases. The employee database is opened specifying an argument reflecting the status of the employee who wants to make some queries. The status could reflect his or her position in the organization, like tt(BOARD), tt(SUPERVISOR), tt(SALESPERSON), or tt(CLERK). The first two categories are allowed to see all information about the employees, a tt(SALESPERSON) is allowed to see the employee's phone numbers, while the tt(CLERK) is only allowed to verify whether a person is actually a member of the organization. We now construct a member tt(string personInfo(char const *name)) in the database class. A standard implementation of this class could be: verb( string PersonData::personInfo(char const *name) { Person *p = lookup(name); // see if `name' exists if (!p) return "not found"; switch (d_category) { case BOARD: case SUPERVISOR: return allInfo(p); case SALESPERSON: return noPhone(p); case CLERK: return nameOnly(p); } } ) Although it doesn't take much time, the tt(switch) must nonetheless be evaluated every time tt(personInfo) is called. Instead of using a switch, we could define a member tt(d_infoPtr) as a pointer to a member function of the class tt(PersonData) returning a tt(string) and expecting a pointer to a tt(Person) as its argument. Instead of evaluating the switch this pointer can be used to point to tt(allInfo), tt(noPhone) or tt(nameOnly). Furthermore, the member function the pointer points to will be known by the time the tt(PersonData) object is constructed and so its value needs to be determined only once (at the PersonData object's construction time). Having initialized tt(d_infoPtr) the tt(personInfo) member function is now implemented simply as: verb( string PersonData::personInfo(char const *name) { Person *p = lookup(name); // see if `name' exists return p ? (this->*d_infoPtr)(p) : "not found"; } ) The member tt(d_infoPtr) is defined as follows (within the class tt(PersonData), omitting other members): verb( class PersonData { string (PersonData::*d_infoPtr)(Person *p); }; ) Finally, the constructor initializes tt(d_infoPtr). This could be realized using a simple switch: verb( PersonData::PersonData(PersonData::EmployeeCategory cat) : switch (cat) { case BOARD: case SUPERVISOR: d_infoPtr = &PersonData::allInfo; break; case SALESPERSON: d_infoPtr = &PersonData::noPhone; break; case CLERK: d_infoPtr = &PersonData::nameOnly; break; } } ) Note how addresses of member functions are determined. The class tt(PersonData) scope em(must) be specified, even though we're already inside a member function of the class tt(PersonData). An example using pointers to data members is provided in section ref(STABSORT), in the context of the tt(stable_sort) generic algorithm. c++-annotations-10.5.0/yo/pointermembers/implement.yo0000644000175000017500000002105712635354026021524 0ustar frankfrankitemization( it() First, the necessary class interfaces are defined. The existence of a class tt(Date) is assumed, containing overloaded operators like tt(<) and tt(>) to compare dates. To start with, we present the interface of the class tt(Person), omitting all the standard stuff like overloaded assignment operator, (copy) constructors, etc.: verb( #include // for qsort() class Date; class Person { public: size_t length() const; size_t mass() const; char const *name() const; char const *city() const; Date const &birthdate() const; private: // all necessary data members }; ) it() Next, the class tt(Person_dbase). Within this class a tt(struct CmpPerson) is defined, containing two fields: itemization( it() A pointer to a union of compare functions. As the compare functions are static functions of the class tt(Person_dbase), pointers to these functions are indiscernible from pointers to functions at the global (tt(::)) level. The compare functions return tt(int)s (for tt(qsort())), and expect two pointers to tt(Person const) objects. The field tt(persons) expects the two pointers to tt(Person const) objects. The field tt(voids) is the alternate interpretation, to be used with tt(qsort()), instead of the typecast tt((pif2vp)). it() A field tt(pf) (pointer to access function) of the nested tt(union Person_accessor). The types of as many different access functions of the tt(Person) class as are used in the class are declared in this union. Access functions returning tt(int)s, tt(char const *)s and tt(Date &)s are needed. Consequently, the tt(Person_accessor) union contains these (three) types. ) From this tt(CmpPerson) struct a static array tt(cmpPerson[]) is constructed. It is a tt(static Person_dbase) array, making it possible for the compare functions to inspect its elements+footnote( The number of elements of the tt(cmpPerson[]) array is not specified in the interface: that number is determined at compile-time by the compiler, when the static variable tt(cmpPerson[]) is initialized.). Also note the tt(static Listtype selector). This variable is used by the compare functions to find the actual tt(Person) access function to be used. Here, then, is the interface of the class tt(Person_dbase): verb( class Person_dbase { public: enum Listtype { list_by_length, list_by_mass, list_by_name, list_by_city, list_by_birthday, }; // ... constructors etc. void list(Listtype type); // list the information private: struct CmpPerson { union Compare_function { int (*persons)// comparing two Persons (Person const *p1, Person const *p2); int (*voids)// for qsort() (void const *p1, void const *p2); } cmp; union Person_accessor { char const *(Person::*cp)() const; int (Person::*i)() const; Date const &(Person::*d)() const; } pf; // to Person's access functions }; static CmpPerson cmpPerson[]; static Listtype selector; static int cmpstr(Person const *p1, Person const *p2); static int cmpint(Person const *p1, Person const *p2); static int cmpdate(Person const *p1, Person const *p2); Person *pp; // pointer to the info size_t n; // number of persons stored. }; ) Next, we define each of the members of the tt(Person_dbase) class (as far as necessary). it() The tt(list()) function now only has to do three things: itemization( it() The tt(Listtype) parameter is copied to tt(selector), it() The function tt(qsort()) is called. Note the use of the tt(cmpPerson) array to determine which compare function to use. it() The information of the tt(Person)objects is displayed. This part is left for the reader to implement. ) verb( void Person_dbase::list(Listtype type) { selector = type; qsort(pp, n, sizeof(Person), cmpPerson[type].cmp.voids); // list the sorted Person-database (to be implemented) } ) it() The array tt(cmpPerson[]) is a static array of tt(CmpPerson) elements. In this example there are five different ways to sort the data. Consequently, there are five elements in the array tt(cmpPerson[]). All these elements can be defined and initialized by the compiler. No run-time execution time is needed for this. However, note the form of the declaration: the array is defined in the scope of the tt(Person_dbase) class. Its elements are tt(CmpPerson)s, also defined in the scope of the tt(Person_dbase) class. Hence the double mentioning of tt(Person_dbase). verb( Person_dbase::CmpPerson Person_dbase::cmpPerson[] = { { // compare- and access // function to compare length cmpint, Person::length, }, { // same for mass cmpint, Person::mass, }, { // same for name cmpstr, Person::name, }, { // same for city cmpstr, Person::city, }, { // same for Date cmpdate, Person::birthdate, }, }; ) it() Now only the compare functions remain to be implemented. Although five accessors can be used, only three compare functions are needed. The compare functions, being static functions, have access to the tt(cmpPerson[]) array and to the tt(Listtype selector) variable. This information is used by the compare functions to call the relevant access member function of the two tt(Person) objects, pointed to by the parameters of the compare functions. For this, the tt(pointer to member) operator tt(->*) is used. The element tt(cmpPerson[selector]) contains the function pointers to the functions to be used: they are the fields tt(pf), variant tt(cp, i) or tt(d). These fields return a pointer to a particular access function of a tt(Person) object. Through these pointers the functions can be associated to a particular tt(Person) object using the pointer to member operator. This results in expressions like: center(tt(p1->*cmpPerson[selector].pf.cp)) By this time we have the name (i.e., address) of an access function for a particular tt(Person) object. To call this function, parentheses are needed, one set of parentheses to protect this expression from desintegrating due to the high priority of the second set of parentheses, which are needed for the actual call of the function. Hence, we get: center(tt((p1->*cmpPerson[selector].pf.cp)())) Finally, here are the three compare functions: verb( int Person_dbase::cmpstr(Person const *p1, Person const *p2) { return ( strcmp ( (p1->*cmpPerson[selector].pf.cp)(), (p2->*cmpPerson[selector].pf.cp)() ) ); } int Person_dbase::cmpint(Person const *p1, Person const *p2) { return ( (p1->*cmpPerson[selector].pf.i)() - (p2->*cmpPerson[selector].pf.i)() ); } int Person_dbase::cmpdate(Person const *p1, Person const *p2) { return ( (p1->*cmpPerson[selector].pf.d)() < (p2->*cmpPerson[selector].pf.d)() ? -1 : (p1->*cmpPerson[selector].pf.d)() > (p2->*cmpPerson[selector].pf.d)() ); } ) ) c++-annotations-10.5.0/yo/pointermembers/static.yo0000644000175000017500000000241012635354026021011 0ustar frankfrankStatic hi(static: members) members of a class can be used without having available an object of their class. Public static members can be called like free functions, albeit that their class names must be specified when they are called. Assume a class tt(String) has a public static member function tt(count), returning the number of string objects created so far. Then, without using any tt(String) object the function tt(String::count) may be called: verb( void fun() { cout << String::count() << '\n'; } ) em(Public) static members can be called like free functions (but see also section ref(CALLINGCONVENTION)). em(Private) static members can only be called within the context of their class, by their class's member or friend functions. Since static members have no associated objects their addresses can be stored in ordinary function pointer variables, operating at the global level. Pointers to members cannot be used to store addresses of static members. Example: verb( void fun() { size_t (*pf)() = String::count; // initialize pf with the address of a static member function cout << (*pf)() << '\n'; // displays the value returned by String::count() } ) c++-annotations-10.5.0/yo/pointermembers/defining.yo0000644000175000017500000001125612635354026021315 0ustar frankfrankPointers hi(pointer to members: defining) to members are defined by prefixing the normal pointer notation with the appropriate class plus scope resolution operator. Therefore, in the previous section, we used tt(char const * (String::*d_sp)() const) to indicate that tt(d_sp) itemization( it() is a pointer (tt(*d_sp)); it() points to something in the class tt(String) (tt(String::*d_sp)); it() is a pointer to a tt(const) function, returning a tt(char const *) (tt(char const * (String::*d_sp)() const)). ) The prototype of a matching function is therefore: verb( char const *String::somefun() const; ) which is any tt(const) parameterless function in the class tt(String), returning a tt(char const *). When defining pointers to members the standard procedure for constructing pointers to functions can still be applied: itemization( it() put parentheses around the fully qualified function name (i.e., the function's header, including the function's class name): verb( char const * ( String::somefun ) () const ) it() Put a pointer (a star (tt(*))) character immediately before the function name itself: verb( char const * ( String:: * somefun ) () const ) it() Replace the function name with the name of the pointer variable: verb( char const * (String::*d_sp)() const ) ) Here is another example, defining hi(pointer: to a data member) a pointer to a data member. Assume the class tt(String) contains a tt(string d_text) member. How to construct a pointer to this member? Again we follow standard procedure: itemization( it() put parentheses around the fully qualified variable name: verb( std::string (String::d_text) ) it() Put a pointer (a star (tt(*))) character immediately before the variable-name itself: verb( std::string (String::*d_text) ) it() Replace the variable name with the name of the pointer variable: verb( std::string (String::*tp) ) In this case, the parentheses are superfluous and may be omitted: verb( string String::*tp ) ) Alternatively, a very simple i(rule of thumb) is itemization( it() Define a normal (i.e., global) pointer variable, it() Prefix the class name to the pointer character, once you point to something inside a class ) For example, the following pointer to a global function verb( char const * (*sp)() const; ) becomes a pointer to a member function after prefixing the class-scope: verb( char const * (String::*sp)() const; ) Nothing forces us to define pointers to members in their target (tt(String)) classes. Pointers to members em(may) be defined in their target classes (so they become data members), or in another class, or as a local variable or as a global variable. In all these cases the pointer to member variable can be given the address of the kind of member it points to. The important part is that a pointer to member can be initialized or assigned without requiring the existence an object of the pointer's target class. Initializing or assigning an address to such a pointer merely indicates to which member the pointer points. This can be considered some kind of emi(relative address); relative to the object for which the function is called. No object is required when pointers to members are initialized or assigned. While it is allowed to initialize or assign a pointer to member, it is (of course) not possible to em(call) those members without specifying an object of the correct type. In the following example hi(pointer to members: assignment) hi(assignment: pointer to members) initialization of and assignment to pointers to members is illustrated (for illustration purposes all members of the class tt(PointerDemo) are defined tt(public)). In the example itself the tt(&)-operator is used to determine the addresses of the members. These operators as well as the class-scopes are required. Even when used inside member implementations: verbinclude(-a examples/initializing.cc) This involves nothing special. The difference with pointers at global scope is that we're now restricting ourselves to the scope of the tt(PointerDemo) class. Because of this restriction, all em(pointer) definitions and all variables whose addresses are used must be given the tt(PointerDemo) class scope. Pointers to members can also be used with tt(virtual) hi(pointer to members: virtual members) member functions. No special syntax is required when pointing to virtual members. Pointer construction, initialization and assignment is done identically to the way it is done with non-virtual members. c++-annotations-10.5.0/yo/inheritance.yo0000644000175000017500000000275612635354026016775 0ustar frankfrankincludefile(inheritance/intro) lsect(VehicleSystem)(Related types) includefile(inheritance/related) subsect(Inheritance depth: desirable?) includefile(inheritance/depth) sect(Access rights: public, private, protected) includefile(inheritance/accessrights) lsubsect(DERIVATIONTYPES)(Public, protected and private derivation) includefile(inheritance/derivationtypes) lsubsect(ACCESSPROMOTION)(Promoting access rights) includefile(inheritance/accessprom) sect(The constructor of a derived class) includefile(inheritance/constructor) subsect(Move construction) includefile(inheritance/move) subsect(Move assignment) includefile(inheritance/assignment) lsubsect(BASECONS)(Inheriting constructors) includefile(inheritance/usingbase) sect(The destructor of a derived class) includefile(inheritance/destructor) lsect(Truck)(Redefining member functions) includefile(inheritance/redefining) lsect(MULTIPLE)(Multiple inheritance) includefile(inheritance/multiple) sect(Conversions between base classes and derived classes) includefile(inheritance/conversions) subsect(Conversions with object assignments) includefile(inheritance/objectconv) subsect(Conversions with pointer assignments) includefile(inheritance/pointerconv) lsect(NONDEFINIT)(Using non-default constructors with new[]) includefile(inheritance/nondefault) c++-annotations-10.5.0/yo/iostreams/0000755000175000017500000000000012636507641016133 5ustar frankfrankc++-annotations-10.5.0/yo/iostreams/redirection.yo0000644000175000017500000000471412635354026021015 0ustar frankfrankUsing hi(rdbuf)tt(ios::rdbuf) streams can be forced to share their tt(streambuf) objects. Thus information written to one stream is actually written to another stream; a phenomenon normally called emi(redirection). Redirection is commonly implemented at the operating system level, and sometimes that is still necessary (see section ref(REDIRECTION)). A common situation where redirection is useful is when error messages should be written to file rather than to the standard error stream, usually indicated by its i(file descriptor) number 2. In the i(Unix) operating system using the ti(bash) shell, this can be realized as follows: verb( program 2>/tmp/error.log ) Following this command any error messages written by tt(program) are saved on the file tt(/tmp/error.log), instead of appearing on the screen. Here is an example showing how this can be implemented using tt(streambuf) objects. Assume tt(program) expects an argument defining the name of the file to write the error messages to. It could be called as follows: verb( program /tmp/error.log ) The program looks like this, an explanation is provided below the program's source text: verbinclude(-a examples/redirection.cc) itemization( it() At lines 1-2 local variables are defined: tt(errlog) is the tt(ofstream) to write the error messages too, and tt(cerr_buffer) is a pointer to a tt(streambuf), to point to the original tt(cerr) buffer. it() At line 3 the alternate error stream is opened. it() At line 4 redirection takes place: tt(cerr) now writes to the tt(streambuf) defined by tt(errlog). It is important that the original buffer used by tt(cerr) is saved, as explained below. it() At line 5 we pause. At this point, two lines were written to the alternate error file. We get a chance to take a look at its contents: there were indeed two lines written to the file. it() At line 6 the redirection is terminated. This is very important, as the tt(errlog) object is destroyed at the end of tt(main). If tt(cerr)'s buffer would not have been restored, then at that point tt(cerr) would refer to a non-existing tt(streambuf) object, which might produce unexpected results. It is the responsibility of the programmer to make sure that an original tt(streambuf) is saved before redirection, and is restored when the redirection ends. it() Finally, at line 7, tt(Done) is again written to the screen, as the redirection has been terminated. ) c++-annotations-10.5.0/yo/iostreams/ostream.yo0000644000175000017500000000306012635354026020151 0ustar frankfrankThe class ti(ostream) defines basic output facilities. The ti(cout), ti(clog) and ti(cerr) objects are all tt(ostream) objects. All facilities related to output as defined by the tt(ios) class are also available in the tt(ostream) class. We may define tt(ostream) objects using the following emi(ostream constructor): itemization( itt(std::ostream object(std::streambuf *sb)): quote(this constructor creates an tt(ostream) object which is a wrapper around an existing tt(std::streambuf) object. It isn't possible to define a plain tt(ostream) object (e.g., using tt(std::ostream out;)) that can thereupon be used for insertions. When tt(cout) or its friends are used, we are actually using a predefined tt(ostream) object that has already been defined for us and interfaces to the standard output stream using a (also predefined) tt(streambuf) object handling the actual interfacing. It em(is), however, possible to define an tt(ostream) object passing it hi(ostream: define using 0-pointer) a 0-pointer. Such an object cannot be used for insertions (i.e., it raises its tt(ios::bad) flag when something is inserted into it), but it may be given a tt(streambuf) later. Thus it may be preliminary constructed, suspending its use until an appropriate tt(streambuf) becomes available (see also section ref(STREAMINIT)). ) ) To define the tt(ostream) class in bf(C++) sources, the tthi(ostream) header file must be included. To use the predefined tt(ostream) objects (tt(std::cin, std::cout) etc.) the tthi(iostream) header file must be included. c++-annotations-10.5.0/yo/iostreams/formatting.yo0000644000175000017500000000220312635354026020647 0ustar frankfrankThe way information is written to streams (or, occasionally, read from streams) is controlled by emi(formatting flags). Formatting is used when it is necessary to, e.g., set the width of an output field or input buffer and to determine the form (e.g., the emi(radix)) in which values are displayed. Most formatting features belong to the realm of the tt(ios) class. Formatting is controlled by flags, defined by the tt(ios) class. These flags may be manipulated in two ways: using specialized member functions or using em(manipulators), which are directly inserted into or extracted from streams. There is no special reason for using either method; usually both methods are possible. In the following overview the various member functions are first introduced. Following this the flags and manipulators themselves are covered. Examples are provided showing how the flags can be manipulated and what their effects are. Many manipulators are parameterless and are available once a stream header file (e.g., tt(iostream)) has been included. Some manipulators require arguments. To use the latter manipulators the header file ti(iomanip) must be included. c++-annotations-10.5.0/yo/iostreams/moving.yo0000644000175000017500000000172012635354026017777 0ustar frankfrankStream classes (e.g.,, all stream classes covered in this chapter) are movable and can be swapped. This implies that factory functions can be designed for stream classes. Here is an example: verb( ofstream out(string const &name) { ofstream ret(name); // construct ofstream return ret; // return value optimization, but } // OK as moving is supported int main() { ofstream mine(out("out")); // return value optimizations, but // OK as moving is supported ofstream base("base"); ofstream other; base.swap(other); // swapping streams is OK other = std::move(base); // moving streams is OK // other = base; // this would ail: copy assignment // is not available for streams } ) c++-annotations-10.5.0/yo/iostreams/iosbase.yo0000644000175000017500000000331212635354026020124 0ustar frankfrankThe class hi(ios_base)tt(std::ios_base) forms the foundation of all I/O operations, and defines, among other things, facilities for inspecting the i(state of I/O streams) and most i(output formatting) facilities. Every stream class of the I/O library is, through the class ti(ios), em(derived) from this class, and em(inherits) its capabilities. As tt(ios_base) is the foundation on which all bf(C++) I/O was built, we introduce it here as the first class of the bf(C++) I/O library. Note that, as in bf(C), I/O in bf(C++) is em(not) part of the language (although it em(is) part of the i(ANSI/ISO) standard on bf(C++)). Although it is technically possible to ignore all predefined I/O facilities, nobody does so, and the I/O library therefore represents a em(de facto) I/O standard for bf(C++). Also note that, as mentioned before, the iostream classes themselves are not responsible for the eventual I/O, but delegate this to an auxiliary class: the class ti(streambuf) or its derivatives. It is neither possible nor required to construct an tt(ios_base) object directly. Its construction is always a side-effect of constructing an object further down the class hierarchy, like tt(std::ios). tt(Ios) is the next class down the iostream hierarchy (see figure ref(IOCLASSESFIG)). Since all stream classes in turn inherit from tt(ios), and thus also from tt(ios_base), the distinction between tt(ios_base) and ti(ios) is in practice not important. Therefore, facilities actually provided by tt(ios_base) will be discussed as facilities provided by tt(ios). The reader who is interested in the true class in which a particular facility is defined should consult the relevant header files (e.g., ti(ios_base.h) and ti(basic_ios.h)). c++-annotations-10.5.0/yo/iostreams/istringstream.yo0000644000175000017500000000303412635354026021373 0ustar frankfrankTo hi(stream: reading to memory) read information from memory using tt(stream) facilities, hi(istringstream)tt(std::istringstream) objects should be used. As the class tt(istringstream) is derived from the class tt(istream) all tt(istream)'s facilities are available to tt(istringstream) objects as well. To use and define tt(istringstream) objects the header file tthi(sstream) must be included. In addition the class tt(istringstream) offers the following constructors and members: itemization( ithtq(istringstream) (istringstream istr(string const &init, ios::openmode mode = ios::in)) (the object is initialized with tt(init)'s contents) itt(istringstream istr(ios::openmode mode = ios::in)) (this constructor is usually used as the default constructor. Example: verb( std::istringstream in; ) ) ithtq(str)(void str(std::string const &str)) (the current object is reinitialized with new initial contents.) ) The following example illustrates the use of the tt(istringstream) class: several values are extracted from the object. Such tt(istringstream) objects are most often used for doing `string to type'hi(conversions: text to binary) conversions, like converting text to tt(int) values (cf. bf(C)'s ti(atoi) function). Formatting flags can be used with tt(istringstreams) as well, as they are part of the tt(istream) class. In the example note especially the use of the member tt(seekg): verbinclude(-a examples/istringstream.cc) c++-annotations-10.5.0/yo/iostreams/istreamread.yo0000644000175000017500000001455612635354026021013 0ustar frankfrankThe class tt(istream) supports both formatted and unformatted emi(binary input). The emi(extraction operator) (ti(operator>>)) is used to extract values in a i(type safe) way from tt(istream) objects. This is called i(formatted input), whereby human-readable i(ASCII) characters are converted, according to certain formatting rules, to binary values. The extraction operator points to the objects or variables which receive new values. The normal associativity of rshift() remains unaltered, so when a statement like verb( cin >> x >> y; ) is encountered, the leftmost two operands are evaluated first (tt(cin) rshift() tt(x)), and an tt(istream &) object, which is actually the same tt(cin) object, is returned. Now, the statement is reduced to verb( cin >> y ) and the tt(y) variable is extracted from tt(cin). The rshift() operator has many (overloaded) variants and thus many types of variables can be extracted from tt(istream) objects. There is an overloaded rshift() available for the extraction of an tt(int), of a tt(double), of a string, of an array of characters, possibly to a pointer, etc. etc.. String or character array extraction hi(string extraction) hi(extracting strings) by default first skips all white space characters, and then extracts all consecutive non-white space characters. Once an extraction operator has been processed the tt(istream) object from which the information was extracted is returned and it can immediately be used for additional tt(istream) operations that appear in the same expression. Streams lack facilities for formatted input (as used by, e.g., bf(C)'s ti(scanf) and ti(vscanf) functions). Although it is not difficult to add these facilities to the world of streams, tt(scanf)-like functionality is hardly ever required in bf(C++) programs. Furthermore, as it is potentially type-em(unsafe), it might be better to avoid formatted input completely. When hi(binary file) binary files must be read, the information should normally not be formatted: an tt(int) value should be read as a series of unaltered bytes, not as a series of i(ASCII) numeric characters 0 to 9. The following member functions for reading information from tt(istream) objects are available: itemization( ithtq(gcount)(int gcount() const) (the number of characters read from the input stream by the last unformatted input operation is returned.) ithtq(get)(int get()) (the next available single character is returned as an unsigned tt(char) value using an tt(int) return type. endOfFile() is returned if no more character are available.) ittq(istream &get(char &ch)) (the next single character read from the input stream is stored in tt(ch). The member function returns the stream itself which may be inspected to determine whether a character was obtained or not.) ittq(istream& get(char *buffer, int len, char delim = '\n')) (At most tt(len - 1) characters are read from the input stream into the array starting at tt(buffer), which should be at least tt(len) bytes long. Reading also stops when the delimiter tt(delim) is encountered. However, the delimiter itself is em(not removed) from the input stream. Having stored the characters into tt(buffer), an 0-valued character is written beyond the last character stored into the tt(buffer). The functions tt(eof) and tt(fail) (see section ref(IOSTATES)) return 0 (tt(false)) if the delimiter was encountered before reading tt(len - 1) characters or if the delimiter was not encountered after reading tt(len - 1) characters. It is OK to specifiy an 0-valued character delimiter: this way NTB strings may be read from a (binary) file. ) ithtq(getline) (istream& getline(char *buffer, int len, char delim = '\n')) (this member function operates analogously to the tt(get) member function, but tt(getline) removes tt(delim) from the stream if it is actually encountered. The delimiter itself, if encountered, is em(not) stored in the tt(buffer). If tt(delim) was em(not) found (before reading tt(len - 1) characters) the tt(fail) member function, and possibly also tt(eof) returns true. Realize that the tt(std::string) class also offers a function tt(std::getline) which is generally preferred over this tt(getline) member function that is described here (see section ref(STRINGMEMBERS)). ) ithtq(ignore) (istream& ignore()) (one character is skipped from the input stream.) ittq(istream& ignore(int n)) (tt(n) characters are skipped from the input stream.) ittq(istream& ignore(int n, int delim)) (at most tt(n) characters are skipped but skipping characters stops after having removed tt(delim) from the input stream.) ithtq(peek)(int peek()) (this function returns the next available input character, but does not actually remove the character from the input stream. endOfFile() is returned if no more characters are available.) ithtq(putback)(istream& putback(char ch)) (The character tt(ch) is `pushed back' into the input stream, to be read again as the next available character. endOfFile() is returned if this is not allowed. Normally, it is OK to put back one character. Example: verb( string value; cin >> value; cin.putback('X'); // displays: X cout << static_cast(cin.get()); ) ) ithtq(read)(istream &read(char *buffer, int len)) (At most tt(len) bytes are read from the input stream into the buffer. If endOfFile() is encountered first, fewer bytes are read, with the member function tt(eof) returning tt(true). This function is commonly used when reading em(binary) files. Section ref(IFSTREAM) contains an example in which this member function is used. The member function tt(gcount()) may be used to determine the number of characters that were retrieved by tt(read). ) ithtq(readsome)(istream& readsome(char *buffer, int len)) (at most tt(len) bytes are read from the input stream into the buffer. All available characters are read into the buffer, but if endOfFile() is encountered, fewer bytes are read, without setting the tt(ios::eofbit) or tt(ios::failbit). ) ithtq(unget)(istream &unget()) (the last character that was read from the stream is put back.) ) c++-annotations-10.5.0/yo/iostreams/ios.yo0000644000175000017500000000512112635354026017271 0ustar frankfrankThe hi(ios)tt(std::ios) class is derived directly from ti(ios_base), and it defines em(de facto) the foundation for all stream classes of the bf(C++) I/O library. Although it em(is) possible to construct an tt(ios) object directly, this is seldom done. The purpose of the class tt(ios) is to provide the facilities of the class tt(basic_ios), and to add several new facilites, all related to the tt(streambuf) object which is managed by objects of the class tt(ios). All other stream classes are either directly or indirectly derived from tt(ios). This implies, as explained in chapter ref(INHERITANCE), that all facilities of the classes tt(ios) and tt(ios_base) are also available to other stream classes. Before discussing these additional stream classes, the features offered by the class tt(ios) (and by implication: by tt(ios_base)) are now introduced. In some cases it may be required to include ti(ios) explicitly. An example is the situations where the formatting flags themselves (cf. section ref(FORMATFLAGS)) are referred to in source code. The class tt(ios) offers several member functions, most of which are related to i(formatting). Other frequently used member functions are: itemization( ithtq(rdbuf) (std::streambuf *ios::rdbuf()) (A pointer to the tt(streambuf) object forming the interface between the tt(ios) object and the device with which the tt(ios) object communicates is returned. See sections ref(STREAMBUF) and ref(STRBUF) for more information about the tt(class streambuf).) itt(std::streambuf *ios::rdbuf(std::streambuf *new)): quote(The current tt(ios) object is associated with another tt(streambuf) object. A pointer to the tt(ios) object's original tt(streambuf) object is returned. The object to which this pointer points is not destroyed when the tt(stream) object goes out of scope, but is owned by the caller of tt(rdbuf).) ithtq(tie) (std::ostream *ios::tie()) (A pointer to the ti(ostream) object that is currently tied to the tt(ios) object is returned (see the next member). The return value 0 indicates that currently no tt(ostream) object is tied to the tt(ios) object. See section ref(COUPLING) for details.) itt(std::ostream *ios::tie(std::ostream *outs)): quote(The ostream object is tied to current tt(ios) object. This means that the tt(ostream) object is em(flushed) every time before an input or output action is performed by the current tt(ios) object. A pointer to the tt(ios) object's original tt(ostream) object is returned. To break the tie, pass the argument 0. See section ref(COUPLING) for an example.) ) c++-annotations-10.5.0/yo/iostreams/conditions.yo0000644000175000017500000001760412635354026020661 0ustar frankfrankOperations on streams may fail for various reasons. Whenever an operation fails, further operations on the stream are suspended. It is possible to inspect, set and possibly clear the i(condition state) of streams, allowing a program to repair the problem rather than having to abort. The members that are available for interrogating or manipulating the stream's state are described in the current section. Conditions are represented by the following emi(condition flags): itemization( ithtq(badbit)(ios::badbit) (if this flag has been raised an illegal operation has been requested at the level of the tt(streambuf) object to which the stream interfaces. See the member functions below for some examples.) ithtq(eofbit)(ios::eofbit) (if this flag has been raised, the tt(ios) object has sensed end of file.) ithtq(failbit)(ios::failbit) (if this flag has been raised, an operation performed by the stream object has failed (like an attempt to extract an tt(int) when no numeric characters are available on input). In this case the stream itself could not perform the operation that was requested of it.) ithtq(goodbit)(ios::goodbit) (this flag is raised when none of the other three condition flags were raised.) ) Several i(condition member functions) are available to manipulate or determine the states of tt(ios) objects. Originally they returned tt(int) values, but their current return type is tt(bool): itemization( itht(bad)(bool ios::bad()): quote(the value tt(true) is returned when the stream's tt(badbit) has been set and tt(false) otherwise. If tt(true) is returned it indicates that an illegal operation has been requested at the level of the tt(streambuf) object to which the stream interfaces. What does this mean? It indicates that the tt(streambuf) itself is behaving unexpectedly. Consider the following example: verb( std::ostream error(0); ) Here an tt(ostream) object is constructed em(without) providing it with a working tt(streambuf) object. Since this `tt(streambuf)' will never operate properly, its tt(badbit) flag is raised from the very beginning: tt(error.bad()) returns tt(true). ) itht(eof)(bool ios::eof()): quote(the value tt(true) is returned when end of file (endOfFile()) has been sensed (i.e., the tt(eofbit) flag has been set) and tt(false) otherwise. Assume we're reading lines line-by-line from tt(cin), but the last line is not terminated by a final tt(\n) character. In that case hi(getline)tt(std::getline) attempting to read the tt(\n) delimiter hits end-of-file first. This raises the tt(eofbit) flag and tt(cin.eof()) returns tt(true). For example, assume tt(std::string str) and tt(main) executing the statements: verb( getline(cin, str); cout << cin.eof(); ) Then verb( echo "hello world" | program ) prints the value 0 (no EOF sensed). But after verb( echo -n "hello world" | program ) the value 1 (EOF sensed) is printed.) itht(fail)(bool ios::fail()): quote(the value tt(true) is returned when tt(bad) returns tt(true) or when the tt(failbit) flag was set. The value tt(false) is returned otherwise. In the above example, tt(cin.fail()) returns tt(false), whether we terminate the final line with a delimiter or not (as we've read a line). However, executing em(another) tt(getline) results in raising the tt(failbit) flag, causing tt(cin::fail()) to return tt(true). In general: tt(fail) returns tt(true) if the requested stream operation failed. A simple example showing this consists of an attempt to extract an tt(int) when the input stream contains the text tt(hello world). The value tt(not fail()) is returned by the tt(bool) interpretation of a stream object (see below).) itht(good)(ios::good()): quote(the value of the tt(goodbit) flag is returned. It equals tt(true) when none of the other condition flags (tt(badbit, eofbit, failbit)) was raised. Consider the following little program: verb( #include #include using namespace std; void state() { cout << "\n" "Bad: " << cin.bad() << " " "Fail: " << cin.fail() << " " "Eof: " << cin.eof() << " " "Good: " << cin.good() << '\n'; } int main() { string line; int x; cin >> x; state(); cin.clear(); getline(cin, line); state(); getline(cin, line); state(); } ) When this program processes a file having two lines, containing, respectively, tt(hello) and tt(world), while the second line is not terminated by a tt(\n) character the following is shown: verb( Bad: 0 Fail: 1 Eof: 0 Good: 0 Bad: 0 Fail: 0 Eof: 0 Good: 1 Bad: 0 Fail: 0 Eof: 1 Good: 0 ) Thus, extracting tt(x) fails (tt(good) returning tt(false)). Then, the error state is cleared, and the first line is successfully read (tt(good) returning tt(true)). Finally the second line is read (incompletely): tt(good) returning tt(false), and tt(eof) returning tt(true). ) it() hi(ios object: as bool value) hi(stream: as bool value) Interpreting streams as tt(bool) values: quote(streams may be used in expressions expecting logical values. Some examples are: verb( if (cin) // cin itself interpreted as bool if (cin >> x) // cin interpreted as bool after an extraction if (getline(cin, str)) // getline returning cin ) When interpreting a stream as a logical value, it is actually `tt(not fail())' that is interpreted. The above examples may therefore be rewritten as: verb( if (not cin.fail()) if (not (cin >> x).fail()) if (not getline(cin, str).fail()) ) The former incantation, however, is used almost exclusively. ) ) The following members are available to manage error states: itemization( itht(clear)(void ios::clear()): quote(When an error condition has occurred, and the condition can be repaired, then tt(clear) can be used to clear the error state of the file. An overloaded version exists accepting state flags, that are set after first clearing the current set of flags: tt(clear(int state)). Its return type is tt(void)) itht(rdstate)(ios::iostate ios::rdstate()): quote(hi(stream state flags)hi(flags: of ios objects) The current set of flags that are set for an tt(ios) object are returned (as an tt(int)). To test for a particular flag, use the i(bitwise and) operator: verb( if (!(iosObject.rdstate() & ios::failbit)) { // last operation didn't fail } ) Note that this test cannot be performed for the tt(goodbit) flag as its value equals zero. To test for `good' use a construction like: verb( if (iosObject.rdstate() == ios::goodbit) { // state is `good' } ) ) itht(setstate)(void ios::setstate(ios::iostate state)): quote(A stream may be assigned a certain set of states using tt(setstate). Its return type is tt(void). E.g., verb( cin.setstate(ios::failbit); // set state to `fail' ) To set multiple flags in one tt(setstate()) call use the tt(bitor) operator: verb( cin.setstate(ios::failbit | ios::eofbit)) ) The member tt(clear) is a shortcut to clear all error flags. Of course, clearing the flags doesn't automatically mean the error condition has been cleared too. The strategy should be: itemization( it() An error condition is detected, it() The error is repaired it() The member tt(clear) is called. ) ) bf(C++) supports an emi(exception) mechanism to handle exceptional situations. According to the i(ANSI/ISO) standard, exceptions can be used with stream objects. Exceptions are covered in chapter ref(EXCEPTIONS). Using exceptions with stream objects is covered in section ref(IOEXCEPTIONS). c++-annotations-10.5.0/yo/iostreams/sbbuffers.fig0000644000175000017500000000774712635354026020616 0ustar frankfrank#FIG 3.2 Landscape Center Metric A4 100.00 Single -2 1200 2 6 135 135 9450 9360 6 313 135 8648 4753 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 614 1843 1117 1843 1117 2846 614 2846 614 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 1117 1843 1619 1843 1619 2846 1117 2846 1117 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 1619 1843 2120 1843 2120 2846 1619 2846 1619 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 2120 1843 2623 1843 2623 2846 2120 2846 2120 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 2623 1843 3125 1843 3125 2846 2623 2846 2623 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 3125 1843 3627 1843 3627 2846 3125 2846 3125 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 3627 1843 4128 1843 4128 2846 3627 2846 3627 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 4128 1843 4630 1843 4630 2846 4128 2846 4128 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 4630 1843 5133 1843 5133 2846 4630 2846 4630 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 5133 1843 5636 1843 5636 2846 5133 2846 5133 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 5636 1843 6137 1843 6137 2846 5636 2846 5636 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 6137 1843 6640 1843 6640 2846 6137 2846 6137 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 6640 1843 7141 1843 7141 2846 6640 2846 6640 1843 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 7141 1843 7644 1843 7644 2846 7141 2846 7141 1843 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 133.87 267.74 916 2846 916 3849 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 133.87 267.74 3828 2846 3828 3849 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 133.87 267.74 7945 2846 7945 3849 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 133.87 267.74 5836 3448 3828 3448 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 133.87 267.74 1519 1440 3526 1440 4 1 0 50 0 0 27 0.0000 4 360 1125 8046 4652 egptr()\001 4 1 0 50 0 0 27 0.0000 4 345 1230 1016 4652 eback()\001 4 1 0 50 0 0 27 0.0000 4 360 945 3928 4652 gptr()\001 4 1 0 50 0 0 27 0.0000 4 360 1425 2623 1239 put back\001 4 0 0 50 0 0 27 0.0000 4 270 1260 4833 3849 retrieve\001 4 1 0 50 0 0 36 0.0000 4 480 1140 4128 537 Input\001 -6 6 153 5216 9450 9360 6 153 8913 1721 9360 4 1 0 50 0 0 30 0.0000 4 405 1320 937 9248 pbase()\001 -6 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 489 6112 1049 6112 1049 7231 489 7231 489 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 1049 6112 1609 6112 1609 7231 1049 7231 1049 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 1609 6112 2169 6112 2169 7231 1609 7231 1609 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 2169 6112 2729 6112 2729 7231 2169 7231 2169 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 2729 6112 3289 6112 3289 7231 2729 7231 2729 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 3289 6112 3849 6112 3849 7231 3289 7231 3289 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 3849 6112 4410 6112 4410 7231 3849 7231 3849 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 4410 6112 4969 6112 4969 7231 4410 7231 4410 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 4969 6112 5530 6112 5530 7231 4969 7231 4969 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 5530 6112 6089 6112 6089 7231 5530 7231 5530 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 6089 6112 6650 6112 6650 7231 6089 7231 6089 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 6650 6112 7210 6112 7210 7231 6650 7231 6650 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 7210 6112 7770 6112 7770 7231 7210 7231 7210 6112 2 2 0 1 0 7 50 0 -1 0.000 0 0 -1 0 0 5 7770 6112 8330 6112 8330 7231 7770 7231 7770 6112 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 149.35 298.71 825 7231 825 8352 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 149.35 298.71 4073 7231 4073 8352 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 149.35 298.71 8665 7231 8665 8352 2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 0 1 2 0 0 1.00 149.35 298.71 6313 7904 4073 7904 4 1 0 50 0 0 30 0.0000 4 405 1215 8777 9248 epptr()\001 4 1 0 50 0 0 30 0.0000 4 405 1020 4185 9248 pptr()\001 4 0 0 50 0 0 30 0.0000 4 300 990 5193 8464 insert\001 4 1 0 50 0 0 40 0.0000 4 540 1665 4410 5663 Output\001 -6 -6 c++-annotations-10.5.0/yo/iostreams/formatmembers.yo0000644000175000017500000001377412636507641021363 0ustar frankfrank#ifndef INCLUDED_FORMATMEMBERS_YO_ #define INCLUDED_FORMATMEMBERS_YO_ Several em(member functions) are available manipulating the I/O i(formatting) flags. Instead of using the members listed below em(manipulators) are often available that may directly be inserted into or extracted from streams. The available members are listed in alphabetical order, but the most important ones in practice are link(setf)(SETF), link(unsetf)(UNSETF) and link(width)(WIDTH). itemization( ithtq(copyfmt)(ios &ios::copyfmt(ios &obj)) (all format flags of tt(obj) are copied to the current tt(ios) object. The current tt(ios) object is returned.) ithtq(fill)(ios::fill() const) (the current i(padding) character is returned. By default, this is the blank space.) itt(ios::fill(char padding)): quote(the padding character is redefined, the em(previous) padding character is returned. Instead of using this member function the ti(setfill) em(manipulator) may be inserted directly into an tt(ostream). Example: verb( cout.fill('0'); // use '0' as padding char cout << setfill('+'); // use '+' as padding char ) ) ithtq(flags)(ios::fmtflags ios::flags() const) (the current set of flags controlling the format state of the stream for which the member function is called is returned. To inspect whether a particular flag was set, use the tt(bit_and) operator. Example: verb( if (cout.flags() & ios::hex) cout << "Integral values are printed as hex numbers\n" )) itt(ios::fmtflags ios::flags(ios::fmtflags flagset)): quote(the em(previous) set of flags are returned and the new set of flags are defined by tt(flagset). Multiple flags are specified using the tt(bitor) operator. Example: verb( // change the representation to hexadecimal cout.flags(ios::hex | cout.flags() & ~ios::dec); ) ) ithtq(precision)(int ios::precision() const) (the number of significant digits used when outputting floating point values is returned (default: 6).) itt(int ios::precision(int signif)):hi(display floating point numbers) quote(the number of significant digits to use when outputting real values is set to tt(signif). The previously used number of significant digits is returned. If the number of required digits exceeds tt(signif) then the number is displayed in `scientific' notation (cf. section ref(FORMATFLAGS)). Manipulator: ti(setprecision). Example: verb( cout.precision(3); // 3 digits precision cout << setprecision(3); // same, using the manipulator cout << 1.23 << " " << 12.3 << " " << 123.12 << " " << 1234.3 << '\n'; // displays: 1.23 12.3 123 1.23e+03 ) ) ithtq(put_time)(Type std::put_time(std::tm const *tm, char const *fmt)) (hi(display the time)hi(time: display)The function tt(put_time) can be used to display (elements of) the current time. Time elements are provided in a ti(std::tm) object, and the way the time is displayed is defined by the emi(format string) tt(fmt). In the next example tt(put_time) is used to display the current date and time: verb( #include #include int main() { std::time_t tm {time(0)}; std::cout << std::put_time(std::localtime(&tm), "%c") << '\n'; } // displays, e.g., Sun Dec 20 15:05:18 2015 ) The function tt(put_time), as well as tt(std::localtime) and tt(gmtime) is described in more detail in section ref(TIME).) it() hi(setf)label(SETF)tt(ios::fmtflags ios::setf(ios::fmtflags flags)): quote(sets one or more formatting flags (use the tt(bitor) operator to combine multiple flags). Already set flags are not affected. The em(previous) set of flags is returned. Instead of using this member function the manipulator ti(setiosflags) may be used. Examples are provided in the next section (ref(FORMATFLAGS)).) itt(ios::fmtflags ios::setf(ios::fmtflags flags, ios::fmtflags mask)): quote(clears all flags mentioned in tt(mask) and sets the flags specified in tt(flags). The em(previous) set of flags is returned. Some examples are (but see the next section (ref(FORMATFLAGS)) for a more thorough discussion): verb( // left-adjust information in wide fields cout.setf(ios::left, ios::adjustfield); // display integral values as hexadecimal numbers cout.setf(ios::hex, ios::basefield); // display floating point values in scientific notation cout.setf(ios::scientific, ios::floatfield); ) ) it() hi(unsetf)label(UNSETF)tt(ios::fmtflags ios::unsetf(fmtflags flags)): quote(the specified formatting flags are cleared (leaving the remaining flags unaltered) and returns the em(previous) set of flags. A request to unset an active default flag (e.g., tt(cout.unsetf(ios::dec))) is ignored. Instead of this member function the manipulator ti(resetiosflags) may also be used. Example: verb( cout << 12.24; // displays 12.24 cout << setf(ios::fixed); cout << 12.24; // displays 12.240000 cout.unsetf(ios::fixed); // undo a previous ios::fixed setting. cout << 12.24; // displays 12.24 cout << resetiosflags(ios::fixed); // using manipulator rather // than unsetf ) ) it()hi(width)hi(display field width) label(WIDTH)tt(int ios::width() const): quote(the currently active output field width to use on the next insertion is returned. The default value is 0, meaning `as many characters as needed to write the value'.) itt(int ios::width(int nchars)): quote(the field width of the next insertion operation is set to tt(nchars), returning the previously used field width. This setting is not persistent. It is reset to 0 after every insertion operation. Manipulator: hi(setw)tt(std::setw(int)). Example: verb( cout.width(5); cout << 12; // using 5 chars field width cout << setw(12) << "hello"; // using 12 chars field width ) ) ) #endif c++-annotations-10.5.0/yo/iostreams/cc/0000755000175000017500000000000012636507651016521 5ustar frankfrankc++-annotations-10.5.0/yo/iostreams/cc/manipulators.cc0000644000175000017500000000135012636507652021546 0ustar frankfrank#include #include using namespace std; int main() { cout.setf(ios::showbase); cout << hex << 16 << oct << 16 << '\n'; cout.unsetf(ios::showbase); cout << hex << 16 << oct << 16 << '\n'; cout << setprecision(5) << 1.123456789 << '\n'; cout.setf(ios::showpoint); cout << setprecision(2) << dec << 10.0 << '\n'; cout << "|" << setw(4) << 4 << "|" << '\n'; cout.setf(ios::left); cout << "|" << setw(4) << -4 << "|" << '\n'; cout << "|" << setw(4) << 4 << "|" << '\n'; cout.unsetf(ios::left); cout.setf(ios::internal); cout << "|" << setw(4) << -4 << "|" << '\n'; cout << setbase(8) << 16 << " " << 16 << '\n'; cout << dec << 5 << '\n'; return (0); } c++-annotations-10.5.0/yo/iostreams/sbbuffers.eps0000644000175000017500000001737412635354026020635 0ustar frankfrank%!PS-Adobe-2.0 EPSF-2.0 %%Title: sbbuffers.eps %%Creator: fig2dev Version 3.2 Patchlevel 3d %%CreationDate: Sun May 23 18:00:28 2004 %%For: frank@knarfix.oostum.north (Frank B. Brokken,,,) %%BoundingBox: 0 0 592 587 %%Magnification: 1.0000 %%EndComments /$F2psDict 200 dict def $F2psDict begin $F2psDict /mtrx matrix put /col-1 {0 setgray} bind def /col0 {0.000 0.000 0.000 srgb} bind def /col1 {0.000 0.000 1.000 srgb} bind def /col2 {0.000 1.000 0.000 srgb} bind def /col3 {0.000 1.000 1.000 srgb} bind def /col4 {1.000 0.000 0.000 srgb} bind def /col5 {1.000 0.000 1.000 srgb} bind def /col6 {1.000 1.000 0.000 srgb} bind def /col7 {1.000 1.000 1.000 srgb} bind def /col8 {0.000 0.000 0.560 srgb} bind def /col9 {0.000 0.000 0.690 srgb} bind def /col10 {0.000 0.000 0.820 srgb} bind def /col11 {0.530 0.810 1.000 srgb} bind def /col12 {0.000 0.560 0.000 srgb} bind def /col13 {0.000 0.690 0.000 srgb} bind def /col14 {0.000 0.820 0.000 srgb} bind def /col15 {0.000 0.560 0.560 srgb} bind def /col16 {0.000 0.690 0.690 srgb} bind def /col17 {0.000 0.820 0.820 srgb} bind def /col18 {0.560 0.000 0.000 srgb} bind def /col19 {0.690 0.000 0.000 srgb} bind def /col20 {0.820 0.000 0.000 srgb} bind def /col21 {0.560 0.000 0.560 srgb} bind def /col22 {0.690 0.000 0.690 srgb} bind def /col23 {0.820 0.000 0.820 srgb} bind def /col24 {0.500 0.190 0.000 srgb} bind def /col25 {0.630 0.250 0.000 srgb} bind def /col26 {0.750 0.380 0.000 srgb} bind def /col27 {1.000 0.500 0.500 srgb} bind def /col28 {1.000 0.630 0.630 srgb} bind def /col29 {1.000 0.750 0.750 srgb} bind def /col30 {1.000 0.880 0.880 srgb} bind def /col31 {1.000 0.840 0.000 srgb} bind def end save newpath 0 587 moveto 0 0 lineto 592 0 lineto 592 587 lineto closepath clip newpath -10.8 596.7 translate 1 -1 scale /cp {closepath} bind def /ef {eofill} bind def /gr {grestore} bind def /gs {gsave} bind def /sa {save} bind def /rs {restore} bind def /l {lineto} bind def /m {moveto} bind def /rm {rmoveto} bind def /n {newpath} bind def /s {stroke} bind def /sh {show} bind def /slc {setlinecap} bind def /slj {setlinejoin} bind def /slw {setlinewidth} bind def /srgb {setrgbcolor} bind def /rot {rotate} bind def /sc {scale} bind def /sd {setdash} bind def /ff {findfont} bind def /sf {setfont} bind def /scf {scalefont} bind def /sw {stringwidth} bind def /tr {translate} bind def /tnt {dup dup currentrgbcolor 4 -2 roll dup 1 exch sub 3 -1 roll mul add 4 -2 roll dup 1 exch sub 3 -1 roll mul add 4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb} bind def /shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul 4 -2 roll mul srgb} bind def /$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def /$F2psEnd {$F2psEnteredState restore end} def $F2psBegin 10 setmiterlimit 0 slj 0 slc 0.06299 0.06299 sc % % Fig objects follow % % Polyline 7.500 slw n 619 1859 m 1126 1859 l 1126 2872 l 619 2872 l cp gs col0 s gr % Polyline n 1126 1859 m 1633 1859 l 1633 2872 l 1126 2872 l cp gs col0 s gr % Polyline n 1633 1859 m 2139 1859 l 2139 2872 l 1633 2872 l cp gs col0 s gr % Polyline n 2139 1859 m 2647 1859 l 2647 2872 l 2139 2872 l cp gs col0 s gr % Polyline n 2647 1859 m 3154 1859 l 3154 2872 l 2647 2872 l cp gs col0 s gr % Polyline n 3154 1859 m 3661 1859 l 3661 2872 l 3154 2872 l cp gs col0 s gr % Polyline n 3661 1859 m 4167 1859 l 4167 2872 l 3661 2872 l cp gs col0 s gr % Polyline n 4167 1859 m 4674 1859 l 4674 2872 l 4167 2872 l cp gs col0 s gr % Polyline n 4674 1859 m 5182 1859 l 5182 2872 l 4674 2872 l cp gs col0 s gr % Polyline n 5182 1859 m 5689 1859 l 5689 2872 l 5182 2872 l cp gs col0 s gr % Polyline n 5689 1859 m 6195 1859 l 6195 2872 l 5689 2872 l cp gs col0 s gr % Polyline n 6195 1859 m 6702 1859 l 6702 2872 l 6195 2872 l cp gs col0 s gr % Polyline n 6702 1859 m 7209 1859 l 7209 2872 l 6702 2872 l cp gs col0 s gr % Polyline n 7209 1859 m 7717 1859 l 7717 2872 l 7209 2872 l cp gs col0 s gr % Polyline gs clippath 990 2857 m 855 2857 l 855 3159 l 923 2889 l 990 3159 l cp eoclip n 923 2872 m 923 3885 l gs col0 s gr gr % arrowhead n 990 3159 m 923 2889 l 855 3159 l col0 s % Polyline gs clippath 3930 2857 m 3795 2857 l 3795 3159 l 3863 2889 l 3930 3159 l cp eoclip n 3863 2872 m 3863 3885 l gs col0 s gr gr % arrowhead n 3930 3159 m 3863 2889 l 3795 3159 l col0 s % Polyline gs clippath 8088 2857 m 7953 2857 l 7953 3159 l 8021 2889 l 8088 3159 l cp eoclip n 8021 2872 m 8021 3885 l gs col0 s gr gr % arrowhead n 8088 3159 m 8021 2889 l 7953 3159 l col0 s % Polyline gs clippath 5906 3547 m 5906 3412 l 5603 3412 l 5874 3480 l 5603 3547 l cp eoclip n 5891 3480 m 3863 3480 l gs col0 s gr gr % arrowhead n 5603 3547 m 5874 3480 l 5603 3412 l col0 s % Polyline gs clippath 1517 1385 m 1517 1520 l 1819 1520 l 1549 1453 l 1819 1385 l cp eoclip n 1532 1453 m 3559 1453 l gs col0 s gr gr % arrowhead n 1819 1385 m 1549 1453 l 1819 1520 l col0 s /Times-Roman ff 405.00 scf sf 8122 4696 m gs 1 -1 sc (egptr\(\)) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 405.00 scf sf 1024 4696 m gs 1 -1 sc (eback\(\)) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 405.00 scf sf 3965 4696 m gs 1 -1 sc (gptr\(\)) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 405.00 scf sf 2647 1250 m gs 1 -1 sc (put back) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 405.00 scf sf 4878 3885 m gs 1 -1 sc (retrieve) col0 sh gr /Times-Roman ff 540.00 scf sf 4167 541 m gs 1 -1 sc (Input) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 450.00 scf sf 945 9337 m gs 1 -1 sc (pbase\(\)) dup sw pop 2 div neg 0 rm col0 sh gr % Polyline 15.000 slw n 492 6170 m 1058 6170 l 1058 7301 l 492 7301 l cp gs col0 s gr % Polyline n 1058 6170 m 1623 6170 l 1623 7301 l 1058 7301 l cp gs col0 s gr % Polyline n 1623 6170 m 2189 6170 l 2189 7301 l 1623 7301 l cp gs col0 s gr % Polyline n 2189 6170 m 2754 6170 l 2754 7301 l 2189 7301 l cp gs col0 s gr % Polyline n 2754 6170 m 3320 6170 l 3320 7301 l 2754 7301 l cp gs col0 s gr % Polyline n 3320 6170 m 3885 6170 l 3885 7301 l 3320 7301 l cp gs col0 s gr % Polyline n 3885 6170 m 4451 6170 l 4451 7301 l 3885 7301 l cp gs col0 s gr % Polyline n 4451 6170 m 5016 6170 l 5016 7301 l 4451 7301 l cp gs col0 s gr % Polyline n 5016 6170 m 5582 6170 l 5582 7301 l 5016 7301 l cp gs col0 s gr % Polyline n 5582 6170 m 6147 6170 l 6147 7301 l 5582 7301 l cp gs col0 s gr % Polyline n 6147 6170 m 6713 6170 l 6713 7301 l 6147 7301 l cp gs col0 s gr % Polyline n 6713 6170 m 7278 6170 l 7278 7301 l 6713 7301 l cp gs col0 s gr % Polyline n 7278 6170 m 7844 6170 l 7844 7301 l 7278 7301 l cp gs col0 s gr % Polyline n 7844 6170 m 8409 6170 l 8409 7301 l 7844 7301 l cp gs col0 s gr % Polyline gs clippath 907 7286 m 756 7286 l 756 7619 l 832 7318 l 907 7619 l cp eoclip n 832 7301 m 832 8432 l gs col0 s gr gr % arrowhead 7.500 slw n 907 7619 m 832 7318 l 756 7619 l col0 s % Polyline 15.000 slw gs clippath 4186 7286 m 4035 7286 l 4035 7619 l 4111 7318 l 4186 7619 l cp eoclip n 4111 7301 m 4111 8432 l gs col0 s gr gr % arrowhead 7.500 slw n 4186 7619 m 4111 7318 l 4035 7619 l col0 s % Polyline 15.000 slw gs clippath 8823 7286 m 8672 7286 l 8672 7619 l 8748 7318 l 8823 7619 l cp eoclip n 8748 7301 m 8748 8432 l gs col0 s gr gr % arrowhead 7.500 slw n 8823 7619 m 8748 7318 l 8672 7619 l col0 s % Polyline 15.000 slw gs clippath 6388 8055 m 6388 7904 l 6054 7904 l 6356 7980 l 6054 8055 l cp eoclip n 6373 7980 m 4111 7980 l gs col0 s gr gr % arrowhead 7.500 slw n 6054 8055 m 6356 7980 l 6054 7904 l col0 s /Times-Roman ff 450.00 scf sf 8861 9337 m gs 1 -1 sc (epptr\(\)) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 450.00 scf sf 4224 9337 m gs 1 -1 sc (pptr\(\)) dup sw pop 2 div neg 0 rm col0 sh gr /Times-Roman ff 450.00 scf sf 5242 8545 m gs 1 -1 sc (insert) col0 sh gr /Times-Roman ff 600.00 scf sf 4451 5717 m gs 1 -1 sc (Output) dup sw pop 2 div neg 0 rm col0 sh gr $F2psEnd rs c++-annotations-10.5.0/yo/iostreams/intro.yo0000644000175000017500000002046512635354026017642 0ustar frankfrankExtending the standard stream (ti(FILE)) approach, well known from the bf(C) programming language, bf(C++) offers an em(input/output) (i(I/O)) library hi(I/O library) based on tt(class) concepts. All bf(C++) I/O facilities are defined in the namespace ti(std). The tt(std::) prefix is omitted below, except for situations where this would result in ambiguities. Earlier (in chapter ref(FirstImpression)) we've seen several examples of the use of the bf(C++) I/O library, in particular showing insertion operator (lshift()) and the extraction operator (rshift()). In this chapter we'll cover I/O in more detail. The discussion of input and output facilities provided by the bf(C++) programming language heavily uses the tt(class) concept and the notion of member functions. Although class construction has not yet been covered (for that see chapter ref(Classes)) and although em(inheritance) is not covered formally before chapter ref(INHERITANCE), it is quite possible to discuss I/O facilities long before the technical background of class construction has been covered. Most bf(C++) I/O classes have names starting with ti(basic_) (like tt(basic_ios)). However, these ti(basic_) names are not regularly found in bf(C++) programs, as most classes are also defined using ti(typedef) definitions like: verb( typedef basic_ios ios;) Since bf(C++) supports various kinds of character types (e.g., ti(char), ti(wchar_t)), I/O facilities were developed using the emi(template) mechanism allowing for easy conversions to character types other than the traditional tt(char) type. As elaborated in chapter ref(TEMPLATES), this also allows the construction of i(generic software), that could thereupon be used for any particular type representing characters. So, analogously to the above tt(typedef) there exists a verb( typedef basic_ios wios;) This type definition can be used for the tt(wchar_t) type. Because of the existence of these type definitions, the tt(basic_) prefix was omitted from the annotations() without loss of continuity. The annotations() primarily focus on the standard 8-bits tt(char) type. Iostream objects can+em(not) be declared using standard i(forward declaration)s, like: verb( class std::ostream; // now erroneous ) Instead, to i(declare iostream classes) the tthi(iosfwd) header file should be included: verb( #include // correct way to declare iostream classes ) Using bf(C++) I/O offers the additional advantage of emi(type safety). Objects (or plain values) are inserted into streams. Compare this to the situation commonly encountered in bf(C) where the ti(fprintf) function is used to indicate by a format string what kind of value to expect where. Compared to this latter situation bf(C++)'s em(iostream) approach immediately uses the objects where their values should appear, as in verb( cout << "There were " << nMaidens << " virgins present\n"; ) The compiler notices the type of the tt(nMaidens) variable, inserting its proper value at the appropriate place in the sentence inserted into the tt(cout) iostream. Compare this to the situation encountered in bf(C). Although bf(C) compilers are getting smarter and smarter, and although a well-designed bf(C) compiler may warn you for a mismatch between a format specifier and the type of a variable encountered in the corresponding position of the argument list of a tt(printf) statement, it can't do much more than em(warn) you. The em(type safety) seen in bf(C++) em(prevents) you from making type mismatches, as there are no types to match. Apart from this, em(iostreams) offer more or less the same set of possibilities as the standard tt(FILE)-based I/O used in bf(C): files can be opened, closed, positioned, read, written, etc.. In bf(C++) the basic tt(FILE) structure, as used in bf(C), is still available. But bf(C++) adds to this I/O based on classes, resulting in type safety, extensibility, and a clean design. In the i(ANSI/ISO) standard the intent was to create architecture independent I/O. Previous implementations of the iostreams library did not always comply with the standard, resulting in many extensions to the standard. The I/O sections of previously developed software may have to be partially rewritten. This is tough for those who are now forced to modify old software, but every feature and extension that was once available can be rebuilt easily using ANSI/ISO standard conforming I/O. Not all of these reimplementations can be covered in this chapter, as many reimplementations rely on inheritance and polymorphism, which topics are formally covered by chapters ref(INHERITANCE) and ref(POLYMORPHISM). Selected reimplementations are provided in chapter ref(CONCRETE), and in this chapter references to particular sections in other chapters are given where appropriate. figure(iostreams/ioclasses)(Central I/O Classes)(IOCLASSESFIG) This chapter is organized as follows (see also fig(IOCLASSESFIG)): itemization( it() The tt(class) ti(ios_base) is the foundation upon which the iostreams I/O library was built. It defines the core of all I/O operations and offers, among other things, facilities for inspecting the i(state of I/O streams) and for i(output formatting). it() The class ti(ios) was directly derived from tt(ios_base). Every class of the I/O library doing input or output is itself em(derived) from this tt(ios) class, and so em(inherits) its (and, by implication, tt(ios_base)'s) capabilities. The reader is urged to keep this in mind while reading this chapter. The concept of inheritance is not discussed here, but rather in chapter ref(INHERITANCE). The class tt(ios) is important in that it implements the communication with a em(buffer) that is used by streams. This buffer is a ti(streambuf) object which is responsible for the actual I/O to/from the underlying em(device). Consequently tt(iostream) objects do not perform I/O operations themselves, but leave these to the (stream)buffer objects with which they are associated. it() Next, basic bf(C++) output facilities are discussed. The basic class used for output operations is ti(ostream), defining the i(insertion operator) as well as other facilities writing information to streams. Apart from inserting information into files it is possible to insert information into i(memory buffers), for which the ti(ostringstream) class is available. Formatting output is to a great extent possible using the facilities defined in the tt(ios) class, but it is also possible to em(insert) emi(formatting commands) directly into streams using hi(manipulator)em(manipulators). This aspect of bf(C++) output is discussed as well. it() Basic bf(C++) input facilities are implemented by the ti(istream) class. This class defines the i(extraction operator) and related input facilities. Comparably to inserting information into memory buffers (using tt(ostringstream)) a class ti(istringstream) is available to extract information from memory buffers. it() Finally, several advanced I/O-related topics are discussed. E.g., i(reading and writing) from the same stream and i(mixing bf(C) and bf(C++) I/O) using ti(filebuf) objects. Other I/O related topics are covered elsewhere in the annotations(), e.g., in chapter ref(CONCRETE). ) Stream objects have a limited but important role: they are the interface between, on the one hand, the objects to be input or output and, on the other hand, the tt(streambuf), which is responsible for the actual input and output to the i(device) accessed by a tt(streambuf) object. This approach allows us to construct a new kind of tt(streambuf) for a new kind of device, and use that streambuf in combination with the `good old' tt(istream)- and tt(ostream)-class facilities. It is important to understand the distinction between the formatting roles of iostream objects and the buffering interface to an external device as implemented in a tt(streambuf) object. Interfacing to new devices (like hi(socket)em(sockets) or emi(file descriptors)) requires the construction of a new kind of tt(streambuf), rather than a new kind of tt(istream) or tt(ostream) object. A emi(wrapper class) may be constructed around the tt(istream) or tt(ostream) classes, though, to ease the access to a special device. This is how the stringstream classes were constructed. c++-annotations-10.5.0/yo/iostreams/ioclasses.fig0000644000175000017500000000603312635354026020605 0ustar frankfrank#FIG 3.2 Landscape Center Metric A4 100.00 Single -2 1200 2 0 32 #ffdd00 6 4095 8100 5400 8865 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 4140 8145 5355 8145 5355 8820 4140 8820 4140 8145 4 1 0 50 0 2 20 0.0000 4 195 915 4770 8550 fstream\001 -6 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 4275 1710 5175 1710 5175 2385 4275 2385 4275 1710 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 4500 2385 4500 3015 2565 3015 2565 3510 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 4995 2385 4995 3015 6930 3015 6930 3510 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 1845 3510 3060 3510 3060 4185 1845 4185 1845 3510 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 6300 3510 7515 3510 7515 4185 6300 4185 6300 3510 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 2880 4185 2880 4815 3600 4815 3600 5400 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 2070 4185 2070 4815 1080 4815 1080 5355 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 6480 4185 6480 4815 5490 4815 5490 5355 2 1 0 2 0 32 50 0 -1 0.000 0 0 -1 0 0 4 7290 4185 7290 4815 8010 4815 8010 5400 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 450 5355 1665 5355 1665 6030 450 6030 450 5355 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 7110 5400 9000 5400 9000 6030 7110 6030 7110 5400 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 2700 5400 4545 5400 4545 6075 2700 6075 2700 5400 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 4905 5400 6120 5400 6120 6075 4905 6075 4905 5400 2 1 0 1 0 32 50 0 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 3870 3825 3240 3825 2 1 0 1 0 32 50 0 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 5445 3780 6120 3780 2 1 0 2 0 7 50 0 -1 0.000 0 0 -1 0 0 2 4770 1125 4770 1710 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 4140 450 5355 450 5355 1125 4140 1125 4140 450 2 1 0 1 0 32 50 0 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 5175 2025 5985 2025 2 1 0 1 0 32 50 0 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 7065 2025 7425 2025 2 2 0 2 0 32 50 0 20 0.000 0 0 -1 0 0 5 4140 7020 5355 7020 5355 7695 4140 7695 4140 7020 2 1 0 2 0 7 50 0 -1 0.000 0 0 -1 0 0 2 4770 7695 4770 8145 2 1 0 2 0 7 50 0 -1 0.000 0 0 -1 0 0 4 2250 4185 2250 6795 4410 6795 4410 7020 2 1 0 2 0 7 50 0 -1 0.000 0 0 -1 0 0 4 6750 4185 6750 6795 5175 6795 5175 7020 4 1 0 50 0 2 20 0.0000 4 195 315 4725 2070 ios\001 4 1 0 50 0 2 20 0.0000 4 195 900 2520 3915 istream\001 4 1 0 50 0 2 20 0.0000 4 165 960 6885 3915 ostream\001 4 1 0 50 0 2 20 0.0000 4 195 990 1035 5760 ifstream\001 4 1 0 50 0 2 20 0.0000 4 255 1605 3600 5805 istringstream\001 4 1 0 50 0 2 20 0.0000 4 255 1665 8055 5850 ostringstream\001 4 1 0 50 0 2 20 0.0000 4 195 1050 5490 5805 ofstream\001 4 1 0 50 0 2 17 0.0000 4 165 1260 4680 3600 streambuf *\001 4 0 0 50 0 2 26 0.0000 4 345 915 450 3465 Input\001 4 2 0 50 0 2 26 0.0000 4 345 1200 8955 3465 Output\001 4 1 0 50 0 2 17 0.0000 4 165 900 4680 3900 filebuf *\001 4 1 0 50 0 2 20 0.0000 4 255 945 4770 855 ios_base\001 4 0 0 50 0 2 17 0.0000 4 210 855 6165 2115 rdbuf() \001 4 0 0 50 0 2 17 0.0000 4 165 1260 7560 2115 streambuf *\001 4 1 0 50 0 2 20 0.0000 4 195 1035 4770 7425 iostream\001 4 1 0 50 0 2 17 0.0000 4 225 1170 4680 4230 stringbuf *\001 c++-annotations-10.5.0/yo/iostreams/ostreamseek.yo0000644000175000017500000000340612635354026021025 0ustar frankfrankAlthough not every tt(ostream) object supports i(repositioning), they usually do. This means that it is possible to rewrite a section of the stream which was written earlier. Repositioning is frequently used in database applications where it must be possible to access the information in the database at random. The current position can be obtained and modified using the following members: itemization( ithtq(tellp)(ios::pos_type tellp()) (the current (absolute) position in the file where the next write-operation to the stream will take place is returned.) ithtq(seekp) (ostream &seekp(ios::off_type step, ios::seekdir org)) (modifies a stream's actual position. The function expects an ti(off_type) tt(step) representing the number of bytes the current stream position is moved with respect to tt(org). The tt(step) value may be negative, zero or positive. The origin of the step, tt(org) is a value in the hi(seekdir)tt(ios::seekdir) enumeration. Its values are: itemization( ithtq(beg)(ios::beg) (the stepsize is computed relative to the beginning of the stream. This value is used by default. ) ithtq(cur)(ios::cur) (the stepsize is computed relative to the current position of the stream (as returned by tt(tellp)). ) ithtq(end)(ios::end) (the stepsize is interpreted relative to the current end position of the stream.) ) It is OK to hi(write beyond end of file)hi(seek beyond file boundaries) seek or write beyond the last file position. Writing bytes to a location beyond endOfFile() will pad the intermediate bytes with 0-valued bytes: i(null-bytes). Seeking before tt(ios::beg) raises the hi(fail)tt(ios::fail) flag. ) ) c++-annotations-10.5.0/yo/iostreams/flags.yo0000644000175000017500000002471412635354026017604 0ustar frankfrankMost emi(formatting flags) are related to outputting information. Information can be written to output streams in basically two ways: using emi(binary output) information is written directly to an output stream, without converting it first to some i(human-readable) format and using emi(formatted output) by which values stored in the computer's memory are converted to human-readable text first. Formatting flags are used to define the way this conversion takes place. In this section all formatting flags are covered. Formatting flags may be (un)set using member functions, but often manipulators having the same effect may also be used. For each of the flags it is shown how they can be controlled by a member function or -if available- a manipulator. bf(To display information in wide fields): itemization( it() hi(internal)hi(adjustfield)tt(ios::internal): quote(to add i(fill characters) (blanks by default) between the minus sign of negative numbers and the value itself. Other values and data types are right-adjusted. Manipulator: tt(std::internal). Example: verb( cout.setf(ios::internal, ios::adjustfield); cout << internal; // same, using the manipulator cout << '\'' << setw(5) << -5 << "'\n"; // displays '- 5' ) ) ithtq(left)(ios::left) (to left-adjust values in fields that are wider than needed to display the values. Manipulator: tt(std::left). Example: verb( cout.setf(ios::left, ios::adjustfield); cout << left; // same, using the manipulator cout << '\'' << setw(5) << "hi" << "'\n"; // displays 'hi ' ) ) ithtq(right)(ios::right) (to right-adjust values in fields that are wider than needed to display the values. Manipulator: tt(std::right). This is the default. Example: verb( cout.setf(ios::right, ios::adjustfield); cout << right; // same, using the manipulator cout << '\'' << setw(5) << "hi" << "'\n"; // displays ' hi' ) ) ) bf(Using various number representations): itemization( ithtq(dec)(ios::dec) (to display integral values as decimal numbers. Manipulator: tt(std::dec). This is the default. Example: verb( cout.setf(ios::dec, ios::basefield); cout << dec; // same, using the manipulator cout << 0x10; // displays 16 ) ) ithtq(hex)(ios::hex) (to display integral values as hexadecimal numbers. Manipulator: tt(std::hex). Example: verb( cout.setf(ios::hex, ios::basefield); cout << hex; // same, using the manipulator cout << 16; // displays 10 ) ) ithtq(oct)(ios::oct) (to display integral values as octal numbers. Manipulator: tt(std::oct). Example: verb( cout.setf(ios::oct, ios::basefield); cout << oct; // same, using the manipulator cout << 16; // displays 20 ) ) ithtq(setbase)(std::setbase(int radix)) (This is a manipulator that can be used to change the number representation to decimal, hexadecimal or octal. Example: verb( cout << setbase(8); // octal numbers, use 10 for // decimal, 16 for hexadecimal cout << 16; // displays 20 ) ) ) bf(Fine-tuning displaying values): itemization( ithtq(boolalpha)(ios::boolalpha) (logical values may be displayed as text using the text `tt(true)' for the tt(true) logical value, and `tt(false)' for the tt(false) logical value using tt(boolalpha). By default this flag is not set. Complementary flag: tt(ios::noboolalpha). Manipulators: tt(std::boolalpha) and hi(noboolalpha)tt(std::noboolalpha). Example: verb( cout.setf(ios::boolalpha); cout << boolalpha; // same, using the manipulator cout << (1 == 1); // displays true ) ) ithtq(showbase)(ios::showbase) (to display the numeric base of integral values. With hexadecimal values the tt(0x) prefix is used, with octal values the prefix tt(0). For the (default) decimal value no particular prefix is used. Complementary flag: tt(ios::noshowbase). Manipulators: tt(std::showbase) and hi(noshowbase)tt(std::noshowbase). Example: verb( cout.setf(ios::showbase); cout << showbase; // same, using the manipulator cout << hex << 16; // displays 0x10 ) ) ithtq(showpos)(ios::showpos) (to display the tt(+) sign with positive decimal (only) values. Complementary flag:nl()tt(ios::noshowpos). Manipulators: tt(std::showpos) and hi(noshowpos)tt(std::noshowpos). Example: verb( cout.setf(ios::showpos); cout << showpos; // same, using the manipulator cout << 16; // displays +16 cout.unsetf(ios::showpos); // Undo showpos cout << 16; // displays 16 ) ) ithtq(uppercase)(ios::uppercase) (to display letters in hexadecimal values using capital letters. Complementary flag: tt(ios::nouppercase). Manipulators: tt(std::uppercase) and hi(nouppercase)tt(std::nouppercase). By default lower case letters are used. Example: verb( cout.setf(ios::uppercase); cout << uppercase; // same, using the manipulator cout << hex << showbase << 3735928559; // displays 0XDEADBEEF ) ) ) bf(Displaying floating point numbers) itemization( it()hi(fixed)hi(floatfield)hi(display floating point numbers) tt(ios::fixed): quote(to display real values using a fixed decimal point (e.g., 12.25 rather than 1.225e+01), the tt(fixed) formatting flag is used. It can be used to set a fixed number of digits behind the decimal point. Manipulator: tt(fixed). Example: verb( cout.setf(ios::fixed, ios::floatfield); cout.precision(3); // 3 digits behind the . // Alternatively: cout << setiosflags(ios::fixed) << setprecision(3); cout << 3.0 << " " << 3.01 << " " << 3.001 << '\n'; << 3.0004 << " " << 3.0005 << " " << 3.0006 << '\n' // Results in: // 3.000 3.010 3.001 // 3.000 3.001 3.001 ) The example shows that 3.0005 is rounded away from zero, becoming 3.001 (likewise -3.0005 becomes -3.001). First setting precision and then tt(fixed) has the same effect. ) ithtq(scientific)(ios::scientific) (to display real values in emi(scientific notation) (e.g., 1.24e+03). Manipulator: tt(std::scientific). Example: verb( cout.setf(ios::scientific, ios::floatfield); cout << scientific; // same, using the manipulator cout << 12.25; // displays 1.22500e+01 ) ) ithtq(showpoint)(ios::showpoint) (to display a trailing decimal point em(and) trailing decimal zeros when real numbers are displayed. Complementary flag: tt(ios::noshowpoint). Manipulators: tt(std::showpoint), hi(noshowpoint)tt(std::noshowpoint). Example: verb( cout << fixed << setprecision(3); // 3 digits behind . cout.setf(ios::showpoint); // set the flag cout << showpoint; // same, using the manipulator cout << 16.0 << ", " << 16.1 << ", " << 16; // displays: 16.000, 16.100, 16 ) Note that the final 16 is an integral rather than a floating point number, so it has no decimal point. So tt(showpoint) has no effect. If tt(ios::showpoint) is not active trailing zeros are discarded. If the fraction is zero the decimal point is discarded as well. Example: verb( cout.unsetf(ios::fixed, ios::showpoint); // unset the flags cout << 16.0 << ", " << 16.1; // displays: 16, 16.1 ) ) ) bf(Handling white space and flushing streams) itemization( ithtq(endl)(std::endl) (manipulator inserting a newline character and flushing the stream. Often flushing the stream is not required and doing so would needlessly slow down I/O processing. Consequently, using tt(endl) should be avoided (in favor of inserting tt('\n')) unless flusing the stream is explicitly intended. Note that streams are automatically flushed when the program terminates or when a stream is `tied' to another stream (cf. tt(tie) in section ref(IOS)). Example: verb( cout << "hello" << endl; // prefer: << '\n'; ) ) ithtq(ends)(std::ends) (manipulator inserting a 0-byte into a stream. It is usually used in combination with memory-streams (cf. section ref(OSTRINGSTREAM)). ) ithtq(flush)(std::flush) (a stream may be flushed using this member. Often flushing the stream is not required and doing so would needlessly slow down I/O processing. Consequently, using tt(flush) should be avoided unless it is explicitly required to do so. Note that streams are automatically flushed when the program terminates or when a stream is `tied' to another stream (cf. tt(tie) in section ref(IOS)). Example: verb( cout << "hello" << flush; // avoid if possible. ) ) ithtq(skipws)(ios::skipws) (leading i(white space) characters (blanks, tabs, newlines, etc.) are skipped when a value is extracted from a stream. This is the default. If the flag is not set, leading white space characters are not skipped. Manipulator: tt(std::skipws). Example: verb( cin.setf(ios::skipws); // to unset, use // cin.unsetf(ios::skipws) cin >> skipws; // same, using the manipulator int value; cin >> value; // skips initial blanks ) ) ithtq(unitbuf)(ios::unitbuf) (the stream for which this flag is set flushes its buffer after every output operation Often flushing a stream is not required and doing so would needlessly slow down I/O processing. Consequently, setting tt(unitbuf) should be avoided unless flusing the stream is explicitly intended. Note that streams are automatically flushed when the program terminates or when a stream is `tied' to another stream (cf. tt(tie) in section ref(IOS)). Complementary flag: tt(ios::nounitbuf). Manipulators: tt(std::unitbuf), hi(nounitbuf)tt(std::nounitbuf). Example: verb( cout.setf(ios::unitbuf); cout << unitbuf; // same, using the manipulator cout.write("xyz", 3); // flush follows write. ) ) ithtq(ws)(std::ws) (manipulator removing all i(white space) characters (blanks, tabs, newlines, etc.) at the current file position. White space are removed if present even if the flag tt(ios::noskipws) has been set. Example (assume the input contains 4 blank characters followed by the character tt(X)): verb( cin >> ws; // skip white space cin.get(); // returns 'X' ) ) ) c++-annotations-10.5.0/yo/iostreams/examples/0000755000175000017500000000000012636507651017752 5ustar frankfrankc++-annotations-10.5.0/yo/iostreams/examples/ioexceptions.cc0000644000175000017500000000077012636507652022777 0ustar frankfrank #include using namespace std; int main() { cout << "Enter a word, not a number: "; cin.exceptions(ios::failbit); int x; try { cin >> x; } catch(ios::failure failure) { cout << "Here's what: " << failure.what() << '\n'; } } /* Generated output: Enter a word, not a number: grandpa Here's what: basic_ios::clear(iostate) caused exception */ c++-annotations-10.5.0/yo/iostreams/examples/procbufout.OBS0000644000175000017500000000103512635354026022501 0ustar frankfrank #include #include #include int main() { procbuf pb; pb.open("sort -f", ios::out); ostream opb(&pb); string line; while (getline(cin, line)) { size_t pos; if ( line.length() == 0 || (pos = line.find_first_not_of(" \t")) != string::npos && line[pos] == '#' ) continue; opb << line << '\n'; } } c++-annotations-10.5.0/yo/iostreams/examples/readwrite2.cc0000644000175000017500000000277512636507652022345 0ustar frankfrank #include #include #include using namespace std; void err(char const *msg); // see earlier example void err(char const *msg, long value); void read(istream &index, istream &strings) { index.clear(); strings.clear(); // insert the body of the read() function of the earlier example } void write(ostream &index, ostream &strings) { index.clear(); strings.clear(); // insert the body of the write() function of the earlier example } int main() { ifstream index_in("index", ios::trunc | ios::in | ios::out); ifstream strings_in("strings", ios::trunc | ios::in | ios::out); ostream index_out(index_in.rdbuf()); ostream strings_out(strings_in.rdbuf()); cout << "enter `r ' to read line or " "w ' to write a line\n" "or enter `q' to quit.\n"; while (true) { cout << "r , w , q ? "; // show prompt string cmd; cin >> cmd; // read cmd if (cmd == "q") // process the cmd. return 0; if (cmd == "r") read(index_in, strings_in); else if (cmd == "w") write(index_out, strings_out); else cout << "Unknown command: " << cmd << '\n'; } } c++-annotations-10.5.0/yo/iostreams/examples/copycincout.cc0000644000175000017500000000027212636507652022622 0ustar frankfrank#include using namespace::std; int main() { while (true) { char c; cin.get(c); if (cin.fail()) break; cout << c; } } c++-annotations-10.5.0/yo/iostreams/examples/procbuf.OBS0000644000175000017500000000142012635354026021747 0ustar frankfrank#include #include #include int main(int argc, char **argv) { if (argc == 1) { procbuf p("gzip > out.gz", ios::out); ostream ostr(&p); for (int idx = 0; idx < 1000; ++idx) { double d = rand() / static_cast(rand()); ostr.write(&d, sizeof(d)); } } else { procbuf p("gunzip < out.gz", ios::in); istream istr(&p); double d; for (int idx = 0; idx < 1000; ++idx) { if (!(istr.read(&d, sizeof(d)))) { cout << "read stopped at " << idx << '\n'; return (1); } } } } c++-annotations-10.5.0/yo/iostreams/examples/cout.OBS0000644000175000017500000000060312635354026021263 0ustar frankfrank #include #define VP (int) // (void *) int main() { int value = 15, *p = &value; cout << "Value: " << value << "\n" << "via p: " << *p << "\n" << "value's address: " << VP &value << "\n" << "address via p: " << VP p << "\n" << "p's address: " << VP &p << "\n"; } c++-annotations-10.5.0/yo/iostreams/examples/copystreambuf.cc0000644000175000017500000000032412636507652023144 0ustar frankfrank #include using namespace std; int main() { cin.ignore(80, '\n'); // skip the first line and... cout << cin.rdbuf(); // copy the rest through the streambuf * } c++-annotations-10.5.0/yo/iostreams/examples/existingreadwrite.cc0000644000175000017500000000150212636507652024021 0ustar frankfrank #include #include #include using namespace std; int main() { fstream rw("fname", ios::out | ios::in); if (!rw) // file didn't exist yet { rw.clear(); // try again, creating it using ios::trunc rw.open("fname", ios::out | ios::trunc | ios::in); } if (!rw) // can't even create it: bail out { cerr << "Opening `fname' failed miserably" << '\n'; return 1; } cerr << "We're at: " << rw.tellp() << '\n'; // write something rw << "Hello world" << '\n'; rw.seekg(0); // go back and read what's written string s; getline(rw, s); cout << "Read: " << s << '\n'; } c++-annotations-10.5.0/yo/iostreams/examples/stdio.OBS0000644000175000017500000000071112635354026021433 0ustar frankfrank#include int main() { stdiobuf f = fopen("stdio.cc", "r"); // open this source to read cout << &f; // copy it to cout fprintf(cout.rdbuf(), "hello world\n"); // append `hello world', using // a C function. return 0; /* output produced: the contents of this file, and an extra line containing the text `hello world' */ } c++-annotations-10.5.0/yo/iostreams/examples/asciiz.cc0000644000175000017500000000201612636507652021543 0ustar frankfrank #include #include using namespace std; int main() { // r/w the file fstream f("hello", ios::in | ios::out | ios::trunc); f.write("hello", 6); // write 2 NTB strings f.write("hello", 6); f.seekg(0, ios::beg); // reset to begin of file char buffer[100]; // or: char *buffer = new char[100] char c; // read the first `hello' cout << f.get(buffer, sizeof(buffer), 0).tellg() << '\n'; f >> c; // read the NTB delim // and read the second `hello' cout << f.get(buffer + 6, sizeof(buffer) - 6, 0).tellg() << '\n'; buffer[5] = ' '; // change asciiz to ' ' cout << buffer << '\n'; // show 2 times `hello' } /* Generated output: 5 11 hello hello */ c++-annotations-10.5.0/yo/iostreams/examples/hello0000644000175000017500000000001412635354026020766 0ustar frankfrankhellohelloc++-annotations-10.5.0/yo/iostreams/examples/index0000644000175000017500000000000012635354026020765 0ustar frankfrankc++-annotations-10.5.0/yo/iostreams/examples/isopen.cc0000644000175000017500000000063012636507652021556 0ustar frankfrank #include #include using namespace std; int main() { ofstream of; cout << "of's open state: " << boolalpha << of.is_open() << '\n'; of.open("/dev/null"); // on Unix systems cout << "of's open state: " << of.is_open() << '\n'; } /* Generated output: of's open state: false of's open state: true */ c++-annotations-10.5.0/yo/iostreams/examples/redirection.cc0000644000175000017500000000235512636507652022576 0ustar frankfrank #include #include using namespace std; int main(int argc, char **argv) { ofstream errlog; // 1 streambuf *cerr_buffer = 0; // 2 if (argc == 2) { errlog.open(argv[1]); // 3 cerr_buffer = cerr.rdbuf(errlog.rdbuf()); // 4 } else { cerr << "Missing log filename\n"; return 1; } cerr << "Several messages to stderr, msg 1\n"; cerr << "Several messages to stderr, msg 2\n"; cout << "Now inspect the contents of " << argv[1] << "... [Enter] "; cin.get(); // 5 cerr << "Several messages to stderr, msg 3\n"; cerr.rdbuf(cerr_buffer); // 6 cerr << "Done\n"; // 7 } /* Generated output on file argv[1] at cin.get(): Several messages to stderr, msg 1 Several messages to stderr, msg 2 at the end of the program: Several messages to stderr, msg 1 Several messages to stderr, msg 2 Several messages to stderr, msg 3 */ c++-annotations-10.5.0/yo/iostreams/examples/coutprintf.cc0000644000175000017500000000051412636507652022457 0ustar frankfrank #include #include using namespace std; int main() { cout << "hel" << flush; printf("lo wo"); fflush(stdout); cout << "rld" << '\n'; } /* Generated output: hello world Without the flushes: helrld lo wo */ c++-annotations-10.5.0/yo/iostreams/examples/readdouble.cc0000644000175000017500000000042212636507652022366 0ustar frankfrank #include using namespace std; int main(int argc, char **argv) { ifstream in(argv[1]); double value; // reads double in raw, binary form from file. in.read(reinterpret_cast(&value), sizeof(double)); } c++-annotations-10.5.0/yo/iostreams/examples/procbufin.OBS0000644000175000017500000000077612635354026022313 0ustar frankfrank #include #include #include int main() { procbuf pb; pb.open("ls -Fla", ios::in); istream ipb(&pb); string line, dirs; cout << "Files:\n"; while (getline(ipb, line)) { if (line[0] == 'd') dirs += line + '\n'; else cout << line << '\n'; } cout << "Directories:\n" << dirs; } c++-annotations-10.5.0/yo/iostreams/examples/ostringstream.cc0000644000175000017500000000132612636507652023165 0ustar frankfrank #include #include using namespace std; int main() { ostringstream ostr("hello ", ios::ate); cout << ostr.str() << '\n'; ostr.setf(ios::showbase); ostr.setf(ios::hex, ios::basefield); ostr << 12345; cout << ostr.str() << '\n'; ostr << " -- "; ostr.unsetf(ios::hex); ostr << 12; cout << ostr.str() << '\n'; ostr.str("new text"); cout << ostr.str() << '\n'; ostr.seekp(4, ios::beg); ostr << "world"; cout << ostr.str() << '\n'; } /* Output from this program: hello hello 0x3039 hello 0x3039 -- 12 new text new world */ c++-annotations-10.5.0/yo/iostreams/examples/strings0000644000175000017500000000000012635354026021347 0ustar frankfrankc++-annotations-10.5.0/yo/iostreams/examples/readwrite.cc0000644000175000017500000000642212636507652022254 0ustar frankfrank #include #include #include #include using namespace std; void err(char const *msg) { cout << msg << '\n'; } void err(char const *msg, long value) { cout << msg << value << '\n'; } void read(fstream &index, fstream &strings) { int idx; if (!(cin >> idx)) // read index { cin.clear(); // allow reading again cin.ignore(INT_MAX, '\n'); // skip the line return err("line number expected"); } index.seekg(idx * sizeof(long)); // go to index-offset long offset; if ( !index.read // read the line-offset ( reinterpret_cast(&offset), sizeof(long) ) ) return err("no offset for line", idx); if (!strings.seekg(offset)) // go to the line's offset return err("can't get string offset ", offset); string line; if (!getline(strings, line)) // read the line return err("no line at ", offset); cout << "Got line: " << line << '\n'; // show the line } void write(fstream &index, fstream &strings) { string line; if (!getline(cin, line)) // read the line return err("line missing"); strings.seekp(0, ios::end); // to strings index.seekp(0, ios::end); // to index long offset = strings.tellp(); if ( !index.write // write the offset to index ( reinterpret_cast(&offset), sizeof(long) ) ) return err("Writing failed to index: ", offset); if (!(strings << line << '\n')) // write the line itself return err("Writing to `strings' failed"); // confirm writing the line cout << "Write at offset " << offset << " line: " << line << '\n'; } int main() { fstream index("index", ios::trunc | ios::in | ios::out); fstream strings("strings", ios::trunc | ios::in | ios::out); cout << "enter `r ' to read line or " "w ' to write a line\n" "or enter `q' to quit.\n"; while (true) { cout << "r , w , q ? "; // show prompt index.clear(); strings.clear(); string cmd; cin >> cmd; // read cmd if (cmd == "q") // process the cmd. return 0; if (cmd == "r") read(index, strings); else if (cmd == "w") write(index, strings); else if (cin.eof()) { cout << "\n" "Unexpected end-of-file\n"; return 1; } else cout << "Unknown command: " << cmd << '\n'; } } c++-annotations-10.5.0/yo/iostreams/examples/istringstream.cc0000644000175000017500000000132312636507652023154 0ustar frankfrank #include #include using namespace std; int main() { istringstream istr("123 345"); // store some text. int x; istr.seekg(2); // skip "12" istr >> x; // extract int cout << x << '\n'; // write it out istr.seekg(0); // retry from the beginning istr >> x; // extract int cout << x << '\n'; // write it out istr.str("666"); // store another text istr >> x; // extract it cout << x << '\n'; // write it out } /* output of this program: 3 123 666 */ c++-annotations-10.5.0/yo/iostreams/examples/opfstream.OBS0000644000175000017500000000077012635354026022316 0ustar frankfrank #include #include int main() { opfstream opb("|sort -f"); string line; while (getline(cin, line)) { int pos; if ( line.length() == 0 || (pos = line.find_first_not_of(" \t")) != string::npos && line[pos] == '#' ) continue; opb << line << '\n'; } } c++-annotations-10.5.0/yo/iostreams/examples/tiecerrcout.cc0000644000175000017500000000113612636507652022613 0ustar frankfrank #include using namespace std; int main() { cerr.tie(0); // untie cout << "first (buffered) line to cout "; cerr << "first (unbuffered) line to cerr\n"; cout << "\n"; cerr.tie(&cout); // tie cout to cerr cout << "second (buffered) line to cout "; cerr << "second (unbuffered) line to cerr\n"; cout << "\n"; } /* Generated output: first (unbuffered) line to cerr first (buffered) line to cout second (buffered) line to cout second (unbuffered) line to cerr */ c++-annotations-10.5.0/yo/iostreams/istreamseek.yo0000644000175000017500000000314112635354026021013 0ustar frankfrankAlthough not every tt(istream) object supports i(repositioning), some do. This means that it is possible to read the same section of a stream repeatedly. Repositioning is frequently used in emi(database applications) where it must be possible to access the information in the database randomly. The current position can be obtained and modified using the following members: itemization( ithtq(tellg)(ios::pos_type tellg()) (hi(pos_type)the stream's current (absolute) position where the stream's next read-operation will take place is returned.) ithtq(seekg) (istream &seekg(ios::off_type step, ios::seekdir org)) (modifies a stream's actual position. The function expects an ti(off_type) tt(step) representing the number of bytes the current stream position is moved with respect to tt(org). The tt(step) value may be negative, zero or positive. The origin of the step, tt(org) is a value in the hi(seekdir)tt(ios::seekdir) enumeration. Its values are: itemization( ithtq(beg)(ios::beg) (the stepsize is computed relative to the beginning of the stream. This value is used by default. ) ithtq(cur)(ios::cur) (the stepsize is computed relative to the current position of the stream (as returned by tt(tellp)). ) ithtq(end)(ios::end) (the stepsize is interpreted relative to the current end position of the the stream.) ) It is OK to hi(seek beyond file boundaries) seek beyond the last file position. Seeking before tt(ios::beg) raises the hi(failbit)tt(ios::failbit) flag. ) ) c++-annotations-10.5.0/yo/iostreams/ostreamflush.yo0000644000175000017500000000162212635354026021215 0ustar frankfrankUnless the tt(ios::unitbuf) flag has been set, information written to an tt(ostream) object is not immediately written to the physical stream. Rather, an internal buffer is filled during the write-operations, and when full it is flushed. The stream's i(internal buffer) can be flushed under program control: itemization( ithtq(flush)(ostream& flush()) (any buffered information stored internally by the tt(ostream) object is flushed to the device to which the tt(ostream) object interfaces. A stream is flushed automatically when: itemization( it() the object ceases to exist; it() the tt(endl) or tt(flush) em(manipulators) (see section ref(FORMATFLAGS)) are inserted into an tt(ostream) object; it() a stream supporting the ti(close)-operation is explicitly closed (e.g., a tt(std::ofstream) object, cf. section ref(OFSTREAM)). ) ) ) c++-annotations-10.5.0/yo/iostreams/ostringstream.yo0000644000175000017500000000410412635354026021400 0ustar frankfrankTo hi(stream: writing to memory) write information to memory using tt(stream) facilities, hi(ostringstream)tt(std::ostringstream) objects should be used. As the class tt(ostringstream) is derived from the class tt(ostream) all tt(ostream)'s facilities are available to tt(ostringstream) objects as well. To use and define tt(ostringstream) objects the header file tthi(sstream) must be included. In addition the class tt(ostringstream) offers the following constructors and members: itemization( ithtq(ostringstream) (ostringstream ostr(string const &init, ios::openmode mode = ios::out)) (when specifying tt(openmode) as tt(ios::ate), the tt(ostringstream) object is initialized by the tt(string init) and remaining insertions are appended to the contents of the tt(ostringstream) object. ) itt(ostringstream ostr(ios::openmode mode = ios::out)): quote(this constructor can also be used as default constructor. Alternatively it allows, e.g., forced additions at the end of the information stored in the object so far (using tt(ios::app)). Example: verb( std::ostringstream out; ) ) ithtq(str)(std::string str() const) (a copy of the string that is stored inside the tt(ostringstream) object is returned.) itt(void str(std::string const &str)): quote(the current object is reinitialized with new initial contents.) ) The following example illustrates the use of the tt(ostringstream) class: several values are inserted into the object. Then, the text contained by the tt(ostringstream) object is stored in a tt(std::string), whose length and contents are thereupon printed. Such tt(ostringstream) objects are most often used for doing `type to string'hi(conversions: binary to text) conversions, like converting tt(int) values to text. Formatting flags can be used with tt(ostringstreams) as well, as they are part of the tt(ostream) class. Here is an example showing an tt(ostringstream) object being used: verbinclude(-a examples/ostringstream.cc) c++-annotations-10.5.0/yo/iostreams/output.yo0000644000175000017500000000153612635354026020045 0ustar frankfrankIn bf(C++) output is primarily based on the hi(ostream)tt(std::ostream) class. The tt(ostream) class defines the basic operators and members inserting information into streams: the emi(insertion operator) (lshift()), and special members like tt(write) writing unformatted information to streams. The class tt(ostream) acts as em(base class) for several other classes, all offering the functionality of the tt(ostream) class, but adding their own specialties. In the upcoming sections the following classes are discussed: itemization( it() The class tt(ostream), offering the basic output facilities; it() The class ti(ofstream), allowing us to write files (comparable to bf(C)'s hi(fopen) tt(fopen(filename, "w"))); it() The class ti(ostringstream), allowing us to write information to memory (comparable to bf(C)'s ti(sprintf) function). ) c++-annotations-10.5.0/yo/iostreams/coupling.yo0000644000175000017500000000230312635354026020316 0ustar frankfrankOstream objects hi(ostream coupling) can be em(coupled) to ti(ios) objects using the ti(tie) member function. Tying results in flushing the tt(ostream)'s buffer whenever an i(input) or i(output) operation is performed on the tt(ios) object to which the tt(ostream) object is tied. By default ti(cout) is tied to ti(cin) (using tt(cin.tie(cout))). This tie means that whenever an operation on tt(cin) is requested, tt(cout) is flushed first. To break the tie, tt(ios::tie(0)) can be called. In the example: tt(cin.tie(0)). Another useful coupling of streams is shown by the tie between ti(cerr) and ti(cout). Because of the tie standard output and error messages written to the screen are shown in sync with the time at which they were generated: verbinclude(-a examples/tiecerrcout.cc) An alternative way to couple streams is to make streams use a common tt(streambuf) object. This can be implemented using the hi(rdbuf) tt(ios::rdbuf(streambuf *)) member function. This way two streams can use, e.g. their own formatting, one stream can be used for input, the other for output, and redirection using the stream library rather than operating system calls can be implemented. See the next sections for examples. c++-annotations-10.5.0/yo/iostreams/ofstream.yo0000644000175000017500000000632212635354026020323 0ustar frankfrankThe hi(ofstream)tt(std::ofstream) class is derived from the tt(ostream) class: it has the same capabilities as the tt(ostream) class, but can be used to i(access files) or i(create files) for writing. In order to use the tt(ofstream) class in bf(C++) sources, the tthi(fstream) header file must be included. Including tt(fstream) does not automatically make available the standard streams tt(cin), tt(cout) and tt(cerr). Include ti(iostream) to declare these standard streams. The following hi(ofstream constructors) constructors are available for tt(ofstream) objects: itemization( itt(ofstream object): quote(this is the basic constructor. It defines an tt(ofstream) object which may be associated with an actual file later, using its tt(open()) member (see below). ) itt(ofstream object(char const *name, ios::openmode mode = ios::out)): quote(this constructor defines an tt(ofstream) object and associates it immediately with the file named tt(name) using output mode tt(mode). Section ref(OUTPUTMODES) provides an overview of available output modes. Example: verb( ofstream out("/tmp/scratch"); ) ) ) It is not possible to open an tt(ofstream) using a emi(file descriptor). The reason for this is (apparently) that file descriptors are not universally available over different operating systems. Fortunately, file descriptors can be used (indirectly) with a tt(std::streambuf) object (and in some implementations: with a tt(std::filebuf) object, which is also a tt(streambuf)). tt(Streambuf) objects are discussed in section ref(STREAMBUF), tt(filebuf) objects are discussed in section ref(FILEBUF). Instead of directly associating an tt(ofstream) object with a file, the object can be constructed first, and opened later. itemization( ithtq(open)(void open(char const *name, ios::openmode mode = ios::out)) (associates an tt(ofstream) object with an actual file. If the tt(ios::fail) flag was set before calling tt(open) and opening succeeds the flag is cleared. Opening an already open stream fails. To reassociate a stream with another file it must first be closed: verb( ofstream out("/tmp/out"); out << "hello\n"; out.close(); // flushes and closes out out.open("/tmp/out2"); out << "world\n"; ) ) ithtq(close)(void close()) (closes the tt(ofstream) object. The function sets the ti(ios::fail) flag of the closed object. Closing the file flushes any buffered information to the associated file. A file is automatically closed when the associated tt(ofstream) object ceases to exist. ) ithtq(is_open)(bool is_open() const) (assume a stream was properly constructed, but it has not yet been attached to a file. E.g., the statement tt(ofstream ostr) was executed. When we now check its status through tt(good()), a non-zero (i.e., em(OK)) value is returned. The `good' status here indicates that the stream object has been constructed properly. It doesn't mean the file is also open. To test whether a stream is actually open, tt(is_open) should be called. If it returns ti(true), the stream is open. Example: verbinclude(-a examples/isopen.cc) ) ) c++-annotations-10.5.0/yo/iostreams/ostreamwrite.yo0000644000175000017500000000600112635354026021222 0ustar frankfrankThe class ti(ostream) supports both formatted and emi(binary output). The emi(insertion operator) (lshift()) is used to insert values in a type safe way into tt(ostream) objects. This is called i(formatted output), as binary values which are stored in the computer's memory are converted to human-readable i(ASCII) characters according to certain formatting rules. The insertion operator points to the tt(ostream) object to receive the information. The normal associativity of lshift() remains unaltered, so when a statement like verb( cout << "hello " << "world"; ) is encountered, the leftmost two operands are evaluated first (tt(cout) lshift() tt("hello ")), and an tt(ostream &) object, which is actually the same tt(cout) object, is returned. Now, the statement is reduced to verb( cout << "world"; ) and the second string is inserted into tt(cout). The lshift() operator has a lot of (overloaded) variants, so many types of variables can be inserted into tt(ostream) objects. There is an overloaded lshift()-operator expecting an tt(int), a tt(double), a pointer, etc. etc.. Each operator returns the tt(ostream) object into which the information so far has been inserted, and can thus immediately be followed by the next insertion. Streams lack facilities for formatted output like bf(C)'s ti(printf) and ti(vprintf) functions. Although it is not difficult to implement these facilities in the world of streams, tt(printf)-like functionality is hardly ever required in bf(C++) programs. Furthermore, as it is potentially type-em(unsafe), it might be better to avoid this functionality completely. When hi(binary file) binary files must be written, normally no text-formatting is used or required: an tt(int) value should be written as a series of raw bytes, not as a series of i(ASCII) numeric characters 0 to 9. The following member functions of tt(ostream) objects may be used to write `binary files': itemization( ithtq(put)(ostream& put(char c)) (to write a single character to the output stream. Since a character is a byte, this member function could also be used for writing a single character to a text-file.) ithtq(write)(ostream& write(char const *buffer, int length)) (to write at most tt(length) bytes, stored in the tt(char const *buffer) to the tt(ostream) object. Bytes are written as they are stored in the buffer, no formatting is done whatsoever. Note that the first argument is a tt(char const *): a em(type cast) is required to write any other type. For example, to write an tt(int) as an unformatted series of byte-values use: verb( int x; out.write(reinterpret_cast(&x), sizeof(int)); ) ) The bytes written by the above tt(write) call are written to the tt(ostream) in an order depending on the emi(endian)em(-ness) of the underlying hardware. Big-endian computers write the most significant byte(s) of multi-byte values first, little-endian computers first write the least significant byte(s). ) c++-annotations-10.5.0/yo/iostreams/readwrite.yo0000644000175000017500000001573612635354026020502 0ustar frankfrankIn order to both read and write to a stream hi(stream: read and write) an hi(fstream)tt(std::fstream) object must be created. As with tt(ifstream) and tt(ofstream) objects, its constructor receives the name of the file to be opened: verb( fstream inout("iofile", ios::in | ios::out);) Note the use of the constants hi(in)tt(ios::in) and hi(out)tt(ios::out), indicating that the file must be opened for both reading and writing. Multiple mode indicators may be used, concatenated by the tt(bitor) operator. Alternatively, instead of tt(ios::out), hi(app)tt(ios::app) could have been used and mere writing would become appending (at the end of the file). Reading and writing to the same file is always a bit awkward: what to do when the file may not yet exist, but if it already exists it should not be rewritten? Having fought with this problem for some time I now use the following approach: verbinclude(-a examples/existingreadwrite.cc) Under this approach if the first construction attempt fails tt(fname) doesn't exist yet. But then tt(open) can be attempted using the hi(trunc)tt(ios::trunc) flag. If the file already existed, the construction would have succeeded. By specifying hi(ate)tt(ios::ate) when defining tt(rw), the initial read/write action would by default have taken place at endOfFile(). Under hi(MS-WINDOWS) hi(DOS) bf(DOS)-like operating systems that use the multiple character sequence tt(\r\n) to separate lines in i(text files) the flag hi(binary)tt(ios::binary) is required to process i(binary file)s ensuring that tt(\r\n) combinations are processed as two characters. In general, tt(ios::binary) should be specified when binary (non-text) files are to be processed. By default files are opened as text files. i(Unix) operating systems do not distinguish text files from binary files. With tt(fstream) objects, combinations of file flags are used to make sure that a stream is or is not (re)created empty when opened. See section ref(OUTPUTMODES) for details. Once a file has been opened in read and write mode, the lshift() operator can be used to insert information into the file, while the rshift() operator may be used to extract information from the file. These operations may be performed in any order, but a tt(seekg) or tt(seekp) operation is required when switching between insertions and extractions. The seek operation is used to activate the stream's data used for reading or those used for writing (and em(vice versa)). The tt(istream) and tt(ostream) parts of tt(fstream) objects share the stream's data buffer and by performing the seek operation the stream either activates its tt(istream) or its tt(ostream) part. If the seek is omitted, reading after writing and writing after reading simply fails. The example shows a white space delimited word being read from a file, writing another string to the file, just beyond the point where the just read word terminated. Finally yet another string is read which is found just beyond the location where the just written strings ended: verb( fstream f("filename", ios::in | ios::out); string str; f >> str; // read the first word // write a well known text f.seekg(0, ios::cur); f << "hello world"; f.seekp(0, ios::cur); f >> str; // and read again ) Since a em(seek) or em(clear) operation is required when alternating between read and write (extraction and insertion) operations on the same file it is not possible to execute a series of lshift() and rshift() operations in one expression statement. Of course, random insertions and extractions are hardly ever used. Generally, insertions and extractions occur at well-known locations in a file. In those cases, the position where insertions or extractions are required can be controlled and monitored by the tt(seekg), tt(seekp, tellg) and tt(tellp) members (see sections ref(OSTREAMPOS) and ref(ISTREAMPOS)). Error conditions (see section ref(IOSTATES)) occurring due to, e.g., reading beyond end of file, reaching end of file, or positioning before begin of file, can be cleared by the tt(clear) member function. Following tt(clear) processing may continue. E.g., verb( fstream f("filename", ios::in | ios::out); string str; f.seekg(-10); // this fails, but... f.clear(); // processing f continues f >> str; // read the first word ) A situation where files are both read and written is seen in em(database) applications, using files consisting of records having fixed sizes, and where locations and sizes of pieces of information are known. For example, the following program adds text lines to a (possibly existing) file. It can also be used to retrieve a particular line, given its order-number in the file. A emi(binary file) tt(index) allows for the quick retrieval of the location of lines. verbinclude(-a examples/readwrite.cc) Another example showing reading em(and) writing of files is provided by the next program. It also illustrates the processing of NTB strings: verbinclude(-a examples/asciiz.cc) A completely different way to read and write streams may be implemented using tt(streambuf) members. All considerations mentioned so far remain valid (e.g., before a read operation following a write operation tt(seekg) must be used). When tt(streambuf) objects are used, either an tt(istream) is associated with the tt(streambuf) object of another tt(ostream) object, or an tt(ostream) object is associated with the tt(streambuf) object of another tt(istream) object. Here is the previous program again, now using hi(stream: associating) em(associated streams): verbinclude(-a examples/readwrite2.cc) In this example itemization( it() the streams associated with the tt(streambuf) objects of existing streams are not ti(ifstream) or ti(ofstream) objects but basic ti(istream) and ti(ostream) objects. it() The tt(streambuf) object is not defined by an tt(ifstream) or tt(ofstream) object. Instead it is defined outside of the streams, using a tt(filebuf) (cf. section ref(FILEBUF)) and constructions like: verb( filebuf fb("index", ios::in | ios::out | ios::trunc); istream index_in(&fb); ostream index_out(&fb); ) it() An tt(ifstream) object can be constructed using stream modes normally used with tt(ofstream) objects. Conversely, an tt(ofstream) objects can be constructed using stream modes normally used with tt(ifstream) objects. it() If tt(istream) and tt(ostreams) share a tt(streambuf), then their read and write pointers (should) point to the shared buffer: they are tightly coupled. it() The advantage of using an external (separate) tt(streambuf) over a predefined tt(fstream) object is (of course) that it opens the possibility of using tt(stream) objects with specialized tt(streambuf) objects. These tt(streambuf) objects may specifically be constructed to control and interface particular devices. Elaborating this (see also section ref(STREAMBUF)) is left as an exercise to the reader. ) c++-annotations-10.5.0/yo/iostreams/ifstream.yo0000644000175000017500000000551512635354026020320 0ustar frankfrankThe hi(ifstream)tt(std::ifstream) class is derived from the tt(istream) class: it has the same capabilities as the tt(istream) class, but can be used to i(access files) for reading. In order to use the tt(ifstream) class in bf(C++) sources, the tthi(fstream) header file must be included. Including tt(fstream) does not automatically make available the standard streams tt(cin), tt(cout) and tt(cerr). Include ti(iostream) to declare these standard streams. The following hi(ifstream constructors) constructors are available for tt(ifstream) objects: itemization( itt(ifstream object): quote(this is the basic constructor. It defines an tt(ifstream) object which may be associated with an actual file later, using its tt(open()) member (see below). ) itt(ifstream object(char const *name, ios::openmode mode = ios::in)): quote(this constructor can be used to define an tt(ifstream) object and associate it immediately with the file named tt(name) using input mode tt(mode). Section ref(OUTPUTMODES) provides an overview of available input modes. Example: verb( ifstream in("/tmp/input"); ) ) ) Instead of directly associating an tt(ifstream) object with a file, the object can be constructed first, and opened later. itemization( ithtq(open)(void open(char const *name, ios::openmode mode = ios::in)) (associates an tt(ifstream) object with an actual file. If the tt(ios::fail) flag was set before calling tt(open) and opening succeeds the flag is cleared. Opening an already open stream fails. To reassociate a stream with another file it must first be closed: verb( ifstream in("/tmp/in"); in >> variable; in.close(); // closes in in.open("/tmp/in2"); in >> anotherVariable; ) ) ithtq(close)(void close()) (closes the tt(ifstream) object. The function sets the ti(ios::fail) flag of the closed object. Closing the file flushes any buffered information to the associated file. A file is automatically closed when the associated tt(ifstream) object ceases to exist. ) ithtq(is_open)(bool is_open() const) (assume a stream was properly constructed, but it has not yet been attached to a file. E.g., the statement tt(ifstream ostr) was executed. When we now check its status through tt(good()), a non-zero (i.e., em(OK)) value is returned. The `good' status here indicates that the stream object has been constructed properly. It doesn't mean the file is also open. To test whether a stream is actually open, tt(is_open) should be called. If it returns ti(true), the stream is open. Also see the example in section ref(OFSTREAM). The following example illustrates reading from a binary file (see also section ref(ISTREAMREAD)): verbinclude(-a examples/readdouble.cc) ) ) c++-annotations-10.5.0/yo/iostreams/input.yo0000644000175000017500000000164612635354026017646 0ustar frankfrankIn bf(C++) i(input) is primarily based on the hi(istream)tt(std::istream) class. The tt(istream) class defines the basic operators and members extracting information from streams: the emi(extraction operator) (rshift()), and special members like tt(istream::read) reading unformatted information from streams. The class tt(istream) acts as em(base class) for several other classes, all offering the functionality of the tt(istream) class, but adding their own specialties. In the upcoming sections the following classes are discussed: itemization( it() The class tt(istream), offering the basic facilities for doing input; it() The class ti(ifstream), allowing us to read files (comparable to bf(C)'s hi(fopen) tt(fopen(filename, "r"))); it() The class ti(istringstream), allowing us to read information from text that is not stored on files (streams) but in memory (comparable to bf(C)'s ti(sscanf) function). ) c++-annotations-10.5.0/yo/iostreams/copying.yo0000644000175000017500000000422312635354026020151 0ustar frankfrankUsually, files are copied hi(file: copying) either by reading a source file character by character or line by line. The basic em(mold) to process streams hi(stream: processing) is as follows: itemization( it() Continuous loop: enumeration( eit() read from the stream eit() if reading did not succeed (i.e., tt(fail) returns tt(true)), tt(break) from the loop eit() process the information that was read ) ) Note that reading must em(precede) testing, as it is only possible to know after actually attempting to read from a file whether the reading succeeded or not. Of course, variations are possible: tt(getline(istream &, string &)) (see section ref(ISTREAMREAD)) returns an tt(istream &), so here reading and testing may be contracted using one expression. Nevertheless, the above mold represents the general case. So, the following program may be used to copy tt(cin) to tt(cout): verbinclude(-a examples/copycincout.cc) Contraction is possible here by combining tt(get) with the tt(if)-statement, resulting in: verb( if (!cin.get(c)) break; ) Even so, this would still follow the basic rule: `i(read first, test later)'. Simply copying a file isn't required very often. More often a situation is encountered where a file is processed up to a certain point, followed by plain copying the file's remaining information. The next program illustrates this. Using tt(ignore) to skip the first line (for the sake of the example it is assumed that the first line is at most 80 characters long), the second statement uses yet another overloaded version of the lshift()-operator, in which a ti(streambuf) pointer hi(inserting streambuf *) is inserted into a stream. As the member tt(rdbuf) returns a stream's tt(streambuf *), we have a simple means of inserting a stream's contents into an tt(ostream): verbinclude(-a examples/copystreambuf.cc) This way of copying streams only assumes the existence of a tt(streambuf) object. Consequently it can be used with all specializations of the tt(streambuf) class. c++-annotations-10.5.0/yo/iostreams/headers.yo0000644000175000017500000000373612635354026020124 0ustar frankfrank Several iostream related i(header file)s are available. Depending on the situation at hand, the following header files should be used: itemization( iti(iosfwd): sources should include this header file if only a declaration of the stream classes is required. For example, if a function defines a reference parameter to an tt(ostream) then the compiler does not need to know exactly what an tt(ostream) is. When declaring such a function the tt(ostream) class merely needs to be be declared. One cannot use verb( class std::ostream; // erroneous declaration void someFunction(std::ostream &str); ) but, instead, one should use: verb( #include // correctly declares class ostream void someFunction(std::ostream &str); ) ithi(ios): sources should include this header file when using types and facilites (like tt(ios::off_type), see below) defined in the tt(ios) class. ithi(streambuf): sources should include this header file when using tt(streambuf) or ti(filebuf) classes. See sections ref(STREAMBUF) and ref(FILEBUF). ithi(istream): sources should include this preprocessor directive when using the class tt(istream) or when using classes that do both input and output. See section ref(ISTREAM). ithi(ostream): sources should include this header file when using the class ti(ostream) class or when using classes that do both input and output. See section ref(OSTREAM). ithi(iostream): sources should include this header file when using the global stream objects (like ti(cin) and ti(cout)). ithi(fstream): sources should include this header file when using the file stream classes. See sections ref(OFSTREAM), ref(IFSTREAM), and ref(FSTREAM). ithi(sstream): sources should include this header file when using the string stream classes. See sections ref(OSTRINGSTREAM) and ref(ISTRINGSTREAM). ithi(iomanip): sources should include this header file when using parameterized manipulators. See section ref(IOFORMAT). ) c++-annotations-10.5.0/yo/iostreams/istream.yo0000644000175000017500000000167012635354026020150 0ustar frankfrankThe class ti(istream) defines basic input facilities. The ti(cin) object, is an tt(istream) object. All facilities related to input as defined by the tt(ios) class are also available in the tt(istream) class. We may define tt(istream) objects using the following emi(istream constructor): itemization( itt(istream object(streambuf *sb)): quote(this constructor can be used to construct a wrapper around an existing tt(std::streambuf) object. Similarly to tt(ostream) objects, tt(istream) objects may be defined by passing it initially hi(ostream: define using 0-pointer) a 0-pointer. See section ref(OSTREAM) for a discussion, see also section ref(STREAMINIT), and see chapter ref(CONCRETE) for examples. ) ) To define the tt(istream) class in bf(C++) sources, the tthi(istream) header file must be included. To use the predefined tt(istream) object ti(cin), the tthi(iostream) header file must be included. c++-annotations-10.5.0/yo/iostreams/outmodes.yo0000644000175000017500000000505212635354026020341 0ustar frankfrankThe following i(file modes) or i(file flags) are available when constructing or opening tt(ofstream) (or tt(istream), see section ref(IFSTREAM)) objects. The values are of type hi(openmode)tt(ios::openmode). Flags may be combined using the tt(bitor) operator. itemization( ithtq(app)(ios::app) (reposition the stream to its end before every output command (see also tt(ios::ate) below). The file is created if it doesn't yet exist. When opening a stream in this mode any existing contents of the file are kept.) ithtq(ate)(ios::ate) (start initially at the end of the file. Note that any existing contents are em(only) kept if some other flag tells the object to do so. For example tt(ofstream out("gone", ios::ate)) em(rewrites) the file tt(gone), because the implied tt(ios::out) causes the rewriting. If rewriting of an existing file should be prevented, the tt(ios::in) hi(in)hi(file rewriting: preventing) mode should be specified too. However, when tt(ios::in) is specified the file must already exist. The tt(ate) mode only initially positions the file at the end of file position. After that information may be written in the middle of the file using tt(seekp). When the tt(app) mode is used information is em(only) written at end of file (effectively ignoring tt(seekp) operations).) ithtq(binary)(ios::binary) (open a file in hi(file: binary mode)binary mode (used on systems distinguishing text- and binary files, like i(MS-Windows)). ) ithtq(in)(ios::in) (open the file for reading. The file must exist.) ithtq(out)(ios::out) (open the file for writing. Create it if it doesn't yet exist. If it exists, the i(file is rewritten).) ithtq(trunc)(ios::trunc) (start initially with an empty file. Any existing contents of the file are lost.) ) The following combinations of file flags have special meanings: verb( in | out: The stream may be read and written. However, the file must exist. in | out | trunc: The stream may be read and written. It is (re)created empty first. ) An interesting subtlety is that the tt(open) members of the tt(ifstream, ofstream) and tt(fstream) classes have a second parameter of type tt(ios::openmode). In contrast to this, the tt(bitor) operator returns an tt(int) when applied to two enum-values. The question why the tt(bitor) operator may nevertheless be used here is answered in a later chapter (cf. section ref(EnumOverload)). c++-annotations-10.5.0/yo/stl/0000755000175000017500000000000012635354026014723 5ustar frankfrankc++-annotations-10.5.0/yo/stl/uniquearrays.yo0000644000175000017500000000155612635354026020033 0ustar frankfrankWhen a tt(unique_ptr) is used to store arrays the dereferencing operator makes little sense but with arrays tt(unique_ptr) objects benefit from index operators. The distinction between a single object tt(unique_ptr) and a tt(unique_ptr) referring to a dynamically allocated array of objects is realized through a template specialization. With dynamically allocated arrays the following syntax is available: itemization( it() the index (tt([])) notation is used to specify that the smart pointer controls a dynamically allocated em(array). Example: verb( unique_ptr intArr(new int[3]); ) it() the index operator can be used to access the array's elements. Example: verb( intArr[2] = intArr[0]; ) ) In these cases the smart pointer's destructors call tt(delete[]) rather than tt(delete). c++-annotations-10.5.0/yo/stl/extremevalue.yo0000644000175000017500000000271412635354026020006 0ustar frankfrankThe ti(extreme_value_distribution) is related to the Weibull distribution and is used in statistical models where the variable of interest is the minimum of many random factors, all of which can take positive or negative values. It has two parameters: a location parameter tt(a) and scale parameter tt(b). See also nl() tlurl(http://www.itl.nist.gov/div898/handbook/apr/section1/apr163.htm) Defined types: verb( typedef RealType result_type; struct param_type { explicit param_type(RealType a = RealType(0), RealType b = RealType(1)); RealType a() const; // the location parameter RealType b() const; // the scale parameter }; ) Constructors and members: itemization( itt(extreme_value_distribution<>(RealType a = 0, RealType b = 1)) constructs an extreme value distribution with specified tt(a) and tt(b) parameters; itt(extreme_value_distribution<>(param_type const ¶m)) constructs an extreme value distribution according to the values stored in the tt(param) struct. itt(RealType a() const)nl() returns the distribution's location parameter; itt(RealType stddev() const)nl() returns the distribution's scale parameter; itt(result_type min() const)nl() returns the smallest positive value of tt(result_type); itt(result_type max() const)nl() returns the maximum value of tt(result_type); ) c++-annotations-10.5.0/yo/stl/charclass.yo0000644000175000017500000000322712635354026017243 0ustar frankfrankInside a character class all regular expression operators lose their special meanings, except for the special atoms tt(\s, \S, \d, \D, \w,) and tt(\W); the character range operator tt(-); the end of character class operator tt(]); and, at the beginning of the character class, tt(^). Except in combination with the special atoms the escape character is interpreted as a literal backslash character (to define a character class containing a backslash and a tt(d) simply use tt([d\])). To add a closing bracket to a character class use tt([]) immediately following the initial open-bracket, or start with tt([^]) for a negated character class not containing the closing bracket. Minus characters are used to define character ranges (e.g., tt([a-d]), defining tt([abcd])) (be advised that the actual range may depend on the locale being used). To add a literal minus character to a character class put it at the very beginning (tt([-), or tt([^-)) or at the very end (tt(-])) of a character class. Once a character class has started, all subsequent characters are added to the class's set of characters, until the final closing bracket (tt(])) has been reached. In addition to characters and ranges of characters, character classes may also contain em(predefined sets of character). They are: verb( [:alnum:] [:alpha:] [:blank:] [:cntrl:] [:digit:] [:graph:] [:lower:] [:print:] [:punct:] [:space:] [:upper:] [:xdigit:] ) These predefined sets designate sets of characters equivalent to the corresponding standard bf(C) tt(isXXX) function. For example, tt([:alnum:]) defines all characters for which bf(isalnum)(3) returns true. c++-annotations-10.5.0/yo/stl/istreamiterators.yo0000644000175000017500000000204512635354026020676 0ustar frankfrankThe hi(istream_iterator)tt(istream_iterator) can be used to define a set of iterators for hi(istream: iterator) tt(istream) objects. The general form of the tt(istream_iterator) iterator is: verb( istream_iterator identifier(istream &in) ) Here, tt(Type) is the type of the data elements read from the tt(istream) stream. It is used as the `begin' iterator in an interator range. tt(Type) may be any type for which oprshift() is defined in combination with tt(istream) objects. The default constructor is used as the end-iterator and corresponds to the i(end-of-stream). For example, verb( istream_iterator endOfStream; ) The em(stream) object that was specified when defining the begin-iterator is em(not) mentioned with the default constructor. Using tt(back_inserter) and tt(istream_iterator) adaptors, all strings from a stream can easily be stored in a container. Example (using i(anonymous) tt(istream_iterator) adaptors): verbinclude(-a examples/istreamiterator.cc) c++-annotations-10.5.0/yo/stl/uniformreal.yo0000644000175000017500000000242612635354026017623 0ustar frankfrankThe ti(uniform_real_distribution) can be used to select tt(RealType) values randomly from a range of uniformly distributed tt(RealType) values. It has two parameters, tt(a) and tt(b), specifying, respectively, the half-open range of values (rangett(a, b)) that can be returned by the distribution. Defined types: verb( typedef RealType result_type; struct param_type { explicit param_type(RealType a = 0, RealType b = max(RealType)); RealType a() const; RealType b() const; }; ) Constructors and members: itemization( itt(uniform_real_distribution<>(RealType a = 0, RealType b = max(RealType))) constructs a uniform_real distribution for the specified range of values. itt(uniform_real_distribution<>(param_type const ¶m)) constructs a uniform_real distribution according to the values stored in the tt(param) struct. itt(RealType a() const)nl() returns the distribution's tt(a) parameter; itt(RealType b() const)nl() returns the distribution's tt(b) parameter; itt(result_type min() const)nl() returns the distribution's tt(a) parameter; itt(result_type max() const)nl() returns the distribution's tt(b) parameter; ) c++-annotations-10.5.0/yo/stl/studentt.yo0000644000175000017500000000207412635354026017151 0ustar frankfrankThe ti(student_t_distribution) is a probability distribution that is used when estimating the mean of a normally distributed population from small sample sizes. It is characterized by one parameter: the degrees of freedom, which is equal to the sample size - 1. Defined types: verb( typedef RealType result_type; struct param_type { explicit param_type(RealType n = RealType(1)); RealType n() const; // The degrees of freedom }; ) Constructors and members: itemization( itt(student_t_distribution<>(RealType n = RealType(1))) constructs a student_t distribution with indicated degrees of freedom. itt(student_t_distribution<>(param_type const ¶m)) constructs a student_t distribution according to the values stored in the tt(param) struct. itt(RealType n() const)nl() returns the degrees of freedom; itt(result_type min() const)nl() returns 0; itt(result_type max() const)nl() returns the maximum value of tt(result_type); ) c++-annotations-10.5.0/yo/stl/istreambufiterators.yo0000644000175000017500000000226312635354026021375 0ustar frankfrankInput iterators are also available for ti(streambuf) objects. To read from tt(streambuf) objects supporting input operations hi(istreambuf_iterator)tt(istreambuf_iterators) can be used, supporting the operations that are also available for tt(istream_iterator). Different from the latter iterator type tt(istreambuf_iterators) support three constructors: itemization( ittq(istreambuf_iterator) (The end iterator of an iterator range is created using the default tt(istreambuf_iterator) constructor. It represents the i(end-of-stream) condition when extracting values of type tt(Type) from the tt(streambuf). ) ittq(istreambuf_iterator(streambuf *)) (A pointer to a tt(streambuf) may be used when defining an tt(istreambuf_iterator). It represents the begin iterator of an iterator range.) ittq(istreambuf_iterator(istream)) (An em(istream) may be also used when defining an tt(istreambuf_iterator). It accesses the tt(istream)'s tt(streambuf) and it also represents the begin iterator of an iterator range.) ) In section ref(OSTREAMBUFITER) an example is given using both tt(istreambuf_iterators) and tt(ostreambuf_iterators). c++-annotations-10.5.0/yo/stl/fig/0000755000175000017500000000000012635354026015470 5ustar frankfrankc++-annotations-10.5.0/yo/stl/fig/heap0000644000175000017500000000461212635354026016333 0ustar frankfrank#FIG 3.2 Landscape Center Metric Letter 100.00 Single -2 1200 2 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 450 2115 900 2115 900 2475 450 2475 450 2115 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 1395 2115 1845 2115 1845 2475 1395 2475 1395 2115 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 2250 2115 2700 2115 2700 2475 2250 2475 2250 2115 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 3150 2115 3600 2115 3600 2475 3150 2475 3150 2115 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 4050 2115 4500 2115 4500 2475 4050 2475 4050 2115 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 4050 1440 4500 1440 4500 1800 4050 1800 4050 1440 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 2700 1440 3150 1440 3150 1800 2700 1800 2700 1440 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 990 1440 1440 1440 1440 1800 990 1800 990 1440 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 1800 720 2250 720 2250 1080 1800 1080 1800 720 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 5175 1440 5625 1440 5625 1800 5175 1800 5175 1440 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 4590 720 5040 720 5040 1080 4590 1080 4590 720 2 2 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 5 3285 90 3735 90 3735 450 3285 450 3285 90 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 2025 720 2025 585 4815 585 4815 720 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 1215 1440 1215 1305 2925 1305 2925 1440 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 4230 1440 4230 1305 5400 1305 5400 1440 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 675 2115 675 1980 1620 1980 1620 2115 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 2475 2115 2475 1980 3420 1980 3420 2115 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 3510 585 3510 450 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 2025 1305 2025 1080 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 4815 1305 4815 1080 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 1170 1980 1170 1800 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 2925 1980 2925 1800 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 4275 2115 4275 1800 4 1 0 0 0 0 12 0.0000 4 135 180 3510 360 12\001 4 1 0 0 0 0 12 0.0000 4 135 180 2025 990 11\001 4 1 0 0 0 0 12 0.0000 4 135 180 4815 990 10\001 4 1 0 0 0 0 12 0.0000 4 135 90 1215 1710 8\001 4 1 0 0 0 0 12 0.0000 4 135 90 2925 1710 9\001 4 1 0 0 0 0 12 0.0000 4 135 90 4275 1710 7\001 4 1 0 0 0 0 12 0.0000 4 135 90 5400 1710 6\001 4 1 0 0 0 0 12 0.0000 4 135 90 675 2385 1\001 4 1 0 0 0 0 12 0.0000 4 135 90 1620 2385 2\001 4 1 0 0 0 0 12 0.0000 4 135 90 2475 2385 4\001 4 1 0 0 0 0 12 0.0000 4 135 90 3375 2385 3\001 4 1 0 0 0 0 12 0.0000 4 135 90 4275 2385 5\001 c++-annotations-10.5.0/yo/stl/statdist.yo0000644000175000017500000000341112635354026017132 0ustar frankfrank Before the statistical distributions and accompanying random number generators can be used the tthi(random) header file must be included. The STL offers several standard mathematical (statistical) distributions. These distributions allow programmers to obtain randomly selected values from a selected distribution. These statistical distributions need to be provided with a random number generating object. Several of such random number generating objects are provided, extending the traditional ti(rand) function that is part of the bf(C) standard library. These random number generating objects produce pseudo-random numbers, which are then processed by the statistical distribution to obtain values that are randomly selected from the specified distribution. Although the STL offers various statistical distributions their functionality is fairly limited. The distributions allow us to obtain a random number from these distributions, but i(probability density function)s or i(cumulative distribution function)s are currently not provided by the STL. These functions (distributions as well as the density and the cumulative distribution functions) are, however, available in other libraries, like the turl(boost math library)(http://www.boost.org/) (specifically:nl() lurl(http://www.boost.org/doc/libs/1_44_0/libs/math/doc/sf_and_dist/\ html/index.html)). It is beyond the scope of the annotations() to discuss the mathematical characteristics of the various statistical distributions. The interested reader is referred to the pertinent mathematical textbooks (like Stuart and Ord's (2009) hi(Stuart, A. & Ord, K) emi(Kendall's Advanced Theory of Statistics), Wiley) or to web-locations like lurl(http://en.wikipedia.org/wiki/Bernoulli_distribution). c++-annotations-10.5.0/yo/stl/regalg.yo0000644000175000017500000000400712635354026016536 0ustar frankfrankBefore using the functions presented in this section the tthi(regex) header file must be included. There are three major families of functions that can be used to match a target text against a regular expression. Each of these functions, as well as the tt(match_results::format) member, has a final tt(std::regex_constants::match_flag_type) parameter (see the next section), which is given the default value tt(regex_constants::match_default) which can be used to fine-tune the way the regular expression and the matching process is being used. This final parameter is not explicitly mentioned with the regular expression matching functions or with the tt(format) member. The three families of functions are: itemization( ithtq(regex_match)(bool std::regex_match(Parameters)) (This family of functions is used to match a regular expression against a target text. Only if the regular expression matches the full target text tt(true) is returned; otherwise tt(false) is returned. Refer to section ref(REGMATCH) for an overview of the available overloaded tt(regex_match) functions;) ithtq(regex_search)(bool std::regex_search(Parameters)) (This family of functions is also used to match a regular expression against a target text. This function returns true once the regular expression matches a sub-string of the target text; otherwise tt(false) is returned. See below for an overview of the available overloaded tt(regex_search) functions;) ithtq(regex_replace)(ReturnType std::regex_replace(Parameters)) (This family of functions is used to produce modified texts, using the characters of a target string, a tt(regex) object and a format string. This member closely resembles the functionality of the tt(match_results::format) member discussed in section ref(FORMAT).) ) The tt(match_results::format) member can be used after tt(regex_replace) and is discussed after covering tt(regex_replace) (section ref(FORMAT)). c++-annotations-10.5.0/yo/stl/sharedcasts.yo0000644000175000017500000000727712635354026017615 0ustar frankfrankBe cautious when using standard bf(C++) style casts in combination with tt(shared_ptr) objects. Consider the following two classes: verb( struct Base {}; struct Derived: public Base {}; ) As with tt(unique_ptr), when defining a tt(shared_ptr) to store a newly allocated tt(Derived) class object, the returned tt(Base *) may be cast to a tt(Derived *) using a tt(static_cast): polymorphism isn't required, and when resetting the tt(shared_ptr) or when the tt(shared_ptr) goes out of scope, no slicing occurs, and tt(Derived)'s destructor is called (cf. section ref(UNIQUEPTR)). Of course, a tt(shared_ptr) can easily be defined. Since a tt(Derived) object is also a tt(Base) object, a pointer to tt(Derived) can be considered a pointer to tt(Base) without using casts, but a tt(static_cast) could be used for force the interpretation of a tt(Derived *) to a tt(Base *): verb( Derived d; static_cast(&d); ) However, a plain tt(static_cast) cannot be used when initializing a shared pointer to a tt(Base) using the tt(get) member of a shared pointer to a tt(Derived) object. The following code snipped eventually results in an attempt to delete the dynamically allocated tt(Base) object twice: verb( shared_ptr sd(new Derived); shared_ptr sb(static_cast(sd.get())); ) Since tt(sd) and tt(sb) point at the same object tt(~Base) will be called for the same object when tt(sb) goes out of scope and when tt(sd) goes out of scope, resulting in premature termination of the program due to a emi(double free) error. These errors can be prevented using casts that were specifically designed for being used with tt(shared_ptrs). These casts use specialized constructors that create a tt(shared_ptr) pointing to memory but shares ownership (i.e., a reference count) with an existing tt(shared_ptr). These special casts are: itemization( ithtq(static_pointer_cast) (std::static_pointer_cast(std::shared_ptr ptr)) (A tt(shared_ptr) to a tt(Base) class object is returned. The returned tt(shared_ptr) refers to the base class portion of the tt(Derived) class to which the tt(shared_ptr ptr) refers. Example: verb( shared_ptr dp(new Derived()); shared_ptr bp = static_pointer_cast(dp); ) ) ithtq(const_pointer_cast) (std::const_pointer_cast(std::shared_ptr ptr)) (A tt(shared_ptr) to a tt(Class) class object is returned. The returned tt(shared_ptr) refers to a non-const tt(Class) object whereas the tt(ptr) argument refers to a tt(Class const) object. Example: verb( shared_ptr cp(new Derived()); shared_ptr ncp = const_pointer_cast(cp); ) ) ithtq(dynamic_pointer_cast) (std::dynamic_pointer_cast(std::shared_ptr ptr)) (A tt(shared_ptr) to a tt(Derived) class object is returned. The tt(Base) class must have at least one virtual member function, and the class tt(Derived), inheriting from tt(Base) may have overridden tt(Base)'s virtual member(s). The returned tt(shared_ptr) refers to a tt(Derived) class object if the dynamic cast from tt(Base *) to tt(Derived *) succeeded. If the dynamic cast did not succeed the tt(shared_ptr)'s tt(get) member returns 0. Example (assume tt(Derived) and tt(Derived2) were derived from tt(Base)): verb( shared_ptr bp(new Derived()); cout << dynamic_pointer_cast(bp).get() << ' ' << dynamic_pointer_cast(bp).get() << '\n'; ) The first tt(get) returns a non-0 pointer value, the second tt(get) returns 0. ) ) c++-annotations-10.5.0/yo/stl/iterators.yo0000644000175000017500000001541612635354026017317 0ustar frankfrankIn addition to the conceptual iterator types presented in this section the STL defines several adaptors hi(adaptor: object to iterator) allowing objects to be passed as iterators. These adaptors are presented in the upcoming sections. Before those adaptors can be used the tthi(iterator) header file must be included. Iterators are objects acting like pointers. Iterators have the following general hi(iterator) characteristics: itemization( it() Two iterators may be compared for (in)equality using the tt(==) and tt(!=) operators. The em(ordering) operators (e.g., tt(>), tt(<)) can usually not be used. it() Given an iterator tt(iter), tt(*iter) represents the object the iterator points to (alternatively, tt(iter->) can be used to reach the members of the object the iterator points to). it() tt(++iter) or tt(iter++) advances the iterator to the next element. The notion of advancing an iterator to the next element is consequently applied: several containers support emi(reversed_iterator) types, in which the tt(++iter) operation actually reaches a previous element in a sequence. it() em(Pointer arithmetic) may be used with iterators of containers storing their elements consecutively in memory like ti(vector) and ti(deque). For such containers tt(iter + 2) points to the second element beyond the one to which tt(iter) points. See also section ref(DISTANCE), covering ti(std::distance). it() Merely defining an iterator is comparable to having a 0-pointer. Example: verb( #include #include using namespace std; int main() { vector::iterator vi; cout << &*vi; // prints 0 } ) ) STL containers usually define members offering iterators (i.e., they define their own type ti(iterator)). These members are commonly called ti(begin) and ti(end) and (for reversed iterators (type tt(reverse_iterator))) ti(rbegin) and ti(rend). Standard practice requires hi(iterator: range) iterator ranges to be em(left inclusive). The notation rangeti(left, right) indicates that tt(left) is an iterator pointing to the first element, while tt(right) is an iterator pointing just em(beyond) the last element. The iterator range is em(empty) when tt(left == right). The following example shows how all elements of a vector of strings can be inserted into tt(cout) using its iterator ranges rangett(begin(), end()), and rangett(rbegin(), rend()). Note that the tt(for-loops) for both ranges are identical. Furthermore it nicely illustrates how the tt(auto) keyword can be used to define the type of the loop control variable instead of using a much more verbose variable definition like tt(vector::iterator) (see also section ref(AUTO)): verbinclude(-a examples/iterator.cc) Furthermore, the STL defines hi(iterator: to const elements)emi(const_iterator) types that must be used when visiting a series of elements in a constant container. Whereas the elements of the vector in the previous example could have been altered, the elements of the vector in the next example are immutable, and tt(const_iterator)s are required: verbinclude(-a examples/constiterator.cc) The examples also illustrates that plain hi(pointer as iterator) pointers can be used as iterators. The initialization tt(vector args(argv, argv + argc)) provides the tt(args) vector with a pair of pointer-based iterators: tt(argv) points to the first element to initialize tt(args) with, tt(argv + argc) points just beyond the last element to be used, tt(++argv) reaches the next command line argument. This is a general pointer characteristic, which is why they too can be used in situations where tt(iterators) are expected. The STL defines five types hi(iterator: types) of iterators. These iterator types are expected by generic algorithms, and in order to create a particular type of iterator yourself it is important to know their characteristics. In general, iterators hi(iterator: requirements) (see also section ref(ITERATORCONS)) must define: itemization( iti(operator==), testing two iterators for equality, iti(operator!=), testing two iterators for inequality, iti(operator++), incrementing the iterator, as prefix operator, iti(operator*), to access the element the iterator refers to, ) The following types of iterators are used when describing generic algorithms in chapter ref(GENERIC): itemization( it() bi(InputIterator)bf(s): quote(InputIterators are used to read from a container. The dereference operator is guaranteed to work as ti(rvalue) in expressions. Instead of an InputIterator it is also possible to use (see below) Forward-, Bidirectional- or RandomAccessIterators. Notations like ti(InputIterator1) and ti(InputIterator2) may be used as well. In these cases, numbers are used to indicate which iterators `belong together'. E.g., the generic algorithm link(tt(inner_product))(INNERPROD) has the following prototype: verb( Type inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, Type init); ) tt(InputIterator1 first1) and tt(InputIterator1 last1) define a pair of input iterators on one range, while tt(InputIterator2 first2) defines the beginning of another range. Analogous notations may be used with other iterator types.) it() bi(OutputIterator)bf(s): quote(OutputIterators can be used to write to a container. The dereference operator is guaranteed to work as an ti(lvalue) in expressions, but not necessarily as tt(rvalue). Instead of an OutputIterator it is also possible to use (see below) Forward-, Bidirectional- or RandomAccessIterators.) it() bi(ForwardIterator)bf(s): quote(ForwardIterators combine InputIterators and OutputIterators. They can be used to traverse containers in one direction, for reading and/or writing. Instead of a ForwardIterator it is also possible to use (see below) Bidirectional- or RandomAccessIterators.) it() bi(BidirectionalIterator)bf(s): quote(BidirectionalIterators can be used to traverse containers in both directions, for reading and writing. Instead of a BidirectionalIterator it is also possible to use (see below) a RandomAccessIterator.) it() bi(RandomAccessIterator)bf(s): quote(RandomAccessIterators provide i(random access) to container elements. An algorithm like link(tt(sort))(SORT) requires a RandomAccessIterator, and can therefore em(not) be used to sort the elements of lists or maps, which only provide BidirectionalIterators.) ) The example given with the RandomAccessIterator illustrates how to relate iterators and generic algorithms: look for the iterator that's required by the (generic) algorithm, and then see whether the datastructure supports the required type of iterator. If not, the algorithm cannot be used with the particular datastructure. c++-annotations-10.5.0/yo/stl/uniqueptr.yo0000644000175000017500000000765012635354026017340 0ustar frankfrankBefore using the tt(unique_ptr) class presented in this section the tthi(memory) header file must be included. When pointers are used to access dynamically allocated memory strict bookkeeping is required to prevent memory leaks. When a pointer variable referring to dynamically allocated memory goes out of scope, the dynamically allocated memory becomes inaccessible and the program suffers from a i(memory leak). To prevent such memory leaks strict bookkeeping is required: the programmer has to make sure that the dynamically allocated memory is returned to the common pool just before the pointer variable goes out of scope. When a pointer variable points to a dynamically allocated single value or object, bookkeeping requirements are greatly simplified when the pointer variable is defined as a tt(std::unique_ptr)hi(unique_ptr) object. Unique_ptrs are em(objects) masquerading as pointers. Since they are objects, their destructors are called when they go out of scope. Their destructors automatically delete the dynamically allocated memory. tt(Unique_ptrs) have some special characteristics: itemization( it() when assigning a tt(unique_ptr) to another em(move semantics) is used. If move semantics is not available compilation fails. On the other hand, if compilation succeeds then the used containers or generic algorithms support the use of tt(unique_ptr)s. Here is an example: verb( std::unique_ptr up1(new int); std::unique_ptr up2(up1); // compilation error ) The second definition fails to compile as tt(unique_ptr)'s copy constructor is private (the same holds true for the assignment operator). But the tt(unique_ptr) class em(does) offer facilities to initialize and assign from em(rvalue references): verb( class unique_ptr // interface partially shown { public: unique_ptr(unique_ptr &&other); // rvalues bind here private: unique_ptr(const unique_ptr &other); }; ) In the next example move semantics is used and so it compiles correctly: verb( unique_ptr cp(unique_ptr(new int)); ) it() a tt(unique_ptr) object should only point to memory that was made available dynamically, as only dynamically allocated memory can be deleted. it() multiple tt(unique_ptr) objects should not be allowed to point to the same block of dynamically allocated memory. The tt(unique_ptr)'s interface was designed to prevent this from happening. Once a tt(unique_ptr) object goes out of scope, it deletes the memory it points to, immediately changing any other object also pointing to the allocated memory into a hi(pointer: wild) wild pointer. it() When a class tt(Derived) is derived from tt(Base), then a newly allocated tt(Derived) class object can be assigned to a tt(unique_ptr), without having to define a virtual destructor for tt(Base). The tt(Base *) pointer that is returned by the tt(unique_ptr) object can simply be cast statically to tt(Derived), as shown in the following example: verb( class Base { ... }; class Derived: public Base { // assume Derived has a member void process() }; int main() { shared_ptr bp(new Derived); static_cast(bp)->process(); // OK! } // here ~Derived is called: no polymorphism required. ) ) The class tt(unique_ptr) offers several member functions to access the pointer itself or to have a tt(unique_ptr) point to another block of memory. These member functions (and tt(unique_ptr) constructors) are introduced in the next few sections. A tt(unique_ptr) (as well as a tt(shared_ptr), see section ref(SHAREDPTR)) can be used as a safe alternative to the now hi(auto_ptr: deprecated) deprecated tt(auto_ptr). tt(Unique_ptr) also augments tt(auto_ptr) as it can be used with containers and (generic) algorithms as it adds customizable deleters. Arrays can also be handled by tt(unique_ptrs). c++-annotations-10.5.0/yo/stl/negators.yo0000644000175000017500000001031612635354026017117 0ustar frankfrankem(Negators) hi(negators) are function adaptors converting the values returned by predicate function. Traditionally, matching tt(bind1st) and tt(bind2nd), two i(negator function) adaptors were predefined: ti(not1) is the negator to use with unary predicates, ti(not2) is the negator to with binary function objects. In specific situations they may still be usable in combination with the tt(bind) function template, but since tt(bind1st) and tt(bind2nd) will be deprecated in i(C++17), alternative implementations are being considered for tt(not1) and tt(not2) as well (see, e.g., lurl(https://isocpp.org/files/papers/n4076.html)). Since tt(not1) and tt(not2) are still part of the bf(C++) standard, their use is briefly illustrated here. An alternate implementation, suggesting how a future tt(not_fn) might be designed and how it can be used is provided in section ref(NOTFN). Here are some examples illustrating the use of tt(not1) and tt(not2): To count the number of elements in a vector of strings (tt(vs)) that are alphabetically ordered before a certain reference string (tt(target)) one of the following alternatives could be used: itemization( it() a i(binary predicate) directly performing the required comparison: verb( count_if(vs.begin(), vs.end(), bind2nd(less(), target)) ) or, using tt(bind): verb( count_if(vs.begin(), vs.end(), bind(less(), _1, target)); ) it() The comparison can be reversed, using the tt(not2) negator: verb( count_if(vs.begin(), vs.end(), bind2nd(not2(greater_equal()), target)); ) Here tt(not2) is used as it negates the truth value of tt(greater_equal's) truth value. tt(Not2) receives two arguments (one of tt(vs's) elements and tt(target)), passes them on to tt(greater_equal), and returns the negated return value of the called tt(greater_equal) function. In this example tt(bind) could also have been used: verb( count_if(vs.begin(), vs.end(), bind(not2(greater_equal()), _1, target)); ) it() tt(not1) in combination with the tt(bind2nd) predicate: here the arguments that are passed to tt(not1)'s function call operator (i.e., the elements of the tt(vs) vector) are passed on to tt(bind2nd)'s function call operator, which in turn calls tt(greater_equal), using tt(target) as its second argument. The value that is returned by tt(bind2nd)'s function call operator is then negated and subsequently returned as the return value of tt(not1's) function call operator: verb( count_if(vs.begin(), vs.end(), not1(bind2nd(greater_equal(), target))) ) When using tt(bind) in this example a compilation error results, which can be avoided using tt(not_fn) (section ref(NOTFN)). ) COMMENT( One may wonder which of these alternative approaches is the faster. Using the first approach, in which a directly available function object was used, two actions must be performed for each iteration by tt(count_if): itemization( it() The binder's tt(operator()) is called; it() The operation tt(<=) is performed. ) When the compiler uses inline as requested, only the second step is actually performed. Using the second approach, using the tt(not2) negator to negate the truth value of the complementary logical function object, three actions must be performed for each iteration by tt(count_if): itemization( it() The binder's tt(operator()) is called; it() The negator's tt(operator()) is called; it() The operation tt(>) is performed. ) When the compiler uses inline as requested, only the third step is actually performed. Using the third approach, using tt(not1) negator to negate the truth value of the binder, three actions must be performed for each iteration by tt(count_if): itemization( it() The negator's tt(operator()) is called; it() The binder's tt(operator()) is called; it() The operation tt(>) is performed. ) When the compiler uses inline as requested, only the third step is actually performed. With a commonly used optimization flag like tt(-O2) the compiler tries to grant inline requests. However, if the compiler ignores the inline requests the first variant will be faster. END) c++-annotations-10.5.0/yo/stl/ostreamiterators.yo0000644000175000017500000000226312635354026020706 0ustar frankfrankAn hi(ostream_iterator)tt(ostream_iterator) adaptor can be used to pass an tt(ostream) to algorithms expecting an OutputIterator. Two constructors are available for defining tt(ostream_iterators): verb( ostream_iterator identifier(ostream &outStream); ostream_iterator identifier(ostream &outStream, char const *delim); ) tt(Type) is the type of the data elements that should be inserted into an tt(ostream). It may be any type for which oplshift() is defined in combinations with tt(ostream) objects. The latter constructor can be used to separate the individual tt(Type) data elements by ti(delimiter) strings. The former constructor does not use any delimiters. The example shows how link(tt(istream_iterators))(ISTREAMITERATORS) and an tt(ostream_iterator) may be used to copy information of a file to another file. A subtlety here is that you probably want to use tt(in.unsetf(ios::skipws)). It is used to clear the hi(skipws)tt(ios::skipws) flag. As a consequence white space characters are simply returned by the operator, and the file is copied character by character. Here is the program: verbinclude(-a examples/ostreamiterator.cc) c++-annotations-10.5.0/yo/stl/lambdause.yo0000644000175000017500000001732112635354026017235 0ustar frankfrank Now that the syntax of lambda expressions have been covered let's see how they can be used in various situations. First we consider named lambda expressions. Named lambda expressions nicely fit in the niche of hi(function:local) hi(local function) local functions: when a function needs to perform computations which are at a conceptually lower level than the function's task itself, then it's attractive to encapsulate these computations in a separate support function and call the support function where needed. Although support functions can be defined in anonymous namespaces, that quickly becomes awkward when the requiring function is a class member and the support function also must access the class's members. In that case a named lambda expression can be used: it can be defined inside a requiring function, and it may be given full access to the surrounding class. The name to which the lambda expression is assigned becomes the name of a function which can be called from the surrounding function. Here is an example, converting a numeric IP address to a dotted decimal string, which can also be accessed directly from an tt(Dotted) object (all implementations in-class to conserve space): verb( class Dotted { std::string d_dotted; public: std::string const &dotted() const { return d_dotted; } std::string const &dotted(size_t ip) { auto octet = [](size_t idx, size_t numeric) { return to_string(numeric >> idx * 8 & 0xff); }; d_dotted = octet(3, ip) + '.' + octet(2, ip) + '.' + octet(1, ip) + '.' + octet(0, ip); return d_dotted; } }; ) Next we consider the use of generic algorithms, like the tt(for_each) (cf. section ref(FOREACH)): verb( void showSum(vector const &vi) { int total = 0; for_each( vi.begin(), vi.end(), [&](int x) { total += x; } ); std::cout << total << '\n'; } ) Here the variable tt(int total) is passed to the lambda expression by reference and is directly accessed by the function. Its parameter list merely defines an tt(int x), which is initialized in sequence by each of the values stored in tt(vi). Once the generic algorithm has completed tt(showSum)'s variable tt(total) has received a value that is equal to the sum of all the vector's values. It has outlived the lambda expression and its value is displayed. But although generic algorithms are extremely useful, there may not always be one that fits the task at hand. Furthermore, an algorithm like tt(for_each) looks a bit unwieldy, now that the language offers range-based for-loops. So let's try this, instead of the above implementation: verb( void showSum(vector const &vi) { int total = 0; for (auto el: vi) [&](int x) { total += x; }; std::cout << total << '\n'; } ) But when tt(showSum) is now called, its tt(cout) statement consistently reports 0. What's happening here? When a generic algorithm is given a lambda function, its implementation instantiates a reference to a function. that referenced function is thereupon called from within the generic algorithm. But, in the above example the range-based for-loop's nested statement merely represents the em(defintion) of a lamba function. Nothing is actually called, and hence tt(total) remains equal to 0. Thus, to make the above example work we not only must em(define) the lambda expression, but we must also em(call) the lambda function. We can do this by giving the lambda function a em(name), and then call the lamba function by its given name: verb( void showSum(vector const &vi) { int total = 0; for (auto el: vi) { auto lambda = [&](int x) { total += x; }; lambda(el); } std::cout << total << '\n'; } ) In fact, there is no need to give the lambda function a name: the tt(auto lambda) definition represents the lambda function, which could also directly be called. The syntax for doing this may look a bit weird, but there's nothing wrong with it, and it allows us to drop the compound statment, required in the last example, completely. Here goes: verb( void showSum(vector const &vi) { int total = 0; for (auto el: vi) [&](int x) { total += x; }(el); // immediately append the // argument list to the lambda // function's definition std::cout << total << '\n'; } ) lambda expressions can also be used to prevent spurious returns from tt(condition_variable's wait) calls (cf. section ref(CONDEX)). The class tt(condition_variable) allows us to do so by offering tt(wait) members expecting a lock em(and) a predicate. The predicate checks the data's state, and returns tt(true) if the data's state allows the data's processing. Here is an alternative implementation of the tt(down) member shown in section ref(CONDEX), checking for the data's actual availability: verb( void down() { unique_lock lock(sem_mutex); condition.wait(lock, [&]() { return semaphore != 0 } ); --semaphore; } ) The lambda expression ensures that tt(wait) only returns once tt(semaphore) has been incremented. Lambda expression are primarily used to obtain functors that are used in a very localized section of a program. Since they are used inside an existing function we should realize that once we use lambda functions multiple aggregation levels are mixed. Normally a function implements a task which can be described at its own aggregation level using just a few sentences. E.g., ``the function tt(std::sort) sorts a data structure by comparing its elements in a way that is appropriate to the context where tt(sort) is called''. By using an existing comparison method the aggregation level is kept, and the statement is clear by itself. E.g., verb( sort(data.begin(), data.end(), greater()); ) If an existing comparison method is not available, a tailor-made function object must be created. This could be realized using a lambda expression. E.g., verb( sort(data.begin(), data.end(), [&](DataType const &lhs, DataType const &rhs) { return lhs.greater(rhs); } ); ) Looking at the latter example, we should realize that here two different aggregation levels are mixed: at the top level the intent is to sort the elements in tt(data), but at the nested level (inside the lambda expression) something completely different happens. Inside the lambda expression we define how a the decision is made about which of the two objects is the greater. Code exhibiting such mixed aggregation levels is hard to read, and should be avoided. On the other hand: lambda expressions also simplify code because the overhead of defining a tailor-made functor is avoided. The advice, therefore, is to use lambda expressions sparingly. em(When) they are used make sure that their sizes remain small. As a i(rule of thumb): lambda expressions should be treated like in-line functions, and should merely consist of one, or maybe occasionally two expressions. c++-annotations-10.5.0/yo/stl/autoptr.yo0000644000175000017500000000201712635354026016772 0ustar frankfrankThis class is em(deprecated) and will most likely be removed in the upcoming i(C++17) standard. The smart pointer class hi(auto_ptr)tt(std::auto_ptr) has traditionally been offered by bf(C++). This class does not support emi(move semantics), but when an tt(auto_ptr) object is assigned to another, the right-hand object loses its information. The class tt(unique_ptr) does not have tt(auto_ptr)'s drawbacks and consequently using tt(auto_ptr) is now deprecated. tt(Auto_ptrs) suffer from the following drawbacks: itemization( it() they do not support em(move semantics); it() they should not be used to point to arrays; it() they cannot be used as data types of abstract containers. ) Because of its drawbacks and available replacements the tt(auto_ptr) class is no longer covered by the annotations(). Existing software should be modified to use smart pointers (tt(unique_ptrs) or tt(shared_ptrs)) and new software should, where applicable, directly be implemented in terms of these new smart pointer types. c++-annotations-10.5.0/yo/stl/insertiterators.yo0000644000175000017500000000616012635354026020540 0ustar frankfrankGeneric algorithms often require a target container into which the results of the algorithm are deposited. For example, the link(tt(copy))(COPY) generic algorithm has three parameters. The first two define the range of visited elements, the third defines the first position where the results of the copy operation should be stored. With the tt(copy) algorithm the number of elements to copy is usually available beforehand, since that number can usually be provided by pointer arithmetic. However, situations exist where pointer arithmetic cannot be used. Analogously, the number of resulting elements sometimes differs from the number of elements in the initial range. The generic algorithm link(tt(unique_copy))(UNIQUECP) is a case in point. Here the number of elements that are copied to the destination container is normally not known beforehand. In situations like these an emi(inserter) hi(adaptor: inserter) adaptor function can often be used to create elements in the destination container. There are three types of inserter adaptors: itemization( iti(back_inserter): calls the container's ti(push_back) member to add new elements at the end of the container. E.g., to copy all elements of tt(source) in reversed order to the back of tt(destination), using the link(tt(copy))(COPY) generic algorithm: verb( copy(source.rbegin(), source.rend(), back_inserter(destination)); ) iti(front_inserter) calls the container's ti(push_front) member, adding new elements at the beginning of the container. E.g., to copy all elements of tt(source) to the front of the destination container (thereby also reversing the order of the elements): verb( copy(source.begin(), source.end(), front_inserter(destination)); ) iti(inserter) calls the container's ti(insert) member adding new elements starting at a specified starting point. E.g., to copy all elements of tt(source) to the destination container, starting at the beginning of tt(destination), shifting up existing elements to beyond the newly inserted elements: verb( copy(source.begin(), source.end(), inserter(destination, destination.begin())); ) ) The inserter adaptors hi(adaptor: required typedefs) hi(inserter: required typedefs) require the existence of two tt(typedef)s: itemization( itt(typedef Data value_type), where tt(Data) is the data type stored in the class offering tt(push_back, push_front) or tt(insert) members (Example: tt(typedef std::string value_type)); itt(typedef value_type const &const_reference) ) Concentrating on tt(back_inserter), this iterator expects the name of a container supporting a member tt(push_back). The inserter's tt(operator()) member calls the container's tt(push_back) member. Objects hi(inserter: and non-STL classes) of any class supporting a tt(push_back) member can be passed as arguments to tt(back_inserter) provided the class adds verb( typedef DataType const &const_reference; ) to its interface (where tt(DataType const &) is the type of the parameter of the class's member tt(push_back)). Example: verbinclude(-a examples/backinserter.cc) c++-annotations-10.5.0/yo/stl/binders.yo0000644000175000017500000001537612635354026016736 0ustar frankfrankem(Binders) hi(binder) are function adaptors converting hi(binary function object) binary function objects to hi(unary function object) unary function objects. They do so by em(binding) one parameter of a binary function object to a constant value. For example, if the first parameter of the tt(minus) function object is bound to 100, then the resulting value is always equal to 100 minus the value of the function object's second argument. Originally two binder adapters (ti(bind1st) and ti(bind2nd)) binding, respectively, the first and the second argument of a binary function were defined. However, in the next i(C++17) standard tt(bind1st) and tt(bind2nd) are likely to be removed, as they are superseded by the more general tt(bind) binder. tt(Bind) itself is likely to become a deprecated function, as it can easily be replaced by (generic) em(lambda functions) (cf. section ref(LAMBDA)). As tt(bind1st) and tt(bind2nd) are still available, a short example showing their use (concentrating on tt(bind2nd)) is provided. A more elaborate example, using tt(bind) is shown next. Existing code should be modified so that either tt(bind) or a lambda function is used. Before using tt(bind) (or the namespace tt(std::placeholders), see below) the tthi(functional) header file must be included. Here is an example showing how to use tt(bind2nd) to count the number of strings that are equal to a string (tt(target)) in a vector of strings (tt(vs)) (it is assumed that the required headers and tt(using namespace std) have been specified): verb( count_if(vs.begin(), vs.end(), bind2nd(equal_to(), target)); ) In this example the function object tt(equal_to) is instantiated for strings, receiving tt(target) as its second argument, and each of the strings in tt(vs) are passed in sequence to its first argument. In this particular example, where equality is being determined, tt(bind1st) could also have been used. The tt(bind) adaptor expects a function as its first argument, and then any number of arguments that the function may need. Although an unspecified number of arguments may be specified when using tt(bind) it is not a variadic function the way the bf(C) programming language defines them. tt(Bind) is a em(variadic function template), which are covered in section ref(VARIADIC). By default tt(bind) returns the function that is specified as its first argument, receiving the remaining arguments that were passed to tt(bind) as its arguments. The function returned by tt(bind) may then be called. Depending on the way tt(bind) is called, calling the returned function may or may not required arguments. Here is an example: verb( int sub(int lhs, int rhs); // returns lhs - rhs bind(sub, 3, 4); // returns a function object whose // operator() returns sub(3, 4) ) Since tt(bind's) return value is a function object it can be called: verb( bind(sub, 3, 4)();) but more commonly tt(bind's) return value is assigned to a variable, which then represents the returned function object, as in: verb( auto functor = bind(sub, 3, 4); // define a variable for the functor cout << functor() << '\n'; // call the functor, returning -1. ) Instead of specifying the arguments when using tt(bind), emi(placeholders) (cf. section ref(PLACEHOLDERS)) can be specified. Explicit argument values must then be specified when the returned functor is called. Here are some examples: verb( using namespace placeholders; auto ftor1 = bind(sub, _1, 4); // 1st argument must be specified ftor1(10); // returns 10 - 4 = 6 auto ftor2 = bind(sub, 5, _1); // 2nd argument must be specified ftor2(10); // returns 5 - 10 = -5 auto ftor3 = bind(sub, _1, _2); // Both arguments must be specified ftor3(10, 2); // returns 10 - 2 = 8 auto ftor3 = bind(sub, _2, _1); // Both arguments must be specified ftor3(10, 2); // but in reversed order: returns // 2 - 10 = -8 ) Alternatively, the first argument can be the address of a member function. In that case, the first argument specifies the object for which the member function will be called, while the remaining arguments specify the arguments (if any) that are passed to the member function. Some examples: verb( struct Object // Object contains the lhs of a { // subtraction operation int d_lhs; Object(int lhs) : d_lhs(lhs) {} int sub(int rhs) // sub modifies d_lhs { return d_lhs -= rhs; } }; int main() { using namespace placeholders; Object obj(5); auto ftor = bind(&Object::sub, obj, 12); cout << ftor() << '\n'; // shows -7 cout << obj.d_x << '\n'; // obj not modified, bind uses a copy auto ftor = bind(&Object::sub, ref(obj), 12); cout << ftor() << '\n'; // shows -7 cout << obj.d_x << '\n'; // obj modified, cout shows -7 } ) Note the use of tt(ref) in the second tt(bind) call: here tt(obj) is passed by reference, forwarding tt(obj) itself, rather than its copy, to the tt(for2) functor. This is realized using a facility called em(perfect forwarding), which is discussed in detail in section ref(PERFECT). If the return type of the function that is called by the functor doesn't match its context (e.g., the functor is called in an expression where its return value is compared with a tt(size_t)) then the return type of the functor can easily be coerced into the appropriate type (of course, provided that the requested type conversion is possible). In those cases the requested return type can be specified between pointed brackets immediately following tt(bind). E.g., verb( auto ftor = bind(sub, _1, 4); // ftor's return type is size_t size_t target = 5; if (target < ftor(3)) // -1 becomes a large positive value cout << "smaller\n"; // and so 'smaller' is shown. ) Finally, the example given earlier, using tt(bind2nd) can be rewritten using tt(bind) like this: verb( using namespace placeholders; count_if(vs.begin(), vs.end(), bind(equal_to(), _1, target)); ) Here, tt(bind) returns a functor expecting one argument (represented by tt(_1)) and tt(count_if) will pass the strings in tt(vs) will in sequence to the functor returned by tt(bind). The second argument (tt(target)) is embedded inside the functor's implementation, where it is passed as second argument to the tt(equal_to()) function object. c++-annotations-10.5.0/yo/stl/uniquemembers.yo0000644000175000017500000000622712635354026020164 0ustar frankfrankThe class tt(unique_ptr) offers the following hi(unique_ptr: operators) operators: itemization( ithtq(operator=) (unique_ptr &operator=(unique_ptr &&tmp)) (This operator transfers the memory pointed to by the i(rvalue) tt(unique_ptr) object to the i(lvalue) tt(unique_ptr) object using em(move semantics). So, the rvalue object em(loses) the memory it pointed at and turns into a 0-pointer. An existing tt(unique_ptr) may be assigned to another tt(unique_ptr) by converting it to an rvalue reference first using hi(move)tt(std::move). Example: verb( unique_ptr ip1(new int); unique_ptr ip2; ip2 = std::move(ip1); ) ) ithtq(operator bool) (operator bool() const) (This operator returns tt(false) if the tt(unique_ptr) does not point to memory (i.e., its tt(get) member, see below, returns 0). Otherwise, tt(true) is returned.) ithtq(operator*)(Type &operator*()) (This operator returns a reference to the information accessible via a tt(unique_ptr) object . It acts like a normal pointer dereference operator.) ithtq(operator->)(Type *operator->()) (This operator returns a pointer to the information accessible via a tt(unique_ptr) object. This operator allows you to select members of an object accessible via a tt(unique_ptr) object. Example: verb( unique_ptr sp(new string("hello")); cout << sp->c_str(); ) ) ) The class tt(unique_ptr) supports the following hi(member function) member functions: itemization( ithtq(get)(Type *get()) (A pointer to the information controlled by the tt(unique_ptr) object is returned. It acts like tt(operator->). The returned pointer can be inspected. If it is zero the tt(unique_ptr) object does not point to any memory.) ithtq(get_deleter)(Deleter &unique_ptr::get_deleter()) (A reference to the deleter object used by the tt(unique_ptr) is returned.) ithtq(release)(Type *release()) (A pointer to the information accessible via a tt(unique_ptr) object is returned. At the same time the object itself becomes a 0-pointer (i.e., its pointer data member is turned into a 0-pointer). This member can be used to transfer the information accessible via a tt(unique_ptr) object to a plain tt(Type) pointer. After calling this member the proper destruction of the dynamically allocated memory is the i(responsibility of the programmer).) ithtq(reset)(void reset(Type *)) (The dynamically allocated memory controlled by the tt(unique_ptr) object is returned to the common pool; the object thereupon controls the memory to which the argument that is passed to the function points. It can also be called without argument, turning the object into a 0-pointer. This member function can be used to assign a new block of dynamically allocated memory to a tt(unique_ptr) object.) ithtq(swap)(void swap(unique_ptr &)) (Two identically typed tt(unique_ptrs) are swapped.) ) c++-annotations-10.5.0/yo/stl/binomial.yo0000644000175000017500000000243312635354026017070 0ustar frankfrankThe ti(binomial_distribution) is used to determine the probability of the number of successes in a sequence of tt(n) independent success/failure experiments, each of which yields success with probability tt(p). The template type parameter tt(IntType) defines the type of the generated random value, which must be an integral type. Defined types: verb( typedef IntType result_type; struct param_type { explicit param_type(IntType trials, double prob = 0.5); IntType t() const; // returns trials double p() const; // returns prob }; ) Constructors and members and example: itemization( itt(binomial_distribution<>(IntType trials = 1, double prob = 0.5)) constructs a binomial distribution for tt(trials) experiments, each having probability tt(prob) of success. itt(binomial_distribution<>(param_type const ¶m)) constructs a binomial distribution according to the values stored in the tt(param) struct. itt(IntType t() const)nl() returns tt(trials); itt(double p() const)nl() returns tt(prob); itt(result_type min() const) nl() returns 0; itt(result_type max() const)nl() returns tt(trials); ) c++-annotations-10.5.0/yo/stl/chisquared.yo0000644000175000017500000000267312635354026017434 0ustar frankfrankThe ti(chi_squared_distribution) with tt(n) degrees of freedom is the distribution of a sum of the squares of tt(n) independent standard normal random variables. Note that even though the distribution's parameter tt(n) usually is an integral value, it doesn't have to be integral, as the chi_squared distribution is defined in terms of functions (tt(exp) and tt(Gamma)) that take real arguments (see, e.g., the formula shown in the tt() header file, provided with the Gnu tt(g++) compiler distribution). The chi-squared distribution is used, e.g., when testing the goodness of fit of an observed distribution to a theoretical one. Defined types: verb( typedef RealType result_type; struct param_type { explicit param_type(RealType n = RealType(1)); RealType n() const; }; ) Constructors and members: itemization( itt(chi_squared_distribution<>(RealType n = 1)) constructs a chi_squared distribution with specified number of degrees of freedom. itt(chi_squared_distribution<>(param_type const ¶m)) constructs a chi_squared distribution according to the value stored in the tt(param) struct; itt(IntType n() const)nl() returns the distribution's degrees of freedom; itt(result_type min() const)nl() returns 0; itt(result_type max() const)nl() returns the maximum value of tt(result_type); ) c++-annotations-10.5.0/yo/stl/statistical.yo0000644000175000017500000000654312635354026017630 0ustar frankfrankIn the following sections the various statistical distributions that are supported by bf(C++) are covered. The notation ti(RNG) is used to indicate a em(Random Number Generator) and ti(URNG) is used to indicate a em(Uniform Random Number Generator). With each distribution a tt(struct param_type) is defined containing the distribution's parameters. The organization of these tt(param_type) structs depends on (and is described at) the actual distribution. All distributions offer the following members (em(result_type) refers to the type name of the values returned by the distribution): itemization( itt(result_type max() const)nl() returns the distribution's least upper bound; itt(result_type min() const)nl() returns the distribution's greatest lower bound; itt(param_type param() const)nl() returns the object's tt(param_type) struct; itt(void param(const param_type ¶m)) redefines the parameters of the distribution; itt(void reset():) clears all of its cached values; ) All distributions support the following operators (em(distribution-name) should be replaced by the name of the intended distribution, e.g., tt(normal_distribution)): itemization( itt(template result_type operator()(URNG &urng))nl() returns the next random value from the statistical distribution, with the function object tt(urng) returning the next random number selected from a uniform random distribution; itt(template result_type operator())nl() tt((URNG &urng, param_type ¶m))nl() returns the next random value from the statistical distribution initialized with the parameters provided by the tt(param) struct. The function object tt(urng) returns the next random number selected from a uniform random distribution; itt(std::istream &operator>>(std::istream &in, distribution-name &object):) The parameters of the distribution are extracted from an tt(std::istream); itt(std::ostream &operator<<(std::ostream &out, distribution-name const &bd):) The parameters of the distribution are inserted into an tt(std::ostream) ) The following example shows how the distributions can be used. Replacing the name of the distribution (tt(normal_distribution)) by another distribution's name is all that is required to switch distributions. All distributions have parameters, like the mean and standard deviation of the normal distribution, and all parameters have default values. The names of the parameters vary over distributions and are mentioned below at the individual distributions. Distributions offer members returning or setting their parameters. Most distributions are defined as class templates, requiring the specification of a data type that is used for the function's return type. If so, an empty template parameter type specification (tt(<>)) will get you the default type. The default types are either tt(double) (for real valued return types) or tt(int) (for integral valued return types). The template parameter type specification must be omitted with distributions that are not defined as template classes. Here is an example showing the use of the statistical distributions, applied to the normal distribution: verbinclude(-a examples/normal.cc) c++-annotations-10.5.0/yo/stl/poisson.yo0000644000175000017500000000236112635354026016770 0ustar frankfrankThe ti(poisson_distribution) is used to model the probability of a number of events occurring in a fixed period of time if these events occur with a known probability and independently of the time since the last event. It has one parameter, tt(mean), specifying the expected number of events in the interval under consideration. E.g., if on average 2 events are observed in a one-minute interval and the duration of the interval under study is 10 minutes then tt(mean = 20). Defined types: verb( typedef IntType result_type; struct param_type { explicit param_type(double mean = 1.0); double mean() const; }; ) Constructors and members: itemization( itt(poisson_distribution<>(double mean = 1)) constructs a poisson distribution with specified tt(mean) parameter. itt(poisson_distribution<>(param_type const ¶m)) constructs a poisson distribution according to the values stored in the tt(param) struct. itt(double mean() const)nl() returns the distribution's tt(mean) parameter; itt(result_type min() const)nl() returns 0; itt(result_type max() const)nl() returns the maximum value of tt(result_type); ) c++-annotations-10.5.0/yo/stl/lambdac14.yo0000644000175000017500000000547712635354026017041 0ustar frankfrankcXIV() further generalizes lambda expressions by introducing emi(generic lambda) expressions. A generic lambda expression uses tt(auto) to define its parameters. When used, an appropriate lambda expression is created by looking at the actual types of arguments. Since they are generic, they can be used inside one function with different types of arguments. Here is an example (assuming all required headers and namespace declaration): verbinclude(-ns4 //code examples/genlambda.cc) The generic lambda function is defined in lines 3 through 6, and is assigned to the tt(lambda) identifier. Then, tt(lambda) is passed to tt(accumulate) in lines 12 and 13. In line 12 it is instantiated to add tt(int) values, in line 13 to add tt(std::string) values: the same tt(lambda) is instantiated to two completely different functors, which are only locally available in tt(main). As a prelude to our coverage of templates (in particular chapter ref(TEMPLATES)), a generic lambda expression is equivalent to a class template. To illustrate: the above example of a generalized lambda function could also be implemented using a class template like this: verb( struct Lambda { template auto operator()(LHS const &lhs, RHS const &rhs) const { return lhs + rhs; } }; auto lambda = Lambda{}; ) One of the consequences of this identity is that using tt(auto) in the lambda expression's parameterlist is obeys the rules of template argument deduction (cf. section ref(TEMPFUNARGS)), which are somewhat different from the way tt(auto) normally operates. Another extension introduced by the C++14 standard is how lambda expressions capture outer scope variables. C++11 uses capture by either value or reference. A consequence of this is that an outer scope variable of a type that only supports move construction cannot be passed by value to a lambda function. This restriction is lifted by the C++14 standard, allowing variables to be initialized from arbitrary expressions. This not only allows move-initialization of variables in the lambda introducer, but variables may also be initialized here that do not have a correspondingly named variable in the lambda expression's outer scope. Initializer expressions can be used in this case like so: verb( auto fun = [value = 1] { return value; }; ) This lambda function (of course) returns 1: the declared capture deduces the type from the initializer expression as if tt(auto) had been used. To use move-initialization tt(std::move) should be used. E.g., verb( std::unique_ptr ptr(new int(10)); auto fun = [value = std::move(ptr)] { return *value; }; ) c++-annotations-10.5.0/yo/stl/adaptors.yo0000644000175000017500000000062312635354026017112 0ustar frankfrankFunction adaptors modify the working of existing function objects. The STL offers three kinds of hi(function adaptor) function adaptors: binders, negators and member function wrappers. Binders and negators are described in the next two subsections; member function adaptors are covered in section ref(MEMFUNADAPT) of the next chapter, which is a more natural point of coverage than the current chapter. c++-annotations-10.5.0/yo/stl/uniformint.yo0000644000175000017500000000236412635354026017473 0ustar frankfrankThe ti(uniform_int_distribution) can be used to select integral values randomly from a range of uniformly distributed integral values. It has two parameters, tt(a) and tt(b), specifying, respectively, the lowest value that can be returned and the highest value that can be returned. Defined types: verb( typedef IntType result_type; struct param_type { explicit param_type(IntType a = 0, IntType b = max(IntType)); IntType a() const; IntType b() const; }; ) Constructors and members: itemization( itt(uniform_int_distribution<>(IntType a = 0, IntType b = max(IntType))) constructs a uniform_int distribution for the specified range of values. itt(uniform_int_distribution<>(param_type const ¶m)) constructs a uniform_int distribution according to the values stored in the tt(param) struct. itt(IntType a() const)nl() returns the distribution's tt(a) parameter; itt(IntType b() const)nl() returns the distribution's tt(b) parameter; itt(result_type min() const)nl() returns the distribution's tt(a) parameter; itt(result_type max() const)nl() returns the distribution's tt(b) parameter; ) c++-annotations-10.5.0/yo/stl/definingshared.yo0000644000175000017500000000402512635354026020247 0ustar frankfrankThere are four ways to hi(shared_ptr: defining) define tt(shared_ptr) objects. Each definition contains the usual tt() specifier between angle brackets: itemization( it() The default constructor simply creates a tt(shared_ptr) object that does not point to a particular block of memory. Its pointer is initialized to 0 (zero): verb( shared_ptr identifier; ) This form is discussed in section ref(SHAREDPLAIN). it() The copy constructor initializes a tt(shared_ptr) so that both objects share the memory pointed at by the existing object. The copy constructor also increments the tt(shared_ptr)'s reference count. Example: verb( shared_ptr org(new string("hi there")); shared_ptr copy(org); // reference count now 2 ) it() The move constructor initializes a tt(shared_ptr) with the pointer and reference count of a temporary tt(shared_ptr). The temporary tt(shared_ptr) is changed into a 0-pointer. An existing tt(shared_ptr) may have its data moved to a newly defined tt(shared_ptr) (turning the existing tt(shared_ptr) into a 0-pointer as well). In the next example a temporary, anonymous tt(shared_ptr) object is constructed, which is then used to construct tt(grabber). Since tt(grabber)'s constructor receives an anonymous temporary object, the compiler uses tt(shared_ptr)'s move constructor: verb( shared_ptr grabber(shared_ptr(new string("hi there"))); ) it() The form that is used most often initializes a tt(shared_ptr) object to the block of dynamically allocated memory that is passed to the object's constructor. Optionally ti(deleter) can be provided. A (free) function (or function object) receiving the tt(shared_ptr)'s pointer as its argument can be passed as deleter. It is supposed to return the dynamically allocated memory to the common pool (doing nothing if the pointer equals zero). verb( shared_ptr identifier (new-expression [, deleter]); ) This form is discussed in section ref(SHAREDNEW). ) c++-annotations-10.5.0/yo/stl/intro.yo0000644000175000017500000000353212635354026016432 0ustar frankfrankThe ti(Standard Template Library) (i(STL)) is a general purpose library consisting of containers, generic algorithms, iterators, function objects, allocators, adaptors and data structures. The data structures used by the algorithms are em(abstract) in the sense that the algorithms can be used with (practically) any data type. The algorithms can process these abstract data types because they are emi(template) based. This chapter does not cover template em(construction) (see chapter ref(TEMPLATES) for that). Rather, it focuses on the em(use) of the algorithms. Several elements also used by the standard template library have already been discussed in the annotations(). In chapter ref(CONTAINERS) abstract containers were discussed, and in section ref(FUNOBJ) function objects were introduced. Also, em(iterators) were mentioned at several places in this document. The main components of the STL are covered in this and the next chapter. Iterators, adaptors, smart pointers, multi threading and other features of the STL are discussed in coming sections. Generic algorithms are covered in the next chapter (ref(GENERIC)). em(Allocators) take care of the memory allocation within the STL. The default i(allocator class) suffices for most applications, and is not further discussed in the annotations(). All elements of the STL hi(standard namespace: and STL) are defined in the standard namespace. Therefore, a tt(using namespace std) or a comparable directive is required unless it is preferred to specify the required namespace explicitly. In header files the tt(std) namespace should explicitly be used (cf. section ref(NAMESPACEHDR)). In this chapter the empty i(angle bracket notation) is frequently used. In code a typename must be supplied between the angle brackets. E.g., tt(plus<>) is used in the annotations(), but in code tt(plus) may be encountered. c++-annotations-10.5.0/yo/stl/randomnumber.yo0000644000175000017500000000526412635354026017774 0ustar frankfrankThe following hi(generator: random number)generators are available: center( table(5)(lllll)( rowline() rowfive(Class template)(Integral/Floating point)(Quality)(Speed)(Size of state) rowline() rowfive(ti(linear_congruential_engine))(Integral)(Medium)(Medium)(1) rowfive(ti(subtract_with_carry_engine))(Both)(Medium)(Fast)(25) rowfive(mersenne_twister_engine)(Integral)(Good)(Fast)(624) rowline() )) The ti(linear_congruential_engine) random number generator computes center(tt(value)+subs(i+1)tt( = OPENPAa * value)subs(i)tt( + c+CLOSEPAR % m)) It expects template arguments for, respectively, the data type to contain the generated random values; the multiplier tt(a); the additive constant tt(c); and the modulo value tt(m). Example: verb( linear_congruential_engine lincon; ) The tt(linear_congruential) generator may be seeded by providing its constructor with a seeding-argument. E.g., tt(lincon(time(0))). The ti(subtract_with_carry_engine) random number generator computes center(tt(value)+subs(i)tt( = OPENPARvalue)+subs(i-s)tt( - value)+subs(i-r)\ tt( - carry)+subs(i-1)tt(CLOSEPAR % m)) It expects template arguments for, respectively, the data type to contain the generated random values; the modulo value tt(m); and the subtractive constants tt(s) and tt(r). Example: verb( subtract_with_carry_engine subcar; ) The tt(subtract_with_carry_engine) generator may be seeded by providing its constructor with a seeding-argument. E.g., tt(subcar(time(0))). The predefined tt(mersenne_twister_engine mt19937) (predefined using a tt(typedef) defined by the tthi(random) header file) is used in the examples below. It can be constructed using hi(mt19937)`tt(mt19937 mt)' or it can be seeded by providing its constructor with an argument (e.g., tt(mt19937 mt(time(0)))). Other ways to initialize the tt(mersenne_twister_engine) are beyond the scope of the annotations() (but see Lewis+hi(Lewis, P.A.W.) em(et al.)footnote( Lewis, P.A.W., Goodman, A.S., and Miller, J.M. (1969), A pseudorandom number generator for the System/360, IBM Systems Journal, 8, 136-146.) (1969)). The random number generators may also be seeded by calling their members tt(seed) accepting tt(unsigned long) values or generator functions (as in tt(lc.seed(time(0)), lc.seed(mt))). The random number generators offer members ti(min) and ti(max) returning, respectively, their minimum and maximum values (inclusive). If a reduced range is required the generators can be nested in a function or class adapting the range. c++-annotations-10.5.0/yo/stl/arithmetic.yo0000644000175000017500000001036012635354026017425 0ustar frankfrankThe hi(function object: arithmetic)hi(arithmetic function object) arithmetic function objects support the standard i(arithmetic operations): addition, subtraction, multiplication, division, modulo and negation. These function objects invoke the corresponding operators of the data types for which they are instantiated. For example, for addition the function object tt(plus) hi(plus) is available. If we replace tt(Type) by tt(size_t) then the addition operator for tt(size_t) values is used, if we replace tt(Type) by tt(string), the addition operator for strings is used. For example: verbinclude(-a examples/plus.cc) Why is this useful? Note that the function object can be used with all kinds of data types (not only with the predefined datatypes) supporting the operator called by the function object. Suppose we want to perform an operation on a left hand side operand which is always the same variable and a right hand side argument for which, in turn, all elements of an array should be used. E.g., we want to compute the sum of all elements in an array; or we want to concatenate all the strings in a text-array. In situations like these function objects come in handy. As stated, function objects are heavily used in the context of the generic algorithms, so let's take a quick look ahead at yet another one. The generic algorithm tt(accumulate) visits all elements specified by an iterator-range, and performs a requested binary operation on a common element and each of the elements in the range, returning the accumulated result after visiting all elements specified by the iterator range. It's easy to use this algorithm. The next program accumulates all command line arguments and prints the final string: verbinclude(-a examples/plusaccumulate.cc) The first two arguments define the (iterator) range of elements to visit, the third argument is tt(string). This anonymous string object provides an initial value. We could also have used verb( string("All concatenated arguments: ") ) in which case the tt(cout) statement could simply have been tt(cout << result << '\n'). The string-addition operation is used, called from tt(plus). The final concatenated string is returned. Now we define a class tt(Time), overloading ti(operator+). Again, we can apply the predefined function object tt(plus), now tailored to our newly defined datatype, to add times: verbinclude(-a examples/classtypeplus.cc) The design of the above program is fairly straightforward. tt(Time) defines a constructor, it defines an insertion operator and it defines its own tt(operator+), adding two time objects. In tt(main) four tt(Time) objects are stored in a tt(vector))\ (cells(3)(ARG1))) DEFINEMACRO(vlcell)(1)(\ IFDEF(html)(NOTRANS())\ (cell(ARG1))) DEFINEMACRO(vrcell)(1)(\ IFDEF(html)(NOTRANS())\ (cell(ARG1))) DEFINEMACRO(vcell)(1)(\ IFDEF(html)(NOTRANS())(cell(ARG1))) DEFINEMACRO(rcell)(1)(\ IFDEF(html)(NOTRANS())(cell(ARG1))) DEFINEMACRO(lcell)(1)(\ IFDEF(html)(NOTRANS())(cell(ARG1))) DEFINEMACRO(rowthree)(3)(\ row(vrcell(%ARG1)cell(nbsp())vlcell(ARG2)cell(nbsp()nbsp())vlcell(ARG3))\ ) COMMENT(End used by threading/time.yo) def(x)(1)(IFDEF(html)(NOTRANS())()ARG1) def(linkit)(2)(it()link(Chapter )(ARG1)ref(ARG1)link(: ARG2.)(ARG1)) def(itt)(1)(it()tt(ARG1)) def(rangett)(1)(tt(CHAR(91)ARG1+CHAR(41))) def(endOfFile)(1)(tt(CHAR(69)CHAR(79)CHAR(70))) def(c)(1)(COMMENT(ARG1)) def(hix)(1)(\ IFDEF(html)(\ label(an+USECOUNTER(htmlAnchor))\ NOTRANS( )\ )(\ IFDEF(latex)(\ NOTRANS(\index{)\ ARG1\ +NOTRANS(})\ )()\ )\ ) def(hi)(1)(hix(ARG1)) def(i)(1)(hix(ARG1)ARG1) def(tthi)(1)(hix(ARG1: header file)tt()) def(ti)(1)(hix(ARG1)tt(ARG1)) def(bi)(1)(hix(ARG1)bf(ARG1)) def(emi)(1)(hix(ARG1)em(ARG1)) def(ithi)(1)(it()hi(ARG1: header file)tt()) def(iti)(1)(it()ti(ARG1)) def(rangeti)(1)(ti(CHAR(91)ARG1+CHAR(41))) def(itht)(2)(it()hix(ARG1)tt(ARG2)) def(ittq)(2)(it()tt(ARG1):quote(ARG2)) def(ithtq)(3)(it()hix(ARG1)tt(ARG2):quote(ARG3)) def(cellq)(0)(cell(IFDEF(latex)()(quote()))) DEFINEMACRO(cXIV)(0)(\ i(C++14)\ ) IFDEF(html)(\ redef(XXsubsubsect)(1)(\ XXtocentry(sssect SYMBOLVALUE(XXlastnumber): ARG1)\ NOTRANS(

)\ SYMBOLVALUE(XXlastnumber): ARG1\ +NOTRANS(

)\ )\ redef(subsubsubsect)(1) ( NOTRANS(
)\ ARG1\ +NOTRANS(

)\ ) )() c++-annotations-10.5.0/yo/memory.yo0000644000175000017500000000451512635354026016007 0ustar frankfrankincludefile(memory/intro) sect(Operators `new' and `delete') includefile(memory/new) lsubsect(NEWARRAY)(Allocating arrays) includefile(memory/newarray) lsubsect(DELETEARRAY)(Deleting arrays) includefile(memory/deletearray) lsubsect(ENLARGEARRAY)(Enlarging arrays) includefile(memory/enlargearray) subsect(Managing `raw' memory) includefile(memory/raw) lsubsect(PLACEMENT)(The `placement new' operator) includefile(memory/placement) lsect(DESTRUCTOR)(The destructor) includefile(memory/destructor) lsubsect(DELETEPTRS)(Object pointers revisited) includefile(memory/objectp) lsubsect(NEWHANDLER)(The function set_new_handler()) includefile(memory/setnew) lsect(ASSIGNMENT)(The assignment operator) includefile(memory/assignment) lsubsect(OVERLOADASSIGN)(Overloading the assignment operator) includefile(memory/overload) subsubsect(The member 'operator=()') includefile(memory/operator) sect(The `this' pointer) includefile(memory/this) subsect(Sequential assignments and this) includefile(memory/sequential) lsect(COPYCONS)(The copy constructor: initialization vs. assignment) includefile(memory/initialization) lsect(CopyDestroy)(Revising the assignment operator) includefile(memory/revising) subsect(Swapping) includefile(memory/swapping) lsubsubsect(FSWAP)(Fast swapping) includefile(memory/fastswap) lsect(MOVE)(Moving data) includefile(memory/moving.yo) lsubsect(MOVECONS)(The move constructor (dynamic data)) includefile(memory/move) subsect(The move constructor (composition)) includefile(memory/movecomposition) lsubsect(MOVEASS)(Move-assignment) includefile(memory/moveassignment) lsubsect(REVISEDASS)(Revising the assignment operator (part II)) includefile(memory/revising2) subsect(Moving and the destructor) includefile(memory/movedestructor) subsect(Move-only classes) includefile(memory/moveonly) subsect(Default move constructors and assignment operators) includefile(memory/default) lsubsect(MOVEPRINCIPLE)(Moving: implications for class design) includefile(memory/moveimplications) lsect(RVO)(Copy Elision and Return Value Optimization) includefile(memory/elision.yo) lsect(POD)(Plain Old Data) includefile(memory/pod) sect(Conclusion) includefile(memory/conclusion) c++-annotations-10.5.0/yo/containers.yo0000644000175000017500000000530212635354026016637 0ustar frankfrankincludefile(containers/container) sect(Notations used in this chapter) includefile(containers/notations) lsect(PAIR)(The `pair' container) includefile(containers/pair) sect(Allocators) includefile(containers/allocator) sect(Available Containers) subsect(The `array' container) includefile(containers/array) lsubsect(VECTOR)(The `vector' container) includefile(containers/vector) subsect(The `list' container) includefile(containers/list) lsubsect(QUEUE)(The `queue' container) includefile(containers/queue) lsubsect(PRIQUEUE)(The `priority_queue' container) includefile(containers/priority) subsect(The `deque' container) includefile(containers/deque) lsubsect(MAP)(The `map' container) includefile(containers/map) subsubsect(The `map' constructors) includefile(containers/mapconstructors) subsubsect(The `map' operators) includefile(containers/mapoperators) subsubsect(The `map' public members) includefile(containers/mapmembers) subsubsect(The `map': a simple example) includefile(containers/mapexample) lsubsect(MULTIMAP)(The `multimap' container) includefile(containers/multimap) lsubsect(SET)(The `set' container) includefile(containers/set) lsubsect(MULTISET)(The `multiset' container) includefile(containers/multiset) lsubsect(STACK)(The `stack' container) includefile(containers/stack) subsect(The `unordered_map' container (`hash table')) includefile(containers/unorderedmap) subsubsect(The `unordered_map' constructors) includefile(containers/unorderedmapconstructors) lsubsubsect(UMAPMEMBERS)(The `unordered_map' public members) includefile(containers/unorderedmapmembers) subsubsect(The `unordered_multimap' container) includefile(containers/unorderedmultimap) subsect(The `unordered_set' container) includefile(containers/unorderedset) subsubsect(The `unordered_multiset' container) includefile(containers/unorderedmultiset) subsect(C14: heterogeneous lookup) includefile(containers/heterogeneous) lsect(COMPLEX)(The `complex' container) includefile(containers/complex) lsect(UNIONS)(Unrestricted Unions) includefile(containers/unrestricted) subsect(Implementing the destructor) includefile(containers/uniondestructor) subsect(Embedding an unrestricted union in a surrounding class) includefile(containers/embedding) subsect(Destroying an embedded unrestricted union) includefile(containers/destroying) subsect(Copy and move constructors) includefile(containers/ccandmove) subsect(Assignment) includefile(containers/assignment) c++-annotations-10.5.0/yo/classtemplates.yo0000644000175000017500000001026712635354026017524 0ustar frankfrankincludefile(classtemplates/intro) lsect(TEMPCLASSDEF)(Defining class templates) includefile(classtemplates/definitions) subsect(Constructing the circular queue: CirQue) includefile(classtemplates/cirque) subsect(Non-type parameters) includefile(classtemplates/nontype) lsubsect(MEMTEMP)(Member templates) includefile(classtemplates/membertemplates) subsect(CirQue's constructors and member functions) includefile(classtemplates/cirquemembers) subsect(Using CirQue objects) includefile(classtemplates/cirqueuse) subsect(Default class template parameters) includefile(classtemplates/default) lsubsect(DECLCLASSTEMP)(Declaring class templates) includefile(classtemplates/declaring) subsect(Preventing template instantiations) includefile(classtemplates/externtemplate) sect(Static data members) includefile(classtemplates/static) lsubsect(DISTINGUISH)(Extended use of the keyword `typename') includefile(classtemplates/typename) sect(Specializing class templates for deviating types) includefile(classtemplates/specialization) subsect(Example of a class specialization) includefile(classtemplates/cirqueexample) lsect(PARTIAL)(Partial specializations) includefile(classtemplates/partial) subsect(Intermezzo: some simple matrix algebraic concepts) includefile(classtemplates/matrixalgebra) subsect(The Matrix class template) includefile(classtemplates/matrix) subsect(The MatrixRow partial specialization) includefile(classtemplates/matrixrow) subsect(The MatrixColumn partial specialization) includefile(classtemplates/matrixcol) subsect(The 1x1 matrix: avoid ambiguity) includefile(classtemplates/onebyone) lsect(VARIADIC)(Variadic templates) includefile(classtemplates/variadic) lsubsect(DEFVARTEMP)(Defining and using variadic templates) includefile(classtemplates/defining) lsubsect(PERFECT)(Perfect forwarding) includefile(classtemplates/perfect) lsubsect(UNPACK)(The unpack operator) includefile(classtemplates/unpack) subsect(Non-type variadic templates) includefile(classtemplates/variadicnontype) lsubsect(NOTFN)(A bare bones `not_fn' negator) includefile(classtemplates/notfn) lsect(TUPLES)(Tuples) includefile(classtemplates/tuples) sect(Computing the return type of function objects) includefile(classtemplates/returntype) sect(Instantiating class templates) includefile(classtemplates/instantiations) sect(Processing class templates and instantiations) includefile(classtemplates/nameresolution) lsect(TEMPFRIENDS)(Declaring friends) includefile(classtemplates/friends) subsect(Non-templates used as friends in templates) includefile(classtemplates/normalfriends) subsect(Templates instantiated for specific types as friends) includefile(classtemplates/boundfriends) subsect(Unbound templates as friends) includefile(classtemplates/unboundfriends) subsect(Extended friend declarations) includefile(classtemplates/extended) lsect(DERIVEDTEMPCLASS)(Class template derivation) includefile(classtemplates/derived) subsect(Deriving ordinary classes from class templates) includefile(classtemplates/template2concrete) subsect(Deriving class templates from class templates) includefile(classtemplates/template2template) lsubsect(TFROMC)(Deriving class templates from ordinary classes) includefile(classtemplates/concrete2template) lsect(STATICPOLY)(Static Polymorphism) includefile(classtemplates/staticpoly) subsect(An example of static polymorphism) includefile(classtemplates/examplestaticpoly) subsect(Converting dynamic polymorphic classes to static polymorphic classes) includefile(classtemplates/converting) subsect(Using static polymorphism to avoid reimplementations) includefile(classtemplates/using) sect(Class templates and nesting) includefile(classtemplates/nesting) lsect(ITERATORCONS)(Constructing iterators) includefile(classtemplates/iteratorcons) lsubsect(RANDOMIT)(Implementing a `RandomAccessIterator') includefile(classtemplates/randomiterator) lsubsect(REVERSEIT)(Implementing a `reverse_iterator') includefile(classtemplates/reverseiterator) c++-annotations-10.5.0/yo/containers/0000755000175000017500000000000012635354026016266 5ustar frankfrankc++-annotations-10.5.0/yo/containers/queue.yo0000644000175000017500000000711312635354026017765 0ustar frankfrankThe ti(queue) class implements a i(queue data structure). Before using a tt(queue) container the header file tthi(queue) must be included. A queue is depicted in figure ref(queueFig). figure(containers/queue)(A queue data-structure)(queueFig) In figure ref(queueFig) it is shown that a queue has one point (the em(back)) where items can be added to the queue, and one point (the em(front)) where items can be removed (read) from the queue. A tt(queue) is therefore also called a emi(FIFO) data structure, for emi(first in, first out). It is most often used in situations where events should be handled in the same order as they are generated. The following constructors, operators, and member functions are available for the tt(queue) container: itemization( it() hi(queue) Constructors: itemization( it() The copy and move constructors are available; it() A tt(queue) may be constructed empty: verb( queue object; ) As with the tt(vector), it is an error to refer to an element of an empty queue. ) it() The tt(queue) container only supports the basic container operators. it() The following hi(member function)member functions are available for queues: itemization( ithtq(back)(Type &back())(returns a reference to the last element in the queue. It is the i(responsibility of the programmer) to use the member only if the queue is not empty.) ithtq(empty)(bool empty())(returns tt(true) if the queue contains no elements.) ithtq(front)(Type &front())(returns a reference to the first element in the queue. It is the responsibility of the programmer to use the member only if the queue is not empty.) COMMENT(verbinclude(-a queue/front.cc)) ithtq(pop)(void pop())(removes the element at the front of the queue. Note that the element is em(not) returned by this member. Nothing happens if the member is called for an empty queue. One might wonder why tt(pop) returns tt(void), instead of a value of type tt(Type) (cf. tt(front)). One reason is found in the principles of good software design: functions should perform one task. Combining the removal and return of the removed element breaks this principle. Moreover, when this principle is abandoned tt(pop)'s implementation is always flawed. Consider the prototypical implementation of a tt(pop) member that is supposed to return the just popped value: verb( Type queue::pop() { Type ret(front()); erase_front(); return ret; } ) The venom, as usual, is in the tail: since tt(queue) has no control over tt(Type)'s behavior the final statement (tt(return ret)) might throw. By that time the queue's front element has already been removed from the queue and so it is lost. Thus, a tt(Type) returning tt(pop) member cannot offer the em(strong guarantee) and consequently tt(pop) should not return the former tt(front) element. Because of all this, we must first use tt(front) and then tt(pop) to obtain and remove the queue's front element.) ithtq(push)(void push(value))(this member adds tt(value) to the back of the queue.) ithtq(size)(size_t size())(returns the number of elements in the queue.) ) ) Note that the queue does not support iterators or a subscript operator. The only elements that can be accessed are its front and back element. A queue can be emptied by: itemization( it() repeatedly removing its front element; it() assigning an empty queue using the same data type to it; it() having its destructor called. ) c++-annotations-10.5.0/yo/containers/mapmembers.yo0000644000175000017500000001767612635354026021010 0ustar frankfrankThe following member functions are available for the tt(map) container: itemization( ithtq(at)(mapped_type &at(key_type const &key)) (returns a reference to the map's tt(mapped_type) associated with tt(key). If the key is not stored in the tt(map) an tt(std::out_of_range) exception is thrown.) ithtq(begin)(map::iterator begin())(returns an iterator pointing to the first element of the map. ) ithtq(cbegin)(map::const_iterator cbegin()) (returns a i(const_iterator) pointing to the first element in the map, returning tt(cend) if the map is empty.) ithtq(cend)(map::const_iterator cend()) (returns a i(const_iterator) pointing just beyond the map's last element.) ithtq(clear)(void clear())(erases all elements from the map.) ithtq(count)(size_t count(key))(returns 1 if the provided key is available in the tt(map), otherwise 0 is returned.) ithtq(crbegin)(map::reverse_iterator crbegin() const)( hi(reverse_iterator) returns an iterator pointing to the last element of the map.) ithtq(rend)(map::reverse_iterator crend())(returns an iterator pointing before the first element of the map.) ithtq(emplace) (pair emplace(Args &&...args)) (a tt(value_type) object is constructed from tt(emplace)'s arguments. If the tt(map) already contained an object using the same tt(key_type) value, then a tt(std::pair) is returned containing an iterator pointing to the object using the same tt(key_type) value and the value tt(false). If no such tt(key_type) value was found, the newly constructed object is inserted into the tt(map), and the returned tt(std::pair) contains an iterator pointing to the newly inserted inserted tt(value_type) as well as the value tt(true).) ithtq(emplace_hint)(iterator emplace_hint(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted into the tt(map), unless the (at tt(args)) provided key already exists. The implementation may or may not use tt(position) as a em(hint) to start looking for an insertion point. The returned tt(iterator) points to the tt(value_type) using the provided key. It may refer to an already existing tt(value_type) or to a newly added tt(value_type); an existing tt(value_type) is not replaced. If a new value em(was) added, then the container's size has been incremented when tt(emplace_hint) returns.) ithtq(empty)(bool empty())(returns tt(true) if the map contains no elements.) ithtq(end)(map::iterator end())(returns an iterator pointing beyond the last element of the map.) ithtq(equal_range) (pair equal_range(key))(this member returns a pair of iterators, being respectively the return values of the member functions tt(lower_bound) and tt(upper_bound), introduced below. An example illustrating these member functions is given at the discussion of the member function tt(upper_bound).) ithtq(erase)(... erase())(erases a specific element or range of elements from the map:) itemization( itt(bool erase(key)) erases the element having the given tt(key) from the tt(map). tt(True) is returned if the value was removed, tt(false) if the map did not contain an element using the given tt(key). itt(void erase(pos)) erases the element pointed to by the iterator tt(pos). itt(void erase(first, beyond)) erases all elements indicated by the iterator range rangett(first, beyond). ) ithtq(find)(map::iterator find(key))(returns an iterator to the element having the given key. If the element isn't available, tt(end) is returned. The following example illustrates the use of the tt(find) member function:) verbinclude(-a examples/mapfind.cc) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(map) object.) ithtq(insert)(... insert())(inserts elements into the map. Values associated with already existing keys, however, are not replaced by new values. Its return value depends on the version of tt(insert) that is called:) itemization( itt(pair insert(keyvalue)) inserts a new tt(value_type) into the map. The return value is a ti(pair). If the returned ti(bool) field is tt(true), tt(keyvalue) was inserted into the map. The value tt(false) indicates that the key that was specified in tt(keyvalue) was already available in the map, and so tt(keyvalue) was not inserted into the map. In both cases the tt(map::iterator) field points to the data element having the tt(key) that was specified in tt(keyvalue). The use of this variant of tt(insert) is illustrated by the following example: verbinclude(-a examples/mapinsert.cc) Note the somewhat peculiar constructions like verb( cout << ret.first->first << " " << ret.first->second << ... ) Note that `tt(ret)' is equal to the tt(pair) returned by the tt(insert) member function. Its `tt(first)' field is an iterator into the tt(map), so it can be considered a pointer to a tt(map::value_type). These value types themselves are pairs too, having `tt(first)' and `tt(second)' fields. Consequently, `tt(ret.first->first)' is the em(key) of the map value (a tt(string)), and `tt(ret.first->second)' is the em(value) (an tt(int)). itt(map::iterator insert(pos, keyvalue)). This way a tt(map::value_type) may also be inserted into the map. tt(pos) is ignored, and an iterator to the inserted element is returned. itt(void insert(first, beyond)) inserts the (tt(map::value_type)) elements pointed to by the iterator range rangett(first, beyond). ) ithtq(key_comp)(key_compare key_comp()) (returns a copy of the object used by the tt(map) to compare keys. The type tt(map::key_compare) is defined by the map container and tt(key_compare)'s parameters have types tt(KeyType const &). The comparison function returns tt(true) if the first key argument should be ordered before the second key argument. To compare keys em(and) values, use tt(value_comp), listed below.) ithtq(lower_bound) (map::iterator lower_bound(key)) (returns an iterator pointing to the first tt(keyvalue) element of which the tt(key) is at least equal to the specified tt(key). If no such element exists, the function returns tt(end).) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(map) may contain.) ithtq(rbegin)(map::reverse_iterator rbegin())( hi(reverse_iterator) returns an iterator pointing to the last element of the map.) ithtq(rend)(map::reverse_iterator rend())(returns an iterator pointing before the first element of the map.) ithtq(size)(size_t size())(returns the number of elements in the map.) ithtq(swap)(void swap(argument))(swaps two maps using identical key/value types.) ithtq(upper_bound) (map::iterator upper_bound(key)) (returns an iterator pointing to the first tt(keyvalue) element having a tt(key) exceeding the specified tt(key). If no such element exists, the function returns tt(end). The following example illustrates the member functions tt(equal_range), tt(lower_bound) and tt(upper_bound): verbinclude(-a examples/mapbounds.cc) ) ithtq(value_comp)(value_compare value_comp()) (returns a copy of the object used by the tt(map) to compare keys. The type tt(map::value_compare) is defined by the map container and tt(value_compare)'s parameters have types tt(value_type const &). The comparison function returns tt(true) if the first key argument should be ordered before the second key argument. The tt(Value_Type) elements of the tt(value_type) objects passed to this member are not used by the returned function.) ) c++-annotations-10.5.0/yo/containers/mapexample.yo0000644000175000017500000000061012635354026020765 0ustar frankfrank As mentioned at the beginning of section ref(MAP), the tt(map) represents a sorted associative array. In a tt(map) the keys are sorted. If an application must visit all elements in a map the tt(begin) and tt(end) iterators must be used. The following example illustrates how to make a simple table listing all keys and values found in a map: verbinclude(-a examples/maptable.cc) c++-annotations-10.5.0/yo/containers/unorderedmapmembers.yo0000644000175000017500000002015312635354026022700 0ustar frankfrankThe tt(unordered_map) supports the index operator operating identically to the tt(map)'s index operator: a (const) reference to the tt(ValueType) associated with the provided tt(KeyType)'s value is returned. If not yet available, the key is added to the tt(unordered_map), and a default tt(ValueType) value is returned. In addition, it supports tt(operator==). The tt(unordered_map) provides the following hi(unordered_map: member functions) member functions (tt(key_type, value_type) etc. refer to the types defined by the tt(unordered_map)): itemization( ithtq(at)(mapped_type &at(key_type const &key)) (returns a reference to the unordered_map's tt(mapped_type) associated with tt(key). If the key is not stored in the tt(unordered_map) an tt(std::out_of_range) exception is thrown.) ithtq(begin)(unordered_map::iterator begin()) (returns an i(iterator) pointing to the first element in the unordered_map, returning tt(end) if the unordered_map is empty.) ithtq(bucket)(size_t bucket(key_type const &key)) (returns the index location where tt(key) is stored. If tt(key) wasn't stored yet tt(bucket) adds tt(value_type(key, Value())) before returning its index position.) ithtq(bucket_count)(size_t bucket_count()) (returns the number of slots used by the containers. Each slot may contain one (or more, in case of collisions) tt(value_type) objects.) ithtq(bucket_size)(size_t bucket_size(size_t index)) (returns the number of tt(value_type) objects stored at bucket position tt(index).) ithtq(cbegin)(unordered_map::const_iterator cbegin()) (returns a i(const_iterator) pointing to the first element in the unordered_map, returning tt(cend) if the unordered_map is empty.) ithtq(cend)(unordered_map::const_iterator cend()) (returns a i(const_iterator) pointing just beyond the unordered_map's last element.) ithtq(clear)(void clear()) (erases all the unordered_map's elements.) ithtq(count)(size_t count(key_type const &key)) (returns the number of times a tt(value_type) object using tt(key_type) tt(key) is stored in the tt(unordered_map) (which is either one or zero).) ithtq(emplace) (pair emplace(Args &&...args)) (a tt(value_type) object is constructed from tt(emplace)'s arguments. If the tt(unordered_map) already contained an object using the same tt(key_type) value, then a tt(std::pair) is returned containing an iterator pointing to the object using the same tt(key_type) value and the value tt(false). If no such tt(key_type) value was found, the newly constructed object is inserted into the tt(unordered_map), and the returned tt(std::pair) contains an iterator pointing to the newly inserted inserted tt(value_type) as well as the value tt(true).) ithtq(emplace_hint)(iterator emplace_hint(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted into the tt(unordered_map), unless the (at tt(args)) provided key already exists. The implementation may or may not use tt(position) as a em(hint) to start looking for an insertion point. The returned tt(iterator) points to the tt(value_type) using the provided key. It may refer to an already existing tt(value_type) or to a newly added tt(value_type); an existing tt(value_type) is not replaced. If a new value em(was) added, then the container's size has been incremented when tt(emplace_hint) returns.) ithtq(empty)(bool empty()) (returns tt(true) if the unordered_map contains no elements.) ithtq(end)(unordered_map::iterator end()) (returns an iterator pointing beyond the last element in the unordered_map.) ithtq(equal_range) (pair equal_range(key))(this member returns a pair of iterators defining the range of elements having a key that is equal to tt(key). With the tt(unordered_map) this range includes at most one element.) ithtq(erase)(unordered_map::iterator erase()) (erases a specific range of elements in the unordered_map:) itemization( itt(erase(pos)) erases the element pointed to by the iterator tt(pos). The iterator tt(++pos) is returned. itt(erase(first, beyond)) erases elements indicated by the iterator range rangett(first, beyond), returning tt(beyond). ) ithtq(find)(iterator find(key)) (returns an iterator to the element having the given key. If the element isn't available, tt(end) is returned.) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(unordered_map) object.) ithtq(hash_function)(hasher hash_function() const)(returns a copy of the hash function object used by the tt(unordered_map) object.) itht(insert)(... insert()): quote(elements may be inserted starting at a certain position. No insertion is performed if the provided key is already in use. The return value depends on the version of tt(insert()) that is called. When a tt(pair) is returned, then the tt(pair's first) member is an iterator pointing to the element having a key that is equal to the key of the provided tt(value_type), the tt(pair's second) member is tt(true) if tt(value) was actually inserted into the container, and tt(false) if not.) itemization( itt(pair insert(value_type const &value)) attempts to insert tt(value). itt(pair insert(value_type &&tmp)) attempts to insert tt(value) using tt(value_type)'s move constructor. itt(pair insert(const_iterator hint, value_type const &value)) attempts to insert tt(value), possibly using tt(hint) as a starting point when trying to insert tt(value). itt(pair insert(const_iterator hint, value_type &&tmp)) attempts to insert a tt(value) using tt(value_type)'s move constructor, and possibly using tt(hint) as a starting point when trying to insert tt(value). itt(void insert(first, beyond)) tries to insert the elements in the iterator range rangett(first, beyond). itt(void insert(initializer_list iniList)) attempts to insert the elements in tt(iniList) into the container. ) ithtq(key_equal)(hasher key_eq() const)(returns a copy of the tt(key_equal) function object used by the tt(unordered_map) object.) ithtq(load_factor)(float load_factor() const)(returns the container's current load factor, i.e. tt(size / bucket_count).) ithtq(max_bucket_count)(size_t max_bucket_count())(returns the maximum number of buckets this tt(unordered_map) may contain.) ithtq(max_load_factor)(float max_load_factor() const)(identical to tt(load_factor).) ithtq(max_load_factor)(void max_load_factor(float max))(changes the current maximum load factor to tt(max). When a load factor of tt(max) is reached, the container will enlarge its tt(bucket_count), followed by a rehash of its elements. Note that the container's default maximum load factor equals 1.0) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(unordered_map) may contain.) ithtq(rehash)(void rehash(size_t size)) (if tt(size) exceeds the current bucket count, then the bucket count is increased to tt(size), followed by a rehash of its elements.) ithtq(reserve)(void reserve(size_t request)) (if tt(request) is less than or equal to the current bucket count, this call has no effect. Otherwise, the bucket count is increased to a value of at least tt(request), followed by a rehash of the container's elements.) ithtq(size)(size_t size()) (returns the number of elements in the unordered_map.) ithtq(swap)(void swap(unordered_map &other)) (swaps the contents of the current and the other tt(unordered_map).) ) c++-annotations-10.5.0/yo/containers/destroying.yo0000644000175000017500000000162412635354026021031 0ustar frankfranktt(Data)'s destructor has a data member which is an unrestricted union. As the union's destructor can't perform any actions, the union's proper destruction is delegated to a member, tt(Union::destroy) destroying the fields for which destructors are defined. As tt(d_tag) stores the currently used tt(Union) field, tt(Data)'s destructor can pass tt(d_tag) to tt(Union::destroy) to inform it about which field should be destroyed. tt(Union::destroy) does not need to perform any action for tt(INT) tags, but for tt(STRING) tags the memory allocated by tt(u_string) must be returned. For this an explicit destructor call is used. tt(Union::destroy) and tt(Data)'s destructor are therefore implemented like this: verb( void Data::Union::destroy(Tag myTag) { if (myTag == Tag::STRING) u_string.~string(); } Data::~Data() { d_union.destroy(d_tag); } ) c++-annotations-10.5.0/yo/containers/queue.fig0000644000175000017500000000211412635354026020077 0ustar frankfrank#FIG 3.2 Landscape Center Metric Letter 100.00 Single -2 1200 2 1 2 0 2 0 17 0 0 36 0.000 1 0.0000 2025 765 225 450 2250 315 1800 1215 1 2 0 2 0 17 0 0 36 0.000 1 0.0000 5625 765 225 450 5850 315 5400 1215 2 2 0 0 0 17 0 0 36 0.000 0 0 -1 0 0 5 2025 1215 5625 1215 5625 315 2025 315 2025 1215 2 1 0 2 0 17 0 0 36 0.000 0 0 -1 0 0 2 2025 315 5670 315 2 1 0 2 0 17 0 0 36 0.000 0 0 -1 0 0 2 2070 1215 5625 1215 2 1 1 2 0 -1 0 0 -1 6.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 2835 720 4860 720 2 1 1 2 0 -1 0 0 -1 6.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 1395 720 2115 720 2 1 1 2 0 -1 0 0 -1 6.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 315 720 855 720 2 2 0 2 0 6 0 0 18 0.000 0 0 -1 0 0 5 900 495 1350 495 1350 945 900 945 900 495 2 1 1 2 0 -1 0 0 -1 6.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 5490 720 6345 720 2 2 0 2 0 6 0 0 18 0.000 0 0 -1 0 0 5 6300 495 6750 495 6750 945 6300 945 6300 495 2 1 1 2 0 -1 0 0 -1 6.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 6795 720 7200 720 4 1 0 0 0 0 18 0.0000 4 195 645 5715 1575 Front\001 4 1 0 0 0 0 18 0.0000 4 195 555 1890 1530 Back\001 c++-annotations-10.5.0/yo/containers/heterogeneous.yo0000644000175000017500000000143512635354026021516 0ustar frankfrankThe associative containers offered by bf(C++) allow us to find a value (or values) matching a given key. Traditionally, the type of the key used for the lookup must match the container's key type. The cXIV() standard allows an arbitrary lookup key type to be used, as long as the comparison operator can compare that type with the container's key type. Thus, a tt(char const *) key (or any other type for which an tt(operator<) overload for tt(std::string) is available) can be used to lookup values in a tt(map). This is called emi(heterogeneous lookup). Heterogeneous lookup is allowed when the comparator given to the associative container does allow this. The standard library classes tt(std::less) and tt(std::greater) were augmented to allow heterogeneous lookup. c++-annotations-10.5.0/yo/containers/vector.yo0000644000175000017500000002147312635354026020150 0ustar frankfrankThe ti(vector) class implements an hi(array: expandable)i(expandable array). Before using the tt(vector) container the tthi(vector) header file must be included. The following constructors, operators, and member functions are available: itemization( it() hi(vector constructors) Constructors: itemization( it() The copy and move constructors are available; it() A tt(vector) may be constructed empty: verb( vector object; ) it() A vector may be initialized to a certain number of elements: verb( vector object(5, string("Hello")); // initialize to 5 Hello's, vector container(10); // and to 10 empty strings vector names = {"george", "frank", "tony", "karel"}; ) it() A vector may be initialized using iterators. To initialize a vector with elements 5 until 10 (including the last one) of an existing tt(vector) the following construction may be used: verb( extern vector container; vector object(&container[5], &container[11]); ) Note here that the last element pointed to by the second iterator (tt(&container[11])) is em(not) stored in tt(object). This is a simple example of the use of hi(iterator)em(iterators), in which the i(range of values) that is used starts at the first value, and includes all elements up to but not including the element to which the second iterator refers. The standard i(notation) for this is rangeti(begin, end). ) it() In addition to the standard operators for containers, the tt(vector) supports the i(index operator), which can be used to retrieve or reassign individual elements of the vector. Note that the elements which are indexed must exist. For example, having defined an empty vector a statement like tt(ivect[0] = 18) produces an error, as the vector is empty. So, the vector is em(not) automatically hi(automatic expansion) expanded, and tt(operator[]) does em(not) respect its i(array bounds). In this case the vector should be resized first, or tt(ivect.push_back(18)) should be used (see below). If you need run-time array bound checking, use the vector's tt(at) member. it() The tt(vector) class offers the following hi(vector: member functions) member functions: itemization( ithtq(assign)(void assign(...)) (assigns new contents to the vector:) itemization( itt(assign(iterator begin, iterator end)) assigns the values at the iterator range rangett(begin, end) to the vector; itt(assign(size_type n, value_type const &val)) assigns tt(n) copies of tt(val) to the vector; itt(assign(initializer_list values)) assigns the values in the initializer list to the vector. ) ithtq(at)(Type &at(size_t idx)) (returns a reference to the vector's element at index position tt(idx). If tt(idx) exceeds the vector's size a tt(std::out_of_range) exception is thrown.) ithtq(back)(Type &back()) (returns a reference to the last element in the vector. It is the i(responsibility of the programmer) to use the member only if the vector is not empty.) ithtq(begin)(vector::iterator begin()) (returns an i(iterator) pointing to the first element in the vector, returning tt(end) if the vector is empty.) ithtq(capacity)(size_t capacity()) (Number of elements for which memory has been allocated. It returns at least the value returned by tt(size)) ithtq(cbegin)(vector::const_iterator cbegin()) (returns a i(const_iterator) pointing to the first element in the vector, returning tt(cend) if the vector is empty.) ithtq(cend)(vector::const_iterator cend()) (returns a i(const_iterator) pointing just beyond the vector's last element.) ithtq(clear)(void clear()) (erases all the vector's elements.) ithtq(crbegin)(vector::const_reverse_iterator crbegin()) (returns a i(const_reverse_iterator) pointing to the last element in the vector, returning tt(crend) if the vector is empty.) ithtq(crend)(vector::const_reverse_iterator crend()) (returns a i(const_reverse_iterator) pointing just before the vector's first element.) ithtq(data)(value_type *data()) (returns a pointer to the vector's first data element.) ithtq(emplace) (iterator emplace(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the arguments specified after tt(position), and the newly created element is inserted at tt(position).) ithtq(emplace_back)(void emplace_back(Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted beyond the vector's last element.) ithtq(empty)(bool empty()) (returns tt(true) if the vector contains no elements.) ithtq(end)(vector::iterator end()) (returns an iterator pointing beyond the last element in the vector.) ithtq(erase)(vector::iterator erase()) (erases a specific range of elements in the vector:) itemization( itt(erase(pos)) erases the element pointed to by the iterator tt(pos). The iterator tt(++pos) is returned. itt(erase(first, beyond)) erases elements indicated by the iterator range rangett(first, beyond), returning tt(beyond). ) ithtq(front)(Type &front()) (returns a reference to the first element in the vector. It is the responsibility of the programmer to use the member only if the vector is not empty.) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(vector) object.) ithtq(insert)(... insert()) (elements may be inserted starting at a certain position. The return value depends on the version of tt(insert()) that is called:) itemization( itt(vector::iterator insert(pos)) inserts a default value of type tt(Type) at tt(pos), tt(pos) is returned. itt(vector::iterator insert(pos, value)) inserts tt(value) at tt(pos), tt(pos) is returned. itt(void insert(pos, first, beyond)) inserts the elements in the i(iterator range) rangeti(first, beyond). itt(void insert(pos, n, value)) inserts tt(n) elements having value tt(value) at position tt(pos). ) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(vector) may contain.) ithtq(pop_back)(void pop_back()) (removes the last element from the vector. With an i(empty vector) nothing happens.) ithtq(push_back)(void push_back(value)) (adds tt(value) to the end of the vector.) ithtq(rbegin)(vector::reverse_iterator rbegin()) (hi(reverse_iterator) this member returns an iterator pointing to the last element in the vector.) ithtq(rend)(vector::reverse_iterator rend()) (returns an iterator pointing before the first element in the vector.) ithtq(reserve)(void reserve(size_t request)) (if tt(request) is less than or equal to tt(capacity), this call has no effect. Otherwise, it is a request to allocate additional memory. If the call is successful, then tt(capacity) returns a value of at least tt(request). Otherwise, tt(capacity) is unchanged. In either case, tt(size)'s return value won't change, until a function like tt(resize) is called, actually changing the number of accessible elements.) ithtq(resize)(void resize()) (can be used to alter the number of elements that are currently stored in the vector:) itemization( itt(resize(n, value)) may be used to resize the vector to a size of tt(n). tt(Value) is optional. If the vector is expanded and tt(value) is not provided, the additional elements are initialized to the i(default value) of the used data type, otherwise tt(value) is used to initialize extra elements. ) ithtq(shrink_to_fit)(void shrink_to_fit())(optionally reduces the amount of memory allocated by a vector to its current size. The implementor is free to ignore or otherwise optimize this request. In order to guarantee a `shrink to fit' operation the verb( vector(vectorObject).swap(vectorObject) ) idiom can be used.) ithtq(size)(size_t size()) (returns the number of elements in the vector.) ithtq(swap)(void swap()) (swaps two vectors using identical data types. Example:) verb( #include #include using namespace std; int main() { vector v1(7); vector v2(10); v1.swap(v2); cout << v1.size() << " " << v2.size() << '\n'; } /* Produced output: 10 7 */ ) ) ) c++-annotations-10.5.0/yo/containers/insertlist.fig0000644000175000017500000000330212635354026021153 0ustar frankfrank#FIG 3.2 Landscape Center Inches Letter 100.00 Single -2 1200 2 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 600 600 1650 600 1650 1350 600 1350 600 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 2325 600 3375 600 3375 1350 2325 1350 2325 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 4200 600 5250 600 5250 1350 4200 1350 4200 600 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 225 2100 225 675 600 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 1650 675 2325 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5250 675 6375 675 6375 1725 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5700 1950 5700 1200 5250 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 2325 1200 1650 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 5 1 1 2.00 120.00 240.00 600 1200 450 1200 450 1650 900 1650 900 1875 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 3300 2175 4350 2175 4350 2925 3300 2925 3300 2175 2 1 0 1 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 1.00 60.00 120.00 4350 2250 4575 2250 4575 2025 3900 2025 3900 675 4200 675 2 1 0 1 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 1.00 60.00 120.00 3375 675 3750 675 3750 2025 3150 2025 3150 2325 3300 2325 2 1 0 1 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 1.00 60.00 120.00 4200 1200 4050 1200 4050 1800 4800 1800 4800 2775 4350 2775 2 1 0 1 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 1.00 60.00 120.00 3300 2775 3000 2775 3000 1650 3600 1650 3600 1200 3375 1200 4 0 0 0 0 0 18 0.0000 4 255 1125 975 2025 0 (NULL)\001 4 0 0 0 0 0 18 0.0000 4 255 1125 6525 1875 0 (NULL)\001 4 2 0 0 0 0 18 0.0000 4 195 555 5700 2250 Back\001 4 0 0 0 0 0 18 0.0000 4 195 645 225 2475 Front\001 4 1 0 0 0 0 18 0.0000 4 195 1755 3825 3375 New Data-Item\001 c++-annotations-10.5.0/yo/containers/pair.yo0000644000175000017500000000532312635354026017575 0ustar frankfrankThe hi(pair container) ti(pair) container is a rather basic container. It is used to store two elements, called ti(first) and ti(second), and that's about it. Before using tt(pair) containers the header file tthi(utility) must be included. The tt(pair)'s data types are specified when the tt(pair) object is defined (or declared) using the template's angle bracket notation (cf. chapter ref(TEMPLATES)). Examples: verb( pair piper("PA28", "PH-ANI"); pair cessna("C172", "PH-ANG"); ) here, the variables tt(piper) and tt(cessna) are defined as tt(pair) variables containing two tt(strings). Both strings can be retrieved using the tt(first) and tt(second) fields of the tt(pair) type: verb( cout << piper.first << '\n' << // shows 'PA28' cessna.second << '\n'; // shows 'PH-ANG' ) The tt(first) and tt(second) members can also be used to reassign values: verb( cessna.first = "C152"; cessna.second = "PH-ANW"; ) If a tt(pair) object must be completely reassigned, an em(anonymous) hi(anonymous pair) pair object can be used as the i(right-hand) operand of the assignment. An anonymous variable defines a temporary variable (which receives no name) solely for the purpose of (re)assigning another variable of the same type. Its hi(anonymous variable: generic form) generic form is verb( type(initializer list) ) Note that when a tt(pair) object is used the type specification is not completed by just mentioning the containername tt(pair). It also requires the specification of the data types which are stored within the pair. For this the (template) i(angle bracket notation) is used again. E.g., the reassignment of the tt(cessna) pair variable could have been accomplished as follows: verb( cessna = pair("C152", "PH-ANW"); ) In cases like these, the tt(type) specification can become quite elaborate, which has caused a revival of interest in the possibilities offered by the ti(typedef) keyword. If many ti(pair) clauses are used in a source, the typing effort may be reduced and readability might be improved by first defining a name for the clause, and then using the defined name later. E.g., verb( typedef pair pairStrStr; cessna = pairStrStr("C152", "PH-ANW"); ) Apart from this (and the basic set of operations (assignment and comparisons)) the tt(pair) offers no further i(functionality). It is, however, a basic ingredient of the upcoming abstract containers tt(map, multimap) and tt(hash_map). bf(C++) also offers a emi(generalized pair) container: the em(tuple), covered in section ref(TUPLES). c++-annotations-10.5.0/yo/containers/ccandmove.yo0000644000175000017500000000420712635354026020601 0ustar frankfranktt(Union)'s copy and move constructors suffer from the same problem as tt(Union)'s destructor does: the union does not know which is its currently active field. But again: tt(Data) does, and by defining `extended' copy and move constructors, also receiving a tt(Tag) argument, these extended constructors can perform their proper initializations. The tt(Union)'s copy- and move-constructors are deleted, and extended copy- and move constructors are declared: verb( Union(Union const &other) = delete; Union &operator=(Union const &other) = delete; Union(Union const &other, Tag tag); Union(Union &&tmp, Tag tag); ) Shortly we'll encounter a situation where we must be able to initialize a block of memory using an existing tt(Union) object. This task can be performed by tt(copy) members, whose implementations are trivial, and which may be used by the above constructors. They can be declared in tt(Union)'s private section, and have identical parameter lists as the above constructors: verb( void copy(Union const &other, Tag tag); void copy(Union &&other, Tag tag); ) The constructors merely have to call these tt(copy) members: verb( inline Data::Union::Union(Union const &other, Tag tag) { copy(other, tag); } inline Data::Union::Union(Union &&tmp, Tag tag) { copy(std::move(tmp), tag); } ) Interestingly, no `initialization followed by assignment' happens here: tt(d_union) has not been initialized in any way by the the time we reach the statement blocks of the above constructors. But upon reaching the statement blocks, tt(d_union) memory is merely raw memory. This is no problem, as the tt(copy) members use placement new to initialize the tt(Union)'s memory: verb( void Data::Union::copy(Union const &other, Tag otag) { if (tag == INT) u_int = other.u_int; else new (this) string(other.u_string); } void Data::Union::copy(Union &&tmp, Tag tag) { if (tag == INT) u_int = tmp.u_int; else new (this) string(std::move(tmp.u_string)); } ) c++-annotations-10.5.0/yo/containers/unorderedmultimap.yo0000644000175000017500000000614712635354026022407 0ustar frankfrankThe ti(unordered_multimap) allows multiple objects using the same keys to be stored in an unordered map. The tt(unordered_multimap) container offers the same set of members and constructors as the tt(unordered_map), but without the unique-key restriction imposed upon the tt(unordered_map). The tt(unordered_multimap) does not offer tt(operator[]) and does not offer the tt(at) members. Below all members are described whose behavior differs from the behavior of the corresponding tt(unordered_map) members: itemization( itt(at) quote(not supported by the tt(unordered_multimap) container) ithtq(count)(size_t count(key_type const &key)) (returns the number of times a tt(value_type) object using tt(key_type) tt(key) is stored in the tt(unordered_map). This member is commonly used to verify whether tt(key) is available in the tt(unordered_multimap).) ithtq(emplace) (iterator emplace(Args &&...args)) (a tt(value_type) object is constructed from tt(emplace)'s arguments. The returned tt(iterator) points to the newly inserted inserted tt(value_type).) ithtq(emplace_hint)(iterator emplace_hint(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted into the tt(unordered_multimap). The implementation may or may not use tt(position) as a em(hint) to start looking for an insertion point. The returned tt(iterator) points to the tt(value_type) using the provided key.) ithtq(equal_range) (pair equal_range(key))(this member returns a pair of iterators defining the range of elements having a key that is equal to tt(key).) ithtq(find)(terator find(key)) (returns an iterator to an element having the given key. If no such element is available, tt(end) is returned.) itht(insert)(... insert()): quote(elements may be inserted starting at a certain position. The return value depends on the version of tt(insert()) that is called. When an tt(iterator) is returned, then it points to the element that was inserted.) itemization( itt(iterator insert(value_type const &value)) inserts tt(value). itt(iterator insert(value_type &&tmp)) inserts tt(value) using tt(value_type)'s move constructor. itt(iterator insert(const_iterator hint, value_type const &value)) inserts tt(value), possibly using tt(hint) as a starting point when trying to insert tt(value). itt(iterator insert(const_iterator hint, value_type &&tmp)) inserts tt(value) using tt(value_type)'s move constructor, and possibly using tt(hint) as a starting point when trying to insert tt(value). itt(void insert(first, beyond)) inserts the elements in the iterator range rangett(first, beyond). itt(void insert(initializer_list iniList)) inserts the elements in tt(iniList) into the container. ) ) c++-annotations-10.5.0/yo/containers/embedding.yo0000644000175000017500000000273112635354026020560 0ustar frankfrankNext, we embed the unrestricted union in a surrounding aggregate: tt(class Data). The aggregate is provided with an tt(enum Tag), declared in its public section, so tt(Data)'s users may request tags. tt(Union) itself is for tt(Data)'s internal use only, so tt(Union) is declared in tt(Data)'s private section. Using a tt(struct Data) rather than tt(class Data) we start out in a public section, saving us from having to specify the initial tt(public:) section for tt(enum Tag): verb( struct Data { enum Tag { INT, STRING }; private: union Union { int u_int; std::string u_string; ~Union(); // no actions // ... to do: declarations of members }; Tag d_tag; Union d_union; }; ) tt(Data)'s constructors receive tt(int) or tt(string) values. To pass these values on to tt(d_union), we need tt(Union) constructors for the various union fields; matching tt(Data) constructors also initialize tt(d_tag) to proper values: verb( Data::Union::Union(int value) : u_int(value) {} Data::Union::Union(std::string const &str) : u_string(str) {} Data::Data(std::string const &str) : d_tag(STRING), d_union(str) {} Data::Data(int value) : d_tag(INT), d_union(value) {} ) c++-annotations-10.5.0/yo/containers/array.yo0000644000175000017500000001505012635354026017756 0ustar frankfrankThe ti(array) class implements a hi(array: fixed size) i(fixed-size array). Before using the tt(array) container the tthi(array) header file must be included. To define a tt(std::array) both the data type of its elements and its size must be specified: the data type is given after an opening angular bracket, immediately following the `tt(array)' container name. The array's size is provided after the data type specification. Finally, a closing angular bracket completes the array's type. Specifications like this are common practice with containers. The combination of tt(array), type and size defines a em(type). As a result, tt(array) defines another type than tt(array), and a function explicitly defining an tt(array) parameter will not accept an tt(array) argument if tt(N) and tt(M) are unequal. The array's size may may be defined as 0 (although such an array probably has little use as it cannot store any element). The elements of an array are stored contiguously. If tt(array arr) has been defined, then tt(&arr[n] + m == &arr[n + m), assuming tt(0 <= n < N) and assuming tt(0 <= n + m < N). The following constructors, operators, and member functions are available: itemization( it() hi(array constructors) Constructors: itemization( it() The copy and move constructors are available; it() A tt(array) may be constructed with a fixed number tt(N) of default elements: verb( array object; ) it() An initial subset of the elements of an array may be initialized using a brace delimited initializer list: verb( array dArr = {1.2, 2.4}; ) Here tt(dArr) is defined as an array of 4 element, with tt(dArr[0]) and tt(dArr[1]) initialized to, respectively 1.2 and 2.4, and tt(dArr[2]) and tt(dArr[3]) initialized to 0. A attractive characteristic of arrays (and other containers) is that containers initialize hi(container: initialization) their data elements to the data type's default value. The data type's em(default constructor) is used for this i(initialization). With non-class data types the value 0 is used. So, for an tt(array) array we know that all but its explicitly initialized elements are initialized to zero. ) it() In addition to the standard operators for containers, the tt(array) supports the i(index operator), which can be used to retrieve or reassign individual elements of the array. Note that the elements which are indexed must exist. For example, having defined an empty array a statement like tt(iarr[0] = 18) produces an error, as the array is empty. Note that tt(operator[]) does em(not) respect its i(array bounds). If you want run-time array bound checking, use the array's tt(at) member. it() The tt(array) class offers the following hi(array: member functions) member functions: itemization( ithtq(at)(Type &at(size_t idx)) (returns a reference to the array's element at index position tt(idx). If tt(idx) exceeds the array's size a tt(std::out_of_range) exception is thrown.) ithtq(back)(Type &back()) (returns a reference to the last element in the array. It is the i(responsibility of the programmer) to use the member only if the array is not empty.) ithtq(begin)(array::iterator begin()) (returns an i(iterator) pointing to the first element in the array, returning tt(end) if the array is empty.) ithtq(cbegin)(array::const_iterator cbegin()) (returns a i(const_iterator) pointing to the first element in the array, returning tt(cend) if the array is empty.) ithtq(cend)(array::const_iterator cend()) (returns a i(const_iterator) pointing just beyond the array's last element.) ithtq(crbegin)(array::const_reverse_iterator crbegin()) (returns a i(const_reverse_iterator) pointing to the last element in the array, returning tt(crend) if the array is empty.) ithtq(crend)(array::const_reverse_iterator crend()) (returns a i(const_reverse_iterator) pointing just before the array's first element.) ithtq(data)(value_type *data()) (returns a pointer to the array's first data element. With a const array a tt(value_type const *) is returned.) ithtq(empty)(bool empty()) (returns tt(true) if the array contains no elements.) ithtq(end)(array::iterator end()) (returns an iterator pointing beyond the last element in the array.) ithtq(fill)(void fill(Type const &item)) (fills all the array's elements with a copy of tt(item)) ithtq(front)(Type &front()) (returns a reference to the first element in the array. It is the responsibility of the programmer to use the member only if the array is not empty.) ithtq(rbegin)(array::reverse_iterator rbegin()) (hi(reverse_iterator) this member returns an iterator pointing to the last element in the array.) ithtq(rend)(array::reverse_iterator rend()) (returns an iterator pointing before the first element in the array.) ithtq(size)(constexpr size_t size()) (returns the number of elements the array contains.) ithtq(swap)(void swap( &other)) (swaps the contents of the current and other array. The array other's data type and size must be equal to the data type and size of the object calling tt(swap).) ) ) Using an tt(array) rather than a standard bf(C) style array offers several advantages: itemization( it() All its elements are immediately initialized; it() Introspection is possible (e.g., tt(size) can be used); it() The tt(array) container can be used in the context of templates, there code is developed that operates on data types that become available only after the code itself has been developed; it() Since tt(array) supports reverse iterators, it can be immediately be used with generic algorithms performing `reversed' operations (e.g., to perform a descending rather than ascending sort (cf. section ref(SORT))) ) In general, when looking for a sequential data structure, the tt(array) or tt(vector) (introduced in the next section) should be your `weapon of choice'. Only if these containers demonstrably do not fit the problem at hand you should use another type of container. c++-annotations-10.5.0/yo/containers/priority.yo0000644000175000017500000000660012635354026020522 0ustar frankfrankThe ti(priority_queue) class implements a i(priority queue data structure). Before using a tt(priority_queue) container the tthi(queue) header file must have been included. A priority queue is identical to a tt(queue), but allows the entry of data elements according to emi(priority rules). A real-life priority queue is found, e.g., at airport check-in terminals. At a terminal the passengers normally stand in line to wait for their turn to check in, but late passengers are usually allowed to jump the queue: they receive a higher priority than other passengers. The priority queue uses tt(operator<) of the data type stored in the priority queue to decide about the priority of the data elements. The em(smaller) the value, the em(lower) the priority. So, the priority queue em(could) be used to sort values while they arrive. A simple example of such a priority queue application is the following program: it reads words from tt(cin) and writes a sorted list of words to tt(cout): verbinclude(-a examples/prioritywords1.cc) Unfortunately, the words are listed in reversed order: because of the underlying tt(<)-operator the words appearing later in the i(ASCII)-sequence appear first in the priority queue. A solution to that problem is to define a em(wrapper class) around the tt(string) datatype, reversing tt(string)'s tt(operator<). Here is the modified program: verbinclude(-a examples/prioritywords2.cc) Other possibilities to achieve the same exist. One would be to store the contents of the priority queue in, e.g., a vector, from which the elements can be read in reversed order. The following constructors, operators, and member functions are available for the tt(priority_queue) container: itemization( it() hi(priority_queue) Constructors: itemization( it() The copy and move constructors are available; it() A tt(priority_queue) may be constructed empty: verb( priority_queue object; ) As with the tt(vector), it is an error to refer to an element of an empty priority queue. ) it() The tt(priority_queue) only supports the basic operators of containers. it() The following i(member functions) are available for priority queues: itemization( ithtq(empty)(bool empty())(returns tt(true) if the priority queue contains no elements.) ithtq(pop)(void pop())(removes the element at the top of the priority queue. Note that the element is em(not) returned by this member. Nothing happens if this member is called for an empty priority queue. See section ref(QUEUE) for a discussion about the reason why tt(pop) has return type tt(void).) ithtq(push)(void push(value))(inserts tt(value) at the appropriate position in the priority queue.) ithtq(size)(size_t size())(returns the number of elements in the priority queue.) ithtq(top)(Type &top())(returns a reference to the first element of the priority queue. It is the responsibility of the programmer to use the member only if the priority queue is not empty.) ) ) Note that the priority queue does not support iterators or a subscript operator. The only element that can be accessed is its top element. A priority queue can be emptied by: itemization( it() repeatedly removing its top element; it() assigning an empty queue using the same data type to it; it() having its destructor called. ) c++-annotations-10.5.0/yo/containers/unrestricted.yo0000644000175000017500000000360712635354026021360 0ustar frankfrankWe end this chapter about abstract containers with a small detour, introducing extensions to the tt(union) concept. Although unions themselves aren't `abstract containers', having covered containers puts us in a good position to introduce and illustrate hi(unrestricted union)em(unrestricted unions). Whereas traditional unions can only contain primitive data, unrestricted unions allow addition of data fields of types for which non-trivial constructors have been defined. Such data fields commonly are of class-types. Here is an example of such an unrestricted union: verb( union Union { int u_int; std::string u_string; }; ) One of its fields defines a constructor, turning this union into an em(unrestricted) union. As an unrestricted union defines at least one field of a type having a constructor the question becomes how these unions can be constructed and destroyed. The destructor of a union consisting of, e.g. a tt(std::string) and an tt(int) should of course not call the tt(string)'s destructor if the union's last (or only) use referred to its tt(int) field. Likewise, when the tt(std::string) field is used, and a switch is made next from the tt(std::string) to the tt(int) field, tt(std::string)'s destructor should be called before any assignment to the tt(double) field takes place. The compiler does not solve the issue for us, and in fact does em(not) implement default constructors or destructors for unrestricted unions at all. If we try to define an unrestricted union like the one shown above, an error message like the following is issued: verb( error: use of deleted function 'Union::Union()' error: 'Union::Union()' is implicitly deleted because the default definition would be ill-formed: error: union member 'Union::u_string' with non-trivial 'std::basic_string<...>::basic_string() ...' ) c++-annotations-10.5.0/yo/containers/allocator.yo0000644000175000017500000000274612635354026020630 0ustar frankfrankMost containers use a special object for allocating the memory that is managed by them. This object is called an i(allocator), and it's type is (usually by default) specified when a container is constructed. A container's allocator can be obtained using the container's tt(get_allocator) member, which returns a copy of the allocator used by the container. Allocators offer the following members: itemization( itht(address)(value_type *address(value_type &object)) quote(returns the address of tt(object).) itht(allocate)(value_type *allocate(size_t count)) quote(allocates raw memory for holding tt(count) values of the container's tt(value_type).) itht(construct)(void construct(value_type *object, Arg &&...args)) quote(using placement new, uses the arguments following tt(object) to install a value at tt(object).) itht(destroy)(void destroy(value_type *object)) quote(calls tt(object)'s destructor (but doesn't deallocate tt(object)'s own memory).) itht(deallocate member)(void deallocate(value_type *object, size_t count)) quote(calls tt(operator delete) to delete object's memory, previously allocated by tt(allocate).) itht(max_size)(size_t max_size()) quote(returns the maximum number of elements that tt(allocate) can allocate.) ) Here is an example, using the allocator of a vector of strings (see section ref(VECTOR) below for a description of the tt(vector) container): verbinclude(-a examples/allocator.cc) c++-annotations-10.5.0/yo/containers/notations.yo0000644000175000017500000000250412635354026020656 0ustar frankfrank In this chapter about containers, the following notational conventions are used: itemization( it() Containers live in the standard namespace. In code examples this will be clearly visible, but in the text tt(std::) is usually omitted. it() A i(container without angle brackets) represents any container of that type. Mentally add the required type in i(angle bracket notation). E.g., tt(pair) may represent tt(pair). it() The notation ti(Type) represents the i(generic type). tt(Type) could be tt(int), tt(string), etc. it() Identifiers tt(object) and tt(container) represent objects of the container type under discussion. it() The identifier tt(value) represents a value of the type that is stored in the container. it() Simple, one-letter identifiers, like tt(n) represent unsigned values. it() Longer identifiers represent i(iterator)iterators. Examples are tt(pos), tt(from), tt(beyond) ) Some containers, e.g., the tt(map) container, contain pairs of values, usually called `keys' and `values'. For such containers the following notational convention is used in addition: itemization( it() The identifier tt(key) indicates a value of the used key-type it() The identifier tt(keyvalue) indicates a value of the `tt(value_type)' used with the particular container. ) c++-annotations-10.5.0/yo/containers/assignment.yo0000644000175000017500000001405112635354026021010 0ustar frankfrankTo assign a tt(Data) object to another data object, we need an assignment operator. The standard mold for the assignment operator looks like this: verb( Class &Class::operator=(Class const &other) { Class tmp(other); swap(*this, tmp); return *this; } ) This implementation is exception safe: it offers the `commit or roll-back' guarantee (cf. section ref(CopyDestroy)). But can it be applied to tt(Data)? It depends. It depends on whether tt(Data) objects can be em(fast swapped) (cf. section ref(FSWAP)) or not. If tt(Union)'s fields can be fast swapped then we can simply swap bytes and we're done. In that case tt(Union) does not require any additional members (to be specific: it won't need an assignment operator). But now assume that tt(Union)'s fields cannot be fast swapped. How to implement an exception-safe assignment (i.e., an assignment offering the `commit or roll-back' guarantee) in that case? The tt(d_tag) field clearly isn't a problem, so we delegate the responsibility for proper assignment to tt(Union), implementing tt(Data)'s assignment operators as follows: verb( Data &Data::operator=(Data const &rhs) { if (d_union.assign(d_tag, rhs.d_union, rhs.d_tag)) d_tag = rhs.d_tag; return *this; } Data &Data::operator=(Data &&tmp) { if (d_union.assign(d_tag, std::move(tmp.d_union), tmp.d_tag)) d_tag = tmp.d_tag; return *this; } ) But now for tt(Union::assign). Assuming that both tt(Unions) use different fields, but swapping objects of the separate types is allowed. Now things may go wrong. Assume the left-side union uses type X, the right-side union uses type Y and both types use allocation. First, briefly look at standard swapping. It involves three steps: itemization( it() tt(tmp(lhs)): initialize a temporary objecct; it() tt(lhs = rhs): assign the rhs object to the lhs object; it() tt(rhs = tmp): assign the tmp object to the rhs ) Usually we assume that these steps do not throw exceptions, as tt(swap) itself shouldn't throw exceptions. How could we implement swapping for our union? Assume the fields are known (easily done by passing tt(Tag) values to tt(Union::swap)): itemization( it() tt(X tmp(lhs.x)): initialize a temporary X; it() in-place destroy lhs.x; placement new initialize lhs.y from rhs.y (alternatively: placement new default initialize lhs.y, then do the standard lhs.y = rhs.y) it() in-place destroy rhs.y; placement new initialize rhs.x from tmp (alternatively: placement new default initialize rhs.x, then do the standard rhs.x = tmp) ) By bf(C++)-standard requirement, the in-place destruction won't throw. Since the standard swap also performs an assignment that part should work fine as well. And since the standard swap also does a copy construction the placement new operations should perform fine as well, and if so, tt(Union) may be provided with the following tt(swap) member: verb( void Data::Union::swap(Tag myTag, Union &other, Tag oTag) { Union tmp(*this, myTag); // save lhs destroy(myTag); // destroy lhs copy(other, oTag); // assign rhs other.destroy(oTag); // destroy rhs other.copy(tmp, myTag); // save lhs via tmp } ) Now that tt(swap) is available tt(Data)'s assignment operators are easily realized: verb( Data &Data::operator=(Data const &rhs) { Data tmp(rhs); // tmp(std::move(rhs)) for the move assignment d_union.swap(d_tag, tmp.d_union, tmp.d_tag); swap(d_tag, tmp.d_tag); return *this; } ) What if the tt(Union) constructors em(could) throw? In that case we can provide tt(Data) with an 'commit or roll-back' assignment operator like this: verb( Data &Data::operator=(Data const &rhs) { Data tmp(rhs); // rolls back before throwing an exception d_union.assign(d_tag, rhs.d_union, rhs.d_tag); d_tag = rhs.d_tag; return *this; } ) How to implement tt(Union::assign)? Here are the steps tt(assign) must take: itemization( it() First save the current union in a block of memory. This merely involves a non-throwing tt(memcpy) operation; it() Then use placement new to copy the other object's union field into the current object. If this throws: itemization( it() catch the exception, restore the original tt(Union) from the saved block and rethrow the exception: we have rolled-back to our previous (valid) state. ) it() We still have to delete the original field's allocated data. To do so, we perform the following steps: itemization( it() (Fast) swap the current union's new contents with the contents in the previously saved block; it() Call tt(destroy) for the now restored original union; it() Re-install the new union from the memory block. ) As none of the above steps will throw, we have committed the new situation. ) Here is the implementation of the `commit or roll-back' tt(Union::assign): verb( void Data::Union::assign(Tag myTag, Union const &other, Tag otag) { char saved[sizeof(Union)]; memcpy(saved, this, sizeof(Union)); // raw copy: saved <- *this try { copy(other, otag); // *this = other: may throw fswap(*this, // *this <-> saved *reinterpret_cast(saved)); destroy(myTag); // destroy original *this memcpy(this, saved, sizeof(Union)); // install new *this } catch (...) // copy threw { memcpy(this, saved, sizeof(Union)); // roll back: restore *this throw; } } ) The source distribution contains tt(yo/containers/examples/unrestricted2.cc) offering a small demo-program in which the here developed tt(Data) class is used. c++-annotations-10.5.0/yo/containers/unorderedmapconstructors.yo0000644000175000017500000001072212635354026024017 0ustar frankfrankWhen defining an ti(unordered_map) type five template arguments must be specified : itemization( it() a i(KeyType) (becoming ti(unordered_map::key_type)), it() a i(ValueType) (becoming ti(unordered_map::mapped_type)), it() the type of an object computing a hash value from a key value (becoming ti(unordered_map::hasher)), and it() the type of an object that can compare two keys for equality (becoming ti(unordered_map::key_equal)). it() the type of its allocator. This is usually left unspecified, using the allocator provided by default by the implementor. ) The generic definition of an tt(unordered_map) container looks like this: verb( std::unordered_map ) When tt(KeyType) is tt(std::string) or a built-in type then default types are available for the hash type and the predicate type. In practice the allocator type is not specified, as the default allocator suffices. In these cases an tt(unordered_map) object can be defined by merely specifying the key- and value types, like this: verb( std::unordered_map hash(size_t size = implSize); ) Here, tt(implSize) is the container's default initial size, which is specified by the implementor. The map's size is automatically enlarged by the tt(unordered_map) when necessary, in which case the container em(rehashes) all its elements. In practice the default tt(size) argument provided by the implementor is completely satisfactory. The tt(KeyType) frequently consists of text. So, a tt(unordered_map) using a tt(std::string KeyType) is frequently used. Be careful not to use a plain tt(char const * key_type) as two tt(char const *) values pointing to equal bf(C)-strings stored at different locations are considered to be different keys, as their pointer values rather than their textual contents are compared. Here is an example showing how a tt(char const * KeyType) can be used. Note that in the example no arguments are specified when constructing tt(months), since default values and constructors are available: verbinclude(-a examples/hash2.cc) If other tt(KeyTypes) must be used, then the tt(unordered_map)'s constructor requires (constant references to) a hash function object, computing a hash value from a key value, and a predicate function object, returning tt(true) if two tt(unordered_map::key_type) objects are identical. A em(generic algorithm) (see chapter ref(GENERIC)) exists performing tests of equality (i.e., tt(equal_to)). These tests can be used if the key's data type supports the equality operator. Alternatively, an overloaded ti(operator==) or specialized i(function object) could be constructed returning tt(true) if two keys are equal and tt(false) otherwise. bf(Constructors) The tt(unordered_map) supports the following constructors: itemization( it() The copy and move constructors are available; itt(explicit unordered_map+CHAR(40)size_type n = implSize, hasher const &hf = hasher(),)nl() tt(key_equal const &eql = key_equal(),)nl() tt(allocator_type const &alloc = allocator_type()CHAR(41)): this constructor can also be used as default constructor; itt(unordered_map(const_iterator begin, const_iterator end, size_type n = implSize, hasher const &hf = hasher(), key_equal const &eql = key_equal(), allocator_type const &alloc = allocator_type())): this constructor expects two iterators specifying a range of tt(unordered_map::value_type const) objects, and itt(unordered_map(initializer_list initList, size_type n = implSize, hasher const &hf = hasher(), key_equal const &eql = key_equal(), allocator_type const &alloc = allocator_type())): a constructor expecting an tt(initializer_list) of tt(unordered_map::value_type) values. ) The following example shows a program using an unordered_map containing the names of the months of the year and the number of days these months (usually) have. Then, using the subscript operator the days in several months are displayed (the predicate used here is the generic algorithm tt(equal_to), which is provided by the compiler as the default fourth argument of the tt(unordered_map) constructor): verbinclude(-a examples/hash.cc) c++-annotations-10.5.0/yo/containers/map20000644000175000017500000000137112635354026017052 0ustar frankfrank The following members have special meanings with the link(multimap)(MULTIMAP), but they are defined with the plain tt(map) too: startit() itt(upper_bound(key_type key)): same as the previous function. itt(equal_range(key_type key)): a tt(pair) is returned. In the case of a tt(map), the range consists of the data element having as its key the key value that is passed to the function. If no such data element could be found, the pair tt((end(), end())) is returned. ) ithi(map::lower_bound())(map::iterator map::lower_bound(key): returns an iterator pointing to the first element having a key equal to or exceeding the key value that is passed to the member function. If no such value exists, tt(end()) is returned. c++-annotations-10.5.0/yo/containers/multimap.yo0000644000175000017500000000666312635354026020502 0ustar frankfrankLike the tt(map), the ti(multimap) class implements a (sorted) i(associative array). Before using a tt(multimap) container the header file tthi(map) must be included. The main difference between the tt(map) and the tt(multimap) is that the multimap supports multiple values associated with the same key, whereas the map contains single-valued keys. Note that the multimap also accepts multiple identical values associated with identical keys. The tt(map) and the tt(multimap) have the same set of constructors and member functions, with the exception of the i(index operator) which is not supported hi(multimap: no operator[]) with the multimap. This is understandable: if multiple entries of the same key are allowed, which of the possible values should be returned for tt(object[key])? Refer to section ref(MAP) for an overview of the tt(multimap) member functions. Some member functions, however, deserve additional attention when used in the context of the tt(multimap) container. These members are discussed below. itemization( ithtq(count)(size_t map::count(key))(returns the number of entries in the multimap associated with the given tt(key).) ithtq(erase)(... erase())(erases elements from the map:) itemization( itt(size_t erase(key)) erases all elements having the given tt(key). The number of erased elements is returned. itt(void erase(pos)) erases the single element pointed to by tt(pos). Other elements possibly having the same keys are not erased. itt(void erase(first, beyond)) erases all elements indicated by the iterator range rangett(first, beyond). ) ithtq(equal_range) (pair equal_range(key)) (returns a pair of iterators, being respectively the return values of tt(lower_bound) and tt(upper_bound), introduced below. The function provides a simple means to determine all elements in the tt(multimap) that have the same tt(keys). An example illustrating the use of these member functions is given at the end of this section.) ithtq(find)(multimap::iterator find(key))(this member returns an iterator pointing to the first value whose key is tt(key). If the element isn't available, tt(end) is returned. The iterator could be incremented to visit all elements having the same tt(key) until it is either tt(end), or the iterator's tt(first) member is not equal to tt(key) anymore.) ithtq(insert)(multimap::iterator insert())(this member function normally succeeds, and so a em(multimap::iterator) is returned, instead of a tt(pair) as returned with the tt(map) container. The returned iterator points to the newly added element.) ) Although the functions tt(lower_bound) and tt(upper_bound) act identically in the tt(map) and tt(multimap) containers, their operation in a tt(multimap) deserves some additional attention. The next example illustrates tt(lower_bound), tt(upper_bound) and tt(equal_range) applied to a tt(multimap): verbinclude(-a examples/multimap.cc) In particular note the following characteristics: itemization( itt(lower_bound) and tt(upper_bound) produce the same result for non-existing keys: they both return the first element having a key that exceeds the provided key. it() Although the keys are ordered in the tt(multimap), the values for equal keys are not ordered: they are retrieved in the order in which they were enterd. ) c++-annotations-10.5.0/yo/containers/unorderedmap.yo0000644000175000017500000000376212635354026021334 0ustar frankfrankIn bf(C++) hash tables are available as objects of the class ti(unordered_map). Before using tt(unordered_map) or tt(unordered_multimap) containers the header file tthi(unordered_map) must be included. The tt(unordered_map) class implements an i(associative array) in which the elements are stored according to some em(hashing) scheme. As discussed, the map is a sorted data structure. The keys in maps are sorted using the ti(operator<) of the key's data type. Generally, this is not the fastest way to either store or retrieve data. The main benefit of sorting is that a listing of sorted keys appeals more to humans than an unsorted list. However, a by far faster way to store and retrieve data is to use emi(hashing). Hashing uses a function (called the emi(hash function)) to compute an (unsigned) number from the key, which number is thereupon used as an index in the table storing the keys and their values. This number is called the emi(bucket number). Retrieval of a key is as simple as computing the i(hash value) of the provided key, and looking in the table at the computed index location: if the key is present, it is stored in the table, at the computed bucket location and its value can be returned. If it's not present, the key is not currently stored in the container. em(Collisions) hi(collision) occur when a computed index position is already occupied by another element. For these situations the abstract containers have solutions available. A simple solution, used by tt(unordered_maps), consists of using emi(linear chaining), which uses linked list to store colliding table elements. The term em(unordered_map) is used rather than em(hash) to avoid name collisions with hash tables developed before they were added to the language. Because of the hashing method, the emi(efficiency) of a tt(unordered_map) in terms of speed should greatly exceed the efficiency of the tt(map). Comparable conclusions may be drawn for the tt(unordered_set), the tt(unordered_multimap) and the tt(unordered_multiset). c++-annotations-10.5.0/yo/containers/examples/0000755000175000017500000000000012636507650020110 5ustar frankfrankc++-annotations-10.5.0/yo/containers/examples/multiset.cc0000644000175000017500000000402612636507652022271 0ustar frankfrank #include #include using namespace std; int main() { string sa[] = { "alpha", "echo", "hotel", "mike", "romeo" }; multiset object(&sa[0], &sa[5]); object.insert("echo"); object.insert("echo"); multiset::iterator it = object.find("echo"); for (; it != object.end(); ++it) cout << *it << " "; cout << '\n'; cout << "Multiset::equal_range(\"ech\")\n"; pair < multiset::iterator, multiset::iterator > itpair = object.equal_range("ech"); if (itpair.first != object.end()) cout << "lower_bound() points at " << *itpair.first << '\n'; for (; itpair.first != itpair.second; ++itpair.first) cout << *itpair.first << " "; cout << '\n' << object.count("ech") << " occurrences of 'ech'" << '\n'; cout << "Multiset::equal_range(\"echo\")\n"; itpair = object.equal_range("echo"); for (; itpair.first != itpair.second; ++itpair.first) cout << *itpair.first << " "; cout << '\n' << object.count("echo") << " occurrences of 'echo'" << '\n'; cout << "Multiset::equal_range(\"echoo\")\n"; itpair = object.equal_range("echoo"); for (; itpair.first != itpair.second; ++itpair.first) cout << *itpair.first << " "; cout << '\n' << object.count("echoo") << " occurrences of 'echoo'" << '\n'; } /* Generated output: echo echo echo hotel mike romeo Multiset::equal_range("ech") lower_bound() points at echo 0 occurrences of 'ech' Multiset::equal_range("echo") echo echo echo 3 occurrences of 'echo' Multiset::equal_range("echoo") 0 occurrences of 'echoo' */ c++-annotations-10.5.0/yo/containers/examples/listhashmaperase.OBS0000644000175000017500000000364312635354026024014 0ustar frankfrank/* The way to remove elements from a hash_map isn't intuitively obsious: a for_each construction can't be used, as the erase() during the for_each fucks up the for_each process. This also holds true for other gerneric algorithms in which iterators are used, like remove_if etc. The problem is probably caused by the fact that the keys in a hash_map aren't ordered, and therefore reordering keys isn't a well defined operation. the approach taken here is to collect the relevant keys in a set, and then iterate over the set of keys, removing the corresponding elements from the hash_map */ #include #include #include #include class Eraser { public: Eraser(set &keys) : keys(keys) {} void operator()(pair const &it) { if (*it.first == 'a' || *it.first == 'e') keys.insert(set::value_type(it.first)); } private: set &keys; }; class Remove { public: Remove(hash_map &hm) : hm(hm) {} void operator()(char const *cp) { hm.erase(cp); } private: hash_map &hm; }; class List { public: bool operator()(pair const &it) { cerr << it.first << " = " << it.second << '\n'; return true; } }; int main(int argc, char **argv) { hash_map hm; hm["a"] = 1; hm["b"] = 2; hm["c"] = 3; hm["d"] = 4; hm["e"] = 5; hm["f"] = 6; hm["g"] = 7; hm["h"] = 8; set keys; for_each(hm.begin(), hm.end(), Eraser(keys)); for_each(keys.begin(), keys.end(), Remove(hm)); for_each(hm.begin(), hm.end(), List()); } c++-annotations-10.5.0/yo/containers/examples/multimap.cc0000644000175000017500000000336712636507652022262 0ustar frankfrank #include #include using namespace std; int main() { pair pa[] = { pair("alpha", 1), pair("bravo", 2), pair("charley", 3), pair("bravo", 6), // unordered `bravo' values pair("delta", 5), pair("bravo", 4), }; multimap object(&pa[0], &pa[6]); typedef multimap::iterator msiIterator; msiIterator it = object.lower_bound("brava"); cout << "Lower bound for `brava': " << it->first << ", " << it->second << '\n'; it = object.upper_bound("bravu"); cout << "Upper bound for `bravu': " << it->first << ", " << it->second << '\n'; pair itPair = object.equal_range("bravo"); cout << "Equal range for `bravo':\n"; for (it = itPair.first; it != itPair.second; ++it) cout << it->first << ", " << it->second << '\n'; cout << "Upper bound: " << it->first << ", " << it->second << '\n'; cout << "Equal range for `brav':\n"; itPair = object.equal_range("brav"); for (it = itPair.first; it != itPair.second; ++it) cout << it->first << ", " << it->second << '\n'; cout << "Upper bound: " << it->first << ", " << it->second << '\n'; } /* Generated output: Lower bound for `brava': bravo, 2 Upper bound for `bravu': charley, 3 Equal range for `bravo': bravo, 2 bravo, 6 bravo, 4 Upper bound: charley, 3 Equal range for `brav': Upper bound: bravo, 2 */ c++-annotations-10.5.0/yo/containers/examples/hashclasses.h0000644000175000017500000001731212636507651022567 0ustar frankfrank#ifndef INCLUDED_HASHCLASSES_H_ #define INCLUDED_HASHCLASSES_H_ #include #include /* Note that with the Gnu g++ compiler 3.2 (and beyond?) the ext/ header uses the __gnu_cxx namespace for symbols defined in these header files. When using compilers before version 3.2, do: #define __gnu_cxx std before including this file to circumvent problems that may occur because of these namespace conventions which were not yet used in versions before 3.2. */ #include #include /* This file is copyright (c) GPL, 2001-2004 ========================================== august 2004: redundant include guards removed october 2002: provisions for using the hashclasses with the g++ 3.2 compiler were incorporated. april 2002: namespace FBB introduced abbreviated class templates defined, see the END of this comment section for examples of how to use these abbreviations. jan 2002: redundant include guards added, required header files adapted, for_each() rather than transform() used With hash_maps using char const * for the keys: ============ * Use `HashCharPtr' as 3rd template argument for case-sensitive keys * Use `HashCaseCharPtr' as 3rd template argument for case-insensitive keys * Use `EqualCharPtr' as 4th template argument for case-sensitive keys * Use `EqualCaseCharPtr' as 4th template argument for case-insensitive keys With hash_maps using std::string for the keys: =========== * Use `HashString' as 3rd template argument for case-sensitive keys * Use `HashCaseString' as 3rd template argument for case-insensitive keys * OMIT the 4th template argument for case-sensitive keys * Use `EqualCaseString' as 4th template argument for case-insensitive keys Examples, using int as the value type. Any other type can be used instead for the value type: // key is char const *, case sensitive __gnu_cxx::hash_map hashtab; // key is char const *, case insensitive __gnu_cxx::hash_map hashtab; // key is std::string, case sensitive __gnu_cxx::hash_map hashtab; // key is std::string, case insensitive __gnu_cxx::hash_map hashtab; Instead of the above full typedeclarations, the following shortcuts should work as well: FBB::CharPtrHash // key is char const *, case sensitive hashtab; FBB::CharCasePtrHash // key is char const *, case insensitive hashtab; FBB::StringHash // key is std::string, case sensitive hashtab; FBB::StringCaseHash // key is std::string, case insensitive hashtab; With these template types iterators and other map-members are also available. E.g., -------------------------------------------------------------------------- extern FBB::StringHash dh; for (FBB::StringHash::iterator it = dh.begin(); it != dh.end(); it++) std::cout << it->first << " - " << it->second << '\n'; -------------------------------------------------------------------------- Feb. 2001 - April 2002 Frank B. Brokken (f.b.brokken@rug.nl) */ namespace FBB { class HashCharPtr { public: size_t operator()(char const *str) const { return __gnu_cxx::hash()(str); } }; class EqualCharPtr { public: bool operator()(char const *x, char const *y) const { return !strcmp(x, y); } }; class HashCaseCharPtr { public: size_t operator()(char const *str) const { std::string s = str; for_each(s.begin(), s.end(), *this); return __gnu_cxx::hash()(s.c_str()); } void operator()(char &c) const { c = tolower(c); } }; class EqualCaseCharPtr { public: bool operator()(char const *x, char const *y) const { return !strcasecmp(x, y); } }; class HashString { public: size_t operator()(std::string const &str) const { return __gnu_cxx::hash()(str.c_str()); } }; class HashCaseString: public HashCaseCharPtr { public: size_t operator()(std::string const &str) const { return HashCaseCharPtr::operator()(str.c_str()); } }; class EqualCaseString { public: bool operator()(std::string const &s1, std::string const &s2) const { return !strcasecmp(s1.c_str(), s2.c_str()); } }; template class CharPtrHash: public __gnu_cxx::hash_map { public: CharPtrHash() {} template CharPtrHash(InputIterator first, InputIterator beyond) : __gnu_cxx::hash_map(first, beyond) {} }; template class CharCasePtrHash: public __gnu_cxx::hash_map { public: CharCasePtrHash() {} template CharCasePtrHash(InputIterator first, InputIterator beyond) : __gnu_cxx::hash_map (first, beyond) {} }; template class StringHash: public __gnu_cxx::hash_map { public: StringHash() {} template StringHash(InputIterator first, InputIterator beyond) : __gnu_cxx::hash_map (first, beyond) {} }; template class StringCaseHash: public __gnu_cxx::hash_map { public: StringCaseHash() {} template StringCaseHash(InputIterator first, InputIterator beyond) : __gnu_cxx::hash_map(first, beyond) {} }; template class Hash: public __gnu_cxx::hash_map(), equal()) {}; } #endif c++-annotations-10.5.0/yo/containers/examples/mapconstruct.cc0000644000175000017500000000175312636507652023151 0ustar frankfrank #include #include using namespace std; class MyClass { public: MyClass() { cout << "MyClass constructor\n"; } MyClass(MyClass const &other) { cout << "MyClass copy constructor\n"; } ~MyClass() { cout << "MyClass destructor\n"; } }; int main() { pair pairs[] = { pair("one", MyClass()) }; cout << "pairs constructed\n"; map mapsm(&pairs[0], &pairs[1]); cout << "mapsm constructed\n"; } /* Generated output: MyClass constructor MyClass copy constructor MyClass destructor pairs constructed MyClass copy constructor MyClass copy constructor MyClass destructor mapsm constructed MyClass destructor MyClass destructor */ c++-annotations-10.5.0/yo/containers/examples/mapinsert.cc0000644000175000017500000000231712636507652022426 0ustar frankfrank #include #include #include using namespace std; int main() { pair pa[] = { pair("one", 10), pair("two", 20), pair("three", 30), }; map object(&pa[0], &pa[3]); // {four, 40} and `true' is returned pair::iterator, bool> ret = object.insert ( map::value_type ("four", 40) ); cout << boolalpha; cout << ret.first->first << " " << ret.first->second << " " << ret.second << " " << object["four"] << '\n'; // {four, 40} and `false' is returned ret = object.insert ( map::value_type ("four", 0) ); cout << ret.first->first << " " << ret.first->second << " " << ret.second << " " << object["four"] << '\n'; } /* Generated output: four 40 true 40 four 40 false 40 */ c++-annotations-10.5.0/yo/containers/examples/unrestricted.cc0000644000175000017500000000645312636507652023144 0ustar frankfrank#include #include #include #include #include #include #include #include using namespace std; class Complex { public: Complex(double, double) { cout << "Complex constructor\n"; } Complex(Complex const &other) { cout << "Complex copy constructor\n"; } ~Complex() { cout << "Complex destructor\n"; } Complex &operator=(Complex const &other) { cout << "Complex operator=\n"; } }; class String { friend ostream &operator<<(ostream &out, String const &str); string d_str; public: String(std::string const &txt) : d_str(txt) { cout << "String constructor\n"; } String(String const &other) : d_str(other.d_str) { cout << "String copy constructor\n"; } ~String() { cout << "String destructor\n"; } String &operator=(String const &other) { d_str = other.d_str; cout << "String operator=\n"; } }; ostream &operator<<(ostream &out, String const &str) { return out << str.d_str; } union Union { #if 0 typedef complex Type1; typedef string Type2; #else typedef Complex Type1; typedef String Type2; #endif pair u_int; pair u_complex; pair u_string; Union(Union const &other); Union(int i); Union(double real, double imaginary); Union(string const &str); ~Union(); int &asInt(); Type1 &asComplex(); Type2 &asString(); Union &operator=(Union &&tmp); Union &operator=(Union const &rhs); void swap(Union &other); }; int &Union::asInt() { return u_int.second; } Union::Type1 &Union::asComplex() { return u_complex.second; } Union::Type2 &Union::asString() { return u_string.second; } Union::Union(Union const &other) { switch (other.u_int.first) { case 1: new (&u_int) pair(other.u_int); break; case 2: new (&u_complex) pair(other.u_complex); break; case 3: new (&u_string) pair(other.u_string); break; } } Union::Union(int i) : u_int(1, i) {} Union::Union(double real, double imaginary) : u_complex(2, {real, imaginary}) {} Union::Union(string const &str) : u_string(3, str) {} Union::~Union() { switch (u_int.first) { case 2: u_complex.second.~Type1(); break; case 3: u_string.second.~Type2(); break; } } Union &Union::operator=(Union &&tmp) { swap(tmp); return *this; } Union &Union::operator=(Union const &other) { Union tmp(other); return *this = std::move(tmp); } void Union::swap(Union &other) { char memory[sizeof(Union)]; memcpy(memory, &other, sizeof(Union)); memcpy(&other, this, sizeof(Union)); memcpy(this, memory, sizeof(Union)); } int main() { Union ustr("hello world"); Union ucom(12.4, 12.5); ustr = ucom; ustr = Union("hi there, again"); cout << ustr.asString() << '\n'; } c++-annotations-10.5.0/yo/containers/examples/listremove.cc0000644000175000017500000000106112636507652022610 0ustar frankfrank #include #include #include using namespace std; int main() { list object; object.push_back(string("Hello")); object.push_back(string("World")); object.push_back(string("Hello")); object.push_back(string("World")); object.remove(string("Hello")); while (object.size()) { cout << object.front() << '\n'; object.pop_front(); } } /* Generated output: World World */ c++-annotations-10.5.0/yo/containers/examples/listunique.cc0000644000175000017500000000231112636507652022620 0ustar frankfrank #include #include #include using namespace std; // see the merge() example void showlist(list &target) { for ( list::iterator from = target.begin(); from != target.end(); ++from ) cout << *from << " "; cout << '\n'; } int main() { string array[] = { "charley", "alpha", "bravo", "alpha" }; list target ( array, array + sizeof(array) / sizeof(string) ); cout << "Initially we have:\n"; showlist(target); target.sort(); cout << "After sort() we have:\n"; showlist(target); target.unique(); cout << "After unique() we have:\n"; showlist(target); } /* Generated output: Initially we have: charley alpha bravo alpha After sort() we have: alpha alpha bravo charley After unique() we have: alpha bravo charley */ c++-annotations-10.5.0/yo/containers/examples/mapfind.cc0000644000175000017500000000101212636507652022031 0ustar frankfrank #include #include using namespace std; int main() { map object; object["one"] = 1; map::iterator it = object.find("one"); cout << "`one' " << (it == object.end() ? "not " : "") << "found\n"; it = object.find("three"); cout << "`three' " << (it == object.end() ? "not " : "") << "found\n"; } /* Generated output: `one' found `three' not found */ c++-annotations-10.5.0/yo/containers/examples/hash.cc0000644000175000017500000000162712636507652021352 0ustar frankfrank #include #include #include using namespace std; int main() { unordered_map months; months["january"] = 31; months["february"] = 28; months["march"] = 31; months["april"] = 30; months["may"] = 31; months["june"] = 30; months["july"] = 31; months["august"] = 31; months["september"] = 30; months["october"] = 31; months["november"] = 30; months["december"] = 31; cout << "september -> " << months["september"] << '\n' << "april -> " << months["april"] << '\n' << "june -> " << months["june"] << '\n' << "november -> " << months["november"] << '\n'; } /* Generated output: september -> 30 april -> 30 june -> 30 november -> 30 */ c++-annotations-10.5.0/yo/containers/examples/listsplice.cc0000644000175000017500000000103312636507652022571 0ustar frankfrank#include #include #include using namespace std; int main() { list object; object.push_front(string("Hello")); object.push_back(string("World")); list argument(object); object.splice(++object.begin(), argument); cout << "Object contains " << object.size() << " elements, " << "Argument contains " << argument.size() << " elements,\n"; while (object.size()) { cout << object.front() << '\n'; object.pop_front(); } } c++-annotations-10.5.0/yo/containers/examples/regex.OBS0000644000175000017500000000167512635354026021574 0ustar frankfrank#include #include using namespace std; int main() { const char *reg_esp = "[ ,.\\t\\n;:]" ; // List of separator characters. regex rgx(reg_esp) ; // 'regex' is an instance of the template class // 'basic_regex' with argument of type 'char'. cmatch match ; // 'cmatch' is an instance of the template class // 'match_results' with argument of type 'const char *'. const char *target = "Polytechnic University of Turin " ; // Identifies all words of 'target' separated by characters of 'reg_esp'. if( regex_search( target, match, rgx ) ) { // If words separated by specified characters are present. const size_t n = match.size(); for( size_t a = 0 ; a < n ; a++ ) { string str( match[a].first, match[a].second ) ; cout << str << "\n" ; } } } c++-annotations-10.5.0/yo/containers/examples/hash2.cc0000644000175000017500000000165312636507652021433 0ustar frankfrank #include #include #include #include using namespace std; struct EqualCp { bool operator()(char const *l, char const *r) const { return strcmp(l, r) == 0; } }; struct HashCp { size_t operator()(char const *str) const { return std::hash()(str); } }; int main() { unordered_map months; // or explicitly: unordered_map monthsTwo(61, HashCp(), EqualCp()); months["april"] = 30; months["november"] = 31; string apr("april"); // different pointers, same string cout << "april -> " << months["april"] << '\n' << "april -> " << months[apr.c_str()] << '\n'; } c++-annotations-10.5.0/yo/containers/examples/vector.cc0000644000175000017500000000047212636507652021726 0ustar frankfrank#include #include #include using namespace std; int main() try { vector vi; // vi[0] = 12; // segfaults vi.at(0) = 12; // throws an exception } catch (std::exception const &exc) { cerr << typeid(exc).name() << ' ' << exc.what() << '\n'; } c++-annotations-10.5.0/yo/containers/examples/unrestricted2.cc0000644000175000017500000001133612636507652023222 0ustar frankfrank#include #include #include #include using namespace std; using namespace FBB; struct Data { enum Tag { INT, STRING }; private: union Union { int u_int; std::string u_string; Union(int value); Union(std::string const &init); Union(Union const &other) = delete; Union &operator=(Union const &other) = delete; Union(Union const &other, Tag tag); Union(Union &&tmp, Tag tag); ~Union(); // no action void destroy(Tag myTag); // use this instead void assign(Tag myTag, Union const &other, Tag otag); void assign(Tag myTag, Union &&tmp, Tag otag); void swap(Tag myTag, Union &other, Tag otag); private: void copy(Union const &other, Tag tag); void copy(Union &&other, Tag tag); }; Tag d_tag; Union d_union; public: // constructors Data(std::string const &str); Data(int value); Data(Data const &other); Data(Data &&tmp); ~Data(); Data &operator=(Data const &rhs); Data &operator=(Data &&rhs); string const &str() const; int value() const; }; void Data::Union::swap(Tag myTag, Union &other, Tag oTag) { Union tmp(*this, myTag); destroy(myTag); copy(other, oTag); other.destroy(oTag); other.copy(tmp, myTag); } void Data::Union::assign(Tag myTag, Union const &other, Tag otag) { char saved[sizeof(Union)]; memcpy(saved, this, sizeof(Union)); // raw copy: saved <- *this try { copy(other, otag); // *this = other: may throw // *this <-> saved fswap(*this, *reinterpret_cast(saved)); destroy(myTag); // destroy original *this memcpy(this, saved, sizeof(Union)); // install new *this } catch (...) // copy threw { memcpy(this, saved, sizeof(Union)); // roll back: restore *this throw; } } void Data::Union::assign(Tag myTag, Union &&tmp, Tag otag) { char saved[sizeof(Union)]; memcpy(saved, this, sizeof(Union)); try { copy(std::move(tmp), otag); fswap(*this, *reinterpret_cast(saved)); destroy(myTag); memcpy(this, saved, sizeof(Union)); } catch (...) { memcpy(this, saved, sizeof(Union)); throw; } } inline Data::Union::Union(Union const &other, Tag tag) { copy(other, tag); } inline Data::Union::Union(Union &&tmp, Tag tag) { copy(std::move(tmp), tag); } void Data::Union::destroy(Tag myTag) { if (myTag == Tag::STRING) u_string.~string(); } void Data::Union::copy(Union const &other, Tag tag) { if (tag == INT) u_int = other.u_int; else new (this) string(other.u_string); } void Data::Union::copy(Union &&tmp, Tag tag) { if (tag == INT) u_int = tmp.u_int; else new (this) string(std::move(tmp.u_string)); } inline Data::Union::~Union() {}; inline Data::Union::Union(int value) : u_int(value) {} inline Data::Union::Union(std::string const &str) : u_string(str) {} Data::Data(Data const &other) : d_tag(other.d_tag), d_union(other.d_union, d_tag) {} Data::Data(Data &&tmp) : d_tag(tmp.d_tag), d_union(std::move(tmp.d_union), d_tag) {} // destructor Data::~Data() { d_union.destroy(d_tag); } // overloaded assignment operator Data &Data::operator=(Data const &rhs) { Data tmp(rhs); d_union.swap(d_tag, tmp.d_union, tmp.d_tag); swap(d_tag, tmp.d_tag); // if (d_union.assign(d_tag, rhs.d_union, rhs.d_tag)) // d_tag = rhs.d_tag; return *this; } Data &Data::operator=(Data &&tmp) { d_union.assign(d_tag, std::move(tmp.d_union), tmp.d_tag); d_tag = tmp.d_tag; return *this; } // accessors inline string const &Data::str() const { return d_union.u_string; } inline int Data::value() const { return d_union.u_int; } Data::Data(std::string const &str) : d_tag(STRING), d_union(str) {} Data::Data(int value) : d_tag(INT), d_union(value) {} int main(int argc, char **argv) { Data v(2); cout << v.value() << '\n'; Data a("hi"); Data b("lo"); cout << a.str() << ' ' << b.str() << '\n'; a = b; cout << a.str() << ' ' << b.str() << '\n'; a = v; cout << v.value() << '\n'; a = b; cout << a.str() << ' ' << b.str() << '\n'; a = a; cout << a.str() << ' ' << b.str() << '\n'; } c++-annotations-10.5.0/yo/containers/examples/prioritywords2.cc0000644000175000017500000000114512636507652023444 0ustar frankfrank#include #include #include class Text { std::string d_s; public: Text(std::string const &str) : d_s(str) {} operator std::string const &() const { return d_s; } bool operator<(Text const &right) const { return d_s > right.d_s; } }; using namespace std; int main() { priority_queue q; string word; while (cin >> word) q.push(word); while (q.size()) { word = q.top(); cout << word << '\n'; q.pop(); } } c++-annotations-10.5.0/yo/containers/examples/listhashmapErase2.OBS0000644000175000017500000000400612635354026024030 0ustar frankfrank/* The way to remove elements from a hash_map isn't intuitively obsious: a for_each construction can't be used, as the erase() during the for_each fucks up the for_each process. This also holds true for other gerneric algorithms in which iterators are used, like remove_if etc. The problem is probably caused by the fact that the keys in a hash_map aren't ordered, and therefore reordering keys isn't a well defined operation. the approach taken here is to find successive elements in the hash_map, using a Finder object. Each object found is then removed outside of the iterating loop. The assumption being that iterators can be incremented while the element still exist, and that the element can safely be removed after incrementing the iterator. Also, the end() iterator is assumed not to change it value when intermediate elements of the hash_map are erased. Hence, the procedure is based on the functioning of a construction like hm.erase(iterator++) */ #include #include #include class Finder { public: bool operator()(pair const &it) { cout << "Saw " << it.first << '\n'; return *it.first == 'a' || *it.first == 'e'; } }; class List { public: void operator()(pair const &it) { cout << "Element [" << it.first << "] = " << it.second << '\n'; } }; int main(int argc, char **argv) { hash_map hm; hm["a"] = 1; hm["b"] = 2; hm["c"] = 3; hm["d"] = 4; hm["e"] = 5; hm["f"] = 6; hm["g"] = 7; hm["h"] = 8; hash_map::iterator end = hm.end(), found = hm.begin(); while ((found = find_if(found, end, Finder())) != end) { cout << "Removing " << found->first << " " << found->second << '\n'; hm.erase(found++); } cout << "\nListing:\n\n"; for_each(hm.begin(), hm.end(), List()); } c++-annotations-10.5.0/yo/containers/examples/listmaperase.OBS0000644000175000017500000000140112635354026023136 0ustar frankfrank/* This example shows that the map's erase() function does not use the delete operator if the data element of the map is a pointer. Remove the explicit delete operator and notice that the destructor isn't called anymore */ #include #include class Item { public: ~Item() { cerr << "Destructor called\n"; } }; int main(int argc, char **argv) { hash_map hm; if (hm["item"]) cout << "hm[item] exists\n"; else cout << "hm[item] does not exist\n"; hm["item"] = new Item; delete hm["item"]; hm.erase("item"); if (hm["item"]) cout << "hm[item] exists\n"; else cout << "hm[item] does not exist\n"; } c++-annotations-10.5.0/yo/containers/examples/complexstack.cc0000644000175000017500000000102612636507652023115 0ustar frankfrank #include #include #include using namespace std; int main() { stack> cstack; cstack.push(complex(3.14, 2.71)); cstack.push(complex(-3.14, -2.71)); while (cstack.size()) { cout << cstack.top().real() << ", " << cstack.top().imag() << "i" << '\n'; cstack.pop(); } } /* Generated output: -3.14, -2.71i 3.14, 2.71i */ c++-annotations-10.5.0/yo/containers/examples/maptable.cc0000644000175000017500000000133612636507652022211 0ustar frankfrank #include #include #include using namespace std; int main() { pair pa[] = { pair("one", 10), pair("two", 20), pair("three", 30), }; map object(&pa[0], &pa[3]); for ( map::iterator it = object.begin(); it != object.end(); ++it ) cout << setw(5) << it->first.c_str() << setw(5) << it->second << '\n'; } /* Generated output: one 10 three 30 two 20 */ c++-annotations-10.5.0/yo/containers/examples/mapbounds.cc0000644000175000017500000000376212636507652022421 0ustar frankfrank #include #include using namespace std; int main() { pair pa[] = { pair("one", 10), pair("two", 20), pair("three", 30), }; map object(&pa[0], &pa[3]); map::iterator it; if ((it = object.lower_bound("tw")) != object.end()) cout << "lower-bound `tw' is available, it is: " << it->first << '\n'; if (object.lower_bound("twoo") == object.end()) cout << "lower-bound `twoo' not available" << '\n'; cout << "lower-bound two: " << object.lower_bound("two")->first << " is available\n"; if ((it = object.upper_bound("tw")) != object.end()) cout << "upper-bound `tw' is available, it is: " << it->first << '\n'; if (object.upper_bound("twoo") == object.end()) cout << "upper-bound `twoo' not available" << '\n'; if (object.upper_bound("two") == object.end()) cout << "upper-bound `two' not available" << '\n'; pair < map::iterator, map::iterator > p = object.equal_range("two"); cout << "equal range: `first' points to " << p.first->first << ", `second' is " << ( p.second == object.end() ? "not available" : p.second->first ) << '\n'; } /* Generated output: lower-bound `tw' is available, it is: two lower-bound `twoo' not available lower-bound two: two is available upper-bound `tw' is available, it is: two upper-bound `twoo' not available upper-bound `two' not available equal range: `first' points to two, `second' is not available */ c++-annotations-10.5.0/yo/containers/examples/listmerge.cc0000644000175000017500000000147312636507652022421 0ustar frankfrank #include #include #include using namespace std; void showlist(list &target) { for ( list::iterator from = target.begin(); from != target.end(); ++from ) cout << *from << " "; cout << '\n'; } int main() { list first; list second; first.push_back(string("alpha")); first.push_back(string("bravo")); first.push_back(string("golf")); first.push_back(string("quebec")); second.push_back(string("oscar")); second.push_back(string("mike")); second.push_back(string("november")); second.push_back(string("zulu")); first.merge(second); showlist(first); } c++-annotations-10.5.0/yo/containers/examples/allocator.cc0000644000175000017500000000166212636507652022406 0ustar frankfrank#include #include #include using namespace std; int main() { vector vs; auto allocator = vs.get_allocator(); // get the allocator string *sp = allocator.allocate(3); // alloc. space for 3 strings allocator.construct(&sp[0], "hello world"); // initialize 1st string allocator.construct(&sp[1], sp[0]); // use the copy constructor allocator.construct(&sp[2], 12, '='); // string of 12 = chars cout << sp[0] << '\n' << // show the strings sp[1] << '\n' << sp[2] << '\n' << "could have allocated " << allocator.max_size() << " strings\n"; for (size_t idx = 0; idx != 3; ++idx) allocator.destroy(sp + idx); // delete the string's // contents allocator.deallocate(sp, 3); // and delete sp itself again. } c++-annotations-10.5.0/yo/containers/examples/prioritywords1.cc0000644000175000017500000000041612636507652023443 0ustar frankfrank#include #include #include using namespace std; int main() { priority_queue q; string word; while (cin >> word) q.push(word); while (q.size()) { cout << q.top() << '\n'; q.pop(); } } c++-annotations-10.5.0/yo/containers/set/0000755000175000017500000000000012636507650017065 5ustar frankfrankc++-annotations-10.5.0/yo/containers/set/insert.cc0000644000175000017500000000074712636507652020712 0ustar frankfrank#include #include #include using namespace std; int main() { set object; pair::iterator, bool> result = object.insert(set::value_type(4)); cout << "Element " << *result.first << " was " << (result.second ? "" : "not ") << "inserted\n"; result = object.insert(set::value_type(4)); cout << "Element " << *result.first << " was " << (result.second ? "" : "not ") << "inserted\n"; } c++-annotations-10.5.0/yo/containers/dellist.fig0000644000175000017500000000246512635354026020424 0ustar frankfrank#FIG 3.2 Landscape Center Inches Letter 100.00 Single -2 1200 2 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 600 600 1650 600 1650 1350 600 1350 600 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 2325 600 3375 600 3375 1350 2325 1350 2325 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 4200 600 5250 600 5250 1350 4200 1350 4200 600 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 225 2100 225 675 600 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5250 675 6375 675 6375 1725 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5700 1950 5700 1200 5250 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 5 1 1 2.00 120.00 240.00 600 1200 450 1200 450 1650 900 1650 900 1875 2 1 0 2 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 2.00 120.00 240.00 1650 675 1800 675 1800 375 3900 375 3900 675 4200 675 2 1 0 2 0 -1 0 0 -1 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 3375 675 4200 675 2 1 0 2 0 -1 0 0 -1 0.000 0 0 -1 1 0 6 1 1 2.00 120.00 240.00 4200 1275 3900 1275 3900 1650 2025 1650 2025 1275 1650 1275 2 1 0 2 0 -1 0 0 -1 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 2325 1275 1650 1275 4 0 0 0 0 0 18 0.0000 4 255 1125 975 2025 0 (NULL)\001 4 0 0 0 0 0 18 0.0000 4 255 1125 6525 1875 0 (NULL)\001 4 2 0 0 0 0 18 0.0000 4 195 555 5700 2250 Back\001 4 0 0 0 0 0 18 0.0000 4 195 645 225 2475 Front\001 c++-annotations-10.5.0/yo/containers/mapconstructors.yo0000644000175000017500000000532612635354026022113 0ustar frankfrank The following hi(map constructors) constructors are available for the tt(map) container: itemization( it() The copy and move constructors are available; it() A tt(map) may be constructed empty: verb( map object; ) Note that the values stored in maps may be containers themselves. For example, the following defines a tt(map) in which the value is a tt(pair): a container hi(nested container) hi(container: nested) nested under another container: verb( map> object; ) Note the use of the two hi(>>: with templates)hi(angle brackets: consecutive) i(consecutive closing angle brackets), which does not result in ambiguities as their syntactical context differs from their use as binary operators in expressions. it() A map may be initialized using two iterators. The iterators may either point to tt(value_type) values for the map to be constructed, or to plain ti(pair) objects. If pairs are used, their tt(first) element represents the type of the keys, and their tt(second) element represents the type of the values. Example: verb( pair pa[] = { pair("one", 1), pair("two", 2), pair("three", 3), }; map object(&pa[0], &pa[3]); ) In this example, tt(map::value_type) could have been written instead of tt(pair) as well. If tt(begin) represents the first iterator that is used to construct a map and if tt(end) represents the second iterator, rangett(begin, end) will be used to initialize the map. Maybe contrary to intuition, the tt(map) constructor only enters em(new) keys. If the last element of tt(pa) would have been tt("one", 3), only em(two) elements would have entered the tt(map): tt("one", 1) and tt("two", 2). The value tt("one", 3) would silently have been ignored. The tt(map) receives its own copies of the data to which the iterators point as illustrated by the following example: verbinclude(-a examples/mapconstruct.cc) When tracing the output of this program, we see that, first, the constructor of a tt(MyClass) object is called to initialize the anonymous element of the array tt(pairs). This object is then copied into the first element of the array tt(pairs) by the copy constructor. Next, the original element is not required anymore and is destroyed. At that point the array tt(pairs) has been constructed. Thereupon, the tt(map) constructs a temporary tt(pair) object, which is used to construct the map element. Having constructed the map element, the temporary tt(pair) object is destroyed. Eventually, when the program terminates, the tt(pair) element stored in the tt(map) is destroyed too. ) c++-annotations-10.5.0/yo/containers/list.fig0000644000175000017500000000234512635354026017734 0ustar frankfrank#FIG 3.2 Landscape Center Inches Letter 100.00 Single -2 1200 2 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 600 600 1650 600 1650 1350 600 1350 600 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 2325 600 3375 600 3375 1350 2325 1350 2325 600 2 2 0 1 0 6 0 0 17 0.000 0 0 -1 0 0 5 4200 600 5250 600 5250 1350 4200 1350 4200 600 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 225 2100 225 675 600 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 1650 675 2325 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 3375 675 4200 675 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5250 675 6375 675 6375 1725 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 3 1 1 2.00 120.00 240.00 5700 1950 5700 1200 5250 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 4200 1200 3375 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 2 1 1 2.00 120.00 240.00 2325 1200 1650 1200 2 1 0 2 0 7 0 0 20 0.000 0 0 -1 1 0 5 1 1 2.00 120.00 240.00 600 1200 450 1200 450 1650 900 1650 900 1875 4 0 0 0 0 0 18 0.0000 4 255 1125 975 2025 0 (NULL)\001 4 0 0 0 0 0 18 0.0000 4 255 1125 6525 1875 0 (NULL)\001 4 2 0 0 0 0 18 0.0000 4 195 555 5700 2250 Back\001 4 0 0 0 0 0 18 0.0000 4 195 645 225 2475 Front\001 c++-annotations-10.5.0/yo/containers/map.yo0000644000175000017500000000575412635354026017427 0ustar frankfrankThe ti(map) class offers a (sorted) i(associative array). Before using a tt(map) container the tthi(map) header file must be included. A tt(map) is filled with emi(key/value) pairs, which may be of any container-accepted type. Since types are associated with both the key and the value, we must specify em(two types) in the angle bracket notation, comparable to the specification we've seen with the tt(pair) container (cf. section ref(PAIR)). The first type represents the key's type, the second type represents the value's type. For example, a tt(map) in which the key is a tt(string) and the value is a tt(double) can be defined as follows: verb( map object; ) The emi(key) is used to access its associated information. That information is called the emi(value). For example, a phone book uses the names of people as the key, and uses the telephone number and maybe other information (e.g., the zip-code, the address, the profession) as value. Since a tt(map) sorts its keys, the tt(key)'s ti(operator<) must be defined, and it must be sensible to use it. For example, it is generally a bad idea to use pointers for keys, as sorting pointers is something different than sorting the values pointed at by those pointers. The two fundamental operations on maps are the storage of em(Key/Value) combinations, and the retrieval of values, given their keys. The index operator using a key as the index, can be used for both. If the index operator is used as em(lvalue), the expression's tt(rvalue) is inserted into the map. If it is used as em(rvalue), the key's associated value is retrieved. Each key can be stored only once in a tt(map). If the same key is entered again, the new value replaces the formerly stored value, which is lost. A specific key/value combination can implicitly or explicitly be inserted into a tt(map). If explicit insertion is required, the key/value combination must be constructed first. For this, every tt(map) defines a ti(value_type) which may be used to create values that can be stored in the tt(map). For example, a value for a tt(map) can be constructed as follows: verb( map::value_type siValue("Hello", 1); ) The tt(value_type) is associated with the tt(map): the type of the key is tt(string), the type of the value is tt(int). Anonymous tt(value_type) objects are also often used. E.g., verb( map::value_type("Hello", 1); ) Instead of using the line tt(map::value_type(...)) over and over again, a ti(typedef) is frequently used to reduce typing and to improve readability: verb( typedef map::value_type StringIntValue ) Using this typedef, values for the tt(map) may now be constructed using: verb( StringIntValue("Hello", 1); ) Alternatively, tt(pairs) may be used to represent key/value combinations used by maps: verb( pair("Hello", 1); ) c++-annotations-10.5.0/yo/containers/queue/0000755000175000017500000000000012636507650017416 5ustar frankfrankc++-annotations-10.5.0/yo/containers/queue/front.cc0000644000175000017500000000033712636507652021062 0ustar frankfrank#include #include #include using namespace std; int main() { queue q; q.push("Hello"); q.front() = "Hello World"; cout << q.front() << '\n'; return (0); } c++-annotations-10.5.0/yo/containers/set.yo0000644000175000017500000001602512635354026017436 0ustar frankfrankThe ti(set) class implements a i(sorted collection of values). Before using tt(set) containers the tthi(set) header file must be included. A set contains unique values (of a container-acceptable type). Each value is stored only once. A specific value can be explicitly created: Every tt(set) defines a ti(value_type) which may be used to create values that can be stored in the tt(set). For example, a value for a tt(set) can be constructed as follows: verb( set::value_type setValue("Hello"); ) The tt(value_type) is associated with the tt(set). Anonymous tt(value_type) objects are also often used. E.g., verb( set::value_type("Hello"); ) Instead of using the line tt(set::value_type(...)) over and over again, a tt(typedef) is often used to reduce typing and to improve readability: verb( typedef set::value_type StringSetValue ) Using this typedef, values for the tt(set) may be constructed as follows: verb( StringSetValue("Hello"); ) Alternatively, values of the set's type may be used immediately. In that case the value of type tt(Type) is implicitly converted to a tt(set::value_type). The following constructors, operators, and member functions are available for the tt(set) container: itemization( it() Constructors: itemization( it() The copy and move constructors are available; it() A tt(set) may be constructed empty: verb( set object; ) it() A set may be initialized using two iterators. For example: verb( int intarr[] = {1, 2, 3, 4, 5}; set object(&intarr[0], &intarr[5]); ) ) Note that all values in the set must be different: it is not possible to store the same value repeatedly when the set is constructed. If the same value occurs repeatedly, only the first instance of the value is entered into the set; the remaining values are silently ignored. Like the link(map)(MAP), the tt(set) receives its own copy of the data it contains. it() The tt(set) container only supports the standard set of operators that are available for containers. it() The tt(set) class has the following member functions: itemization( ithtq(begin)(set::iterator begin())(returns an i(iterator) pointing to the first element of the set. If the set is empty tt(end) is returned.) ithtq(clear)(void clear()) (erases all elements from the set.) ithtq(count)(size_t count(key))(returns 1 if the provided key is available in the tt(set), otherwise 0 is returned.) ithtq(empty)(bool empty())(returns tt(true) if the set contains no elements.) ithtq(end)(set::iterator end())(returns an iterator pointing beyond the last element of the set.) ithtq(equal_range) (pair equal_range(key))(this member returns a pair of iterators, being respectively the return values of the member functions tt(lower_bound) and tt(upper_bound), introduced below.) ithtq(erase)(... erase())(erases a specific element or range of elements from the set:) itemization( itt(bool erase(value)) erases the element having the given tt(value) from the tt(set). tt(True) is returned if the value was removed, tt(false) if the set did not contain an element `tt(value)'. itt(void erase(pos)) erases the element pointed to by the iterator tt(pos). itt(void erase(first, beyond)) erases all elements indicated by the iterator range rangett(first, beyond). ) ithtq(find)(set::iterator find(value))(returns an iterator to the element having the given value. If the element isn't available, tt(end) is returned.) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(set) object.) ithtq(insert)(... insert())(inserts elements into the tt(set). If the element already exists, the existing element is left untouched and the element to be inserted is ignored. The return value depends on the version of tt(insert) that is called:) itemization( itt(pair insert(keyvalue)) inserts a new tt(set::value_type) into the set. The return value is a ti(pair). If the returned ti(bool) field is tt(true), tt(value) was inserted into the set. The value tt(false) indicates that the value that was specified was already available in the set, and so the provided tt(value) was not inserted into the set. In both cases the tt(set::iterator) field points to the data element in the tt(set) having the specified tt(value). itt(set::iterator insert(pos, keyvalue)). This way a tt(set::value_type) may also be inserted into the set. tt(pos) is ignored, and an iterator to the inserted element is returned. itt(void insert(first, beyond)) inserts the (tt(set::value_type)) elements pointed to by the i(iterator range) rangeti(first, beyond) into the set. ) ithtq(key_comp)(key_compare key_comp()) (returns a copy of the object used by the tt(set) to compare keys. The type nl() tt(set::key_compare) is defined by the set container and tt(key_compare)'s parameters have types tt(ValueType const &). The comparison function returns tt(true) if its first argument should be ordered before its second argument.) ithtq(lower_bound) (set::iterator lower_bound(key)) (returns an iterator pointing to the first tt(keyvalue) element of which the tt(key) is at least equal to the specified tt(key). If no such element exists, the function returns tt(end).) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(set) may contain.) ithtq(rbegin)(set::reverse_iterator rbegin())( hi(reverse_iterator) returns an iterator pointing to the last element of the set.) ithtq(rend)(set::reverse_iterator rend)(returns an iterator pointing before the first element of the set.) ithtq(size)(size_t size())(returns the number of elements in the set.) ithtq(swap)(void swap(argument))(swaps two sets (tt(argument) being the second set) that use identical data types.) ithtq(upper_bound) (set::iterator upper_bound(key)) (returns an iterator pointing to the first tt(keyvalue) element having a tt(key) exceeding the specified tt(key). If no such element exists, the function returns tt(end).) ) ithtq(value_comp)(value_compare value_comp()) (returns a copy of the object used by the tt(set) to compare keys. The type nl() tt(set::value_compare) is defined by the set container and tt(value_compare)'s parameters have types tt(ValueType const &). The comparison function returns tt(true) if its first argument should be ordered before its second argument. Its operation is identical to that of a tt(key_compare) object, returned by tt(key_comp).) ) c++-annotations-10.5.0/yo/containers/deque.yo0000644000175000017500000001733212635354026017750 0ustar frankfrankThe ti(deque) (pronounce: `deck') class implements a i(doubly ended queue) data structure (deque). Before using a tt(deque) container the header file tthi(deque) must be included. A tt(deque) is comparable to a queue, but it allows for reading and writing at both ends. Actually, the tt(deque) data type supports a lot more functionality than the tt(queue), as illustrated by the following overview of available member functions. A tt(deque) is a combination of a tt(vector) and two queues, operating at both ends of the vector. In situations where random insertions and the addition and/or removal of elements at one or both sides of the vector occurs frequently using a tt(deque) should be considered. The following constructors, operators, and member functions are available for deques: itemization( it() hi(deque constructors) Constructors: itemization( it() The copy and move constructors are available; it() A tt(deque) may be constructed empty: verb( deque object; ) As with the tt(vector), it is an error to refer to an element of an empty deque. it() A deque may be initialized to a certain number of elements. By default, if the initialization value is not explicitly mentioned, the default value or default constructor for the actual data type is used. For example: verb( deque object(5, string("Hello")), // initialize to 5 Hello's deque container(10); // and to 10 empty strings ) it() A deque may be initialized using two iterators. To initialize a deque with elements 5 until 10 (including the last one) of a tt(vector) the following construction may be used: verb( extern vector container; deque object(&container[5], &container[11]); ) ) it() In addition to the standard operators for containers, the deque supports the i(index operator), which may be used to retrieve or reassign random elements of the deque. Note that the indexed elements must exist. it() The following member functions are available for deques: itemization( itht(assign)(void assign(...)): quote(assigns new contents to the deque:) itemization( itt(assign(iterator begin, iterator end)) assigns the values at the iterator range rangett(begin, end) to the deque; itt(assign(size_type n, value_type const &val)) assigns tt(n) copies of tt(val) to the deque; ) itht(at)(Type &at(size_t idx)): quote(returns a reference to the deque's element at index position tt(idx). If tt(idx) exceeds the deque's size a tt(std::out_of_range) exception is thrown.) ithtq(back)(Type &back())(returns a reference to the last element in the deque. It is the i(responsibility of the programmer) to use the member only if the deque is not empty.) ithtq(begin)(deque::iterator begin())(returns an i(iterator) pointing to the first element in the deque. ) itht(cbegin)(deque::const_iterator cbegin()): quote(returns a i(const_iterator) pointing to the first element in the deque, returning tt(cend) if the deque is empty.) itht(cend)(deque::const_iterator cend()): quote(returns a i(const_iterator) pointing just beyond the deque's last element.) ithtq(clear)(void clear())(erases all elements in the deque.) itht(crbegin)(deque::const_reverse_iterator crbegin()): quote(returns a i(const_reverse_iterator) pointing to the last element in the deque, returning tt(crend) if the deque is empty.) itht(crend)(deque::const_reverse_iterator crend()): quote(returns a i(const_reverse_iterator) pointing just before the deque's first element.) itht(emplace) (iterator emplace(const_iterator position, Args &&...args)) quote(a tt(value_type) object is constructed from the arguments specified after tt(position), and the newly created element is inserted at tt(position).) itht(emplace_back)(void emplace_back(Args &&...args)) quote(a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted beyond the deque's last element.) itht(emplace_front)(void emplace_front(Args &&...args)) quote(a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted before the deque's first element.) ithtq(empty)(bool empty())(returns tt(true) if the deque contains no elements.) ithtq(end)(deque::iterator end())(returns an iterator pointing beyond the last element in the deque. ) ithtq(erase)(deque::iterator erase())(the member can be used to erase a specific range of elements in the deque:) itemization( itt(erase(pos)) erases the element pointed to by tt(pos). The iterator tt(++pos) is returned. itt(erase(first, beyond)) erases elements indicated by the iterator range rangett(first, beyond). tt(Beyond) is returned. ) ithtq(front)(Type &front())(returns a reference to the first element in the deque. It is the responsibility of the programmer to use the member only if the deque is not empty.) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(deque) object.) ithtq(insert)(... insert())(inserts elements starting at a certain position. The return value depends on the version of tt(insert) that is called:) itemization( itt(deque::iterator insert(pos)) inserts a default value of type tt(Type) at tt(pos), tt(pos) is returned. itt(deque::iterator insert(pos, value)) inserts tt(value) at tt(pos), tt(pos) is returned. itt(void insert(pos, first, beyond)) inserts the elements in the i(iterator range) rangeti(first, beyond). itt(void insert(pos, n, value)) inserts tt(n) elements having value tt(value) starting at iterator position tt(pos). ) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(deque) may contain.) ithtq(pop_back)(void pop_back())(removes the last element from the deque. With an i(empty deque) nothing happens.) ithtq(pop_front)(void pop_front())(removes the first element from the deque. With an i(empty deque) nothing happens.) ithtq(push_back)(void push_back(value))(adds tt(value) to the end of the deque.) ithtq(push_front)(void push_front(value))(adds tt(value) before the first element of the deque.) ithtq(rbegin)(deque::reverse_iterator rbegin())( hi(reverse_iterator) returns an iterator pointing to the last element in the deque.) ithtq(rend)(deque::reverse_iterator rend())(this member returns an iterator pointing before the first element in the deque.) ithtq(resize)(void resize())(alters the number of elements that are currently stored in the deque:) itemization( itt(resize(n, value)) may be used to resize the deque to a size of tt(n). tt(Value) is optional. If the deque is expanded and tt(value) is not provided, the additional elements are initialized to the i(default value) of the used data type, otherwise tt(value) is used to initialize extra elements. ) ithtq(shrink_to_fit)(void shrink_to_fit())(optionally reduces the amount of memory allocated by a deque to its current size. The implementor is free to ignore or otherwise optimize this request. In order to guarantee a `shrink to fit' operation tt(deque(dequeObject).swap(dequeObject)) idiom can be used.) ithtq(size)(size_t size())(returns the number of elements in the deque.) ithtq(swap)(void swap(argument))(swaps two deques using identical data types.) ) ) c++-annotations-10.5.0/yo/containers/container.yo0000644000175000017500000002014412635354026020622 0ustar frankfrankbf(C++) offers several predefined datatypes, all part of the link(Standard Template Library)(STL), which can be used to implement solutions to frequently occurring problems. The datatypes discussed in this chapter are all hi(container) em(containers): you can put stuff inside them, and you can retrieve the stored information from them. The interesting part is that the kind of data that can be stored inside these containers has been left unspecified at the time the containers were constructed. That's why they are spoken of as em(abstract) containers. Abstract containers rely heavily on em(templates), covered in chapter ref(TEMPLATES) and beyond. To use abstract containers, only a minimal grasp of the template concept is required. In bf(C++) a template is in fact a recipe for constructing a function or a complete class. The recipe tries to abstract the functionality of the class or function as much as possible from the data on which the class or function operates. As the data types on which the templates operate were not known when the template was implemented, the datatypes are either inferred from the context in which a function template is used, or they are mentioned explicitly when a class template is used (the term that's used here is em(instantiated)). In situations where the types are explicitly mentioned, the em(angle bracket notation) is used to indicate which data types are required. For example, below (in section ref(PAIR)) we'll encounter the hi(pair container)tt(pair) container, which requires the explicit mentioning of two data types. Here is a tt(pair) object containing both an tt(int) and a tt(string): verb( pair myPair; ) The object tt(myPair) is defined as an object holding both an tt(int) and a tt(string). The angle bracket notation is used intensively in the upcoming discussion of abstract containers. Actually, understanding this part of templates is the only real requirement for using abstract containers. Now that we've introduced this notation, we can postpone the more thorough discussion of templates to chapter ref(TEMPLATES), and concentrate on their use in this chapter. Most of the abstract containers are em(sequential) containers: they contain data that can be stored and retrieved in some sequential way. Examples are the tt(array), implementing a fixed-sized array; a tt(vector), implementing an extendable array; the tt(list), implementing a data structure that allows for the easy insertion or deletion of data; the tt(queue), also called a emi(FIFO) (i(first in, first out)) structure, in which the first element that is entered is the first element to be retrieved again; and the tt(stack), which is a emi(first in, last out) (i(FILO) or i(LIFO)) structure. In addition to sequential containers several special containers are available. The tt(pair) is a basic container in which a pair of values (of types that are left open for further specification) can be stored, like two strings, two ints, a string and a double, etc.. Pairs are often used to return data elements that naturally come in pairs. For example, the tt(map) is an abstract container storing keys and their associated values. Elements of these maps are returned as tt(pairs). A variant of the tt(pair) is the tt(complex) container, implementing operations that are defined on complex numbers. A tt(tuple) (cf. section ref(TUPLES)) generalizes the tt(pair) container to a data structure accomodating any number of different data types. All abstract containers described in this chapter as well as the tt(string) and stream datatypes (cf. chapters ref(String) and ref(IOStreams)) are part of the Standard Template Library. All but the unordered containers support hi(basic operators of containers) hi(container: basic operators) hi(operators of containers) the following basic set of operators: itemization( it() The i(overloaded assignment) operator, so we can assign two containers of the same types to each other. If the container's data type supports move assignment, then assignment of an anonymous temporary container to a destination container will use move assignment when assigning new values to the destination container's element. Overloaded assignment is em(also) supported by the unordered containers; it() hi(container: equality tests) Tests for equality: ti(==) and ti(!=) The i(equality operator) applied to two containers returns tt(true) if the two containers have the same number of elements, which are pairwise equal according to the equality operator of the contained data type. The i(inequality operator) does the opposite; it() hi(container: ordering) Ordering operators: ti(<), ti(<=), ti(>) and ti(>=). The tt(<) operator returns tt(true) if each element in the i(left-hand) side container is less than each corresponding element in the i(right-hand) side container. Additional elements in either the left-hand side container or the right-hand side container are ignored. verb( container left; container right; left = {0, 2, 4}; right = {1, 3}; // left < right right = {1, 3, 6, 1, 2}; // left < right ) ) Note that hi(container: data type requirements) before a user-defined type (usually a tt(class)-type) can be stored in a container, the user-defined type should at least support: itemization( it() A default value (e.g., a i(default constructor)) it() The i(equality operator) (ti(==)) it() The i(less-than operator) (ti(<)) ) Sequential containers can also be initialized using em(initializer lists). Most containers (exceptions are the link(stack)(STACK) (section ref(STACK)), link(priority_queue)(PRIQUEUE) (section ref(PRIQUEUE)), and link(queue)(QUEUE) (section ref(QUEUE)) containers) support members to determine their maximum sizes (through their member function i(max_size)). Virtually all containers support copy construction. If the container supports copy construction and the container's data type supports move construction, then move construction is automatically used for the container's data elements when a container is initialized with an anonymous temporary container. Closely linked to the standard template library are the emi(generic algorithms). These algorithms may be used to perform frequently occurring tasks or more complex tasks than is possible with the containers themselves, like counting, filling, merging, filtering etc.. An i(overview of generic algorithms) and their applications is given in chapter ref(GENERIC). Generic algorithms usually rely on the availability of hi(iterator)link(em(iterators))(ITERATORS), representing begin and end-points for processing data stored inside containers. The abstract containers usually support constructors and members expecting iterators, and they often have members returning iterators (comparable to the tt(string::begin) and tt(string::end) members). In this chapter the iterator concept is not further investigated. Refer to chapter ref(STL) for this. The url hi(http://www.sgi.com/.../STL) tlurl(http://www.sgi.com/Technology/STL) is worth visiting as it offers more extensive coverage of abstract containers and the standard template library than can be provided by the bf(C++) annotations. Containers often collect data during their lifetimes. When a container goes out of scope, its destructor tries to destroy its data elements. This only succeeds if the data elements themselves are stored inside the container. If the hi(container: storing pointers) data elements of containers are pointers to dynamically allocated memory then the memory pointed to by these pointers is not destroyed, resulting in a i(memory leak). A consequence of this scheme is that the data stored in a container should often be considered the `property' of the container: the container should be able to destroy its data elements when the container's destructor is called. So, normally containers should not contain pointers to data. Also, a container should not be required hi(containter: storing const data) hi(const data and containers) to contain tt(const) data, as tt(const) data prevent the use of many of the container's members, like the assignment operator. c++-annotations-10.5.0/yo/containers/list.yo0000644000175000017500000003074312635354026017621 0ustar frankfrankThe ti(list) container hi(list container) implements a list data structure. Before using a tt(list) container the header file tthi(list) must be included. The organization of a tt(list) is shown in figure ref(listFig). figure(containers/list)(A list data-structure)(listFig) Figure ref(listFig) shows that a list consists of separate list-elements, connected by pointers. The list can be hi(list: traversal) traversed in two directions: starting at em(Front) the list may be traversed from left to right, until the 0-pointer is reached at the end of the rightmost list-element. The list can also be traversed from right to left: starting at em(Back), the list is traversed from right to left, until eventually the 0-pointer emanating from the leftmost list-element is reached. As a subtlety note that the representation given in figure ref(listFig) is not necessarily used in actual implementations of the list. For example, consider the following little program: verb( int main() { list l; cout << "size: " << l.size() << ", first element: " << l.front() << '\n'; } ) When this program is run it might actually produce the output: verb( size: 0, first element: 0 ) Its front element can even be assigned a value. In this case the implementor has chosen to provide the list with a hidden element. The list actually is a em(circular) hi(list: circular) list, where the hidden element serves as terminating element, replacing the 0-pointers in figure ref(listFig). As noted, this is a subtlety, which doesn't affect the conceptual notion of a list as a data structure ending in 0-pointers. Note also that it is well known that various implementations of list-structures are possible (cf. i(Aho, A.V.), i(Hopcroft J.E.) and i(Ullman, J.D.), (1983) emi(Data Structures and Algorithms) (Addison-Wesley)). Both lists and vectors are often appropriate data structures in situations where an hi(storing data) unknown number of data elements must be stored. However, there are some hi(rule of thumb) rules of thumb to follow when selecting the appropriate data structure. itemization( it() When most accesses are i(random), a tt(vector) is the preferred data structure. Example: in a program counting character frequencies in a textfile, a tt(vector frequencies(256)) is the datastructure of choice, as the values of the received characters can be used as indices into the tt(frequencies) vector. it() The previous example illustrates a second rule of thumb, also favoring the tt(vector): if the number of elements is known in advance (and does not notably change during the lifetime of the program), the vector is also preferred over the list. it() In cases where i(insertions) or i(deletions) prevail and the data structure is large the list is generally preferred. ) At present lists aren't as useful anymore as they used to be (when computers were much slower and more memory-constrained). Except maybe for some rare cases, a tt(vector) should be the preferred container; even when implementing algorithms traditionally using lists. Other considerations related to the choice between lists and vectors should also be given some thought. Although it is true that the vector is able to grow dynamically, the i(dynamic growth) requires data-copying. Clearly, copying a million large data structures takes a considerable amount of time, even on fast computers. On the other hand, inserting a large number of elements in a list doesn't require us to i(copy non-involved data). Inserting a new element in a list merely requires us to juggle some pointers. In figure ref(listAdd) this is shown: a new element is inserted between the second and third element, creating a new list of four elements. figure(containers/insertlist)(Adding a new element to a list)(listAdd) Removing an element from a list is also fairly easy. Starting again from the situation shown in figure ref(listFig), figure ref(listDel) shows what happens if element two is removed from our list. Again: only pointers need to be juggled. In this case it's even simpler than adding an element: only two pointers need to be rerouted. figure(containers/dellist)(Removing an element from a list)(listDel) To summarize the comparison between lists and vectors: it's probably best to conclude that there is no clear-cut answer to the question what data structure to prefer. There are rules of thumb, which may be adhered to. But if worse comes to worst, a i(profiler) may be required to find out what's best. The tt(list) container offers the following constructors, operators, and member functions: itemization( it() hi(list constructors) Constructors: itemization( it() The copy and move constructors are available; it() A tt(list) may be constructed empty: verb( list object; ) As with the tt(vector), it is an error to refer to an element of an empty list. it() A list may be initialized to a certain number of elements. By default, if the initialization value is not explicitly mentioned, the default value or default constructor for the actual data type is used. For example: verb( list object(5, string("Hello")); // initialize to 5 Hello's list container(10); // and to 10 empty strings ) it() A list may be initialized using a two iterators. To initialize a list with elements 5 until 10 (including the last one) of a tt(vector) the following construction may be used: verb( extern vector container; list object(&container[5], &container[11]); ) ) it() The tt(list) does not offer specialized operators, apart from the standard operators for containers. it() The following hi(member function)member functions are available: itemization( itht(assign)(void assign(...)): quote(assigns new contents to the list:) itemization( itt(assign(iterator begin, iterator end)) assigns the values at the iterator range rangett(begin, end) to the list; itt(assign(size_type n, value_type const &val)) assigns tt(n) copies of tt(val) to the list; ) ithtq(back)(Type &back())(returns a reference to the last element in the list. It is the i(responsibility of the programmer) to use this member only if the list is not empty.) ithtq(begin)(list::iterator begin())(returns an i(iterator) pointing to the first element in the list, returning tt(end) if the list is empty.) ithtq(clear)(void clear())(erases all elements from the list.) ithtq(empty)(bool empty())(returns tt(true) if the list contains no elements.) ithtq(end)(list::iterator end())(returns an iterator pointing beyond the last element in the list.) ithtq(erase)(list::iterator erase())(erases a specific range of elements in the list:) itemization( itt(erase(pos)) erases the element pointed to by tt(pos). The iterator tt(++pos) is returned. itt(erase(first, beyond)) erases elements indicated by the iterator range rangett(first, beyond). tt(Beyond) is returned. ) ithtq(front)(Type &front())(returns a reference to the first element in the list. It is the responsibility of the programmer to use this member only if the list is not empty.) ithtq(get_allocator)(allocator_type get_allocator() const)(returns a copy of the allocator object used by the tt(list) object.) ithtq(insert)(... insert())(inserts elements into the list. The return value depends on the version of tt(insert) that is called:) itemization( itt(list::iterator insert(pos)) inserts a default value of type tt(Type) at tt(pos), tt(pos) is returned. itt(list::iterator insert(pos, value)) inserts tt(value) at tt(pos), tt(pos) is returned. itt(void insert(pos, first, beyond)) inserts the elements in the i(iterator range) rangeti(first, beyond). itt(void insert(pos, n, value)) inserts tt(n) elements having value tt(value) at position tt(pos). ) ithtq(max_size)(size_t max_size())(returns the maximum number of elements this tt(list) may contain.) ithtq(merge)(void merge(list other))(this member function assumes that the current and other lists are sorted (see below, the member tt(sort)). Based on that assumption, it inserts the elements of tt(other) into the current list in such a way that the modified list remains sorted. If both list are not sorted, the resulting list will be ordered `as much as possible', given the initial ordering of the elements in the two lists. tt(list::merge) uses tt(Type::operator<) to sort the data in the list, which operator must therefore be available. The next example illustrates the use of the tt(merge) member: the list `tt(object)' is not sorted, so the resulting list is ordered 'as much as possible'. verbinclude(-a examples/listmerge.cc) A subtlety is that tt(merge) doesn't alter the list if the list itself is used as argument: tt(object.merge(object)) won't change the list `tt(object)'.) ithtq(pop_back)(void pop_back())(removes the last element from the list. With an i(empty list) nothing happens.) ithtq(pop_front)(void pop_front())(removes the first element from the list. With an i(empty list) nothing happens.) ithtq(push_back)(void push_back(value))(adds tt(value) to the end of the list.) ithtq(push_front)(void push_front(value))(adds tt(value) before the first element of the list.) ithtq(rbegin)(list::reverse_iterator rbegin())( hi(reverse_iterator) returns an iterator pointing to the last element in the list.) ithtq(remove)(void remove(value))(removes all occurrences of tt(value) from the list. In the following example, the two strings `tt(Hello)' are removed from the list tt(object): verbinclude(-a examples/listremove.cc)) ithtq(remove_if)(void remove_if(Predicate pred))(removes all occurrences from the list for which the predicate function or function object tt(pred) returns tt(true). For each of the objects stored in the list the predicate is called as tt(pred(*iter)), where tt(iter) represents the iterator used internally by tt(remove_if). If a function tt(pred) is used, its prototype should be tt(bool pred(value_type const &object)). ithtq(rend)(list::reverse_iterator rend())(this member returns an iterator pointing before the first element in the list.) ithtq(resize)(void resize())(alters the number of elements that are currently stored in the list:) itemization( itt(resize(n, value)) may be used to resize the list to a size of tt(n). tt(Value) is optional. If the list is expanded and tt(value) is not provided, the extra elements are initialized to the i(default value) of the used data type, otherwise tt(value) is used to initialize extra elements. ) ithtq(reverse)(void reverse())(reverses the order of the elements in the list. The element tt(back) becomes tt(front) and em(vice versa).) ithtq(size)(size_t size())(returns the number of elements in the list.) ithtq(sort)(void sort())(sorts the list. Once the list has been sorted, An example of its use is given at the description of the tt(unique) member function below. tt(list::sort) uses tt(Type::operator<) to sort the data in the list, which operator must therefore be available.) ithtq(splice)(void splice(pos, object))(transfers the contents of tt(object) to the current list, starting the insertion at the iterator position tt(pos) of the object using the tt(splice) member. Following tt(splice), tt(object) is empty. For example: verbinclude(-a examples/listsplice.cc) Alternatively, tt(argument) may be followed by an iterator of tt(argument), indicating the first element of tt(argument) that should be spliced, or by two iterators tt(begin) and tt(end) defining the iterator-range rangett(begin, end) on tt(argument) that should be spliced into tt(object).) ithtq(swap)(void swap())(swaps two lists using identical data types.) ithtq(unique)(void unique())(operating on a sorted list, this member function removes all consecutively identical elements from the list. tt(list::unique) uses tt(Type::operator==) to identify identical data elements, which operator must therefore be available. Here's an example removing all multiply occurring words from the list: verbinclude(-a examples/listunique.cc)) ) ) ) c++-annotations-10.5.0/yo/containers/stack.yo0000644000175000017500000001154312635354026017750 0ustar frankfrankThe ti(stack) class implements a i(stack data structure). Before using tt(stack) containers the header file tthi(stack) must be included. A stack is also called a i(first in, last out) (i(FILO) or i(LIFO)) data structure as the first item to enter the stack is the last item to leave. A stack is an extremely useful data structure in situations where data must temporarily remain available. For example, programs maintain a stack to store local variables of functions: the lifetime of these variables is determined by the time these functions are active, contrary to global (or static local) variables, which live for as long as the program itself lives. Another example is found in calculators using the emi(Reverse Polish Notation) (i(RPN)), in which the operands of operators are kept in a stack, whereas operators pop their operands off the stack and push the results of their work back onto the stack. As an example of the use of a stack, consider figure ref(StackFig), in which the contents of the stack is shown while the expression tt((3 + 4) * 2) is evaluated. In the RPN this expression becomes tt(3 4 + 2 *), and figure ref(StackFig) shows the stack contents after each emi(token) (i.e., the operands and the operators) is read from the input. Notice that each operand is indeed pushed on the stack, while each operator changes the contents of the stack. figure(containers/stack/stack) (The contents of a stack while evaluating tt(3 4 + 2 *)) (StackFig) The expression is evaluated in five steps. The caret between the tokens in the expressions shown on the first line of figure ref(StackFig) shows what token has just been read. The next line shows the actual stack-contents, and the final line shows the steps for referential purposes. Note that at step 2, two numbers have been pushed on the stack. The first number (tt(3)) is now at the bottom of the stack. Next, in step 3, the tt(+) operator is read. The operator pops two operands (so that the stack is empty at that moment), calculates their sum, and pushes the resulting value (tt(7)) on the stack. Then, in step 4, the number tt(2) is read, which is dutifully pushed on the stack again. Finally, in step 5 the final operator tt(*) is read, which pops the values tt(2) and tt(7) from the stack, computes their product, and pushes the result back on the stack. This result (tt(14)) could then be popped to be displayed on some medium. From figure ref(StackFig) we see that a stack has one location (the emi(top)) where items can be pushed onto and popped off the stack. This top element is the stack's only immediately visible element. It may be accessed and modified directly. Bearing this model of the stack in mind, let's see what we formally can do with the tt(stack) container. For the tt(stack), the following constructors, operators, and member functions are available: itemization( it() hi(stack constructors) Constructors: itemization( it() The copy and move constructors are available; it() A tt(stack) may be constructed empty: verb( stack object; ) ) it() Only the basic set of container operators are supported by the tt(stack) it() The following member functions are available for stacks: itemization( ithtq(empty)(bool empty())(this member returns tt(true) if the stack contains no elements.) ithtq(pop)(void pop())(removes the element at the top of the stack. Note that the popped element is em(not) returned by this member, and refer to section ref(QUEUE) for a discussion about the reason why tt(pop) has return type tt(void).) Furthermore, it is the responsibility of the stack's user to assure that tt(pop) is not called when the stack is empty. If tt(pop) em(is) called for an empty stack, its internal administration breaks, resulting, e.g., in a negative size (showing itself as a very large stacksize due to its tt(size) member returning a tt(size_t), and other operations (like tt(push)) fail and may crash your program. Of course, with a well designed algorithm requests to pop from empty stacks do not occur (which is probably why this implementation was used for the stack container). ithtq(push)(void push(value))(places tt(value) at the top of the stack, hiding the other elements from view.) ithtq(size)(size_t size())(this member returns the number of elements in the stack.) ithtq(top)(Type &top())(this member returns a reference to the stack's top (and only visible) element. It is the i(responsibility of the programmer) to use this member only if the stack is not empty.) ) ) The stack does not support iterators or a subscript operator. The only elements that can be accessed is its top element. To empty a stack: itemization( it() repeatedly remove its front element; it() assign an empty stack to it; it() have its destructor called (e.g., by ending its lifetime). ) ) c++-annotations-10.5.0/yo/containers/unorderedset.yo0000644000175000017500000001176712635354026021356 0ustar frankfrankThe em(set) container, like the tt(map) container, orders its elements. If ordering is not an issue, but fast lookups are, then a hash-based set and/or multi-set may be preferred. bf(C++) provides such hash-based sets and multi-sets: the ti(unordered_set) and tt(unordered_multiset). Before using these hash-based set containers the header file tthi(unordered_set) must be included. Elements stored in the tt(unordered_set) are immutable, but they can be inserted and removed from the container. Different from the tt(unordered_map), the tt(unordered_set) does not use a tt(ValueType). The set merely stores elements, and the stored element itself is its own key. The tt(unordered_set) has the same constructors as the tt(unordered_map), but the set's tt(value_type) is equal to its tt(key_type). When defining an ti(unordered_set) type four template arguments must be specified : itemization( it() a i(KeyType) (becoming ti(unordered_set::key_type)), it() the type of an object computing a hash value from a key value (becoming ti(unordered_set::hasher)), and it() the type of an object that can compare two keys for equality (becoming ti(unordered_set::key_equal)). it() the type of its allocator. This is usually left unspecified, using the allocator provided by default by the implementor. ) The generic definition of an tt(unordered_set) container looks like this: verb( std::unordered_set ) When tt(KeyType) is tt(std::string) or a built-in type then default types are available for the hash type and the predicate type. In practice the allocator type is not specified, as the default allocator suffices. In these cases an tt(unordered_set) object can be defined by merely specifying the key- and value types, like this: verb( std::unordered_set rawSet(size_t size = implSize); ) Here, tt(implSize) is the container's default initial size, which is specified by the implementor. The set's size is automatically enlarged when necessary, in which case the container em(rehashes) all its elements. In practice the default tt(size) argument provided by the implementor is completely satisfactory. The tt(unordered_set) supports the following constructors: itemization( it() The copy and move constructors are available; itt(explicit unordered_set+CHAR(40)size_type n = implSize, hasher const &hf = hasher(),)nl() tt(key_equal const &eql = key_equal(),)nl() tt(allocator_type const &alloc = allocator_type()CHAR(41)): this constructor can also be used as default constructor; itt(unordered_set(const_iterator begin, const_iterator end, size_type n = implSize, hasher const &hf = hasher(), key_equal const &eql = key_equal(), allocator_type const &alloc = allocator_type())): this constructor expects two iterators specifying a range of tt(unordered_set::value_type const) objects, and itt(unordered_set(initializer_list initList, size_type n = implSize, hasher const &hf = hasher(), key_equal const &eql = key_equal(), allocator_type const &alloc = allocator_type())): a constructor expecting an tt(initializer_list) of tt(unordered_set::value_type) values. ) The tt(unordered_set) does not offer an index operator, and it does not offer an tt(at) member. Other than those, it offers the same members as the tt(unordered_map). Below the members whose behavior differs from the behavior of the tt(unordered_map) are discussed. For a description of the remaining members, please refer to section ref(UMAPMEMBERS). itemization( ithtq(emplace) (iterator emplace(Args &&...args)) (a tt(value_type) object is constructed from tt(emplace)'s arguments. It is added to the set if it is unique, and an iterator to the tt(value_type) is returned.) ithtq(emplace_hint)(iterator emplace_hint(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and if the newly created element is unique it is inserted into the tt(unordered_set). The implementation may or may not use tt(position) as a em(hint) to start looking for an insertion point. The returned tt(iterator) points to the tt(value_type).) ithtq(erase)(unordered_set::iterator erase()) (erases a specific range of elements in the unordered_set:) itemization( itt(erase(key_type const &key)) erases tt(key) from the set. An iterator pointing to the next element is returned. itt(erase(pos)) erases the element pointed to by the iterator tt(pos). The iterator tt(++pos) is returned. itt(erase(first, beyond)) erases elements indicated by the iterator range rangett(first, beyond), returning tt(beyond). ) ) c++-annotations-10.5.0/yo/containers/hashmap.OBS/0000755000175000017500000000000012636507650020335 5ustar frankfrankc++-annotations-10.5.0/yo/containers/hashmap.OBS/hashmap.cc0000644000175000017500000000252112636507652022267 0ustar frankfrank #include #include #include class Equal { public: size_t operator()(string const &s1, string const &s2) const { return (s1 == s2); } }; class hashString { public: size_t operator()(string const &str) const { hash h; return (h(str.c_str())); } }; int main() { hash_map < string, int, hashString, Equal > months; months["january"] = 31; months["february"] = 28; months["march"] = 31; months["april"] = 30; months["may"] = 31; months["june"] = 30; months["july"] = 31; months["august"] = 31; months["september"] = 30; months["october"] = 31; months["november"] = 30; months["december"] = 31; cout << "february -> " << months["february"] << '\n' << "april -> " << months["april"] << '\n' << "june -> " << months["june"] << '\n' << "november -> " << months["november"] << '\n' << "december -> " << months["december"] << '\n'; return (0); } c++-annotations-10.5.0/yo/containers/complex.yo0000644000175000017500000000752012635354026020312 0ustar frankfrankThe ti(complex) container defines the standard operations that can be performed on i(complex numbers). Before using tt(complex) containers the header file tthi(complex) must be included. The complex number's real and imaginary types are specified as the container's data type. Examples: verb( complex complex complex ) Note that the real and imaginary parts of complex numbers have the same datatypes. When initializing (or assigning) a complex object, the i(imaginary part) may be omitted from the initialization or assignment resulting in its value being 0 (zero). By default, both parts are zero. Below it is silently assumed that the used tt(complex) type is tt(complex). Given this assumption, complex numbers may be initialized as follows: itemization( itt(target): A default initialization: real and imaginary parts are 0. itt(target(1)): The i(real part) is 1, imaginary part is 0 itt(target(0, 3.5)): The real part is 0, imaginary part is 3.5 itt(target(source)): tt(target) is initialized with the values of tt(source). ) Anonymous complex values may also be used. In the next example two anonymous complex values are pushed on a stack of complex numbers, to be popped again thereafter: verbinclude(-a examples/complexstack.cc) The following member functions and operators are defined for complex numbers (below, tt(value) may be either a primitve i(scalar type) or a tt(complex) object): itemization( it() Apart from the standard container operators, the following operators are supported from the tt(complex) container. itemization( ithtq(operator+)(complex operator+(value))( this member returns the sum of the current tt(complex) container and tt(value).) ithtq(operator-)(complex operator-(value))( this member returns the difference between the current tt(complex) container and tt(value).) ithtq(operator*)(complex operator*(value))( this member returns the product of the current tt(complex) container and tt(value).) ithtq(operator/)(complex operator/(value))( this member returns the quotient of the current tt(complex) container and tt(value).) ithtq(operator+=)(complex operator+=(value))( this member adds tt(value) to the current tt(complex) container, returning the new value.) ithtq(operator-=)(complex operator-=(value))( this member subtracts tt(value) from the current tt(complex) container, returning the new value.) ithtq(operator*=)(complex operator*=(value))( this member multiplies the current tt(complex) container by tt(value), returning the new value) ithtq(operator/=)(complex operator/=(value))( this member divides the current tt(complex) container by tt(value), returning the new value.) ) ithtq(real)(Type real())(returns the i(real part) of a complex number.) ithtq(imag)(Type imag())(returns the i(imaginary part) of a complex number.) it() Several i(mathematical functions) are available for the tt(complex) container, such as ti(abs), ti(arg), ti(conj), ti(cos), ti(cosh), ti(exp), ti(log), ti(norm), ti(polar), ti(pow), ti(sin), ti(sinh) and ti(sqrt). All these functions are free functions, not member functions, accepting complex numbers as their arguments. For example, verb( abs(complex(3, -5)); pow(target, complex(2, 3)); ) it() Complex numbers may be hi(operator>>) extracted from tt(istream) objects and inserted hi(operator<<) into tt(ostream) objects. The insertion results in an i(ordered pair) tt((x, y)), in which tt(x) represents the real part and tt(y) the imaginary part of the complex number. The same form may also be used when extracting a complex number from an tt(istream) object. However, simpler forms are also allowed. E.g., when extracting tt(1.2345) the imaginary part is set to 0. ) c++-annotations-10.5.0/yo/containers/mapoperators.yo0000644000175000017500000000155512635354026021361 0ustar frankfrank The map supports, in addition to the standard operators for containers, the i(index operator). The index operator may be used to retrieve or reassign individual elements of the map. The argument of the index operator is called a em(key). If the provided key is not available in the tt(map), a new data element is automatically added to the tt(map) using the default value or default constructor to initialize the value part of the new element. This default value is returned if the index operator is used as an rvalue. When initializing a new or reassigning another element of the map, the type of the right-hand side of the assignment operator must be equal to (or promotable to) the type of the map's value part. E.g., to add or change the value of element tt("two") in a map, the following statement can be used: verb( mapsm["two"] = MyClass(); ) c++-annotations-10.5.0/yo/containers/stack/0000755000175000017500000000000012635354026017373 5ustar frankfrankc++-annotations-10.5.0/yo/containers/stack/stack.fig0000644000175000017500000000327612635354026021177 0ustar frankfrank#FIG 3.2 Landscape Center Inches Letter 100.00 Single -2 1200 2 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 75 1050 6300 1050 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 375 1275 375 1650 825 1650 825 1275 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 2850 1350 2850 1725 3300 1725 3300 1350 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 5400 1350 5400 1725 5850 1725 5850 1350 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 1575 1275 1575 2025 2025 2025 2025 1275 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 4 4050 1275 4050 2025 4500 2025 4500 1275 2 1 0 1 0 7 0 0 -1 0.000 0 0 -1 0 0 2 75 2325 6300 2325 4 0 0 0 0 0 16 0.0000 4 165 855 300 525 3 4 + 2 *\001 4 0 0 0 0 0 16 0.0000 4 165 855 1500 525 3 4 + 2 *\001 4 0 0 0 0 0 16 0.0000 4 165 855 2700 525 3 4 + 2 *\001 4 0 0 0 0 0 16 0.0000 4 165 855 2700 525 3 4 + 2 *\001 4 0 0 0 0 0 16 0.0000 4 165 855 3900 525 3 4 + 2 *\001 4 0 0 0 0 0 16 0.0000 4 165 855 5100 525 3 4 + 2 *\001 4 1 0 0 0 0 16 0.0000 4 105 120 450 750 ^\001 4 1 0 0 0 0 16 0.0000 4 105 120 1800 750 ^\001 4 1 0 0 0 0 16 0.0000 4 105 120 3225 750 ^\001 4 1 0 0 0 0 16 0.0000 4 105 120 4575 750 ^\001 4 1 0 0 0 0 16 0.0000 4 105 120 6000 750 ^\001 4 1 0 0 0 0 16 0.0000 4 165 120 600 1500 3\001 4 1 0 0 0 0 16 0.0000 4 165 120 3075 1500 7\001 4 1 0 0 0 0 16 0.0000 4 165 240 5625 1500 14\001 4 1 0 0 0 0 16 0.0000 4 165 120 1800 1500 4\001 4 1 0 0 0 0 16 0.0000 4 165 120 1800 1785 3\001 4 1 0 0 0 0 16 0.0000 4 165 120 4275 1500 2\001 4 1 0 0 0 0 16 0.0000 4 165 120 4275 1800 7\001 4 1 0 0 0 0 16 0.0000 4 210 270 600 2775 (1)\001 4 1 0 0 0 0 16 0.0000 4 210 270 3075 2775 (3)\001 4 1 0 0 0 0 16 0.0000 4 210 270 4275 2775 (4)\001 4 1 0 0 0 0 16 0.0000 4 210 270 5625 2775 (5)\001 4 1 0 0 0 0 16 0.0000 4 210 270 1800 2775 (2)\001 c++-annotations-10.5.0/yo/containers/uniondestructor.yo0000644000175000017500000000214112635354026022104 0ustar frankfrankAlthough the compiler won't provide (default) implementations for constructors and destructors of unrestricted unions, em(we) can. The task isn't difficult, but there are some caveats. Consider our unrestricted union's destructor. It clearly should destroy tt(u_string)'s data if that is its currently active field; but it should do nothing if tt(u_int) is its currently active field. But how does the destructor know what field to destroy? It doesn't as the unrestricted union holds no information about what field is currently active. Here is one way to tackle this problem: If we embed the unrestricted union in a larger aggregate, like a class or a struct, then the class or struct can be provided with a emi(tag) data member storing the currently active union-field. The tag can be an enumeration type, defined by the aggregate. The unrestricted union may then be controlled by the aggregate. Under this approach we start out with an explicit empty implementations of the destructor, as there's no way to tell the destructor itself what field to destroy: verb( Data::Union::~Union() {}; ) c++-annotations-10.5.0/yo/containers/unorderedmultiset.yo0000644000175000017500000000565512635354026022430 0ustar frankfrankThe ti(unordered_multiset) allows multiple objects using the same keys to be stored in an unordered set. The tt(unordered_multiset) container offers the same set of members and constructors as the tt(unordered_set), but without the unique-key restriction imposed upon the tt(unordered_set). Below all members are described whose behavior differs from the behavior of the corresponding tt(unordered_set) members: itemization( ithtq(count)(size_t count(key_type const &key)) (returns the number of times a tt(value_type) object using tt(key_type) tt(key) is stored in the tt(unordered_set). This member is commonly used to verify whether tt(key) is available in the tt(unordered_multiset).) ithtq(emplace) (iterator emplace(Args &&...args)) (a tt(value_type) object is constructed from tt(emplace)'s arguments. The returned tt(iterator) points to the newly inserted inserted tt(value_type).) ithtq(emplace_hint)(iterator emplace_hint(const_iterator position, Args &&...args)) (a tt(value_type) object is constructed from the member's arguments, and the newly created element is inserted into the tt(unordered_multiset). The implementation may or may not use tt(position) as a em(hint) to start looking for an insertion point. The returned tt(iterator) points to the tt(value_type) using the provided key.) ithtq(equal_range) (pair equal_range(key))(this member returns a pair of iterators defining the range of elements having a key that is equal to tt(key).) ithtq(find)(terator find(key)) (returns an iterator to an element having the given key. If no such element is available, tt(end) is returned.) itht(insert)(... insert()): quote(elements may be inserted starting at a certain position. The return value depends on the version of tt(insert()) that is called. When an tt(iterator) is returned, then it points to the element that was inserted.) itemization( itt(iterator insert(value_type const &value)) inserts tt(value). itt(iterator insert(value_type &&tmp)) inserts tt(value) using tt(value_type)'s move constructor. itt(iterator insert(const_iterator hint, value_type const &value)) inserts tt(value), possibly using tt(hint) as a starting point when trying to insert tt(value). itt(iterator insert(const_iterator hint, value_type &&tmp)) inserts tt(value) using tt(value_type)'s move constructor, and possibly using tt(hint) as a starting point when trying to insert tt(value). itt(void insert(first, beyond)) inserts the elements in the iterator range rangett(first, beyond). itt(void insert(initializer_list iniList)) inserts the elements in tt(iniList) into the container. ) ) c++-annotations-10.5.0/yo/containers/multiset.yo0000644000175000017500000000535612635354026020516 0ustar frankfrankLike the tt(set), the ti(multiset) class implements a hi(sorted collection of value) sorted collection of values. Before using tt(multiset) containers the header file tthi(set) must be included. The main difference between the tt(set) and the tt(multiset) is that the multiset supports multiple entries of the same value, whereas the set contains unique values. The tt(set) and the tt(multiset) have the same set of constructors and member functions. Refer to section ref(SET) for an overview of the tt(multiset) member functions. Some member functions, however, behave slightly different than their counterparts of the tt(set) container. Those members are mentioned here. itemization( ithtq(count)(size_t count(value))(returns the number of entries in the multiset associated with the given tt(value).) ithtq(erase)(... erase())(erases elements from the set:) itemization( itt(size_t erase(value)) erases all elements having the given tt(value). The number of erased elements is returned. itt(void erase(pos)) erases the element pointed to by the iterator tt(pos). Other elements possibly having the same values are not erased. itt(void erase(first, beyond)) erases all elements indicated by the iterator range rangett(first, beyond). ) ithtq(equal_range) (pair equal_range(value)) (returns a pair of iterators, being respectively the return values of tt(lower_bound) and tt(upper_bound), introduced below. The function provides a simple means to determine all elements in the tt(multiset) that have the same tt(values).) ithtq(find)(multiset::iterator find(value))(returns an iterator pointing to the first element having the specified value. If the element isn't available, tt(end) is returned. The iterator could be incremented to visit all elements having the given tt(value) until it is either tt(end), or the iterator doesn't point to `tt(value)' anymore.) ithtq(insert)(... insert())(this member function normally succeeds and returns a emi(multiset::iterator) rather than a tt(pair) as returned with the tt(set) container. The returned iterator points to the newly added element.) ) Although the functions tt(lower_bound) and tt(upper_bound) act identically in the tt(set) and tt(multiset) containers, their operation in a tt(multiset) deserves some additional attention. With a tt(multiset) container tt(lower_bound) and tt(upper_bound) produce the same result for non-existing keys: they both return the first element having a key exceeding the provided key. Here is an example showing the use of various member functions of a multiset: verbinclude(-a examples/multiset.cc) c++-annotations-10.5.0/yo/classes/0000755000175000017500000000000012635354026015556 5ustar frankfrankc++-annotations-10.5.0/yo/classes/uniforminit.yo0000644000175000017500000001320012635354026020466 0ustar frankfrankWhen defining variables and objects they may immediately be given initial values. Class type objects are always initialized using one of their available constructors. bf(C) already supports the array and struct hi(initialization)emi(initializer list) consisting of a list of constant expressions surrounded by a pair of curly braces. bf(C++) supports a comparable initialization, called emi(uniform initialization). It uses the following syntax: verb( Type object {value list}; ) When defining objects using a list of objects each individual object may use its own uniform initialization. The advantage of uniform initialization over using constructors is that using constructor arguments may sometimes result in an ambiguity as constructing an object may sometimes be confused with using the object's overloaded function call operator (cf. section ref(FUNOBJ)). As initializer lists can only be used with em(plain old data) (POD) types (cf. section ref(POD)) and with classes that are `initializer list aware' (like tt(std::vector)) the ambiguity does not arise when initializer lists are used. Uniform initialization can be used to initialize an object or variable, but also to initialize data members in a constructor or implicitly in the return statement of functions. Examples: verb( class Person { // data members public: Person(std::string const &name, size_t mass) : d_name {name}, d_mass {mass} {} Person copy() const { return {d_name, d_mass}; } }; ) Object definitions may be encountered in unexpected places, easily resulting in (human) confusion. Consider a function `tt(func)' and a very simple class tt(Fun) (tt(struct) is used, as data hiding is not an issue here; in-class implementatinos are used for brevity): verb( void func(); struct Fun { Fun(void (*f)()) { std::cout << "Constructor\n"; }; void process() { std::cout << "process\n"; } }; ) In tt(main) a tt(Fun) object is defined: tt(Fun fun(func)). Running this program displays tt(Constructor): tt(fun) is constructed. Next we intend to call tt(process) for an anonymous tt(Fun) object: verb( Fun fun(func); Fun(func).process(); ) tt(Constructor) appears twice, and then tt(process) is displayed. What about just defining an anonymous tt(Fun) object? We do: verb( Fun(func); ) Now we're in for a surprise. The compiler complains that tt(Fun)'s default constructor is missing. Why's that? Insert some blanks immediately after tt(Fun) and you get tt(Fun (func)). Parentheses around an identifier are OK, and are stripped off once the parenthesized expression has been parsed. In this case: tt((func)) equals tt(func), and so we have tt(Fun func): the definition of a tt(Fun func) object, using tt(Fun)'s default constructor (which isn't provided). So why does tt(Fun(func).process()) compile? In this case we have a member selector operator, whose left-hand operand must be an class-type object. The object must exist, and tt(Fun(func)) represents that object. It's not the name of an existing object, but a constructor expecting a function like tt(func) exists. The compiler now creates an anonymous tt(Fun), passing it tt(func) as its argument. Clearly, in this example, parentheses cannot be used to create an anonymous tt(Fun) object. However, the uniform initialization em(can) be used. To define the anonymous tt(Fun) object use this syntax: verb( Fun {func}; ) (which can also be used to immediately call one of its members. E.g., tt(Fun{func}.process())). Although the uniform intialization syntax is slightly different from the syntax of an initializer list (the latter using the assignment operator) the compiler nevertheless uses the initializer list if a constructor supporting an initializer list is available. As an example consider: verb( class Vector { public: Vector(size_t size); Vector(std::initializer_list const &values); }; Vector vi = {4}; ) When defining tt(vi) the constructor expecting the initializer list is called rather than the constructor expecting a tt(size_t) argument. If the latter constructor is required the definition using the standard constructor syntax must be used. I.e., tt(Vector vi(4)). Initializer lists are themselves objects that may be constructed using another initializer list. However, values stored in an initializer list are immutable. Once the initializer list has been defined their values remain as-is. Before using the tt(initializer_list) the tt(initializer_list)hi(initializer list) header file must be included. Initializer lists support a basic set of member functions and constructors: itemization( ithtq(initializer_list)(initializer_list object) (defines tt(object) as an empty initializer list) ittq(initializer_list object { list of Type values }) (defines tt(object) as an initializer list containing tt(Type) values) ittq(initializer_list object(other)) (initializes tt(object) using the values stored in tt(other)) ithtq(size)(size_t size() const) (returns the number of elements in the initializer list) ithtq(begin)(Type const *begin() const) (returns a pointer to the first element of the initializer list) ithtq(end)(Type const *end() const) (returns a pointer just beyond the location of the last element of the initializer list) ) c++-annotations-10.5.0/yo/classes/whennot2use.yo0000644000175000017500000000366612635354026020423 0ustar frankfrank hi(inline: avoid!) As a prelude to chapter ref(POLYMORPHISM) (Polymorphism), there is one situation in which inline functions should definitely be avoided. At this point in the annotations() it's a bit too early to expose the full details, but since the keyword tt(inline) is the topic of this section this is considered the appropriate location for the advice. There are situations where the compiler is confronted with so-called emi(vague linkage) nl()(cf. tlurl(http://gcc.gnu.org/onlinedocs/gcc-4.6.0/gcc/Vague-Linkage.html)). These situations occur when the compiler does not have a clear indication in what object file to put its compiled code. This happens, e.g., with inline functions, which are usually encountered in multiple source files. Since the compiler may insert the code of ordinary inline functions in places where these functions are called, vague linking is usually no problem with these ordinary functions. However, as explained in chapter ref(POLYMORPHISM), when using polymorphism the compiler must ignore the tt(inline) keyword and define so-called em(virtual members) as true (em(out-of-line) hi(out-of-line functions) functions). In this situation the vague linkage may cause problems, as the compiler must decide in what object file(s) to put their code. Usually that's not a big problem as long as the function is at least called once. But virtual functions are special in the sense that they may very well never be explicitly called. On some architectures (e.g., armel) the compiler may fail to compile such inline virtual functions. This may result in missing symbols in programs using them. To make matters slightly more complex: the problem may emerge when shared libraries are used, but not when static libraries are used. To avoid all of these problems virtual functions should em(never) be defined inline, but they should always be defined em(out-of-line). I.e., they should be defined in source files. c++-annotations-10.5.0/yo/classes/composition.yo0000644000175000017500000000062212635354026020472 0ustar frankfrankIn the class tt(Person) objects are used as data members. This construction technique is called emi(composition). Composition is neither extraordinary nor bf(C++) specific: in bf(C) a tt(struct) or tt(union) field is commonly used in other compound types. In bf(C++) it requires some special thought as their initialization sometimes is subject to restrictions, as discussed in the next few sections. c++-annotations-10.5.0/yo/classes/application.yo0000644000175000017500000000711512635354026020436 0ustar frankfrankOur example class tt(Person) has three string data members and a tt(size_t d_mass) data member. Access to these data members is controlled by i(interface functions). Whenever an object is defined the class's constructor(s) ensure that its data members are given `sensible' values. Thus, objects never suffer from uninitialized values. Data members may be given new values, but that should never be directly allowed. It is a core principle (called emi(data hiding)) of good class design that its data members are private. The modification of data members is therefore fully controlled by member functions and thus, indirectly, by the class-designer. The class em(encapsulates) all actions performed on its data members and due to this emi(encapsulation) the class object may assume the `responsibility' for its own data-integrity. Here is a minimal definition of tt(Person)'s manipulating members: verbinclude(-a examples/setmembers.cc) It's a minimal definition in that no checks are performed. But it should be clear that checks are easy to implement. E.g., to ensure that a phone number only contains digits one could define: verb( void Person::setPhone(string const &phone) { if (phone.find_first_not_of("0123456789") == string::npos) d_phone = phone; else cout << "A phone number may only contain digits\n"; } ) Similarly, access to the data members is controlled by encapsulating emi(accessor) members. Accessors ensure that data members cannot suffer from uncontrolled modifications. Since accessors conceptually do not modify the object's data (but only retrieve the data) these member functions are given the predicate tt(const). They are called hi(member: const)emi(const member) em(functions), which, as they are guaranteed not to modify their object's data, are available to both modifiable and constant objects (cf. section ref(ConstFunctions)). To prevent emi(backdoors) we must also make sure that the data member is not modifiable through an accessor's return value. For values of built-in primitive types that's easy, as they are usually returned by value, which are copies of the values found in variables. But since objects may be fairly large making copies are usually prevented by returning objects by reference. A backdoor is created by returning a data member by reference, as in the following example, showing the allowed abuse below the function definition: verb( string &Person::name() const { return d_name; } Person somebody; somebody.setName("Nemo"); somebody.name() = "Eve"; // Oops, backdoor changing the name ) To prevent the backdoor objects are returned as em(const references) from accessors. Here are the implementations of tt(Person)'s accessors: verbinclude(-a examples/getmembers.cc) The tt(Person) class interface remains the starting point for the class design: its member functions define what can be asked of a tt(Person) object. In the end the implementation of its members merely is a technicality allowing tt(Person) objects to do their jobs. The next example shows how the class tt(Person) may be used. An object is initialized and passed to a function tt(printperson()), printing the person's data. Note the reference operator in the parameter list of the function tt(printperson). Only a reference to an existing tt(Person) object is passed to the function, rather than a complete object. The fact that tt(printperson) does not modify its argument is evident from the fact that the parameter is declared tt(const). verbinclude(-a examples/persondemo.cc) c++-annotations-10.5.0/yo/classes/mutable.yo0000644000175000017500000000435712635354026017571 0ustar frankfrankEarlier, in section ref(ConstFunctions), the concepts of const member functions and const objects were introduced. bf(C++) also allows the declaration of data members which may be modified, even by const member function. The declaration of such data members in the class interface start with the keyword ti(mutable). Mutable should be used for those data members that may be modified without logically changing the object, which might therefore still be considered a constant object. An example of a situation where tt(mutable) is appropriately used is found in the implementation of a string class. Consider the tt(std::string)'s tt(c_str) and tt(data) members. The actual data returned by the two members are identical, but tt(c_str) must ensure that the returned string is terminated by an 0-byte. As a string object has both a length and a capacity an easy way to implement tt(c_str) is to ensure that the string's capacity exceeds its length by at least one character. This invariant allows tt(c_str) to be implemented as follows: verb( char const *string::c_str() const { d_data[d_length] = 0; return d_data; } ) This implementation logically does not modify the object's data as the bytes beyond the object's initial (length) characters have undefined values. But in order to use this implementation tt(d_data) must be declared tt(mutable): verb( mutable char *d_data; ) The keyword tt(mutable) is also useful in classes implementing, e.g., reference counting. Consider a class implementing reference counting for textstrings. The object doing the reference counting might be a const object, but the class may define a copy constructor. Since const objects can't be modified, how would the copy constructor be able to increment the reference count? Here the tt(mutable) keyword may profitably be used, as it can be incremented and decremented, even though its object is a const object. The keyword tt(mutable) should sparingly be used. Data modified by const member functions should never logically modify the object, and it should be easy to demonstrate this. As a i(rule of thumb): do not use tt(mutable) unless there is a very clear reason (the object is logically not altered) for violating this rule. c++-annotations-10.5.0/yo/classes/constructorscall.yo0000644000175000017500000000622212635354026021535 0ustar frankfrankOften constructors are specializations of each other, allowing objects to be constructed specifying only subsets of arguments for all of its data members, using default argument values for the remaining data members. Before the C++11 standard common practice was to define a member like tt(init) performing all initializations common to constructors. Such an tt(init) function, however, cannot be used to initialize tt(const) or reference data members, nor can it be used to perform so-called em(base class) initializations (cf. chapter ref(INHERITANCE)). Here is an example where such an tt(init) function might have been used. A class tt(Stat) is designed as a wrapper class around bf(C)'s bi(stat)(2) function. The class might define three constructors: one expecting no arguments and initializing all data members to appropriate values; a second one doing the same, but it calls tt(stat) for the filename provided to the constructor; and a third one expecting a filename and a search path for the provided file name. Instead of repeating the initialization code in each constructor, the common code can be factorized into a member tt(init) which is called by the constructors. Currently, bf(C++) offers an alternative by allowing constructors to call each other. This is called hi(constructor: delegation) emi(delegating constructors) The C++11 standard allows us to delegate constructors as illustrated by the next example: verb( class Stat { public: Stat() : State("", "") // no filename/searchpath {} Stat(std::string const &fileName) : Stat(fileName, "") // only a filename {} Stat(std::string const &fileName, std::string const &searchPath) : d_filename(fileName), d_searchPath(searchPath) { // remaining actions to be performed by the constructor } }; ) bf(C++) allows static const integral data members to be initialized within the hi(data member: initialization) class interfaces (cf. chapter ref(StaticDataFun)). The i(C++11) standard adds to this the facility to define default initializations for plain data members in class interfaces (these data members may or may not be tt(const) or of integral types, but (of course) they cannot be reference data members). These default initializations may be overruled by constructors. E.g., if the class tt(Stat) uses a data member tt(bool d_hasPath) which is tt(false) by default but the third constructor (see above) should initialize it to tt(true) then the following approach is possible: verb( class Stat { bool d_hasPath = false; public: Stat(std::string const &fileName, std::string const &searchPath) : d_hasPath(true) // overrule the interface-specified // value {} }; ) Here tt(d_hasPath) receives its value only once: it's always initialized to tt(false) except when the shown constructor is used in which case it is initialized to tt(true). c++-annotations-10.5.0/yo/classes/comconst.yo0000644000175000017500000001015312635354026017754 0ustar frankfrankUnless specified otherwise object data members of classes are initialized by their default constructors. Using the default constructor might not always be the optimal way to intialize an object and it might not even be possible: a class might simply not define a default constructor. Earlier we've encountered the following constructor of the tt(Person): verb( Person::Person(string const &name, string const &address, string const &phone, size_t mass) { d_name = name; d_address = address; d_phone = phone; d_mass = mass; } ) Think briefly about what is going on in this constructor. In the constructor's body we encounter assignments to string objects. Since assignments are used in the constructor's body their left-hand side objects must exist. But when objects are coming into existence constructors em(must) have been called. The initialization of those objects is thereupon immediately undone by the body of tt(Person)'s constructor. That is not only inefficient but sometimes downright impossible. Assume that the class interface mentions a tt(string const) data member: a data member whose value is not supposed to change at all (like a birthday, which usually doesn't change very much and is therefore a good candidate for a tt(string const) data member). Constructing a birthday object and providing it with an initial value is OK, but changing the initial value isn't. The body of a constructor allows assignments to data members. The em(initialization) of data members happens before that. bf(C++) defines the emi(member initializer) syntax allowing us to specify the way data members are initialized at construction time. Member initializers are specified as a list of constructor specifications between a colon following a constructor's parameter list and the opening curly brace of a constructor's body, as follows: verb( Person::Person(string const &name, string const &address, string const &phone, size_t mass) : d_name(name), d_address(address), d_phone(phone), d_mass(mass) {} ) Member initialization em(always) occurs when objects are composed in classes: if em(no) constructors are mentioned in the member initializer list the default constructors of the objects are called. Note that this only holds true for em(objects). Data members of primitive data types are em(not) initialized automatically. Member initialization can, however, also be used for primitive data members, like tt(int) and tt(double). The above example shows the initialization of the data member tt(d_mass) from the parameter tt(mass). When member initializers are used the data member could even have the same name as the constructor's parameter (although this is deprecated) as there is no ambiguity and the first (left) identifier used in a member initializer is always a data member that is initialized whereas the identifier between parentheses is interpreted as the parameter. The em(order) in which class type data members are initialized is defined by the order in which those members are defined in the composing class interface. If the order of the initialization in the constructor differs from the order in the class interface, the compiler complains, and reorders the initialization so as to match the order of the class interface. Member initializers should be used as often as possible. As shown it may be required to use them (e.g., to initialize const data members, or to initialize objects of classes lacking default constructors) but em(not) using member initializers also results in inefficient code as the default constructor of a data member is always automatically called unless an explicit member initializer is specified. Reassignment in the constructor's body following default construction is then clearly inefficient. Of course, sometimes it is fine to use the default constructor, but in those cases the explicit member initializer can be omitted. As a i(rule of thumb): if a value is assigned to a data member in the constructor's body then try to avoid that assignment in favor of using a member initializer. c++-annotations-10.5.0/yo/classes/parentheses.yo0000644000175000017500000000475412635354026020462 0ustar frankfrankLet's play some more. At some point in our program we defined tt(int b). Then, in a compound statement we need to construct an anonymous tt(Data) object, initialized using tt(b), followed by displaying tt(b): verb( int b = 18; { Data(b); cout << b; } ) About that tt(cout) statement the compiler tells us (I modified the error message to reveal its meaning): em(error: cannot bind `std::ostream & << Data const &') Here we didn't insert tt(int b) but tt(Data b). Had we omitted the compound statement, the compiler would have complained about a doubly defined tt(b) entity, as tt(Data(b)) simply means tt(Data b), a tt(Data) object constructed by default. The compiler may omit superfluous parentheses when parsing a definition or declaration. Of course, the question now becomes how a temporary object tt(Data), initialized with tt(int b) can be defined. Remember that the compiler may remove superfluous parentheses. So, what we need to do is to pass an tt(int) to the anonymous tt(Data) object, without using the tt(int)'s name. itemization( it() We can use a cast: tt(Data(static_cast(b))); it() We can use a curly-brace initialization: tt(Data {b}). ) Values and types make big differences. Consider the following definitions: verb( Data (*d4)(int); // 1 Data (*d5)(3); // 2 ) Definition 1 should cause no problems: it's a pointer to a function, expecting an tt(int), returning a tt(Data) object. Hence, tt(d4) is a pointer variable. Definition 2 is slightly more complex. Yes, it's a pointer. But it has nothing to do with a function. So what's that argument list containing 3 doing there? Well, it's not an argument list. It's an initialization that looks like an argument list. Remember that variables can be initialized using the assignment statement, by parentheses or by curly parentheses. So instead of tt(`(3)') we could have written tt(`= 3') or tt(`{3}'). Let's pick the first alternative, resulting in: verb( Data (*d5) = 3; ) Now we get to `play compiler' again. Removing some superfluous parentheses we get: verb( Data *d5 = 3; ) It's a pointer to a tt(Data) object, initialized to 3 (semantically incorrect, but that's only clear after the syntactical analysis. If I had initially written verb( Data (*d5)(&d1); // 2 ) the fun resulting from contrasting tt(int) and tt(3) would most likely have been spoiled). c++-annotations-10.5.0/yo/classes/order.yo0000644000175000017500000000074012635354026017243 0ustar frankfrankThe possibility to pass arguments to constructors allows us to monitor the construction order of objects during program execution. This is illustrated by the next program using a class tt(Test). The program defines a global tt(Test) object and two local tt(Test) objects. The order of construction is as expected: first global, then main's first local object, then tt(func)'s local object, and then, finally, tt(main)'s second local object: verbinclude(-a examples/order.cc) c++-annotations-10.5.0/yo/classes/when2use.yo0000644000175000017500000000460712635354026017676 0ustar frankfrankWhen should i(inline) functions be used, and when not? There are some hi(rule of thumb) rules of thumb which may be followed: itemization( it() In general inline functions should bf(not) be used. em(Voil\`a); that's simple, isn't it? it() Consider defining a function inline once a fully developed and tested program runs too slowly and shows `bottlenecks' in certain functions, and the bottleneck is removed by defining inline members. A i(profiler), which runs a program and determines where most of the time is spent, is necessary to perform such optimizations. it() Defining inline functions may be considered when they consist of one very simple statement (such as the return statement in the function tt(Person::name)). it() When a function is defined inline, its implementation is inserted in the code wherever the function is used. As a consequence, when the em(implementation) of the inline function changes, all sources using the inline function must be recompiled. In practice that means that all functions must be recompiled that include (either directly or indirectly) the header file of the class in which the inline function is defined. Not a very attractive prospect. it() It is only useful to implement an inline function when the time spent during a function call is long compared to the time spent by the function's body. An example of an inline function which hardly affects the program's speed is: verb( inline void Person::printname() const { cout << d_name << '\n'; } ) This function contains only one statement. However, the statement takes a relatively long time to execute. In general, functions which perform input and output take lots of time. The effect of the conversion of this function tt(printname()) to inline would therefore lead to an insignificant gain in execution time. ) All inline functions hi(inline: disadvantage) have one disadvantage: the actual code is inserted by the compiler and must therefore be known at compile-time. Therefore, as mentioned earlier, an inline function can never be located in a run-time library. Practically this means that an inline function is found near the interface of a class, usually in the same header file. The result is a header file which not only shows the bf(declaration) of a class, but also part of its bf(implementation), thus always blurring the distinction between interface and implementation. c++-annotations-10.5.0/yo/classes/defineinline.yo0000644000175000017500000000662112635354026020565 0ustar frankfrankInline functions may be implemented em(in the class interface itself). For the class tt(Person) this results in the following implementation of tt(name): verb( class Person { public: std::string const &name() const { return d_name; } }; ) Note that the i(inline) code of the function tt(name) now literally occurs inline in the interface of the class tt(Person). The keyword tt(const) is again added to the function's header. Although members can be defined hi(member: in-class) em(in-class) (i.e., inside the class interface itself), it is considered bad practice for the following reasons: itemization( it() Defining members inside the interface contaminates the interface with implementations. The interface's purpose is to document what functionality the class offers. Mixing member declarations and implementation details complicates understanding the interface. Readers need to skip implementation details which takes time and makes it hard to grab the `broad picture', and thus to understand at a glance what functionality the class's objects are offering. it() In-class implementations of private member functions may usually be avoided altogether (as they are private members). They should be moved to the internal header file (em(unless) inline public members use such inline private members). it() Although members that are eligible for inline-coding should remain inline, situations do exist where such inline members migrate from an inline to a non-inline definition. In-class inline definitions still need editing (sometimes considerable editing) before they can be compiled. This additional editing is undesirable. ) Because of the above considerations inline members should not be defined in-class. Rather, they should be defined following the class interface. The tt(Person::name) member is therefore preferably defined as follows: verb( class Person { public: std::string const &name() const; }; inline std::string const &Person::name() const { return d_name; } ) If it is ever necessary to cancel tt(Person::name)'s inline implementation, then this becomes its non-inline implementation: verb( #include "person.ih" std::string const &Person::name() const { return d_name; } ) Only the tt(inline) keyword needs to be removed to obtain the correct non-inline implementation. Defining members inline has the following effect: whenever an inline-defined function is called, the compiler may em(insert the function's body) at the location of the function call. It may be that the function itself is never actually called. This construction, where the function code itself is inserted rather than a call to the function, is called an i(inline function). Note that using inline functions may result in multiple occurrences of the code of those functions in a program: one copy for each invocation of the inline function. This is probably OK if the function is a small one, and needs to be executed fast. It's not so desirable if the code of the function is extensive. The compiler knows this too, and handles the use of inline functions as a em(request) rather than a em(command). If the compiler considers the function too long, it will not grant the request. Instead it will treat the function as a normal function. c++-annotations-10.5.0/yo/classes/construc.yo0000644000175000017500000000537612635354026020002 0ustar frankfrankbf(C++) classes may contain two special categories of member functions which are essential to the proper working of the class. These categories are the constructors and the i(destructor). The em(destructor)'s primary task is to return memory allocated by an object to the common pool when an object goes `out of scope'. Allocation of memory is discussed in chapter ref(MEMORY), and destructors are therefore be discussed in depth in that chapter. In this chapter the emphasis is on the class's organization and its constructors. Constructor are recognized by their names which is equal to the class name. Constructors do not specify return values, not even tt(void). E.g., the class tt(Person) may define a constructor tt(Person::Person()). The bf(C++) run-time system ensures that the constructor of a class is called when a variable of the class is defined. It is possible to define a class lacking any constructor. In that case the compiler defines a hi(constructor: default) default constructor that is called when an object of that class is defined. What actually happens in that case depends on the data members that are defined by that class (cf. section ref(MemberInitializers)). Objects may be defined locally or globally. However, in bf(C++) most objects are defined locally. Globally defined objects are hardly ever required and are somewhat deprecated. When a local object is defined its constructor is called every time the function is called. The object's constructor is activated at the point where the object is defined (a subtlety is that an object may be defined implicitly as, e.g., a temporary variable in an expression). When an object is defined as a static object hi(static object)hi(object: static/global) it is constructed when the program starts. In this case its constructor is called even before the function tt(main) starts. Example: verbinclude(-a examples/emptymain.cc) The program contains one global object of the class tt(Demo) with tt(main) having an empty body. Nonetheless, the program produces some output generated by the constructor of the globally defined tt(Demo) object. Constructors have a very important and well-defined role. They must ensure that all the class's data members have sensible or at least well-defined values once the object has been constructed. We'll get back to this important task shortly. The em(default constructor)hi(constructor: default) has no argument. It is defined by the compiler unless another constructor is defined and unless its definition is suppressed (cf. section ref(DEFAULTED)). If a default constructor is required in addition to another constructor then the default constructor must explicitly be defined as well. bf(C++) provides special syntax to do that as well, which is also covered by section ref(DEFAULTED). c++-annotations-10.5.0/yo/classes/member.yo0000644000175000017500000000552112635354026017401 0ustar frankfrankThe keyword tt(const) is often used behind the parameter list of member functions. This keyword indicates that a member function does not alter the data members of its object. Such member functions are called emi(const member functions). In the class tt(Person), we see that the accessor functions were declared tt(const): verb( class Person { public: std::string const &name() const; std::string const &address() const; std::string const &phone() const; size_t mass() const; }; ) The rule of thumb given in section ref(ConstRule) applies here too: whichever appears to the em(left) of the keyword tt(const), is not altered. With member functions this should be interpreted as `doesn't alter its own data'. When implementing a const member function the tt(const) attribute must be repeated: verb( string const &Person::name() const { return d_name; } ) The compiler prevents the data members of a class from being modified by one of its const member functions. Therefore a statement like verb( d_name[0] = toupper(static_cast(d_name[0])); ) results in a compiler error when added to the above function's definition. tt(Const) member functions are used to prevent inadvertent data modification. Except for constructors and the destructor (cf. chapter ref(MEMORY)) only const member functions can be used with (plain, references or pointers to) tt(const) objects. Const objects are frequently encounterd as tt(const &) parameters of functions. Inside such functions only the object's const members may be used. Here is an example: verb( void displayMass(ostream &out, Person const &person) { out << person.name() << " weighs " << person.mass() << " kg.\n"; } ) Since tt(person) is defined as a tt(Person const &) the function tt(displayMass) cannot call, e.g.,nl() tt(person.setMass(75)). The tt(const) member function attribute can be used to hi(function overloading) overload member functions. When functions are overloaded by their tt(const) attribute the compiler uses the member function matching most closely the i(const-qualification) of the object: itemization( it() When the object is a tt(const) object, only tt(const) member functions can be used. it() When the object is not a tt(const) object, non-tt(const) member functions are used, em(unless) only a tt(const) member function is available. In that case, the tt(const) member function is used. ) The next example illustrates how (non) tt(const) member functions are selected: verbinclude(-a examples/constmembers.cc) As a general principle of design: member functions should always be given the tt(const) attribute, unless they actually modify the object's data. c++-annotations-10.5.0/yo/classes/intro.yo0000644000175000017500000001672312635354026017273 0ustar frankfrankThe bf(C) programming language offers two methods for structuring data of different types. The bf(C) tt(struct) holds data members of various types, and the bf(C) tt(union) also defines data members of various types. However, a union's data members all occupy the same location in memory and the programmer may decide on which one to use. In this chapter classes are introduced. A tt(class) is a kind of tt(struct), but its contents are by default inaccessible to the outside world, whereas the contents of a bf(C++) tt(struct) are by default accessible to the outside world. In bf(C++) tt(struct)s find little use: they are mainly used to aggregate data within the context of classes or to define elaborate return values. Often a bf(C++) tt(struct) merely contains em(plain old data) (POD, cf. section ref(POD)). In bf(C++) the tt(class) is the main data structuring device, by default enforcing two core concepts of current-day software engineering: em(data hiding) and em(encapsulation) (cf. sections ref(HIDING) and ref(APPLICATION)). The tt(union) is another data structuring device the language offers. The traditional bf(C) union is still available, but bf(C++) also offers em(unrestricted unions). Unrestricted unions are unions whose data fields may be of class types. The annotations() covers these unrestricted unions in section ref(UNIONS), after having introduced several other new concepts of bf(C++), bf(C++) extends the bf(C) tt(struct) and tt(union) concepts by allowing the definition of em(member) hi(member function) functions (introduced in this chapter) within these data types. Member functions are functions that can only be used with objects of these data types or within the scope of these data types. Some of these member functions are special in that they are always, usually automatically, called when an object starts its life (the so-called em(constructor)) or ends its life (the so-called em(destructor)). These and other types of member functions, as well as the design and construction of, and philosophy behind, classes are introduced in this chapter. We step-by-step construct a class tt(Person), which could be used in a database application to store a person's name, address and phone number. label(PERSON) Let's start by creating a tt(class Person) right away. From the onset, it is important to make the distinction between the class emi(interface) and its emi(implementation). A class may loosely be defined as `a set of data and all the functions operating on those data'. This definition is later refined but for now it is sufficient to get us started. A class interface is a definition, defining the organization of objects of that class. Normally a definition results in memory reservation. E.g., when defining tt(int variable) the compiler ensures that some memory is reserved in the final program storing tt(variable)'s values. Although it is a definition no memory is set aside by the compiler once it has processed the class definition. But a class definition follows the emi(one definition rule): in bf(C++) entities may be defined only once. As a em(class definition) does not imply that memory is being reserved the term em(class interface) is preferred instead. Class interfaces are normally contained in a class em(header file), e.g., tt(person.h). We'll start our tt(class Person) interface here (cf section ref(ConstFunctions) for an explanation of the tt(const) keywords behind some of the class's member functions): verbinclude(-a examples/person.h) The member functions that are em(declared) in the interface must still be implemented. The implementation of these members is properly called their definition. In addition to the member function a class defines the data manipulated by the member functions. These data are called the i(data member)em(data members). In tt(Person) they are tt(d_name, d_address, d_phone) and tt(d_mass). Data members should be given private i(access rights). Since the class uses private access rights by default they may simply be listed at the top of the interface. All communication between the outer world and the class data is routed through the class's member functions. Data members may receive new values (e.g., using tt(setName)) or they may be retrieved for inspection (e.g., using tt(name)). Functions merely returning values stored inside the object, not allowing the caller to modify these internally stored values, are called hi(accessor)em(accessors). Syntactically there is only a marginal difference between a class and a struct. Classes by default define em(private) members, structs define em(public) members. Conceptually, though, there are differences. In bf(C++) structs are used in the way they are used in bf(C): to aggregate data, which are all freely accessible. Classes, on the other hand, hide their data from access by the outside world (which is aptly called emi(data hiding)) and offer member functions to define the communication between the outer world and the class's data members. Following em(Lakos) (Lakos, J., 2001) hi(Lakos, J.) bf(Large-Scale C++ Software Design) (Addison-Wesley) I suggest the following setup of class interfaces: itemization( it() All data members have em(private access rights), and are placed at the top of the interface. it() All data members start with tt(d_), followed by a name suggesting their meaning (in chapter ref(StaticDataFun) we'll also encounter data members starting with tt(s_)). it() Non-private data members em(do) exist, but one should be hesitant to define non-private access rights for data members (see also chapter ref(INHERITANCE)). it() Two broad categories of member functions are hi(manipulator)em(manipulators) and em(accessors). Manipulators allow the users of objects to modify the internal data of the objects. By convention, manipulators start with tt(set). E.g., tt(setName). it() With em(accessors), a tt(get)-prefix is still frequently encountered, e.g., tt(getName). However, following the conventions promoted by the bi(Qt) (see ti(http://www.trolltech.com)) emi(Graphical User Interface Toolkit), the tt(get)-prefix is now deprecated. So, rather than defining the member tt(getAddress), it should simply be named tt(address). it() Normally (exceptions exist) the public member functions of a class are listed first, immediately following the class's data members. They are the important elements of the interface as they define the features the class is offering to its users. It's a matter of convention to list them high up in the interface. The keyword tt(private) is needed beyond the public members to switch back from public members to private access rights which nicely separates the members that may be used `by the general public' from the class's own support members. ) Style conventions usually take a long time to develop. There is nothing obligatory about them, though. I suggest that readers who have compelling reasons em(not) to follow the above style conventions use their own. All others are strongly advised to adopt the above style conventions. Finally, referring back to section ref(INTRONAME) that verb( using namespace std; ) must be used in most (if not all) examples of source code. As explained in sections ref(CLASSHEADER) and ref(NAMESPACEHDR) the tt(using) directive should follow the preprocessor directive(s) including the header files, using a setup like the following: verb( #include #include "person.h" using namespace std; int main() { ... } ) c++-annotations-10.5.0/yo/classes/subtleties.yo0000644000175000017500000001151612635354026020316 0ustar frankfrankAnonymous objects can be used to initialize function parameters that are tt(const) references to objects. These objects are created just before such a function is called, and are destroyed once the function has terminated. bf(C++)'s grammar allows us to use anonymous objects in other situations as well. Consider the following snippet of code: verb( int main() { // initial statements Print("hello", "world"); // later statements } ) In this example an anonymous tt(Print) object is constructed, and it is immediately destroyed thereafter. So, following the `initial statements' our tt(Print) object is constructed. Then it is destroyed again followed by the execution of the `later statements'. The example illustrates that the standard lifetime rules do not apply to anonymous objects. hi(lifetime: anonymous objects) hi(anonymous object: lifetime) Their lifetimes are limited to the em(statements), rather than to the em(end of the block) in which they are defined. Plain anonymous object are at least useful in one situation. Assume we want to put em(markers) in our code producing some output when the program's execution reaches a certain point. An object's constructor could be implemented so as to provide that marker-functionality allowing us to put markers in our code by defining anonymous, rather than named objects. bf(C++)'s grammar contains another remarkable characteristic illustrated by the next example: verb( int main(int argc, char **argv) { Print p(cout, "", ""); // 1 allArgs(Print(p), argc, argv); // 2 } ) In this example a non-anonymous object tt(p) is constructed in statement 1, which is then used in statement 2 to em(initialize) an anonymous object. The anonymous object, in turn, is then used to initialize tt(allArgs)'s tt(const) reference parameter. This use of an existing object to initialize another object is common practice, and is based on the existence of a so-called emi(copy constructor). A copy constructor creates an object (as it is a constructor) using an existing object's characteristics to initialize the data of the object that's created. Copy constructors are discussed in depth in chapter ref(MEMORY), but presently only the concept of a copy constructor is used. In the above example a copy constructor is used to initialize an anonymous object. The anonymous object was then used to initialize a parameter of a function. However, when we try to apply the same trick (i.e., using an existing object to initialize an anonymous object) to a plain statement, the compiler generates an error: the object tt(p) can't be redefined (in statement 3, below): verb( int main(int argc, char *argv[]) { Print p("", ""); // 1 allArgs(Print(p), argc, argv); // 2 Print(p); // 3 error! } ) Does this mean that using an existing object to initialize an anonymous object that is used as function argument is OK, while an existing object can't be used to initialize an anonymous object in a plain statement? The compiler actually provides us with the answer to this apparent contradiction. About statement 3 the compiler reports something like: verb( error: redeclaration of 'Print p' ) which solves the problem when realizing that within a compound statement objects and variables may be defined. Inside a compound statement, a em(type name) followed by a tt(variable name) is the grammatical form of a variable definition. em(Parentheses) can be used to break priorities, but if there are no priorities to break, they have no effect, and are simply ignored by the compiler. In statement 3 the parentheses allowed us to get rid of the blank that's required between a type name and the variable name, but to the compiler we wrote verb( Print (p); ) which is, since the parentheses are superfluous, equal to verb( Print p; ) thus producing tt(p)'s redeclaration. As a further example: when we define a variable using a built-in type (e.g., tt(double)) using superfluous parentheses the compiler quietly removes these parentheses for us: verb( double ((((a)))); // weird, but OK. ) To summarize our findings about anonymous variables: itemization( it() Anonymous objects are great for initializing tt(const) reference parameters. it() The same syntaxis, however, can also be used in stand-alone statements, in which they are interpreted as variable definitions if our intention actually was to initialize an anonymous object using an existing object. it() Since this may cause confusion, it's probably best to restrict the use of anonymous objects to the first (and main) form: initializing function parameters. ) c++-annotations-10.5.0/yo/classes/examples/0000755000175000017500000000000012636507650017400 5ustar frankfrankc++-annotations-10.5.0/yo/classes/examples/getmembers.cc0000644000175000017500000000057112636507651022045 0ustar frankfrank #include "person.h" // given earlier using namespace std; string const &Person::name() const { return d_name; } string const &Person::address() const { return d_address; } string const &Person::phone() const { return d_phone; } size_t Person::mass() const { return d_mass; } c++-annotations-10.5.0/yo/classes/examples/volg.OBS0000644000175000017500000000130312635354026020705 0ustar frankfrank#include class Test { // datavelden: char *n; // naam-dataveld public: // constructoren: Test (); // parameter-vrije Test (char const *name); // met een naam // destructor: ~Test (); }; Test::Test () { n = "without name"; printf ("Test object without name created\n"); } Test::Test (char const *name) { n = (char *) name; printf ("Test object %s created\n", n); } Test::~Test () { printf ("Test object %s destroyed\n", n); } Test globaltest ("global"); void func () { Test functest ("func"); } int main () { Test maintest ("main"); func (); } c++-annotations-10.5.0/yo/classes/examples/local.cc0000644000175000017500000000176212636507651021010 0ustar frankfrank#include #include using namespace std; int main(int argc, char *argv[]) { static size_t staticValue = 0; class Local { int d_argc; // non-static data members OK public: enum // enums OK { VALUE = 5 }; Local(int argc) // constructors and member functions OK : // in-class implementation required d_argc(argc) { // global data: accessible cout << "Local constructor\n"; // static function variables: accessible staticValue += 5; } static void hello() // static member functions: OK { cout << "hello world\n"; } }; Local::hello(); // call Local static member Local loc(argc); // define object of a local class. } c++-annotations-10.5.0/yo/classes/examples/order.cc0000644000175000017500000000120712636507651021023 0ustar frankfrank #include #include using namespace std; class Test { public: Test(string const &name); // constructor with an argument }; Test::Test(string const &name) { cout << "Test object " << name << " created" << '\n'; } Test globaltest("global"); void func() { Test functest("func"); } int main() { Test first("main first"); func(); Test second("main second"); } /* Generated output: Test object global created Test object main first created Test object func created Test object main second created */ c++-annotations-10.5.0/yo/classes/examples/setmembers.cc0000644000175000017500000000063412636507651022061 0ustar frankfrank #include "person.h" // given earlier using namespace std; void Person::setName(string const &name) { d_name = name; } void Person::setAddress(string const &address) { d_address = address; } void Person::setPhone(string const &phone) { d_phone = phone; } void Person::setMass(size_t mass) { d_mass = mass; } c++-annotations-10.5.0/yo/classes/examples/constmembers.cc0000644000175000017500000000115712636507651022415 0ustar frankfrank #include using namespace std; class Members { public: Members(); void member(); void member() const; }; Members::Members() {} void Members::member() { cout << "non const member\n"; } void Members::member() const { cout << "const member\n"; } int main() { Members const constObject; Members nonConstObject; constObject.member(); nonConstObject.member(); } /* Generated output: const member non const member */ c++-annotations-10.5.0/yo/classes/examples/persondemo.cc0000644000175000017500000000134512636507651022066 0ustar frankfrank #include #include "person.h" // given earlier using namespace std; void printperson(Person const &p) { cout << "Name : " << p.name() << "\n" "Address : " << p.address() << "\n" "Phone : " << p.phone() << "\n" "Mass : " << p.mass() << '\n'; } int main() { Person p; p.setName("Linus Torvalds"); p.setAddress("E-mail: Torvalds@cs.helsinki.fi"); p.setPhone(" - not sure - "); p.setMass(75); // kg. printperson(p); } /* Produced output: Name : Linus Torvalds Address : E-mail: Torvalds@cs.helsinki.fi Phone : - not sure - Mass : 75 */ c++-annotations-10.5.0/yo/classes/examples/emptymain.cc0000644000175000017500000000044612636507651021717 0ustar frankfrank #include using namespace std; class Demo { public: Demo(); }; Demo::Demo() { cout << "Demo constructor called\n"; } Demo d; int main() {} /* Generated output: Demo constructor called */ c++-annotations-10.5.0/yo/classes/examples/person.h0000644000175000017500000000132112636507651021055 0ustar frankfrank #include class Person { std::string d_name; // name of person std::string d_address; // address field std::string d_phone; // telephone number size_t d_mass; // the mass in kg. public: // member functions void setName(std::string const &name); void setAddress(std::string const &address); void setPhone(std::string const &phone); void setMass(size_t mass); std::string const &name() const; std::string const &address() const; std::string const &phone() const; size_t mass() const; }; c++-annotations-10.5.0/yo/classes/examples/globalobject.cc0000644000175000017500000000202012636507651022331 0ustar frankfrank #include using namespace std; // a class Test with a constructor function class Test { public: // 'public' function: Test(); // the constructor }; Test::Test() // here is the { // definition cout << "constructor of class Test called\n"; } // and here is the test program: Test g; // global object void func() { Test // local object l; // in function func() cout << "here's function func()" << '\n'; } int main() { Test // local object x; // in function main() cout << "main() function" << '\n'; func(); return (0); } /* Generated output: constructor of class Test called constructor of class Test called main() function constructor of class Test called here's function func() */ c++-annotations-10.5.0/yo/classes/examples/personconstr.cc0000644000175000017500000000373412636507651022456 0ustar frankfrank COMMENT( Also note that the example doesn't show where the destructor is called; this action occurs implicitly when the below function tt(main()) terminates and hence when its local variable tt(p) ceases to exist. When tt(printperson()) receives a fully defined tt(Person) object (i.e., containing a name, address and phone number), the data are correctly printed. However, when a tt(Person) object is only partially filled, e.g. with only a name, tt(printperson()) passes 0-pointers to tt(cout). This unesthetic feature can be remedied with a little more code: verb( void printperson(Person const &p) { if (p.name()) cout << "Name : " << p.name() << "\n"; if (p.address()) cout << "Address : " << p.address() << "\n"; if (p.phone()) cout << "Phone : " << p.phone() << "\n"; } ) Alternatively, the constructor tt(Person::Person()) might initialize the members to `printable defaults', like tt(" ** undefined ** "). The destructor, constructor and the class definition are given below. verb( // class definition class Person { public: Person(); // constructor ~Person(); // destructor // functions to set fields void setName(string const &n); void setAddress(string const &a); void setPhone(string const &p); // functions to inspect fields string const &name() const; string const &address() const; string const &phone() const; private: char *name; // name of person char *address; // address field char *phone; // telephone number }; // constructor Person::Person() { name = 0; address = 0; phone = 0; } // destructor Person::~Person() { free(name); free(address); free(phone); } ) END COMMENT) c++-annotations-10.5.0/yo/classes/examples/delete.OBS0000644000175000017500000000432012635354026021202 0ustar frankfrank/* This example illustrates the use of delete[] in combination with arrays. First a new array is allocated, and deleted thereafter. It shows that only the first object is deleted. If, however, a single object is allocated, and delete[] is called, a segmentation error results: the compiler keeps deleting objects that don't exist. If the array contains plain values or pointers nothing in particular happens: delete and delete[] may both be used. Finally, if the array contains auto_pointers, the same situation as with objects can be observed: in the `delete array' situation the objects reached via the remaining auto-ptrs are not released, whereas they are released in the situation where delete[] is used. */ #include #include #include class X { public: X() { cerr << "X constructor called" << '\n'; } ~X() { cerr << "X destructor called" << '\n'; } }; int main(int argc, char **argv) { cerr << "deleting an array with objects without []:\n"; delete new X[3]; cerr << "deleting an array with objects with []:\n"; delete[] new X[3]; // cout << "deleting a non-existing array\n": //delete[] new X(); THIS RESULTS IN A SEGMENTATION FAULT!!! cerr << "deleting an array with plain values without []:\n"; delete new int[3]; cerr << "deleting an array with plain values with []:\n"; delete[] new int[3]; cerr << "deleting an array with pointers without []:\n"; delete new int *[3]; cerr << "deleting an array with pointers with []:\n"; delete[] new int *[3]; cerr << "deleting an array with auto-pointers without []:\n"; auto_ptr *a1 = new auto_ptr[3]; a1[0].reset(auto_ptr(new X()).release()); a1[1].reset(auto_ptr(new X()).release()); a1[2].reset(auto_ptr(new X()).release()); delete a1; cerr << "deleting an array with auto-pointers with []:\n"; auto_ptr *a2 = new auto_ptr[3]; a2[0].reset(auto_ptr(new X()).release()); a2[1].reset(auto_ptr(new X()).release()); a2[2].reset(auto_ptr(new X()).release()); delete[] a2; } c++-annotations-10.5.0/yo/classes/existingtypes.yo0000644000175000017500000000346712635354026021060 0ustar frankfrankOnce a type name has been defined it also prevails over identifiers representing variables, if the compiler is given a choice. This, too, can result in interesting constructions. Assume a function tt(process) expecting an tt(int) exists in a library. We want to use this function to process some tt(int) data values. So in tt(main) tt(process) is declared and called: verb( int process(int Data); process(argc); ) No problems here. But unfortunately we once decided to `beautify' our code, by throwing in some superfluous parentheses, like so: verb( int process(int (Data)); process(argc); ) Now we're in trouble. The compiler now generates an error, caused by its rule to let declarations prevail over definitions. tt(Data) now becomes the name of the tt(class Data), and analogous to tt(int (x)) the parameter tt(int (Data)) is parsed as tt(int (*)(Data)): a pointer to a function, expecting a tt(Data) object, returning an tt(int). Here is another example. When, instead of declaring verb( int process(int Data[10]); ) we declare, e.g., to emphasize the fact that an array is passed to tt(process): verb( int process(int (Data[10])); ) the tt(process) function does not expect a pointer to tt(int) values, but a pointer to a function expecting a pointer to tt(Data) elements, returning an tt(int). To summarize the findings in the `Ambiguity Resolution' section: itemization( it() The compiler will try to remove superfluous parentheses; it() But if the parenthesized construction represents a type, it will try to use the type; it() More in general: when possible the compiler will interpret a syntactic construction as a declaration, rather than as a definition (of an object or variable). ) c++-annotations-10.5.0/yo/classes/inline.yo0000644000175000017500000000311412635354026017404 0ustar frankfrankLet us take another look at the implementation of the function tt(Person::name()): verb( std::string const &Person::name() const { return d_name; } ) This function is used to retrieve the name field of an object of the class tt(Person). Example: verb( void showName(Person const &person) { cout << person.name(); } ) To insert tt(person)'s name the following actions are performed: itemization( it() The function tt(Person::name()) is called. it() This function returns tt(person)'s tt(d_name) as a reference. it() The referenced name is inserted into tt(cout). ) Especially the first part of these actions causes some time loss, since an extra function call is necessary to retrieve the value of the tt(name) field. Sometimes a faster procedure immediately making the tt(d_name) data member available is preferred without ever actually calling a function tt(name). This can be realized using ti(inline) functions. An inline function is a request to the compiler to insert the function's code at the location of the function's call. This may speed up execution by avoiding a function call, which typically comes with some (stack handling and parameter passing) overhead. Note that tt(inline) is a em(request) to the compiler: the compiler may decide to ignore it, and em(will) probably ignore it when the function's body contains much code. Good programming discipline suggests to be aware of this, and to avoid tt(inline) unless the function's body is fairly small. More on this in section ref(WHENINLINE). c++-annotations-10.5.0/yo/classes/local.yo0000644000175000017500000000425512635354026017227 0ustar frankfrankClasses are usually defined at the global or namespace level. However, it is entirely possible to define hi(class: local) a local class, i.e., inside a function. Such classes are called hi(local class)em(local classes). Local classes can be very useful in advanced applications involving inheritance or templates (cf. section ref(NONDEFINIT)). At this point in the annotations() they have limited use, although their main features can be described. At the end of this section an example is provided. itemization( it() Local classes may use almost all characteristics of normal classes. They may have constructors, destructors, data members, and member functions; it() Local classes cannot define static data members. Static member functions, however, em(can) be defined. it() Since a local class may define static member functions, it is possible to define emi(nested functions) in bf(C++) somewhat comparable to the way programming languages like bi(Pascal) allow nested functions to be defined. it() If a local class needs access to a constant integral value, a local em(enum) can be used. The tt(enum) may be anonymous, exposing only the tt(enum) values. it() Local classes cannot directly access the non-static variables of their surrounding context. For example, in the example shown below the class tt(Local) cannot directly access tt(main)'s tt(argc) parameter. it() Local classes may directly access global data and static variables defined by their surrounding function. This includes variables defined in the anonymous namespace of the source file containing the local class. it() Local class objects can be defined inside the function body, but they cannot leave the function as objects of their own type. I.e., a local class name cannot be used for either the return type or for the parameter types of its surrounding function. it() As a prelude to emi(inheritance) (chapter ref(INHERITANCE)): a local class may be derived from an existing class allowing the surrounding function to return a dynamically allocated locally constructed class object, pointer or reference could be returned via a base class pointer or reference. ) verbinclude(-a examples/local.cc) c++-annotations-10.5.0/yo/classes/arguments.yo0000644000175000017500000001205512635354026020137 0ustar frankfrankThe class tt(Person)'s constructor so far has no parameters. bf(C++) allows constructors to be defined with or without parameter lists. The arguments are supplied when an object is defined. For the class tt(Person) a constructor expecting three strings and a tt(size_t) might be useful. Representing, respectively, the person's name, address, phone number and mass. This constructor is (but see also section ref(MemberInitializers)): verb( Person::Person(string const &name, string const &address, string const &phone, size_t mass) { d_name = name; d_address = address; d_phone = phone; d_mass = mass; } ) It must of course also be declared in the class interface: verb( class Person { // data members (not altered) public: Person(std::string const &name, std::string const &address, std::string const &phone, size_t mass); // rest of the class interface (not altered) }; ) Now that this constructor has been declared, the default constructor must explicitly be declared as well if we still want to be able to construct a plain tt(Person) object without any specific initial values for its data members. The class tt(Person) would thus support two constructors, and the part declaring the constructors now becomes: verb( class Person { // data members public: Person(); Person(std::string const &name, std::string const &address, std::string const &phone, size_t mass); // additional members }; ) In this case, the default constructor doesn't have to do very much, as it doesn't have to initialize the tt(string) data members of the tt(Person) object. As these data members are objects themselves, they are initialized to empty strings by their own default constructor. However, there is also a tt(size_t) data member. That member is a variable of a built-in type and such variabes do not have constructors and so are not initialized automatically. Therefore, unless the value of the tt(d_mass) data member is explicitly initialized its value is: itemization( it() a em(random) value for local tt(Person) objects; it() 0 for global and static tt(Person) objects. ) The 0-value might not be too bad, but normally we don't want a em(random) value for our data members. So, even the default constructor has a job to do: initializing the data members which are not initialized to sensible values automatically. Its implementation can be: verb( Person::Person() { d_mass = 0; } ) Using constructors with and without arguments is illustrated next. The object tt(karel) is initialized by the constructor defining a non-empty parameter list while the default constructor is used with the tt(anon) object: verb( int main() { Person karel("Karel", "Rietveldlaan 37", "542 6044", 70); Person anon; } ) The two tt(Person) objects are defined when tt(main) starts as they are em(local) objects, living only for as long as tt(main) is active. If tt(Person) objects must be definable using other arguments, corresponding constructors must be added to tt(Person)'s interface. Apart from overloading class constructors it is also possible to provide constructors with default argument values. These default arguments must be specified with the constructor declarations in the class interface, like so: verb( class Person { public: Person(std::string const &name, std::string const &address = "--unknown--", std::string const &phone = "--unknown--", size_t mass = 0); }; ) Often, constructors use highly similar implementions. This results from the fact that the constructor's parameters are often defined for convenience: a constructor not requiring a tt(phone) number but requiring a tt(mass) cannot be defined using default arguments, since tt(phone) is not the constructor's last parameter. Consequently a special constructor is required not having tt(phone) in its parameter list. Before the C++11 standard this situation was commonly handled like this: all constructors em(must) initialize their reference and tt(const) data members, or the compiler (rightfully) complains. To initialize the remaining members (non-const and non-reference members) we have two options: itemization( it() If the body of the construction process is sizeable but (parameterizable) identical to other constructors bodies then factorize. Define a private member tt(init) which is called by the constructors to provide the object's data members with their appropriate values. it() If the constructors act fundamentally differently, then there's nothing to factorize and each constructor must be implemented by itself. ) Currently, bf(C++) allows constructors to call each other (called em(constructor delegation)). This is illustrated in section ref(CONSCALL) below. c++-annotations-10.5.0/yo/classes/namespaces.yo0000644000175000017500000000452412635354026020253 0ustar frankfrankWhen entities from hi(namespace) namespaces are used in hi(header file) header files, no ti(using) directive should be specified in those header files if they are to be used as general header files declaring classes or other entities from a i(library). When the tt(using) directive is used in a header file then users of such a header file are forced to accept and use the declarations in all code that includes the particular header file. For example, if in a namespace tt(special) an object tt(Inserter cout) is declared, then tt(special::cout) is of course a different object than tt(std::cout). Now, if a class tt(Flaw) is constructed, in which the constructor expects a reference to a tt(special::Inserter), then the class should be constructed as follows: verb( class special::Inserter; class Flaw { public: Flaw(special::Inserter &ins); }; ) Now the person designing the class tt(Flaw) may be in a lazy mood, and might get bored by continuously having to prefix tt(special::) before every entity from that namespace. So, the following construction is used: verb( using namespace special; class Inserter; class Flaw { public: Flaw(Inserter &ins); }; ) This works fine, up to the point where somebody wants to include tt(flaw.h) in other source files: because of the tt(using) directive, this latter person is now by implication also tt(using namespace special), which could produce unwanted or unexpected effects: verb( #include #include using std::cout; int main() { cout << "starting\n"; // won't compile } ) The compiler is confronted with two interpretations for tt(cout): first, because of the tt(using) directive in the tt(flaw.h) header file, it considers tt(cout) a tt(special::Inserter), then, because of the tt(using) directive in the user program, it considers tt(cout) a tt(std::ostream). Consequently, the compiler reports an error. As a i(rule of thumb), header files intended for general use should not contain tt(using) declarations. This rule does not hold true for header files which are only included by the sources of a class: here the programmer is free to apply as many tt(using) declarations as desired, as these directives never reach other sources. c++-annotations-10.5.0/yo/classes/headers.yo0000644000175000017500000002414112635354026017544 0ustar frankfrankIn section ref(CHeaders) the requirements for header files when a bf(C++) program also uses bf(C) functions were discussed. hi(header file) Header files containing class interfaces have additional requirements. First, source files. With the exception of the occasional classless function, source files contain the code of member functions of classes. here there are basically two approaches: itemization( it() All required header files for a member function are included in each individual source file. it() All required header files (for all member functions of a class) are included in a header file that is included by each of the source files defining class members. ) The first alternative has the advantage of economy for the compiler: it only needs to read the header files that are necessary for a particular source file. It has the disadvantage that the program developer must include multiple header files again and again in sourcefiles: it both takes time to type the tt(include)-directives and to think about the header files which are needed in a particular source file. The second alternative has the advantage of economy for the program developer: the header file of the class accumulates header files, so it tends to become more and more generally useful. It has the disadvantage that the compiler frequently has to process many header files which aren't actually used by the function to compile. With computers running faster and faster (and compilers getting smarter and smarter) I think the second alternative is to be preferred over the first alternative. So, as a starting point source files of a particular class tt(MyClass) could be organized according to the following example: verb( #include int MyClass::aMemberFunction() {} ) There is only one tt(include)-directive. Note that the directive refers to a header file in a directory mentioned in the ti(INCLUDE)-file environment variable. Local header files (using tt(#include "myclass.h")) could be used too, but that tends to complicate the organization of the class header file itself somewhat. COMMENT( If i(name collision)s with existing header files might occur it is advised to create a subdirectory in one of the directories mentioned in the tt(INCLUDE) environment variable (e.g., tt(/usr/local/include/myheaders/)) to contain all user If a class tt(MyClass) is developed in that subdirectory, create a subdirectory (or subdirectory link) tt(myheaders) in one of the standard tt(INCLUDE) directories to contain all header files of all classes that are developed as part of the project. The tt(include)-directives will then be similar to tt(#include ), and name collisions with other header files are avoided. END) The organization of the header file itself requires some attention. Consider the following example, in which two classes tt(File) and tt(String) are used. Assume the tt(File) class has a member tt(gets(String &destination)), while the class tt(String) has a member function tt(getLine(File &file)). The (partial) header file for the tt(class String) is then: verb( #ifndef STRING_H_ #define STRING_H_ #include // to know about a File class String { public: void getLine(File &file); }; #endif ) Unfortunately a similar setup is required for the class tt(File): verb( #ifndef FILE_H_ #define FILE_H_ #include // to know about a String class File { public: void gets(String &string); }; #endif ) Now we have created a problem. The compiler, trying to compile the source file of the function tt(File::gets) proceeds as follows: itemization( it() The header file tt(project/file.h) is opened to be read; it() tt(FILE_H_) is defined it() The header file tt(project/string.h) is opened to be read it() tt(STRING_H_) is defined it() The header file tt(project/file.h) is (again) opened to be read it() Apparently, tt(FILE_H_) is already defined, so the remainder of tt(project/file.h) is skipped. it() The interface of the class tt(String) is now parsed. it() In the class interface a reference to a tt(File) object is encountered. it() As the tt(class File) hasn't been parsed yet, a tt(File) is still an undefined type, and the compiler quits with an error. ) The solution to this problem is to use a emi(forward class reference) em(before) the class interface, and to include the corresponding class header file em(beyond) the class interface. So we get: verb( #ifndef STRING_H_ #define STRING_H_ class File; // forward reference class String { public: void getLine(File &file); }; #include // to know about a File #endif ) A similar setup is required for the class tt(File): verb( #ifndef FILE_H_ #define FILE_H_ class String; // forward reference class File { public: void gets(String &string); }; #include // to know about a String #endif ) This works well in all situations where either references or pointers to other classes are involved and with (non-inline) member functions having i(class-type return values) or hi(class-type parameters) parameters. This setup doesn't work with i(composition), nor with in-class inline member functions. Assume the class tt(File) has a em(composed) data member of the class tt(String). In that case, the class interface of the class tt(File) em(must) include the header file of the class tt(String) before the class interface itself, because otherwise the compiler can't tell how big a tt(File) object is. A tt(File) object contains a tt(String) member, but the compiler can't determine the size of that tt(String) data member and thus, by implication, it can't determine the size of a tt(File) object. In cases where classes contain composed objects (or are derived from other classes, see chapter ref(INHERITANCE)) the header files of the classes of the composed objects must have been read em(before) the class interface itself. In such a case the tt(class File) might be defined as follows: verb( #ifndef FILE_H_ #define FILE_H_ #include // to know about a String class File { String d_line; // composition ! public: void gets(String &string); }; #endif ) The class tt(String) can't declare a tt(File) object as a composed member: such a situation would again result in an undefined class while compiling the sources of these classes. All remaining header files (appearing below the class interface itself) are required only because they are used by the class's source files. This approach allows us to introduce yet another refinement: itemization( it() Header files defining a class interface should em(declare) what can be declared before defining the class interface itself. So, classes that are mentioned in a class interface should be specified using hi(forward declaration) forward declarations em(unless) itemization( it() They are a em(base class) of the current class (see chapter ref(INHERITANCE)); it() They are the class types of composed data members; it() They are used in inline member functions. ) In particular: additional actual header files are em(not) required for: itemization( it() class-type return values of functions; it() class-type value parameters of functions. ) Class header files of objects that are either composed or inherited or that are used in inline functions, em(must) be known to the compiler before the interface of the current class starts. The information in the header file itself is protected by the tt(#ifndef ... #endif) construction introduced in section ref(CHeaders). it() Program sources in which the class is used only need to include this header file. hi(Lakos, J.) em(Lakos), (2001) refines this process even further. See his book bf(Large-Scale bf(C++) Software Design) for further details. This header file should be made available in a well-known location, such as a directory or subdirectory of the standard ti(INCLUDE) path. it() To implement member functions the class's header file is required and usually additional header files (like the tt(string) header file) as well. The class header file itself as well as these additional header files should be included in a separate internal header file (for which the extension tt(.ih) hi(.ih extension) (`i(internal header)') is suggested). The tt(.ih) file should be defined in the same directory as the source files of the class. It has the following characteristics: itemization( it() There is em(no) need for a protective tt(#ifndef) .. tt(#endif) shield, as the header file is never included by other header files. it() The standard tt(.h) header file defining the class interface is included. it() The header files of all classes used as forward references in the standard tt(.h) header file are included. it() Finally, all other header files that are required in the source files of the class are included. ) An example of such a header file organization is: itemization( it() First part, e.g., tt(/usr/local/include/myheaders/file.h): verb( #ifndef FILE_H_ #define FILE_H_ #include // for composed 'ifstream' class Buffer; // forward reference class File // class interface { std::ifstream d_instream; public: void gets(Buffer &buffer); }; #endif ) it() Second part, e.g., tt(~/myproject/file/file.ih), where all sources of the class File are stored: verb( #include // make the class File known #include // make Buffer known to File #include // used by members of the class #include // File. ) ) ) c++-annotations-10.5.0/yo/classes/defaulted.yo0000644000175000017500000000361712635354026020073 0ustar frankfrankIn everyday class design two situations are frequently encountered: itemization( it() A class offering constructors explicitly has to define a default constructor; it() A class (e.g., a class implementing a stream) cannot initialize objects by copying the values from an existing object of that class (called emi(copy construction)) and cannot assign objects to each other. ) Once a class defines at least one constructor its default constructor is not automatically defined by the compiler. bf(C++) relaxes that restriction somewhat by offering the hi(default)`ti(= default)' syntax. A class specifying `tt(= default)' with its default constructor declaration indicates that the i(trivial default constructor) should be provided by the compiler. A trivial default constructor performs the following actions: itemization( it() Its data members of built-in or primitive types are not initialized; it() Its composed (class type) data members are initialized by their default constructors. it() If the class is derived from a base class (cf. chapter ref(INHERITANCE)) the base class is initialized by its default constructor. ) Trivial implementations can also be provided for the em(copy constructor), the em(overloaded assignment operator), and the em(destructor). Those members are introduced in chapter ref(MEMORY). Conversely, situations exist where some (otherwise automatically provided) members should em(not) be made available. This is realized by specifying hi(delete)`ti(= delete)'. Using tt(= default) and tt(= delete) is illustrated by the following example. The default constructor receives its trivial implementation, copy-construction is prevented: verb( class Strings { public: Strings() = default; Strings(std::string const *sp, size_t size); Strings(Strings const &other) = delete; }; ) c++-annotations-10.5.0/yo/classes/sizeof.yo0000644000175000017500000000111512635354026017424 0ustar frankfrankIn bf(C++) the well-known ti(sizeof) operator can be applied to data members of classes without the need to specify an object as well. Consider: verb( class Data { std::string d_name; ... }; ) To obtain the size of tt(Data)'s tt(d_name) member the following expression can be used: verb( sizeof(Data::d_name); ) However, note that the compiler observes data protection here as well. tt(Sizeof(Data::d_name)) can only be used where tt(d_name) may be visible as well, i.e., by tt(Data)'s member functions and friends. c++-annotations-10.5.0/yo/classes/anonymous.yo0000644000175000017500000000736212635354026020167 0ustar frankfrankSometimes objects are used because they offer a certain functionality. The objects only exist because of their functionality, and nothing in the objects themselves is ever changed. The following class tt(Print) offers a facility to print a string, using a configurable prefix and suffix. A partial class interface could be: verb( class Print { public: Print(ostream &out); void print(std::string const &prefix, std::string const &text, std::string const &suffix) const; }; ) An interface like this would allow us to do things like: verb( Print print(cout); for (int idx = 0; idx != argc; ++idx) print.print("arg: ", argv[idx], "\n"); ) This works fine, but it could greatly be improved if we could pass tt(print)'s invariant arguments to tt(Print)'s constructor. This would simplify tt(print)'s prototype (only one argument would need to be passed rather than three) and we could wrap the above code in a function expecting a tt(Print) object: verb( void allArgs(Print const &print, int argc, char *argv[]) { for (int idx = 0; idx != argc; ++idx) print.print(argv[idx]); } ) The above is a fairly generic piece of code, at least it is with respect to tt(Print). Since tt(prefix) and tt(suffix) don't change they can be passed to the constructor which could be given the prototype: verb( Print(ostream &out, string const &prefix = "", string const &suffix = ""); ) Now tt(allArgs) may be used as follows: verb( Print p1(cout, "arg: ", "\n"); // prints to cout Print p2(cerr, "err: --", "--\n"); // prints to cerr allArgs(p1, argc, argv); // prints to cout allArgs(p2, argc, argv); // prints to cerr ) But now we note that tt(p1) and tt(p2) are only used inside the tt(allArgs) function. Furthermore, as we can see from tt(print)'s prototype, tt(print) doesn't modify the internal data of the tt(Print) object it is using. In such situations it is actually not necessary to define objects before they are used. Instead emi(anonymous object)em(s)hi(object: anonymous) may be used. Anonymous objects can be used: itemization( it() to initialize a function parameter which is a tt(const) reference to an object; it() if the object is em(only) used inside the function call. ) These anonymous objects are considered constant as they merely exist for passing the information of (class type) objects to functions. They are not considered 'variables'. Of course, a tt(const_cast) could be used to cast away the const reference's constness, but any change is lost once the function returns. These anonymous objects used to initialize const references should not be confused with rvalue references (section ref(RREF)) which have a completely different purpose in life. Rvalue references primarily exist to be `swallowed' by functions receiving them. Thus, the information made available by rvalue references outlives the rvalue reference objects which are also anonymous. Anonymous objects are defined when a constructor is used without providing a name for the constructed object. Here is the corresponding example: verb( allArgs(Print(cout, "arg: ", "\n"), argc, argv); // prints to cout allArgs(Print(cerr, "err: --", "--\n"), argc, argv);// prints to cerr ) In this situation the tt(Print) objects are constructed and immediately passed as first arguments to the tt(allArgs) functions, where they are accessible as the function's tt(print) parameter. While the tt(allArgs) function is executing they can be used, but once the function has completed, the anonymous tt(Print) objects are no longer accessible. c++-annotations-10.5.0/yo/classes/memberinit.yo0000644000175000017500000001003412635354026020260 0ustar frankfrankNon-static data members of classes are usually initialized by the class's constructors. Frequently (but not always) the same initializations are used by different constructors, resulting in multiple points where the initializations are performed, which in turn complicates class maintenance. Consider a class defining several data members: a pointer to data, a data member storing the number of data elements the pointer points at, a data member storing the sequence number of the object. The class also offer a basic set of constructors, as shown in the following class interface: verb( class Container { Data *d_data; size_t d_size; size_t d_nr; static size_t s_nObjects; public: Container(); Container(Container const &other); Container(Data *data, size_t size); Container(Container &&tmp); }; ) The initial values of the data members are easy to describe, but somewhat hard to implement. Consider the initial situation and assume the default constructor is used: all data members should be set to 0, except for tt(d_nr) which must be given the value tt(++s_nObjects). Since these are em(non)-default actions, we can't declare the default constructor using tt(= default), but we must provide an actual implementation: verb( Container() : d_data(0), d_size(0), d_nr(++s_nObjects) {} ) In fact, em(all) constructors require us to state the tt(d_nr(++s_nObjects)) initialization. So if tt(d_data)'s type would have been a (move aware) class type, we would still have to provide implementations for all of the above constructors. bf(C++), however, also supports emi(data member initializers), simplifying the initialization of non-static data members. Data member initializers allow us to assign initial values to data members. The compiler must be able to compute these initial values from initialization expressions, but the initial values do not have to be constant expressions. So tt(++s_nObjects) can be an initial value. Using data member initializers for the class tt(Container) we get: verb( class Container { Data *d_data = 0; size_t d_size = 0; size_t d_nr = ++nObjects; static size_t s_nObjects; public: Container() = default; Container(Container const &other); Container(Data *data, size_t size); Container(Container &&tmp); }; ) Note that the data member initializations are recognized by the compiler, and are applied to its implementation of the default constructor. In fact, all constructors will apply the data member initializations, unless explicitly initialized otherwise. E.g., the move-constructor may now be implented like this: verb( Container(Container &&tmp) : d_data(tmp.d_data), d_size(tmp.d_size) { tmp.d_data = 0; } ) Although tt(d_nr)'s intialization is left out of the implementation it em(is) initialized due to the data member initialization provided in the class's interface. An emi(aggregate) is an array or a tt(class) (usually a tt(struct) with no user-defined constructors, no private or protected non-static data members, no base classes (cf. chapter ref(INHERITANCE)), and no virtual functions (cf. chapter ref(POLYMORPHISM))). E.g., verb( struct POD // defining aggregate POD { int first = 5; double second = 1.28; std::string hello {"hello"}; }; ) The cXIV() standard allows initialization of such aggregates using em(braced initializer lists). E.g., verb( POD pod {4, 13.5, "hi there"}; ) When using braced-initializer lists not all data members need to be initialized. Specification may stop at any data member, in which case the default (or explicitly defined initialization values) of the remaining data members are used. E.g., verb( POD pod {4}; // uses second: 1.28, hello: "hello" ) c++-annotations-10.5.0/yo/classes/ambiguity.yo0000644000175000017500000000574112635354026020130 0ustar frankfrankDefining objects may result in some unexpected surprises. Assume the following class interface is available: verb( class Data { public: Data(); Data(int one); Data(int one, int two); void display(); }; ) The intention is to define two objects of the class Data, using, respectively, the first and second constructors. Your code looks like this (and compiles correctly): verb( #include "data.h" int main() { Data d1(); Data d2(argc); } ) Now it's time to make some good use of the tt(Data) objects. You add two statements to tt(main): verb( d1.display(); d2.display(); ) But, surprise, the compiler complains about the first of these two: em(error: request for member 'display' in 'd1', which is of non-class type 'Data()') What's going on here? First of all, notice the data type the compiler refers to: tt(Data()), rather than tt(Data). What are those tt(()) doing there? Before answering that question, let's broaden our story somewhat. We know that somewhere in a library a emi(factory function) tt(dataFactory) exists. A factory function creates and returns an object of a certain type. This tt(dataFactory) function returns a tt(Data) object, constructed using tt(Data)'s default constructor. Hence, tt(dataFactory) needs no arguments. We want to use tt(dataFactory) in our program, but must declare the function. So we add the declaration to tt(main), as that's the only location where tt(dataFactory) will be used. It's a function, not requiring arguments, returning a tt(Data) object: verb( Data dataFactory(); ) This, however, looks remarkably similar to our tt(d1) object definition: verb( Data d1(); ) We found the source of our problem: tt(Data d1()) apparently is em(not) the definition of a tt(d1) object, but the em(declaration) of a function, returning a tt(Data) object. So, what's happening here and how should we define a tt(Data) object using tt(Data)'s default constructor? First: what's happening here is that the compiler, when confronted with tt(Data d1()), actually had a choice. It could either define a tt(Data) object, or declare a function. It declares a function. In fact, we're encountering an i(ambiguity) in bf(C++)'s syntax here, which is solved, according to the language's standard, by always letting a declaration prevail over a definition. We'll encounter more situations where this ambiguity occurs later on in this section. Second: there are several ways we can solve this ambiguity the way we want it to be solved. To define an object using its default constructor: itemization( it() merely mention it (like tt(int x)): tt(Data d1); it() use the curly-brace initialization: tt(Data d1{}); it() use the assignment operator and an anonymous default constructed tt(Data) object: tt(Data d1 = Data()). ) c++-annotations-10.5.0/yo/classes/comref.yo0000644000175000017500000000714312635354026017407 0ustar frankfrankApart from using member initializers to initialize composed objects (be they tt(const) objects or not), there is another situation where member initializers must be used. Consider the following situation. A program uses an object of the class tt(Configfile), defined in tt(main) to access the information in a configuration file. The configuration file contains parameters of the program which may be set by changing the values in the configuration file, rather than by supplying command line arguments. Assume another object used in tt(main) is an object of the class tt(Process), doing `all the work'. What possibilities do we have to tell the object of the class tt(Process) that an object of the class tt(Configfile) exists? itemization( it() The objects could have been declared as em(global) objects. This em(is) a possibility, but not a very good one, since all the advantages of local objects are lost. it() The tt(Configfile) object may be passed to the tt(Process) object at construction time. Bluntly passing an object (i.e., by value) might not be a very good idea, since the object must be copied into the tt(Configfile) parameter, and then a data member of the tt(Process) class can be used to make the tt(Configfile) object accessible throughout the tt(Process) class. This might involve yet another object-copying task, as in the following situation: verb( Process::Process(Configfile conf) // a copy from the caller { d_conf = conf; // copying to d_conf member } ) it() The copy-instructions can be avoided if em(pointers) to the tt(Configfile) objects are used, as in: verb( Process::Process(Configfile *conf) // pointer to external object { d_conf = conf; // d_conf is a Configfile * } ) This construction as such is OK, but forces us to use the `tt(->)' field selector operator, rather than the `tt(.)' operator, which is (disputably) awkward. Conceptually one tends to think of the tt(Configfile) object as an object, and not as a pointer to an object. In bf(C) this would probably have been the preferred method, but in bf(C++) we can do better. it() Rather than using value or pointer parameters, the tt(Configfile) parameter could be defined as a emi(reference parameter) of tt(Process)'s constructor. Next, use a tt(Config) reference data member in the tt(class Process). ) But a reference variable cannot be initialized using an assignment, and so the following is incorrect: verb( Process::Process(Configfile &conf) { d_conf = conf; // wrong: no assignment } ) The statement tt(d_conf = conf) fails, because it is not an initialization, but an assignment of one tt(Configfile) object (i.e., tt(conf)), to another (tt(d_conf)). An assignment to a reference variable is actually an assignment to the variable the reference variable refers to. But which variable does tt(d_conf) refer to? To no variable at all, since we haven't initialized tt(d_conf). After all, the whole purpose of the statement tt(d_conf = conf) was to initialize tt(d_conf).... How to initialize tt(d_conf)? We once again use the member initializer syntax. Here is the correct way to initialize tt(d_conf): verb( Process::Process(Configfile &conf) : d_conf(conf) // initializing reference member {} ) The above syntax must be used in all cases where reference data members are used. E.g., if tt(d_ir) would have been an tt(int) reference data member, a construction like verb( Process::Process(int &ir) : d_ir(ir) {} ) would have been required. c++-annotations-10.5.0/yo/classes/types.yo0000644000175000017500000000416412635354026017300 0ustar frankfrank tt(Data()), which in the above context defines a default constructed anonymous tt(Data) object, takes us back to the compiler error. According to the compiler, our original tt(d1) apparently was not of type tt(Data), but of type tt(Data()). So what's that? Let's first have a look at our second constructor. It expects an tt(int). We would like to define another tt(Data) object, using the second constructor, but want to pass the default tt(int) value to the constructor, using tt(int()). We know this defines a default tt(int) value, as tt(cout << int() << '\n') nicely displays 0, and tt(int x = int()) also initialized x to 0. So we define tt(`Data di(int())') in tt(main). Not good: again the compiler complains when we try to use tt(di). After tt(`di.display()') the compiler tells us: em(error: request for member 'display' in 'di', which is of non-class type 'Data(int (*)())') Oops, not as expected.... Didn't we pass 0? Why the sudden pointer? It's that same `use a declaration when possible' strategy again. The notation tt(Type()) not only represents the default value of type tt(Type), but it's also a shorthand notation for an anonymous pointer to a function, not expecting arguments, and returning a tt(Type) value, which you can verify by defining tt(`int (*ip)() = nullptr'), and passing tt(ip) as argument to tt(di): tt(di(ip)) compiles fine. So why doesn't the error occur when inserting tt(int()) or assigning tt(int()) to tt(int x)? In these latter cases nothing is declared. Rather, tt(cout) and tt(int x =) need expressions determining values, which is provided by tt(int())'s `natural' interpretation. But with tt(`Data di(int())') the compiler again has a choice, and (by design) it chooses a declaration because the declaration takes priority. Now tt(int())'s interpretation as an anonymous pointer is available and therefore used. Likewise, if tt(int x) has been defined, tt(`Data b1(int(x))') declares tt(b1) as a function, expecting an tt(int) (as tt(int(x)) represents a type), while tt(`Data b2((int)x)') defines tt(b2) as a tt(Data) object, using the constructor expecting a single tt(int) value. c++-annotations-10.5.0/yo/friends/0000755000175000017500000000000012635354026015553 5ustar frankfrankc++-annotations-10.5.0/yo/friends/intro.yo0000644000175000017500000000536012635354026017263 0ustar frankfrankIn all examples discussed up to now, we've seen that tt(private) members are only accessible by the members of their class. This is em(good), as it enforces i(encapsulation) and i(data hiding). By encapsulating functionality within a class we prevent that a class exposes multiple responsibilities; by hiding data we promote a class's i(data integrity) and we prevent that other parts of the software become i(implementation dependent) on the data that belong to a class. In this (very) short chapter we introduce the ti(friend) keyword and the principles that underly its use. The bottom line being that by using the tt(friend) keyword functions are granted access to a class's tt(private) members. Even so, this does not imply that the principle of data hiding is abandoned when the tt(friend) keyword is used. In this chapter the topic of i(friendship among classes) is not discussed. Situations in which it is natural to use friendship among classes are discussed in chapters ref(NESTEDCLASSES) and ref(TEMPLATES) and such situations are natural extensions of the way friendship is handled for functions. There should be a well-defined conceptual reason for declaring friendship (i.e., using the tt(friend) keyword). The traditionally offered definition of the hi(class: concept defined) class concept usually looks something like this: quote(em(A class is a set of data together with the functions that operate on that set of data.)) As we've seen in chapter ref(OVERLOADING) some functions have to be defined outside of a class interface. They are defined outside of the class interface to allow promotions for their operands or to extend the facilities of existing classes not directly under our control. According to the above traditional definition of the class concept those functions that cannot be defined in the class interface itself should nevertheless be considered functions belonging to the class. Stated otherwise: if permitted by the language's syntax they would certainly have been defined inside the class interface. There are two ways to implement such functions. One way consists of implementing those functions using available public member functions. This approach was used, e.g., in section ref(EXTRACTORS). Another approach applies the definition of the class concept to those functions. By stating that those functions in fact belong to the class they should be given direct access to the data members of objects. This is accomplished by the tt(friend) keyword. As a general principle hi(class: externally declared functions) we state that all functions operating on the data of objects of a class that are declared in the same file as the class interface itself belong to that class and may be granted direct access to the class's data members. c++-annotations-10.5.0/yo/friends/extended.yo0000644000175000017500000000175512635354026017734 0ustar frankfrankbf(C++) has added emi(extended friend) em(declarations) hi(friend: extended declaration) to the language. When a class is declared as a friend, then the tt(class) keyword no longer has to be provided. E.g., verb( class Friend; // declare a class typedef Friend FriendType; // and a typedef for it using FName = Friend; // and a using declaration class Class1 { friend Friend; // FriendType and FNaem: also OK }; ) In the pre-C++11 standards the friend declaration required an explicit tt(class); e.g., tt(friend class Friend). The explicit use of tt(class) remains required if the compiler hasn't seen the friend's name yet. E.g., verb( class Class1 { // friend Unseen; // fails to compile: Unseen unknown. friend class Unseen; // OK }; ) Section ref(TEMPFRIENDS) covers the use of extended friend declarations in class templates. c++-annotations-10.5.0/yo/friends/friendfun.yo0000644000175000017500000000622112635354026020105 0ustar frankfrank In section ref(EXTRACTORS) the insertion operator of the class tt(Person) (cf. section ref(ASSIGNMENT)) was implemented like this: verb( ostream &operator<<(ostream &out, Person const &person) { return out << "Name: " << person.name() << ", " "Address: " << person.address() << ", " "Phone: " << person.phone(); } ) tt(Person) objects can now be inserted into streams. However, this implementation required three member functions to be called, which may be considered a source of inefficiency. An improvement would be reached by defining a member tt(Person::insertInto) and let tt(operator<<) call that function. These two functions could be defined as follows: verb( std::ostream &operator<<(std::ostream &out, Person const &person) { return person.insertInto(out); } std::ostream &Person::insertInto(std::ostream &out) { return out << "Name: " << d_name << ", " "Address: " << d_address << ", " "Phone: " << d_phone; } ) As tt(insertInto) is a member function it has direct access to the object's data members so no additional member functions must be called when inserting tt(person) into tt(out). The next step consists of realizing that tt(insertInto) is only defined for the benefit of tt(operator<<), and that tt(operator<<), as it is declared in the header file containing tt(Person)'s class interface should be considered a function belonging to the class tt(Person). The member tt(insertInto) can therefore be omitted when tt(operator<<) is declared as a friend. Friend functions must be declared as friends in the class interface. These hi(friend: function declaration) em(friend declarations) are not em(member) functions, and so they are independent of the class's tt(private, protected) and tt(public) sections. Friend declaration may be placed anywhere in the class interface. Convention dictates that friend declaractions are listed directly at the top of the class interface. The class tt(Person), using tt(friend) declaration for its extraction and insertion operators starts like this: verb( class Person { friend std::ostream &operator<<(std::ostream &out, Person &pd); friend std::istream &operator>>(std::istream &in, Person &pd); // previously shown interface (data and functions) }; ) The insertion operator may now directly access a tt(Person) object's data members: verb( std::ostream &operator<<(std::ostream &out, Person const &person) { return cout << "Name: " << person.d_name << ", " "Address: " << person.d_address << ", " "Phone: " << person.d_phone; } ) Friend declarations are true declarations. Once a class contains friend declarations these friend functions do not have to be declared again below the class's interface. This also clearly indicates the class designer's intent: the friend functions are declared by the class, and can thus be considered functions belonging to the class. c++-annotations-10.5.0/yo/static.yo0000644000175000017500000000127512635354026015766 0ustar frankfrankincludefile(static/intro) lsect(StaticData)(Static data) includefile(static/data) subsect(Private static data) includefile(static/private) subsect(Public static data) includefile(static/public) subsect(Initializing static const data) includefile(static/const) lsubsect(GENCONST)(Generalized constant expressions (constexpr)) includefile(static/genconst) lsubsubsect(CONSTEXPR)(Constant expression data) includefile(static/constexprdata) sect(Static member functions) includefile(static/function) lsubsect(CALLINGCONVENTION)(Calling conventions) includefile(static/calling) c++-annotations-10.5.0/yo/friends.yo0000644000175000017500000000026712635354026016131 0ustar frankfrankincludefile(friends/intro) lsect(FriendsFriendfun)(Friend functions) includefile(friends/friendfun) sect(Extended friend declarations) includefile(friends/extended)
\n" << "\n"; // left column as a table for (unsigned idx = 0; idx < halfway; idx++) // print left column { cout << "\n"; display(idx); cout << "\n"; } cout << "
\n" << "		\n" << "\n"; // right column as a table for (unsigned idx = halfway; idx < n; idx++) // print right column { cout << "\n"; display(idx); cout << "\n"; } cout << "
\n" << "		)\ bf(ARG1)NOTRANS()\ ARG1+NOTRANS()\ ARG1+NOTRANS()\ ARG1+NOTRANS()\ ARG1+NOTRANS() ARG1+NOTRANS(