class TSomeClass {
public:
    int GetValue() const {
        return Value_; // C++ "видит" Value_, хотя он определен "позже"
    }
private:
    int Value_;
};

    auto lam = [](double param) { /* do something */ };

    struct {
        void operator()(double param) const { /* do something */ }
    } lam;

auto foo = [](int a, int b) { return a + b; };
decltype(foo) bar;
// ^ (до C++20) error: no matching constructor for initialization of 'decltype(foo)'

auto v1 = [&]{ /* .../ }();
auto v2 = std::invoke([&]{ /* .../ });

std::visit(overloaded{
    [](A a) { std::cout << a.name << std::endl; },
    [](B b) { std::cout << b.type << std::endl; },
    [](C c) { std::cout << c.age << std::endl; }
}, something);

for (b2Body* b = myWorld->GetBodyList(); b; b = b->GetNext())
    b->... // do something with the body

strength = M_свинка * V_свинка + M_предмет * V_предмет

for (b2Contact* contact = world->GetContactList(); contact; contact = contact->GetNext())
    contact->... //do something with the contact

// в .h-файле:
extern const std::string DVCC_DVVC_BLOCK_TYPE_NAME;
// в .cpp-файле:
const std::string DVCC_DVVC_BLOCK_TYPE_NAME = "Dolby Vision configuration";

// так плохо! в .h-файле:
const std::string DVCC_DVVC_BLOCK_TYPE_NAME = "Dolby Vision configuration";

// в .h-файле
inline const std::string DVCC_DVVC_BLOCK_TYPE_NAME = "Dolby Vision configuration";

  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
    return LangOpts.CPlusPlus17;
  }

  auto NonInlineConstVarDecl =
      varDecl(hasGlobalStorage(),
              hasDeclContext(anyOf(translationUnitDecl(),
                                   namespaceDecl())), // is at file scope
              hasType(isConstQualified()),            // const-qualified
              unless(anyOf(
                  isInAnonymousNamespace(), // not within an anonymous namespace
                  isTemplateVariable(),     // non-template
                  isInline(),               // non-inline
                  hasType(isVolatileQualified()), // non-volatile
                  isExternC()                     // not "extern C" variable
                  )));

    Finder->addMatcher(varDecl(NonInlineConstVarDecl, isExternallyVisible())
                           .bind("extern-var-declaration"),
                       this);

    Finder->addMatcher(varDecl(NonInlineConstVarDecl, isDefinition(),
                               unless(isExternallyVisible()))
                           .bind("non-inline-var-definition"),
                       this);

  const VarDecl *D = nullptr;
  StringRef Msg;
  bool InsertInlineKeyword = false;

  if ((D = Result.Nodes.getNodeAs<VarDecl>("non-inline-var-definition"))) {
    Msg = "global constant %0 should be marked as 'inline'";
    InsertInlineKeyword = true;
  } else {
    D = Result.Nodes.getNodeAs<VarDecl>("extern-var-declaration");
    Msg = "global constant %0 should be converted to C++17 'inline variable'";
  }

  DiagnosticBuilder Diag = diag(D->getLocation(), Msg) << D;
  if (InsertInlineKeyword)
    Diag << FixItHint::CreateInsertion(D->getBeginLoc(), "inline ");

(f(x+h) - f(x-h)) / 2h

(f(x + h) - 2f(x) + f(x-h)) / 4h^2

    const std::vector<int> vec{1, 3, 5, 7, 9};
    // внизу аналог выражения `for (int value : vec) { /* ... */ }`
    auto __begin = vec.begin();
    auto __end = vec.end();
    for ( ; __begin != __end; ++__begin) {
        int value = *__begin;
        /* do something with `value`... */
    }

    std::default_sentinel_t end() { 
        return {}; 
    }

    bool operator==(std::default_sentinel_t) const { 
        return /* какое-то условие */; 
    }

-ftime-trace
    Turn on time profiler. Generates JSON file based on output filename. Results can be analyzed with chrome://tracing or Speedscope App for flamegraph visualization.
-ftime-trace-granularity=<arg>
    Minimum time granularity (in microseconds) traced by time profiler

clang++ main.cpp -c -ftime-trace -ftime-trace-granularity=50