├── .github
    └── workflows
    │   └── gh-pages.yml
├── .gitignore
├── .gitmodules
├── LICENSE.txt
├── README.md
├── STYLE.md
├── archetypes
    └── default.md
├── config.toml
├── content
    ├── faq
    │   ├── decay.md
    │   ├── enable-warnings.md
    │   ├── fixed-width-integers.md
    │   ├── include-guards-pragma-once.md
    │   ├── iterators.md
    │   ├── member-initializer-list.md
    │   ├── undefined-behaviour.md
    │   ├── unspecified-impldefined.md
    │   └── using-namespace-std.md
    ├── meta
    │   └── about.md
    └── search.md
└── layouts
    ├── _default
        ├── list.html
        └── single.html
    └── partials
        └── post_meta.html


/.github/workflows/gh-pages.yml:
--------------------------------------------------------------------------------
 1 | name: github pages
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   deploy:
10 |     runs-on: ubuntu-18.04
11 |     steps:
12 |       - uses: actions/checkout@v2
13 |         with:
14 |           submodules: true  # Fetch Hugo themes (true OR recursive)
15 |           fetch-depth: 0    # Fetch all history for .GitInfo and .Lastmod
16 | 
17 |       - name: Setup Hugo
18 |         uses: peaceiris/actions-hugo@v2
19 |         with:
20 |           hugo-version: 'latest'
21 |           # extended: true
22 | 
23 |       - name: Build
24 |         run: hugo --minify
25 | 
26 |       - name: Deploy
27 |         uses: peaceiris/actions-gh-pages@v3
28 |         with:
29 |           github_token: ${{ secrets.GITHUB_TOKEN }}
30 |           publish_dir: ./public
31 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /public
2 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "themes/PaperMod"]
2 | 	path = themes/PaperMod
3 | 	url = https://github.com/adityatelange/hugo-PaperMod.git
4 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 | The content of this website (not including the software code used to
  2 | operate the website) is licensed as follows:
  3 | 
  4 | =======================================================================
  5 | 
  6 | Attribution-ShareAlike 4.0 International
  7 | 
  8 | =======================================================================
  9 | 
 10 | Creative Commons Corporation ("Creative Commons") is not a law firm and
 11 | does not provide legal services or legal advice. Distribution of
 12 | Creative Commons public licenses does not create a lawyer-client or
 13 | other relationship. Creative Commons makes its licenses and related
 14 | information available on an "as-is" basis. Creative Commons gives no
 15 | warranties regarding its licenses, any material licensed under their
 16 | terms and conditions, or any related information. Creative Commons
 17 | disclaims all liability for damages resulting from their use to the
 18 | fullest extent possible.
 19 | 
 20 | Using Creative Commons Public Licenses
 21 | 
 22 | Creative Commons public licenses provide a standard set of terms and
 23 | conditions that creators and other rights holders may use to share
 24 | original works of authorship and other material subject to copyright
 25 | and certain other rights specified in the public license below. The
 26 | following considerations are for informational purposes only, are not
 27 | exhaustive, and do not form part of our licenses.
 28 | 
 29 |      Considerations for licensors: Our public licenses are
 30 |      intended for use by those authorized to give the public
 31 |      permission to use material in ways otherwise restricted by
 32 |      copyright and certain other rights. Our licenses are
 33 |      irrevocable. Licensors should read and understand the terms
 34 |      and conditions of the license they choose before applying it.
 35 |      Licensors should also secure all rights necessary before
 36 |      applying our licenses so that the public can reuse the
 37 |      material as expected. Licensors should clearly mark any
 38 |      material not subject to the license. This includes other CC-
 39 |      licensed material, or material used under an exception or
 40 |      limitation to copyright. More considerations for licensors:
 41 |      wiki.creativecommons.org/Considerations_for_licensors
 42 | 
 43 |      Considerations for the public: By using one of our public
 44 |      licenses, a licensor grants the public permission to use the
 45 |      licensed material under specified terms and conditions. If
 46 |      the licensor's permission is not necessary for any reason--for
 47 |      example, because of any applicable exception or limitation to
 48 |      copyright--then that use is not regulated by the license. Our
 49 |      licenses grant only permissions under copyright and certain
 50 |      other rights that a licensor has authority to grant. Use of
 51 |      the licensed material may still be restricted for other
 52 |      reasons, including because others have copyright or other
 53 |      rights in the material. A licensor may make special requests,
 54 |      such as asking that all changes be marked or described.
 55 |      Although not required by our licenses, you are encouraged to
 56 |      respect those requests where reasonable. More considerations
 57 |      for the public:
 58 |      wiki.creativecommons.org/Considerations_for_licensees
 59 | 
 60 | =======================================================================
 61 | 
 62 | Creative Commons Attribution-ShareAlike 4.0 International Public
 63 | License
 64 | 
 65 | By exercising the Licensed Rights (defined below), You accept and agree
 66 | to be bound by the terms and conditions of this Creative Commons
 67 | Attribution-ShareAlike 4.0 International Public License ("Public
 68 | License"). To the extent this Public License may be interpreted as a
 69 | contract, You are granted the Licensed Rights in consideration of Your
 70 | acceptance of these terms and conditions, and the Licensor grants You
 71 | such rights in consideration of benefits the Licensor receives from
 72 | making the Licensed Material available under these terms and
 73 | conditions.
 74 | 
 75 | 
 76 | Section 1 -- Definitions.
 77 | 
 78 |   a. Adapted Material means material subject to Copyright and Similar
 79 |      Rights that is derived from or based upon the Licensed Material
 80 |      and in which the Licensed Material is translated, altered,
 81 |      arranged, transformed, or otherwise modified in a manner requiring
 82 |      permission under the Copyright and Similar Rights held by the
 83 |      Licensor. For purposes of this Public License, where the Licensed
 84 |      Material is a musical work, performance, or sound recording,
 85 |      Adapted Material is always produced where the Licensed Material is
 86 |      synched in timed relation with a moving image.
 87 | 
 88 |   b. Adapter's License means the license You apply to Your Copyright
 89 |      and Similar Rights in Your contributions to Adapted Material in
 90 |      accordance with the terms and conditions of this Public License.
 91 | 
 92 |   c. BY-SA Compatible License means a license listed at
 93 |      creativecommons.org/compatiblelicenses, approved by Creative
 94 |      Commons as essentially the equivalent of this Public License.
 95 | 
 96 |   d. Copyright and Similar Rights means copyright and/or similar rights
 97 |      closely related to copyright including, without limitation,
 98 |      performance, broadcast, sound recording, and Sui Generis Database
 99 |      Rights, without regard to how the rights are labeled or
100 |      categorized. For purposes of this Public License, the rights
101 |      specified in Section 2(b)(1)-(2) are not Copyright and Similar
102 |      Rights.
103 | 
104 |   e. Effective Technological Measures means those measures that, in the
105 |      absence of proper authority, may not be circumvented under laws
106 |      fulfilling obligations under Article 11 of the WIPO Copyright
107 |      Treaty adopted on December 20, 1996, and/or similar international
108 |      agreements.
109 | 
110 |   f. Exceptions and Limitations means fair use, fair dealing, and/or
111 |      any other exception or limitation to Copyright and Similar Rights
112 |      that applies to Your use of the Licensed Material.
113 | 
114 |   g. License Elements means the license attributes listed in the name
115 |      of a Creative Commons Public License. The License Elements of this
116 |      Public License are Attribution and ShareAlike.
117 | 
118 |   h. Licensed Material means the artistic or literary work, database,
119 |      or other material to which the Licensor applied this Public
120 |      License.
121 | 
122 |   i. Licensed Rights means the rights granted to You subject to the
123 |      terms and conditions of this Public License, which are limited to
124 |      all Copyright and Similar Rights that apply to Your use of the
125 |      Licensed Material and that the Licensor has authority to license.
126 | 
127 |   j. Licensor means the individual(s) or entity(ies) granting rights
128 |      under this Public License.
129 | 
130 |   k. Share means to provide material to the public by any means or
131 |      process that requires permission under the Licensed Rights, such
132 |      as reproduction, public display, public performance, distribution,
133 |      dissemination, communication, or importation, and to make material
134 |      available to the public including in ways that members of the
135 |      public may access the material from a place and at a time
136 |      individually chosen by them.
137 | 
138 |   l. Sui Generis Database Rights means rights other than copyright
139 |      resulting from Directive 96/9/EC of the European Parliament and of
140 |      the Council of 11 March 1996 on the legal protection of databases,
141 |      as amended and/or succeeded, as well as other essentially
142 |      equivalent rights anywhere in the world.
143 | 
144 |   m. You means the individual or entity exercising the Licensed Rights
145 |      under this Public License. Your has a corresponding meaning.
146 | 
147 | 
148 | Section 2 -- Scope.
149 | 
150 |   a. License grant.
151 | 
152 |        1. Subject to the terms and conditions of this Public License,
153 |           the Licensor hereby grants You a worldwide, royalty-free,
154 |           non-sublicensable, non-exclusive, irrevocable license to
155 |           exercise the Licensed Rights in the Licensed Material to:
156 | 
157 |             a. reproduce and Share the Licensed Material, in whole or
158 |                in part; and
159 | 
160 |             b. produce, reproduce, and Share Adapted Material.
161 | 
162 |        2. Exceptions and Limitations. For the avoidance of doubt, where
163 |           Exceptions and Limitations apply to Your use, this Public
164 |           License does not apply, and You do not need to comply with
165 |           its terms and conditions.
166 | 
167 |        3. Term. The term of this Public License is specified in Section
168 |           6(a).
169 | 
170 |        4. Media and formats; technical modifications allowed. The
171 |           Licensor authorizes You to exercise the Licensed Rights in
172 |           all media and formats whether now known or hereafter created,
173 |           and to make technical modifications necessary to do so. The
174 |           Licensor waives and/or agrees not to assert any right or
175 |           authority to forbid You from making technical modifications
176 |           necessary to exercise the Licensed Rights, including
177 |           technical modifications necessary to circumvent Effective
178 |           Technological Measures. For purposes of this Public License,
179 |           simply making modifications authorized by this Section 2(a)
180 |           (4) never produces Adapted Material.
181 | 
182 |        5. Downstream recipients.
183 | 
184 |             a. Offer from the Licensor -- Licensed Material. Every
185 |                recipient of the Licensed Material automatically
186 |                receives an offer from the Licensor to exercise the
187 |                Licensed Rights under the terms and conditions of this
188 |                Public License.
189 | 
190 |             b. Additional offer from the Licensor -- Adapted Material.
191 |                Every recipient of Adapted Material from You
192 |                automatically receives an offer from the Licensor to
193 |                exercise the Licensed Rights in the Adapted Material
194 |                under the conditions of the Adapter's License You apply.
195 | 
196 |             c. No downstream restrictions. You may not offer or impose
197 |                any additional or different terms or conditions on, or
198 |                apply any Effective Technological Measures to, the
199 |                Licensed Material if doing so restricts exercise of the
200 |                Licensed Rights by any recipient of the Licensed
201 |                Material.
202 | 
203 |        6. No endorsement. Nothing in this Public License constitutes or
204 |           may be construed as permission to assert or imply that You
205 |           are, or that Your use of the Licensed Material is, connected
206 |           with, or sponsored, endorsed, or granted official status by,
207 |           the Licensor or others designated to receive attribution as
208 |           provided in Section 3(a)(1)(A)(i).
209 | 
210 |   b. Other rights.
211 | 
212 |        1. Moral rights, such as the right of integrity, are not
213 |           licensed under this Public License, nor are publicity,
214 |           privacy, and/or other similar personality rights; however, to
215 |           the extent possible, the Licensor waives and/or agrees not to
216 |           assert any such rights held by the Licensor to the limited
217 |           extent necessary to allow You to exercise the Licensed
218 |           Rights, but not otherwise.
219 | 
220 |        2. Patent and trademark rights are not licensed under this
221 |           Public License.
222 | 
223 |        3. To the extent possible, the Licensor waives any right to
224 |           collect royalties from You for the exercise of the Licensed
225 |           Rights, whether directly or through a collecting society
226 |           under any voluntary or waivable statutory or compulsory
227 |           licensing scheme. In all other cases the Licensor expressly
228 |           reserves any right to collect such royalties.
229 | 
230 | 
231 | Section 3 -- License Conditions.
232 | 
233 | Your exercise of the Licensed Rights is expressly made subject to the
234 | following conditions.
235 | 
236 |   a. Attribution.
237 | 
238 |        1. If You Share the Licensed Material (including in modified
239 |           form), You must:
240 | 
241 |             a. retain the following if it is supplied by the Licensor
242 |                with the Licensed Material:
243 | 
244 |                  i. identification of the creator(s) of the Licensed
245 |                     Material and any others designated to receive
246 |                     attribution, in any reasonable manner requested by
247 |                     the Licensor (including by pseudonym if
248 |                     designated);
249 | 
250 |                 ii. a copyright notice;
251 | 
252 |                iii. a notice that refers to this Public License;
253 | 
254 |                 iv. a notice that refers to the disclaimer of
255 |                     warranties;
256 | 
257 |                  v. a URI or hyperlink to the Licensed Material to the
258 |                     extent reasonably practicable;
259 | 
260 |             b. indicate if You modified the Licensed Material and
261 |                retain an indication of any previous modifications; and
262 | 
263 |             c. indicate the Licensed Material is licensed under this
264 |                Public License, and include the text of, or the URI or
265 |                hyperlink to, this Public License.
266 | 
267 |        2. You may satisfy the conditions in Section 3(a)(1) in any
268 |           reasonable manner based on the medium, means, and context in
269 |           which You Share the Licensed Material. For example, it may be
270 |           reasonable to satisfy the conditions by providing a URI or
271 |           hyperlink to a resource that includes the required
272 |           information.
273 | 
274 |        3. If requested by the Licensor, You must remove any of the
275 |           information required by Section 3(a)(1)(A) to the extent
276 |           reasonably practicable.
277 | 
278 |   b. ShareAlike.
279 | 
280 |      In addition to the conditions in Section 3(a), if You Share
281 |      Adapted Material You produce, the following conditions also apply.
282 | 
283 |        1. The Adapter's License You apply must be a Creative Commons
284 |           license with the same License Elements, this version or
285 |           later, or a BY-SA Compatible License.
286 | 
287 |        2. You must include the text of, or the URI or hyperlink to, the
288 |           Adapter's License You apply. You may satisfy this condition
289 |           in any reasonable manner based on the medium, means, and
290 |           context in which You Share Adapted Material.
291 | 
292 |        3. You may not offer or impose any additional or different terms
293 |           or conditions on, or apply any Effective Technological
294 |           Measures to, Adapted Material that restrict exercise of the
295 |           rights granted under the Adapter's License You apply.
296 | 
297 | 
298 | Section 4 -- Sui Generis Database Rights.
299 | 
300 | Where the Licensed Rights include Sui Generis Database Rights that
301 | apply to Your use of the Licensed Material:
302 | 
303 |   a. for the avoidance of doubt, Section 2(a)(1) grants You the right
304 |      to extract, reuse, reproduce, and Share all or a substantial
305 |      portion of the contents of the database;
306 | 
307 |   b. if You include all or a substantial portion of the database
308 |      contents in a database in which You have Sui Generis Database
309 |      Rights, then the database in which You have Sui Generis Database
310 |      Rights (but not its individual contents) is Adapted Material,
311 | 
312 |      including for purposes of Section 3(b); and
313 |   c. You must comply with the conditions in Section 3(a) if You Share
314 |      all or a substantial portion of the contents of the database.
315 | 
316 | For the avoidance of doubt, this Section 4 supplements and does not
317 | replace Your obligations under this Public License where the Licensed
318 | Rights include other Copyright and Similar Rights.
319 | 
320 | 
321 | Section 5 -- Disclaimer of Warranties and Limitation of Liability.
322 | 
323 |   a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
324 |      EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
325 |      AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
326 |      ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
327 |      IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
328 |      WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
329 |      PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
330 |      ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
331 |      KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
332 |      ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
333 | 
334 |   b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
335 |      TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
336 |      NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
337 |      INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
338 |      COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
339 |      USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
340 |      ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
341 |      DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
342 |      IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
343 | 
344 |   c. The disclaimer of warranties and limitation of liability provided
345 |      above shall be interpreted in a manner that, to the extent
346 |      possible, most closely approximates an absolute disclaimer and
347 |      waiver of all liability.
348 | 
349 | 
350 | Section 6 -- Term and Termination.
351 | 
352 |   a. This Public License applies for the term of the Copyright and
353 |      Similar Rights licensed here. However, if You fail to comply with
354 |      this Public License, then Your rights under this Public License
355 |      terminate automatically.
356 | 
357 |   b. Where Your right to use the Licensed Material has terminated under
358 |      Section 6(a), it reinstates:
359 | 
360 |        1. automatically as of the date the violation is cured, provided
361 |           it is cured within 30 days of Your discovery of the
362 |           violation; or
363 | 
364 |        2. upon express reinstatement by the Licensor.
365 | 
366 |      For the avoidance of doubt, this Section 6(b) does not affect any
367 |      right the Licensor may have to seek remedies for Your violations
368 |      of this Public License.
369 | 
370 |   c. For the avoidance of doubt, the Licensor may also offer the
371 |      Licensed Material under separate terms or conditions or stop
372 |      distributing the Licensed Material at any time; however, doing so
373 |      will not terminate this Public License.
374 | 
375 |   d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
376 |      License.
377 | 
378 | 
379 | Section 7 -- Other Terms and Conditions.
380 | 
381 |   a. The Licensor shall not be bound by any additional or different
382 |      terms or conditions communicated by You unless expressly agreed.
383 | 
384 |   b. Any arrangements, understandings, or agreements regarding the
385 |      Licensed Material not stated herein are separate from and
386 |      independent of the terms and conditions of this Public License.
387 | 
388 | 
389 | Section 8 -- Interpretation.
390 | 
391 |   a. For the avoidance of doubt, this Public License does not, and
392 |      shall not be interpreted to, reduce, limit, restrict, or impose
393 |      conditions on any use of the Licensed Material that could lawfully
394 |      be made without permission under this Public License.
395 | 
396 |   b. To the extent possible, if any provision of this Public License is
397 |      deemed unenforceable, it shall be automatically reformed to the
398 |      minimum extent necessary to make it enforceable. If the provision
399 |      cannot be reformed, it shall be severed from this Public License
400 |      without affecting the enforceability of the remaining terms and
401 |      conditions.
402 | 
403 |   c. No term or condition of this Public License will be waived and no
404 |      failure to comply consented to unless expressly agreed to by the
405 |      Licensor.
406 | 
407 |   d. Nothing in this Public License constitutes or may be interpreted
408 |      as a limitation upon, or waiver of, any privileges and immunities
409 |      that apply to the Licensor or You, including from the legal
410 |      processes of any jurisdiction or authority.
411 | 
412 | 
413 | =======================================================================
414 | 
415 | Creative Commons is not a party to its public licenses.
416 | Notwithstanding, Creative Commons may elect to apply one of its public
417 | licenses to material it publishes and in those instances will be
418 | considered the “Licensor.” The text of the Creative Commons public
419 | licenses is dedicated to the public domain under the CC0 Public Domain
420 | Dedication. Except for the limited purpose of indicating that material
421 | is shared under a Creative Commons public license or as otherwise
422 | permitted by the Creative Commons policies published at
423 | creativecommons.org/policies, Creative Commons does not authorize the
424 | use of the trademark "Creative Commons" or any other trademark or logo
425 | of Creative Commons without its prior written consent including,
426 | without limitation, in connection with any unauthorized modifications
427 | to any of its public licenses or any other arrangements,
428 | understandings, or agreements concerning use of licensed material. For
429 | the avoidance of doubt, this paragraph does not form part of the public
430 | licenses.
431 | 
432 | Creative Commons may be contacted at creativecommons.org.
433 | 
434 | =======================================================================
435 | 
436 | The software used to run this website is licensed as follows:
437 | 
438 | =======================================================================
439 | 
440 | Copyright 2021 64
441 | 
442 | Permission is hereby granted, free of charge, to any person obtaining a
443 | copy of this software and associated documentation files
444 | (the "Software"), to deal in the Software without restriction, including
445 | without limitation the rights to use, copy, modify, merge, publish,
446 | distribute, sublicense, and/or sell copies of the Software, and to
447 | permit persons to whom the Software is furnished to do so, subject to
448 | the following conditions:
449 | 
450 | The above copyright notice and this permission notice shall be included
451 | in all copies or substantial portions of the Software.
452 | 
453 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
454 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
455 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
456 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
457 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
458 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
459 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
460 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # C++ FAQ
 2 | 
 3 | An open source FAQ for C++, available at (temporary URL) [https://64.github.io/cpp-faq](https://64.github.io/cpp-faq).
 4 | 
 5 | The content of this repository (excluding software) is licensed under the [CC BY-SA 4.0 license](LICENSE.txt). The software itself is licensed under the [MIT license](LICENSE.txt). By contributing to this project, you agree to have your work licensed under these agreements.
 6 | 
 7 | ⚠️ **This project is heavily WIP**: don't expect links here to work for long. Bugfixes and new FAQ entries are most welcome - see below.
 8 | 
 9 | ## Contributing
10 | 
11 | First [install `hugo`](https://gohugo.io/getting-started/installing#readout).
12 | 
13 | Please read [`STYLE.md`](STYLE.md) to familiarize yourself with the style and tone in which articles should be written.
14 | 
15 | See [Projects/FAQ Articles](https://github.com/64/cpp-faq/projects/1) for a list of suggested topics to write about.
16 | 
17 | To create new articles - run `hugo new faq/my-faq-post.md`. This generates a file named `content/faq/my-faq-post.md` with the appropriate template. Add the content (in markdown format) below the bottom `---`. Hugo will be able to locate your content without any additional work.
18 | 
19 | ## Building
20 | 
21 | 1. [Install `hugo`](https://gohugo.io/getting-started/installing#readout).
22 | 2. Run `git submodule update --init` to download the theme if you haven't already
23 | 3. Run `hugo server -D` then navigate to [http://localhost:1313/cpp-faq/](http://localhost:1313/cpp-faq/) in your browser.
24 | 


--------------------------------------------------------------------------------
/STYLE.md:
--------------------------------------------------------------------------------
1 | # Style Guide
2 | 
3 | 1. **All FAQ titles should be posed as a question.** This is an FA**Q**, after all.
4 | 1. **Keep explanations to 'the same level' as that of the question.** For example, an answer to the question 'what is UB?' should not involve a lengthy discussion of how the C++ memory model's forward progress guarantees treat infinite loops with no side effects.
5 | 1. **Link to external resources.** Give the reader a place to learn more, rather than overwhelming them with information.
6 | 1. **Articles should only do one thing.** For example, 'what is an iterator' and 'how do I implement an iterator' should be separate articles. Note that this isn't a prescription on how long an article should be - some topics will require more explanation than others.
7 | 1. todo... grammar etc
8 | 


--------------------------------------------------------------------------------
/archetypes/default.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "{{ replace .Name "-" " " | title }}"
3 | tags: ["none"]
4 | draft: false
5 | disableShare: false
6 | disableHLJS: false
7 | searchHidden: false
8 | ---
9 | 


--------------------------------------------------------------------------------
/config.toml:
--------------------------------------------------------------------------------
 1 | baseURL = "https://64.github.io/cpp-faq"
 2 | title = "C++ FAQ"
 3 | languageCode = "en-us"
 4 | theme = "PaperMod"
 5 | enableInlineShortcodes = true
 6 | enableRobotsTXT = true
 7 | 
 8 | [minify]
 9 | disableXML = true
10 | minifyOutput = true
11 | 
12 | [outputs]
13 | home = ["HTML", "RSS", "JSON"]
14 | 
15 | [permalinks]
16 | faq = "/:filename" # So that we have /faq-entry-name instead of /faq/faq-entry-name
17 | 
18 | [params]
19 | mainSections = ["faq", "meta"]
20 | env = "production"
21 | title = "C++ FAQ"
22 | showtoc = false
23 | tocopen = false
24 | hidemeta = false
25 | comments = false
26 | socialIcons = [{ name = "github", url = "https://github.com/64/cpp-faq" }]
27 | 
28 | [params.homeInfoParams]
29 | Title = "C++ FAQ"
30 | Content = "Frequently Asked Questions for the C and C++ programming languages."
31 | 
32 | [params.fuseOpts]
33 | isCaseSensitive = false
34 | shouldSort = true
35 | location = 0.0
36 | distance = 1000.0
37 | threshold = 0.4
38 | minMatchCharLength = 0.0
39 | keys = ["title", "permalink", "summary", "content", "slug"]
40 | 


--------------------------------------------------------------------------------
/content/faq/decay.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "What is decay and array-to-pointer conversion?"
  3 | tags: [""]
  4 | draft: false
  5 | disableShare: false
  6 | disableHLJS: false
  7 | searchHidden: false
  8 | ---
  9 | 
 10 | When we call functions in C++, our arguments may need to undergo type conversions.
 11 | For example, we can call a function that takes an `int` with a `const int` argument, which copies its value.
 12 | For parameters which are passed by value, some of these conversions rules are called *decay*.
 13 | They are called *decay* because in most cases, some type information is lost, such as the size of an array or the
 14 | `const` qualifier in our example.
 15 | 
 16 | ## Array-to-Pointer Conversion
 17 | 
 18 | A commonly known form of decay is array-to-pointer conversion:
 19 | ```cpp
 20 | // We seemingly accept an array by value as our parameter:
 21 | void print_size(char arr[128]) {
 22 |     // warning: 'sizeof' on array function parameter 'arr'
 23 |     //          will return size of 'char *' [-Wsizeof-array-argument]
 24 |     std::cout << sizeof(arr) << '\n';
 25 | }
 26 | ```
 27 | **Sample output:** `8`
 28 | 
 29 | We have attempted to specify that our `print_size` should accept an array with size `128` of `char` by value as its
 30 | function parameter.
 31 | However, arrays cannot be passed by value and instead decay to pointers.
 32 | So from the compiler's point of view, our function signature is equal to:
 33 | ```cpp
 34 | void print_size(char *arr);
 35 | ```
 36 | Using `sizeof` with arrays that have decayed to a pointer is a common source of bugs, as in the above example, where
 37 | we obtain the size of a pointer, which is less than the size of the entire array.
 38 | Thankfully, GCC and clang warn us about this.
 39 | 
 40 | ## Function-to-Pointer conversion
 41 | 
 42 | Another very similar form of decay is function-to-pointer conversion:
 43 | ```cpp
 44 | void call(void callback(int), int x) {
 45 |     callback(x);
 46 | }
 47 | ```
 48 | Here, our first function parameter appears to be another function `callback`, which takes an `int` and returns nothing.
 49 | However, just as an array, the function `callback` decays to a pointer.
 50 | It would be equivalent to write:
 51 | ```cpp
 52 | void call(void (*callback)(int), int x) {
 53 |     callback(x);
 54 | }
 55 | ```
 56 | The danger of misuse is not as great here; decay simply gives us a nicer syntax for accepting function pointers.
 57 | 
 58 | ## Discarding `const`/`volatile` qualifiers and removing references
 59 | 
 60 | This form of decay is something that you have likely understood already by intuition.
 61 | When we accept a type `T` as a parameter to our function by value, we don't care whether the arguments were `const`,
 62 | `volatile`, references, other values, etc. 
 63 | Inside of the function, we are simply using `T`.
 64 | 
 65 | This form of decay can be seen in the following examples:
 66 | ```cpp
 67 | void use_int(int my_int) {
 68 |     /* ... */
 69 | }
 70 | 
 71 | int main() {
 72 |     // Calling use_int with a literal of type int:
 73 |     use_int(3);
 74 |     
 75 |     // Calling use_int with a const volatile int: This copies the value of x.
 76 |     // const and volatile are discarded, so inside of use_int,
 77 |     // we don't care that the argument was const or volatile.
 78 |     const volatile int x = 7;
 79 |     use_int(x);
 80 |     
 81 |     // Calling use_int with an int& copies the referenced value:
 82 |     // Inside of use_int, we don't see or care that the argument was a reference.
 83 |     int y = 5;
 84 |     int &yref = y;
 85 |     use_int(y);
 86 | }
 87 | ```
 88 | 
 89 | ## Using `std::decay`
 90 | 
 91 | The documentation of the [`std::decay`](https://en.cppreference.com/w/cpp/types/decay) type trait lists all these
 92 | *decay* conversions.
 93 | `std::decay` can be used to simulate them and there is also a templated type alias `std::decay_t` for convenience.
 94 | Here are a few examples:
 95 | ```cpp
 96 | // no decay
 97 | std::decay_t<int>           -> int  
 98 | // discarding references
 99 | std::decay_t<int&>          -> int  
100 | // discarding references and const qualifier
101 | std::decay_t<const int&>    -> int
102 | // discarding volatile
103 | std::decay_t<volatile int>  -> int
104 | // array-to-pointer
105 | std::decay_t<int[8]>        -> int*
106 | // array-to-pointer, and also discarding the reference
107 | std::decay_t<int(&)[8]>     -> int*
108 | // function-to-pointer
109 | std::decay_t<int(int)>      -> int(*)(int)
110 | ```
111 | 


--------------------------------------------------------------------------------
/content/faq/enable-warnings.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "How do I enable compiler warnings?"
 3 | tags: ["beginner", "dev-env"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | ### For `gcc` and `clang` users:
11 | **Add `-Wall -Wextra` to your compilation flags.**
12 | 
13 | Other useful options include:
14 | * `-Werror`: treats warnings as if they were errors
15 | * `-pedantic`: generates warnings if you use any language extensions
16 | * `-Wno-x`: disables warning `x`, e.g if the compiler gives you a `-Wunused-variable` warning, you can turn it off with `-Wno-unused-variable`
17 | 
18 | (Note that, contrary to what the name `-Wall` may imply, this does not enable *all* warnings, but it does enable most of the important ones.)
19 | 
20 | ### For Visual Studio users:
21 | Unlike `gcc` and `clang`, Visual Studio does enable *some* warnings by default. To set the warning level to something different, Consult [Microsoft's documentation here](https://docs.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level?view=msvc-160#to-set-the-compiler-options-in-the-visual-studio-development-environment).
22 | 


--------------------------------------------------------------------------------
/content/faq/fixed-width-integers.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "What are fixed-width integers?"
 3 | tags: ["beginner"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | Fixed-width integers are integral types with a fixed number of bits. The C++ standard only specifies a minimum byte count for types such as `short`, `int` and `long`. Fixed-width integers guarantee a specific size, but their use can have an impact on portability, since they are not supported by all platforms.
11 | 
12 | ## Fixed-width integer types
13 | These can be used by including `<cstdint>`. The `intX_t` types are signed integers with exactly `X` bits. `uintX_t` types are the same, but unsigned.
14 | - `std::int8_t` / `std::uint8_t` (1 byte)
15 |   - **Note:** These are treated as characters on most systems. When printing variables of this type, they might show up as their ASCII equivalent.
16 | - `std::int16_t` / `std::uint16_t` (2 bytes)
17 | - `std::int32_t` / `std::uint32_t` (4 bytes)
18 | - `std::int64_t` / `std::uint64_t` (8 bytes)
19 | 
20 | **Note:** The number of bytes is the number of bits in the type, divided by the number of bits in one byte. On architectures where bits per byte != 8, some or even all of these types may not be defined.
21 | 
22 | ### The more portable alternative
23 | To optimize integral types for faster access times and to ensure portability with more exotic architectures, the following types allow the compiler to choose a suitable integer size, while also ensuring a minimum number of bits.
24 | 
25 | For every `std::(u)intX_t` type there is a `std::(u)int_leastX_t` that represents the smallest integral type with at least X bits. These optimize for memory.
26 | 
27 | Likewise, there are types that optimize for speed: `std::(u)int_fastX_t` (the fastest integral type with at least X bits).
28 | 
29 | ## Fixed-width integer range
30 | Unsigned integers with X bits range from 0 to 2<sup>X</sup> - 1. Signed integers with X bits typically range from -2<sup>X-1</sup> to 2<sup>X-1</sup> - 1, assuming two's complement representation.
31 | 
32 | Accurate, platform-specific ranges can also be found in `<cstdint>`:
33 | - `INTX_MIN` / `INTX_MAX` (minimum and maximum values for `std::intX_t` and `std::uintX_t`)
34 | - `INT_LEASTX_MIN` / `INT_LEASTX_MAX` (minimum and maximum values for `std::int_leastX_t` and `std::uint_leastX_t`)
35 | - `INT_FASTX_MIN` / `INT_FASTX_MAX` (minimum and maximum values for `std::int_fastX_t` and `std::uint_fastX_t`)
36 | 
37 | In C++, the standardized way of getting the limits of various numeric types is the class template `std::numeric_limits` defined in `<limits>`:
38 | - `std::numeric_limits<T>.min()` - minimum value for an integer of type T
39 | - `std::numeric_limits<T>.max()` - maximum value for an integer of type T
40 | 
41 | ## Example
42 | 
43 | ```cpp
44 | #include <cstdint>
45 | #include <climits> // for CHAR_BIT
46 | #include <iostream>
47 | 
48 | int main() {
49 |     // 16-bit (2-byte) integer
50 |     std::uint16_t year = 1984;
51 |   
52 |     // Check size in bytes, will usually be 2
53 |     std::cout << year << ": " << sizeof(year) << " bytes" << std::endl;
54 |   
55 |     // Multiply by CHAR_BIT (number of bits in one byte) to get size in bits
56 |     std::cout << "Size of fastest integer with at least 16 bits: " << (CHAR_BIT * sizeof(std::int_fast16_t)) << std::endl;
57 |     std::cout << "Maximum value: " << INT_FAST16_MAX << std::endl;
58 |   
59 |     return 0;
60 | }
61 | ```
62 | 
63 | Compiling and running the above program with `gcc` on a 64-bit Intel architecture produces the following result:
64 | ```
65 | 1984: 2 bytes
66 | Size of fastest integer with at least 16 bits: 64
67 | Maximum value: 9223372036854775807
68 | ```
69 | 
70 | The `std::uint16_t` variable is 2 bytes wide, as expected. The compiler decided that the fastest integral type with at least 16 bits is the 64-bit integer on this architecture.
71 | 
72 | ### See Also
73 | * https://en.cppreference.com/w/cpp/types/integer
74 | * https://en.cppreference.com/w/cpp/types/numeric_limits
75 | 


--------------------------------------------------------------------------------
/content/faq/include-guards-pragma-once.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "What are 'Include Guards' and `#pragma once`?"
  3 | tags: ["beginner"]
  4 | draft: false
  5 | disableShare: false
  6 | disableHLJS: false
  7 | searchHidden: false
  8 | ---
  9 | 
 10 | Include guards, or sometimes called *macro guards*, *header guards*, or *file guards* are a common C/C++ idiom that
 11 | allows including a header file multiple times safely.
 12 | The non-standard preprocessor directive `#pragma once` is an almost equivalent alternative to this idiom.
 13 | 
 14 | ## The Problem
 15 | 
 16 | The preprocessor directive `#include` effectively copies the named header into our source file.
 17 | If we `#include` a header file more than once, this will result in redefinitions and possibly compiler errors.
 18 | Consider this example:
 19 | ```cpp
 20 | // point.hpp
 21 | 
 22 | struct point {
 23 |     int x, y;
 24 | };
 25 | ```
 26 | ```cpp
 27 | // main.cpp
 28 | 
 29 | #include "point.hpp"
 30 | #include "point.hpp"
 31 | #include <iostream>
 32 | 
 33 | int main() {
 34 |     point p;
 35 |     std::cin >> p.x >> p.y;
 36 |     std::cout << p.x << ' ' << p.y << '\n';
 37 | }
 38 | ```
 39 | This code does not compile, because we have included `point.hpp` twice.
 40 | After these two includes are processed by the preprocessor, `main.cpp` (ignoring comments) will be the following:
 41 | ```cpp
 42 | struct point {
 43 |     int x, y;
 44 | };
 45 | struct point {
 46 |     int x, y;
 47 | };
 48 | #include <iostream>
 49 | 
 50 | int main() {
 51 |     point p;
 52 |     std::cin >> p.x >> p.y;
 53 |     std::cout << p.x << ' ' << p.y << '\n';
 54 | }
 55 | ```
 56 | The program is ill-formed and we get a compiler error:
 57 | ```txt
 58 | <source>:4:8: error: redefinition of 'point'
 59 | struct point {
 60 |        ^
 61 | <source>:1:8: note: previous definition is here
 62 | struct point {
 63 |        ^
 64 | ```
 65 | At this point you might think: *"Okay then just don't include it twice and the problem is solved."*.
 66 | But including headers multiple times is not always easy to avoid.
 67 | We could have two more header files `pointmath.hpp` and `pointlist.hpp`, both of which `#include "point.hpp"`.
 68 | The include-tree would look as follows:
 69 | ```txt
 70 | main.cpp
 71 |   └─ pointmath.hpp
 72 |        └─ point.hpp
 73 |   └─ pointlist.hpp
 74 |        └─ point.hpp
 75 | ```
 76 | `main.cpp` indirectly includes `point.hpp` twice.
 77 | And this is by no means unusual.
 78 | Smaller standard library headers such as `<utility>` or `<new>` are included by many other headers like `<vector>`, so
 79 | each source file may have many copies of `<new>`.
 80 | 
 81 | ## Solution A: Include Guards
 82 | 
 83 | Include guards are put around the entirety of the header file:
 84 | ```cpp
 85 | // point.hpp
 86 | #ifndef MYPROJECT_POINT_HPP_GUARD
 87 | #define MYPROJECT_POINT_HPP_GUARD
 88 | struct point {
 89 |     int x, y;
 90 | };
 91 | #endif
 92 | ```
 93 | This idiom works by letting the preprocessor skip the entirety of the header file if `MYPROJECT_POINT_HPP_GUARD` has
 94 | already been defined.
 95 | Only the first time we include the header file, will `MYPROJECT_POINT_HPP_GUARD` be undefined.
 96 | We `#define` this macro inside of the `#ifndef` block, so all subsequent copies of the header will not be processed.
 97 | Here is how this works if we process the first two includes in `main.cpp`:
 98 | ```cpp
 99 | #ifndef MYPROJECT_POINT_HPP_GUARD // not defined yet, so we enter the ifndef-block
100 | #define MYPROJECT_POINT_HPP_GUARD // we define the guard
101 | struct point {
102 |     int x, y;
103 | };
104 | #endif                            // we exit the ifndef-block
105 | #ifndef MYPROJECT_POINT_HPP_GUARD // the guard has already been defined => skip
106 | #define MYPROJECT_POINT_HPP_GUARD // this is not processed
107 | struct point {
108 |     int x, y;
109 | };
110 | #endif                            // we stop skipping code here
111 | #include <iostream>
112 | 
113 | int main() {
114 |     point p;
115 |     std::cin >> p.x >> p.y;
116 |     std::cout << p.x << ' ' << p.y << '\n';
117 | }
118 | ```
119 | After processing the `#ifndef` blocks, the code will effectively look like this:
120 | ```cpp
121 | #define MYPROJECT_POINT_HPP_GUARD
122 | struct point {
123 |     int x, y;
124 | };
125 | #include <iostream>
126 | 
127 | int main() {
128 |     point p;
129 |     std::cin >> p.x >> p.y;
130 |     std::cout << p.x << ' ' << p.y << '\n';
131 | }
132 | ```
133 | We could now include our `point.hpp` header as many times as we want in as many headers as we want without worrying
134 | about redefining our functions and receiving compiler errors.
135 | 
136 | Note: `MYPROJECT_POINT_HPP_GUARD` is an arbitrary definition, we could name it something else too.
137 | But the name should be long and unique so we don't accidentally use the same guard twice.
138 | 
139 | ## Solution B: #pragma once
140 | 
141 | `#pragma once` is a non-standard preprocessor directive which tells the preprocessor to skip the current header if it
142 | has already been included.
143 | The goal is to achieve the same effect as our include guards, but more concisely.
144 | We can use it like this:
145 | ```cpp
146 | // mymath.hpp
147 | #pragma once
148 | struct point {
149 |     int x, y;
150 | };
151 | ```
152 | At first glance, this is much more elegant than include guards and we could just use `#pragma once` in all cases.
153 | However, as already mentioned, `#pragma` directives are not part of the C or C++ standard, so the behavior is dependent
154 | on the compiler.
155 | 
156 | One alleged advantage of `#pragma once` is that
157 | [it can be faster](https://web.archive.org/web/20080930061318/http://www.gamesfromwithin.com/articles/0501/000067.html),
158 | since the preprocessor doesn't need to read the entire file to find a matching `#endif` for the `#ifndef` directive.
159 | The file contents can be skipped at an earlier stage.
160 | However, these claims are hard to reproduce with modern compilers and practical examples.
161 | 
162 | It is worth noting that identifying whether a file is included multiple times is not a trival problem.
163 | In modern file systems, many symbolic links or hardlinks can lead to the same file.
164 | Usually the file contents and sometimes the timestamp are used by preprocessor to test for duplicates.
165 | 
166 | In most cases and with virtually every compiler, `#pragma once` will work as intended.
167 | But it is the subject of scepticism because it is neither fully standardized nor perfectly reliable.
168 | An example where `#pragma once` fails can be seen here:
169 | ```cpp
170 | // a.hpp
171 | #pragma once
172 | struct foo {};
173 | ```
174 | ```cpp
175 | // b.hpp
176 | #pragma once
177 | struct foo {};
178 | ```
179 | ```cpp
180 | // main.cpp
181 | namespace a {
182 | #include "a.hpp"
183 | }
184 | namespace b {
185 | #include "b.hpp"
186 | }
187 | int main() {
188 |   b::foo x;
189 | }
190 | ```
191 | We get a compiler error:
192 | ```txt
193 | main.cpp:8:3: error: foo is not a member of ´b´
194 |    b::foo x;
195 |    ^~~
196 | ```
197 | The contents of `a.hpp` and `b.hpp` are completely identical (ignoring the comments at the top).
198 | When we attempt to `#include "b.hpp"`, the preprocessor will falsely believe that `b.hpp` has already been included,
199 | because it is identical to `a.hpp`.
200 | Arguably, this is an unusual example and including inside of a `namespace` is considered bad practice by many.
201 | However, it shows that `#pragma once` is not quite as reliable as include guards.
202 | 
203 | ## Conclusion
204 | 
205 | Include guards are a tried and tested, fully standardized, and efficient idiom which allows including a header file
206 | multiple times.
207 | Headers should be wrapped in include guards, ideally right when creating the file.
208 | Many IDEs can be configured so that they automatically add include guards when you create a new header file.
209 | 
210 | `#pragma once` is a viable, but non-standard alternative for simple projects and will work most of the time, but
211 | it can produce cryptic and very hard-to-track errors.
212 | If you do measure a significant difference in compile times and want to use `#pragma once` anyways, you can use both
213 | include guards and `#pragma once`.
214 | Because include guards are unique for each file, the previously shown error would have been prevented:
215 | ```cpp
216 | // point.hpp
217 | #pragma once
218 | #ifndef MYPROJECT_POINT_HPP_GUARD
219 | #define MYPROJECT_POINT_HPP_GUARD
220 | struct point {
221 |     int x, y;
222 | };
223 | #endif
224 | ```
225 | 
226 | ### See Also
227 | - https://en.wikipedia.org/wiki/Include_guard
228 | - https://en.wikipedia.org/wiki/Pragma_once
229 | - https://en.cppreference.com/w/cpp/preprocessor/include
230 | 


--------------------------------------------------------------------------------
/content/faq/iterators.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "What is an iterator?"
  3 | date: 2021-03-26T16:37:10Z
  4 | tags: ["c++", "c++11"]
  5 | draft: false
  6 | disableShare: false
  7 | disableHLJS: false
  8 | searchHidden: false
  9 | ---
 10 | 
 11 | Iterators provide a unified API for accessing different containers. On the surface, they work similar to pointers:
 12 | 
 13 | ```cpp
 14 | std::vector<int> vec { 1, 2, 3 };
 15 | 
 16 | auto it = vec.begin(); // gives us an iterator which points to '1'
 17 | it++; // start now points to '2'
 18 | it++; // start now points to '3'
 19 | 
 20 | std::cout << *it << '\n'; // prints '3'
 21 | ```
 22 | 
 23 | TODO
 24 | 
 25 | ##### Noncontiguous containers (std::list):
 26 | 
 27 | linked list isn't a contiguous sequence, so it's impossible to relay on pointers for iteration instead you should provide an iterator that performs the same arithmetic operations as a pointer would do.
 28 | ```cpp
 29 | int main() {
 30 |     std::list<int> mlist{7, 4, 5, 8, 9};
 31 |     for(auto it = mlist.begin(); it != mlist.end(); ++it) {
 32 |         std::cout << *it << '\n';
 33 |     }
 34 | }
 35 | ```
 36 | 
 37 | #### Algorithms
 38 | 
 39 | the 'algorithm' header has a niche collection of useful algorithms, however these algorithms doesn't apply on all of the iterator categories i.e (std::sort):
 40 | ```cpp
 41 | int main() {
 42 |     std::list<int> my_list{6, 5, 4, 3, 8, 9};
 43 |     std::vector<int> my_vec{6, 5, 4, 3, 8, 9};
 44 |     std::sort(my_vec.begin(), my_vec.end());
 45 |     std::sort(my_list.begin(), my_list.end());
 46 | }
 47 | ```
 48 | the above code works fine for [std::vector](https://en.cppreference.com/w/cpp/container/vector) [std::list](https://en.cppreference.com/w/cpp/container/list) that's due to [std::sort](https://en.cppreference.com/w/cpp/algorithm/sort)'s iterator requirements, since it uses specific arithmetic operations that are supported by certain iterator (Random Access Iterator).
 49 | 
 50 | 
 51 | ### interface of an iterator (i.e Bidirectional Iterator):
 52 | 
 53 | *iterator: returns the stored value pointed by the iterator.
 54 | 
 55 | iterator++, ++iterator: increments the pointer.
 56 | 
 57 | iterator--, --iterator: decrements the pointers. 
 58 | 
 59 | iterator !=/== iterator: compare the pointers held by both operands. Useful for indicating where a range starts and ends.
 60 | 
 61 | #### note:
 62 | An iterator itself mustn't have begin/end functions as it's container's responsibility to handle these functions.
 63 | 
 64 | 
 65 | ### categories of an iterator:
 66 | 
 67 | there are 5 iterators in C++ defined by the standard as:
 68 | - [input iterator](https://en.cppreference.com/w/cpp/named_req/InputIterator):
 69 | input iterator is a single direction iterator and read only means you can only increment it and read from it. It's one of the simplest iterators. Usually used for reading from input streams like files in read only mode, stdin.
 70 | 
 71 | - [output iterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
 72 | same as input iterator, output iterator is a single direction iterator, but can only used for writing to a stream. 
 73 | 
 74 | - [forward iterator](https://en.cppreference.com/w/cpp/named_req/ForwardIterator):
 75 | forward iterator is a single direction iterator that can be used for both reading and writing, usually used in containers like [std::forward_list](https://en.cppreference.com/w/cpp/container/forward_list). 
 76 | 
 77 | - [bidirectional iterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
 78 | bidirectional iterator is just a forward iterator that can be moved to both direction incrementing, decrementing 
 79 | 
 80 | - [random access iterator](https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator):
 81 | random access iterator is a bidirectional iterator that can be moved to any direction means if you want to access to the Nth element of a sequence you can just do `auto Nth_Value = container.begin() + N;` unlike previous iterators where you should increment N times. Random access iterator is the hardest and yet most powerful iterator since it supports all of the previously mentioned iterators. 
 82 | - [contiguous iterator (since C++20)](https://en.cppreference.com/w/cpp/named_req/ContiguousIterator):
 83 | contiguous iterator is a random access iterator where the elements it points to are contiguously ordered in the memory
 84 | 
 85 | #### conclusion:
 86 | In brief Contiguous Iterator is a superset of a Random Access Iterator which is a superset of a Bidirectional Iterator a Forward Iterator and a input/output iterator.
 87 | 
 88 | 
 89 | ### iterator vs pointer:
 90 | As discussed earlier an iterator is just an abstraction of a pointer, but with more consistency (i.e we can't just use pointers for iterating over a linked list as it's not contiguous and lead to UB, but we instead create a custom iterator and move the current stored pointer to some node to the next node if the location has changed).
 91 | pointer:
 92 | ```cpp
 93 | int main() {
 94 |     const int N = 2;
 95 |     int arr[] = {6, 8, 5, 6};
 96 |     auto first = arr; // first points to the first element of arr: 6
 97 |     first++; // can be incremented
 98 |     ++first;
 99 |     first--; // decremented
100 |     --first;
101 |     use(*first); // deferenceced
102 |     use(first[N]); // same as use(*(first + N))
103 |     first += N; // re-assigned to point to another location  
104 |     first -= N;
105 |     
106 | }
107 | ```
108 | RAI (Random Access Iterator):
109 | ```cpp
110 | int main() {
111 |     const int N = 2;
112 |     std::vector<int> vec{6, 8, 5, 6};
113 |     auto first = vec.begin();
114 |     first++;
115 |     ++first;
116 |     first--;
117 |     --first;
118 |     use(*first);
119 |     use(first[N]);
120 |     first += N;
121 |     first -= N;
122 | }
123 | ```
124 | 


--------------------------------------------------------------------------------
/content/faq/member-initializer-list.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "What is a 'Member Initalizer List' and why should I use it?"
  3 | tags: ["beginner"]
  4 | draft: false
  5 | disableShare: false
  6 | disableHLJS: false
  7 | searchHidden: false
  8 | ---
  9 | 
 10 | Constructors in C++ are used to initialize the data members of a class.
 11 | First, it's important to understand the terminology:
 12 | ```cpp
 13 | struct wrapper {
 14 |     int value;
 15 |     
 16 |     wrapper(int v) : value{v}
 17 |     {
 18 |     }
 19 | };
 20 | ```
 21 | Our class `wrapper` has a constructor, consisting of four parts:
 22 | - the class name `wrapper`
 23 | - the parameter list `int v` in parentheses
 24 | - the member initializer list `value{v}`, separated by a `:` from the parameter list
 25 | - the constructor body `{}`, which is empty in this case
 26 | 
 27 | In most other languages that have classes and constructors, the initialization simply takes place in the constructor
 28 | body.
 29 | However, in C++, this is not possible as the constructor body can only be used for reassigning members after they have
 30 | already been initialized.
 31 | 
 32 | ## A Common Mistake: Trying to Initialize in the Constructor Body
 33 | 
 34 | Consider the following example:
 35 | ```cpp
 36 | struct point {
 37 |     int x = 0;
 38 |     int y = 0;
 39 |     
 40 |     point(int x, int y)
 41 |     {
 42 |         this->x = x;
 43 |         this->y = y;
 44 |     }
 45 | };
 46 | ```
 47 | Here, when we call the constructor `point(int,int)`, the members `x` and `y` are first initialized to zero using
 48 | [copy initialization](https://en.cppreference.com/w/cpp/language/copy_initialization).
 49 | Afterwards, they get reassigned to the constructor parameters `x` and `y` respectively.
 50 | **This is not initializing the members to the parameters. It is reassigning them.**
 51 | 
 52 | In such a trivial example, the difference isn't noticeable.
 53 | But if we use `const` members, reference members, array members, or any other non-assignable type, we receive
 54 | compiler errors:
 55 | ```cpp
 56 | struct const_value {
 57 |     // error: uninitialized const member in 'const int' [-fpermissive]
 58 |     // note: 'const int const_value::val' should be initialized
 59 |     const int val;
 60 | 
 61 |     const_value(int val)
 62 |     {
 63 |         // error: assignment of read-only member 'const_value::val'
 64 |         this->val = val;
 65 |     }
 66 | };
 67 | ```
 68 | In this case, we should be glad that we have received a compiler error, because there are also cases where our code
 69 | compiles but performance gets degraded, unnoticeably.
 70 | For example, if we have a `std::string` member, it may be inefficient to first initialize it to an empty string and
 71 | then reassign it to another value.
 72 | 
 73 | ## The Right Way: Using a Member Initializer List
 74 | 
 75 | To initialize our members, we should instead use a member initializer list and leave the constructor body empty:
 76 | ```cpp
 77 | struct const_point {
 78 |     const int x, y;
 79 |     
 80 |     const_point(int x, int y) : x{x}, y{y} {}
 81 | };
 82 | ```
 83 | This code compiles, unlike the previous example.
 84 | We are taking the parameter `x` and `y` and initializing the members `x` and `y` to their values, respectively.
 85 | Unlike in the previous, incorrect example of using `this->x =` to "initialize", we can just use `x` as a parameter
 86 | name without worrying about ambiguity with the members of our class.
 87 | 
 88 | Elements of the member initializer list are separated by a comma and follow the same syntax as initialization as
 89 | variables.
 90 | In this particular example with `x{x}`, `y{y}`, we are using
 91 | [list initialization](https://en.cppreference.com/w/cpp/language/list_initialization) to initialize the members.
 92 | However, we could also use `x()` to [value-initialize](https://en.cppreference.com/w/cpp/language/value_initialization)
 93 | `x` to zero, or `x(5)` to
 94 | [direct-initialize](https://en.cppreference.com/w/cpp/language/direct_initialization) `x` to a `5`.
 95 | Once again, we have the same syntax of initializing members in the member initializer list as for variables.
 96 | 
 97 | The constructor body can usually be left empty if we only initialize our members.
 98 | 
 99 | ### About Initialization Order
100 | 
101 | Sometimes the order of initialization is important.
102 | Initialization in C++ alwas takes place in the order of declaration of members inside the class, even if the member
103 | initializer list suggests otherwise. For example:
104 | ```cpp
105 | struct stringified_value {
106 |     int value;
107 |     std::string str;
108 |     
109 |     // warning: 'stringified_value::str' will be initialized after
110 |     //          'stringified_value::value'
111 |     //          when initialized here [-Wreorder]
112 |     stringified_value(int v) : str{std::to_string(v)}, value{v} {}
113 | };
114 | ```
115 | To avoid compiler warnings, we should always write our member initializer list in the order of declared members:
116 | ```cpp
117 | struct stringified_value {
118 |     int value;
119 |     std::string str;
120 |     
121 |     stringified_value(int v) : value{v}, str{std::to_string(v)} {}
122 | };
123 | ```
124 | 
125 | ### About Default Member Initializers
126 | 
127 | Default member initializers are another correct way of initializing members.
128 | We could make our previous example more concise using them:
129 | ```cpp
130 | struct stringified_value {
131 |     int value;
132 |     // default member initializer here:
133 |     std::string str = std::to_string(value);
134 |     
135 |     stringified_value(int v) : value{v} {}
136 | };
137 | ```
138 | In this example, `value` will first be initialized to `v`, then `str` will initialized to the stringified `value`.
139 | Remember, `str` is declared after `value`, so it's always initialized after.
140 | Default member initializers are always executed for all constructors, unless they are overridden by a member initializer
141 | list.
142 | Say, we were to add a second constructor:
143 | ```cpp
144 | stringified_value(int v, std::string s) : value{v}, str{std::move(s)} {}
145 | ```
146 | Now `str = std::to_string(value)` will not be executed at all for this constructor, but `str` will be initialized to
147 | `s` instead (using [`std::move`](https://en.cppreference.com/w/cpp/utility/move)).
148 | 
149 | ### So What is The Constructor Body For?
150 | 
151 | The constructor body is still useful for performing work more complicated than just initialization.
152 | It allows us to do many things, such as:
153 | - checking pre-conditions, like whether provided names were non-empty strings, etc.
154 | - opening files and checking for success
155 | - managing other resources, like network connections, VRAM buffers, etc.
156 | - generally, calling member functions of our members
157 | - logging the creation of our new object
158 | - counting instances of our new object
159 | - modifying global state in some way
160 | 
161 | As a rule of thumb, if something can be done in the member initializer list, it should.
162 | If there is no reasonable way to do it there, it should be done in the constructor body.
163 | 
164 | ## Summary
165 | 
166 | The correct way to initialize members in C++ is using default member initializers, or in some cases using default member
167 | initializers.
168 | The constructor body can not be used for initialization and trying to abuse it this way can lead to errors.
169 | Often, we can simply leave the constructor body empty.
170 | 
171 | Regardless of how we initialize our members and how we order our member initializer list, the members are **always**
172 | initialized in the order of declaration.
173 | We have many ways to initialize members and the syntax for doing so is the same as for variables.
174 | 
175 | ### See Also
176 | - https://en.cppreference.com/w/cpp/language/constructor
177 | - https://en.cppreference.com/w/cpp/language/constructor#Initialization_order
178 | - https://en.cppreference.com/w/cpp/language/data_members#Member_initialization
179 | 


--------------------------------------------------------------------------------
/content/faq/undefined-behaviour.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "What is 'Undefined Behaviour'?"
 3 | tags: ["beginner"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | Undefined Behaviour (also known as **UB**) occurs when you violate certain language rules. These rules include (but are not limited to): dereferencing a null pointer, signed integer overflow, accessing through a [dangling reference](https://en.cppreference.com/w/cpp/language/reference#Dangling_references), or accessing through an unaligned pointer.
11 | 
12 | **When undefined behaviour occurs, the C and C++ standards do not place any restrictions on what your program might do.** In other words, your program may crash, or continue execution, or call some seemingly unrelated piece of code, or print 42 and open [xkcd](https://xkcd.com/) in your web browser.
13 | 
14 | In practice, you *may* be able to reason about how your compiler will respond to UB, and in some cases compilers will guarantee that certain operations are well-defined, but for maximum portability you should aim to keep your programs UB-free.
15 | 
16 | ## Examples of UB
17 | 
18 | ```cpp
19 | int x;
20 | std::cout << x; // UB: x was used before being initialized
21 | 
22 | int *y = nullptr;
23 | *y = 5; // UB: dereferencing null pointer
24 | 
25 | int arrayA[10];
26 | for(int z : arrayA)
27 |     std::cout << z << ' '; // UB: array elements used when uninitialized
28 | 
29 | int *w = new int;
30 | delete w;
31 | *w = 5; // UB: object used after being destroyed
32 | ``` 
33 | 
34 | ## Avoiding UB
35 | Undefined behaviour can be difficult to diagnose. Always [compile with warnings enabled]({{< ref "faq/enable-warnings.md" >}}), but note that compilers can't detect all problems at compile time. Tools like [ASan](https://en.wikipedia.org/wiki/AddressSanitizer), [UBSan](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html) and [Valgrind](https://valgrind.org/docs/manual/quick-start.html#quick-start.mcrun) perform checks on your code at runtime and are good at catching invalid memory accesses, so are recommended for use during development.
36 | 
37 | For `gcc` and `clang` users, we recommend using
38 | ```nohighlight
39 | -Wall -Wextra -g -fsanitize=address,undefined
40 | ```
41 | in your compilation flags during development. This enables compiler warnings, ASan, UBSan (and debugging symbols for nicer sanitizer error messages).
42 | 
43 | ### See Also
44 | * https://en.cppreference.com/w/c/language/behavior
45 | 


--------------------------------------------------------------------------------
/content/faq/unspecified-impldefined.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "What are 'Unspecified' and 'Implementation-Defined' behavior?"
 3 | tags: ["beginner"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | Unlike [*undefined* behavior](../undefined-behaviour), *unspecified* and *implementation-defined* behavior occur all the
11 | time in a normal C++ program.
12 | Making use of unspecified/implementation-defined behavior is unavoidable, but relying on specific behavior can be fatal.
13 | 
14 | The C++ standard does not specify what happens in every scenario, so the implementation has the freedom to implement
15 | behavior, constants, macro definitions, and more in multiple possible ways.
16 | 
17 | ## Unspecified
18 | 
19 | Behavior unspecified by the standard is not necessary to document, but still valid.
20 | The *range* of possible behavior behavior can be predictable and is sometimes even specified explicitly by the
21 | C++ standard.
22 | However, in most cases, the exact behavior can not be predicted.
23 | 
24 | ### Common Examples
25 | 
26 | The following things are unspecified (list not exhaustive):
27 | - whether all string literals are distinct (they might have different addresses)
28 | - the initial value of storage allocated by `new` (often zero when getting new memory from the OS)
29 | - evaluation order of operands of some operators (for `A + B`, `B` might be evaluated before `A`)
30 | - amount of time it takes for a thread to make progress (but eventual progress is guaranteed)
31 | - whether references require any storage (they usually do, just like pointers)
32 | 
33 | Unspecified behavior can be as predictable as *"we probably know what happens"*, such as a reference requiring some
34 | storage when used as a class member.
35 | However, it can also be nonsensical to define, such as the initial value of storage allocated by `new`.
36 | The `new` operator usually uses `std::malloc` to allocate storage, but the initial value of `std::malloc`'s storage is
37 | indeterminate.
38 | 
39 | From the C++20 standard:
40 | 
41 | > **unspecified behavior**
42 | > *behavior, for a well-formed program construct and correct data, that depends on the implementation*
43 | >
44 | > Note: The implementation is not required to document which behavior occurs. \[...\]
45 | 
46 | See [**3.31 \[defns.unspecified\]**](https://timsong-cpp.github.io/cppwp/n4861/intro.defs#defns.unspecified)
47 | 
48 | ## Implementation-Defined
49 | 
50 | *Implementation-defined* is a lesser evil than *unspecified*, because the implementation details **must** be
51 | documented.
52 | Relying on implementation-defined behavior can still cause portability issues such as code working only on one operating
53 | system, but at least, these portability issues are known and predictable.
54 | 
55 | ### Common Examples
56 | 
57 | The following things are implementation-defined (list not exhaustive):
58 | - the exact size of fundamental types such as `int` and `long`
59 | - definition of the `NULL` macro (possibly `0`, `((void*)0)`, or `nullptr`)
60 | - conversions between pointers and integers (`reinterpret_cast<std::uintptr_t>(...)`)
61 | - nesting limit for `#include` directives
62 | - choice of larger or smaller value for `float` literals (round up or down if necessary)
63 | - operating systems on which implementation depends
64 | - value of `pow(0,0)` (usually `1`)
65 | 
66 | All of these details are documented somewhere, whether it is in standard library headers, manual pages of the OS, etc.
67 | Problems only arise when the developer relies on one particular implementation.
68 | A common example is assuming that `long` will be at least 64 bits in size, when actually, only 32 bits are guaranteed by
69 | the standard.
70 | Windows requires `long` to be 32 bits, while Unix-like operating systems use 64 bits.
71 | 
72 | From the C++20 standard:
73 | 
74 | > **implementation-defined behavior**
75 | > *behavior, for a well-formed program construct and correct data, that depends on the implementation and that each
76 | implementation documents*
77 | 
78 | See [**3.13 \[defns.impl.defined\]**](https://timsong-cpp.github.io/cppwp/n4861/intro.defs#defns.impl.defined)
79 | 
80 | ## See Also
81 | 
82 | - https://en.cppreference.com/w/cpp/language/types#Data_models
83 | - https://en.wikipedia.org/wiki/Unspecified_behavior
84 | - https://timsong-cpp.github.io/cppwp/n4861/impldefindex
85 | 


--------------------------------------------------------------------------------
/content/faq/using-namespace-std.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Why is `using namespace std` considered bad practice?"
 3 | tags: ["beginner"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | Consider this code:
11 | 
12 | ```cpp
13 | #include <iostream>
14 | #include <algorithm>
15 | 
16 | using namespace std;
17 | 
18 | int swap = 0;
19 | 
20 | int main() {
21 | 	cout << swap << endl; // ERROR: reference to "swap" is ambiguous
22 | }
23 | ```
24 | 
25 | Here, the compiler throws an error because it doesn't know whether you refer to your `swap` global variable, or the `std::swap` function inside the `<algorithm>` header.
26 | 
27 | That is to say, **`using namespace` is considered bad practice because it leads to name collisions**, and it also makes your code less clear.
28 | If you *absolutely must*, you can use a **using-declaration** inside a local scope:
29 | 
30 | ```cpp
31 | #include <iostream>
32 | 
33 | int main() {
34 | 	using std::cout; // This only affects the current function
35 | 
36 | 	cout << "Hello" <<'\n';
37 | }
38 | ```
39 | 
40 | Generally speaking, it is better to specify the namespace.
41 | 
42 | ### See also
43 | * https://isocpp.org/wiki/faq/coding-standards#using-namespace-std
44 | 


--------------------------------------------------------------------------------
/content/meta/about.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "About this site"
 3 | tags: ["meta"]
 4 | draft: false
 5 | disableShare: false
 6 | disableHLJS: false
 7 | searchHidden: false
 8 | ---
 9 | 
10 | TODO
11 | 


--------------------------------------------------------------------------------
/content/search.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "Search" # in any language you want
3 | layout: "search" # is necessary
4 | # url: "/archive"
5 | # description: "Description for Search"
6 | summary: "search"
7 | ---
8 | 


--------------------------------------------------------------------------------
/layouts/_default/list.html:
--------------------------------------------------------------------------------
 1 | {{- define "main" }}
 2 | 
 3 | {{- if (and .Site.Params.profileMode.enabled .IsHome) }}
 4 | {{- partial "index_profile.html" . }}
 5 | {{- else }} {{/* if not profileMode */}}
 6 | 
 7 | {{- if not .IsHome | and .Title }}
 8 | <header class="page-header">
 9 |   {{- partial "breadcrumbs.html" . }}
10 |   <h1>{{ .Title }}</h1>
11 |   {{- if .Description }}
12 |   <div class="post-description">
13 |     {{ .Description }}
14 |   </div>
15 |   {{- end }}
16 | </header>
17 | {{- end }}
18 | 
19 | {{- $pages := union .RegularPages .Sections }}
20 | 
21 | {{- if .IsHome }}
22 | {{- $pages = where site.RegularPages "Type" "in" site.Params.mainSections }}
23 | {{- end}}
24 | 
25 | {{ $paginator := .Paginate $pages }}
26 | 
27 | {{- if and .IsHome .Site.Params.homeInfoParams (eq $paginator.PageNumber 1) }}
28 | {{- partial "home_info.html" . }}
29 | {{- end }}
30 | 
31 | {{ $term := .Data.Term}}
32 | {{- range $index, $page := $paginator.Pages }}
33 | 
34 | {{- $class := "post-entry" }}
35 | 
36 | {{- $user_preferred := or .Site.Params.disableSpecial1stPost .Site.Params.homeInfoParams }}
37 | {{- if (and $.IsHome (eq $paginator.PageNumber 1) (eq $index 0) (not $user_preferred)) }}
38 | {{- $class = "first-entry" }}
39 | {{- else if $term }}
40 | {{- $class = "post-entry tag-entry" }}
41 | {{- end }}
42 | 
43 | <article class="{{ $class }}">
44 |   {{- $isHidden := (.Site.Params.cover.hidden | default .Site.Params.cover.hiddenInList)}}
45 |   {{- partial "cover.html" (dict "cxt" . "IsHome" true "isHidden" $isHidden) }}
46 |   <header class="entry-header">
47 |     <h2>
48 |       {{ .Title | markdownify }}
49 |       {{- if .Draft }}<div class="entry-isdraft"><sup>&nbsp;&nbsp;[draft]</sup></div>{{- end }}
50 |     </h2>
51 |   </header>
52 |   {{- if (ne (.Param "hideSummary") true)}}
53 |   <section class="entry-content">
54 |     <p>{{ .Summary | plainify | htmlUnescape }}{{- if .Truncated }}...{{- end -}}</p>
55 |   </section>
56 |   {{- end }}
57 |   {{- if not (.Param "hideMeta") }}
58 |   <footer class="entry-footer">
59 |     {{- partial "post_meta.html" . -}}
60 |   </footer>
61 |   {{- end }}
62 |   <a class="entry-link" aria-label="post link to {{ .Title | plainify }}" href="{{ .Permalink }}"></a>
63 | </article>
64 | {{- end }}
65 | 
66 | {{- if gt $paginator.TotalPages 1 }}
67 | <footer class="page-footer">
68 |   <nav class="pagination">
69 |     {{- if $paginator.HasPrev }}
70 |     <a class="prev" href="{{ $paginator.Prev.URL | absURL }}">« {{ i18n "prev_page" }}</a>
71 |     {{- end }}
72 |     {{- if $paginator.HasNext }}
73 |     <a class="next" href="{{ $paginator.Next.URL | absURL }}">{{ i18n "next_page" }} »</a>
74 |     {{- end }}
75 |   </nav>
76 | </footer>
77 | {{- end }}
78 | {{end}}{{/* end profileMode */}}
79 | {{- end }}{{- /* end main */ -}}
80 | 


--------------------------------------------------------------------------------
/layouts/_default/single.html:
--------------------------------------------------------------------------------
 1 | {{- define "main" }}
 2 | 
 3 | <article class="post-single">
 4 |   <header class="post-header">
 5 |     {{- partial "breadcrumbs.html" . }}
 6 |     <h1 class="post-title">
 7 |       {{ .Title | markdownify }}
 8 |       {{- if .Draft }}<div class="entry-isdraft"><sup>&nbsp;&nbsp;[draft]</sup></div>{{- end }}
 9 |     </h1>
10 |     {{- if .Description }}
11 |     <div class="post-description">
12 |       {{ .Description }}
13 |     </div>
14 |     {{- end }}
15 |     {{- if not (.Param "hideMeta") }}
16 |     <div class="post-meta">
17 |       {{- partial "post_meta.html" .  -}}
18 |       {{- partial "translation_list.html" . -}}
19 |     </div>
20 |     {{- end}}
21 |   </header>
22 |   {{- $isHidden := .Params.cover.hidden | default .Site.Params.cover.hiddenInSingle | default .Site.Params.cover.hidden}}
23 |   {{- partial "cover.html" (dict "cxt" . "IsHome" false "isHidden" $isHidden) }}
24 |   {{- if (.Param "ShowToc") }}
25 |   <div class="toc">
26 |     <details {{if (.Param "TocOpen") }} open{{ end }}>
27 |       <summary accesskey="c" title="(Alt + C)">
28 |         <div class="details">{{- i18n "toc" | default "Table of Contents" }}</div>
29 |       </summary>
30 |       <div class="inner">
31 |         {{- partial "toc.html" . }}
32 |       </div>
33 |     </details>
34 |   </div>
35 |   {{- end }}
36 |   <div class="post-content">
37 |     {{- partial "anchored_headings.html" .Content -}}
38 |   </div>
39 |   <footer class="post-footer">
40 |     {{- if (.Param "ShowPostNavLinks") }}
41 |     {{- $pages := where site.RegularPages "Type" "in" site.Params.mainSections }}
42 |     {{- if and (gt (len $pages) 1) (in $pages . ) }}
43 |     <nav class="paginav">
44 |       {{- with $pages.Next . }}
45 |       <a class="prev" href="{{.Permalink}}">
46 |         <span class="title">« {{ i18n "prev_page" }}</span>
47 |         <br>
48 |         <span>{{- .Name -}}</span>
49 |       </a>
50 |       {{- end}}
51 |       {{- with $pages.Prev . }}
52 |       <a class="next" href="{{.Permalink}}">
53 |         <span class="title">{{ i18n "next_page" }} »</span>
54 |         <br>
55 |         <span>{{- .Name -}}</span>
56 |       </a>
57 |       {{- end}}
58 |     </nav>
59 |     {{- end }}
60 |     {{- end }}
61 |     {{- if (and .Site.Params.ShowShareButtons (ne .Params.disableShare true) ) }}
62 |     {{- partial "share_icons.html" . }}
63 |     {{- end }}
64 |   </footer>
65 | 
66 |   {{- if (.Param "comments") }}
67 |   {{- partial "comments.html" . }}
68 |   {{- end }}
69 | </article>
70 | 
71 | {{- end  }}{{/* end main */}}
72 | 


--------------------------------------------------------------------------------
/layouts/partials/post_meta.html:
--------------------------------------------------------------------------------
 1 | {{- $scratch := newScratch}}
 2 | 
 3 | {{- if .Params.tags }}
 4 | <ul class="post-tags">
 5 |   {{- range ($.GetTerms "tags") }}
 6 |   <li><a href="{{ .Permalink }}">{{ .LinkTitle }}</a></li>
 7 |   {{- end }}
 8 | </ul>
 9 | {{- end }}
10 | 
11 | {{- with ($scratch.Get "meta")}}
12 | {{- delimit . "&nbsp;·&nbsp;"}}
13 | {{- end }}
14 | 


--------------------------------------------------------------------------------