Running list of more terms/concepts we could document in glossary

Personne n'a encore pris cette issue.

The [glossary](https://github.com/mapbox/cpp/blob/master/glossary.md) is developing quickly into a pretty solid resource for the key terms you'll encounter and need to know while learning C++ at Mapbox. Or when starting to teach colleagues about how we write, deploy, and approach C++ at Mapbox.

While the glossary says explicitly that `It is not intended to be a complete reference on language or syntax terms`, there is much more we can do. This is a ticket to brainstorm additional concepts, terms, and keywords that are potential things to cover in the glossary and related docs.

Most of these terms don't need to be defined in the glossary, rather it would be sufficient to simply list them and links to external resources (particularly style guides we support). The overall goal is 1) note they are important to understand for C++ development a mapbox (by their presence), and 2) provide a great resource to learn more about them. We can add extra definitions where our opinions matter.

(_Will be editing this in place as I collect ideas_)

#### Key learning concepts

- the idea of a `main` function in an executable
- how to pass arguments to a C++ program and parse them - refs #35
- const
- `const char*` vs `std::string` and how they relate
- pointers vs references
- dereferencing pointers
- taking the address of a variable
- header guards vs `#pragma once`
- learning the cpp preprocessor
- what are templates and when to use them
- global variables, why not to use them, when they are appropriate
- when to use `static_cast`, `reinterpret_cast`, and `const_cast`. Why to use them rather than c style cases
- how enumerations work `enum` in C++11. Using casts to change between them and integer types
- the max size of numeric types. using `` from the stdlib to know these sizes dynamically
- integer overflow. When it is undefined behavior, when it is defined. How to control it/prevent it. How it differs for signed types and unsigned types
- compiler warnings. how to avoid them, fix them, appropriately suppress them. Why, when starting projects, it makes sense to use `-Werror` and very aggressive warnings, even `-Weverything`
- how to use c++ exceptions: why to always make custom exceptions subclass `std::exception`. How to catch all types by catching `std::exception`. Why to catch exceptions by `const&`.
- when to avoid throwing exceptions due to performance concerns (e.g. in tight loops)
- what is garbage collection
- What is reference counting
- Why, when, and how to use `std::unique_ptr` vs `std::shared_ptr`
- zero copy
- Big takeaways of C++11 vs C++14 vs c++17
- move semantics / [universal references](https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers)
- considerations on when to use `std::vector` vs `std::map` vs `std::list`
- binary size, why it matters, how you can learn about it (https://github.com/google/bloaty)
- What is the `_GLIBCXX_USE_CXX11_ABI` flag on linux and why does it matter?

#### Advanced performance concepts

- Arena allocation vs Memory Pools vs Region-based memory management: https://natsys-lab.blogspot.com/2015/09/fast-memory-pool-allocators-boost-nginx.html
- Alternative allocators: https://howardhinnant.github.io/stack_alloc.html
- Profiling with BCC tools: https://github.com/iovisor/bcc

Commencez par glossary.md et examinez la liste existante de concepts C++ et de ressources externes proposés. L’issue est davantage un compte rendu de brainstorming ouvert qu’une tâche de documentation définie ; sa réalisation nécessiterait de restreindre le périmètre et de convenir des termes ou liens à ajouter.

Rédigé par le modèle d'indexation à partir du texte de l'issue.