#include <string>

int main() {
    std::string s;
    s += 48;    // неявное приведение к char.
    s += 1000;  // а тут еще и с переполнением, очень неприятным
                // на платформе с signed char.
    s += 49.5;  // опять-таки неявное приведение к char
}

const int max_v = 10;

void fun(int y) 
{
   const int max_v = [&]{
       // локальный max_v перекрывает глобальный max_v
       return std::min(max_v, y);
   }();
   ...
}

int main()
{
    char s[10];
    s[0] = 48;
    s[1] = 1000;
    s[2] = 49.5;
}

struct Timer {
    int val;
    explicit Timer(int v = 0) : val(v) {}
};

struct Worker {
    int time_to_work;

    explicit Worker(Timer t) : time_to_work(t.val) {}

    friend std::ostream& operator << (std::ostream& os, const Worker& w) {
        return os << "Time to work=" << w.time_to_work;
    }
};

int main() {
    // ЭТО НЕ ВЫЗОВ КОНСТРУКТОРА!
    Worker w(Timer()); // предобъявление функции, которая возвращает Worker и принимает функцию, возвращающую Timer и не принимающую ничего!

    std::cout << w; // имя функции неявно преобразуется к указателю, который неявно преобразуется к bool
    // будет выведено 1 (true)
}

// пример взят из блога https://mohitmv.github.io/blog/Shocking-Undefined-Behaviour-In-Action/
int main() {
  char buf[50] = "y";
  for (int j = 0; j < 9; ++j) {
    std::cout << (j * 0x20000001) << std::endl;
    if (buf[0] == 'x') break;
  }
}

                target_compile_options(${TARGET} PRIVATE "/WX" "/external:anglebrackets" "/external:W1")

                # !!! Надо разобратся со всеми этими варнингами. Пока дизаблим

                # warning C4435: 'TYPE': Object layout under /vd2 will change due to virtual base 'TYPE_BASE'
                target_compile_options(${TARGET} PRIVATE "/wd4435")

                # warning C4464: exclude warning "relative include path contains '..'"
                target_compile_options(${TARGET} PRIVATE "/wd4464")

                # warning C4505: unreferenced function has been removed
                target_compile_options(${TARGET} PRIVATE "/wd4514")

                # warning C4626: 'TYPE': assignment operator was implicitly defined as deleted
                target_compile_options(${TARGET} PRIVATE "/wd4626")

                # https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4710?view=msvc-170
                # warning C4710: function not inlined
                target_compile_options(${TARGET} PRIVATE "/wd4710")

                # warning C4711: function selected for automatic inline expansion
                target_compile_options(${TARGET} PRIVATE "/wd4711")

                # warning C4738: storing 32-bit float result in memory, possible loss of performance
                target_compile_options(${TARGET} PRIVATE "/wd4738")

                # warning C4810: value of pragma pack(show)
                # target_compile_options(${TARGET} PRIVATE "/wd4810")
                
                # warning C4820: N bytes padding added after data member 'memberName'
                target_compile_options(${TARGET} PRIVATE "/wd4820")

                # warning C4866: compiler may not enforce left-to-right evaluation order for call to 'umba::SimpleFormatter::operator<<<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >'
                target_compile_options(${TARGET} PRIVATE "/wd4866")

                # warning C5027: 'TYPE': move assignment operator was implicitly defined as deleted
                target_compile_options(${TARGET} PRIVATE "/wd5027")

                # warning C5045: Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
                target_compile_options(${TARGET} PRIVATE "/wd5045")

pop.h
push_disable_condition_is_const.h
push_disable_def_ctor_implicitly_deleted.h
push_disable_enumerator_not_handled.h
push_disable_fn_or_var_unsafe.h
push_disable_implicit_copy_ctor_deprecated.h
push_disable_non_portable_variadic.h
push_disable_non_trivial_destructor_not_virtual.h
push_disable_padding_added.h
push_disable_rel_inc_contains_dbldot.h
push_disable_result_not_used.h
push_disable_signed_unsigned_mismatch.h
push_disable_spectre_mitigation.h
push_disable_this_used_in_base_member_initializer_list.h
push_disable_trivial_destructor_not_virtual.h
push_disable_unsafe_conversion.h

  #include "mycore/warnings/push_disable_non_trivial_destructor_not_virtual.h"
  // Проблемный код
  #include "mycore/warnings/pop.h"

В конструкторах и деструкторах в C++ виртуальная диспетчеризация методов не работает

#include <iostream>

class base
{
    virtual void f() { std::cout << "base::f" << std::endl; }
    
public:
    base() {
        std::cout << "base {" << std::endl;
        f();
        std::cout << "base }" << std::endl;
    }
    
    void call_f() {
        std::cout << "===" << std::endl;
        f();
    }
};

class derived : public base
{
    void f() { std::cout << "derived::f" << std::endl; }
    
public:
    derived() {
        std::cout << "derived {" << std::endl;
        f();
        std::cout << "derived }" << std::endl;
    }
};

int main()
{
    derived d;
    
    d.call_f();
}

base {
base::f
base }
derived {
derived::f
derived }
===
derived::f

12.7 (3)
... When a virtual function is called directly or indirectly from a constructor (including from the mem-initializer for a data-member) or from a destructor, and the object to which a call applies is the object under construction or destruction, the function called is the one defined in the constructor or destructor's own class or in one of its bases, ...

#include <iostream>
#include <memory>

class Base
{
public:

    virtual void Stop() { std::cout << "Base::Stop" << std::endl; }
    virtual ~Base() { 
        Stop(); // Вот здесь будет вызван Base::Stop, а не Derived::Stop, как некоторые ожидают.
    }
};

class Derived : public Base
{
public:
    virtual void Stop() { std::cout << "Derived::Stop" << std::endl; }
};

int main() {
    std::shared_ptr<Derived> derived_ptr = std::make_shared<Derived>();
    // При выходе: "Base::stop"
}

В конструкторах и деструкторах в C++ виртуальная диспетчеризация методов не работает

class Processor {
public:
    virtual void start() = 0;
    // stops execution, returns `false` if already stopped
    virtual bool stop() = 0;
    virtual ~Processor() {
        stop();
    }
};

class base {
public:
  base() { f(); }

  virtual void f() {...}
};

class derived_first_level : public base {
public:
  derived_first_level() { f(); /* тут корректно будет вызван base::f() */ }
};

class derived_second_level : public derived_first_level {
public:
  derived_second_level() { f(); /* тут корректно будет вызван derived_second_level::f() */ }

  void f() override {...}
};

class derived_third_level : public derived_second_level {
public:
  derived_second_level() { f(); /* тут корректно будет вызван derived_second_level::f() */ }
};

При деструктурировании наоборот — часть объекта-наследника уже уничтожена, и если позволить динамический вызов, можно легко получить use-after-free.

#include <iostream>

class base
{
    
public:
    base() {
        std::cout << "base {" << std::endl;
        f();
        std::cout << "base }" << std::endl;
    }
    
    virtual void f() { std::cout << "base::f" << std::endl; }
};

void call(base & b) { b.f(); }

class derived : public base
{
    void f() override { std::cout << "derived::f" << std::endl; }
    
public:
    derived() = default;
};

class another_derived final : public base
{
    void f() override { std::cout << "another_derived::f" << std::endl; }
    
public:
    another_derived() = default;
};

int main()
{
    derived d;
    another_derived ad; 
    
    std::cout << "---" << std::endl;
    
    call(d);
    call(ad);
}

В конструкторах и деструкторах в C++ виртуальная диспетчеризация методов не работает (В других языках — например, в C# или Java — наоборот, что доставляет свои проблемы).

class c1 {
  virtual void f() {...};
  ...
};

class c2 : public c1 {
  void f() override {...};
  ...
};

class c3 : public c2 {
  ... // нет своей версии f().
};

class c4 : public c3 {
public:
  c4() { f(); }
};

S>class c1 {
S>  virtual void f() {...};
S>  ...
S>};

S>class c2 : public c1 {
S>  void f() override {...};
S>  ...
S>};

S>class c3 : public c2 {
S>  ... // нет своей версии f().
S>};

S>class c4 : public c3 {
S>public:
S>  c4() { f(); }
S>};
S>

class c1 {
  virtual void f() {};
};

class c2 : public c1 {
  void f() override {};
};

class c3 : public c2 {
  // нет своей версии f().
};

class c4 : public c3 {
public:
  c4() {
      f();      // error: 'virtual void c2::f()' is private within this context
      c4::f();  // error: 'virtual void c2::f()' is private within this context
    }
};

int main() {
}

12.7 (3)
... When a virtual function is called directly or indirectly from a constructor (including from the mem-initializer for a data-member) or from a destructor, and the object to which a call applies is the object under construction or destruction, the function called is the one defined in the constructor or destructor's own class or in one of its bases, ...

class c1 {
public:
  virtual void f() { std::cout << "c1::f" << std::endl; }
};

class c2 : public c1 {
public:
  void f() override { std::cout << "c2::f" << std::endl;};
};

class c3 : public c2 {
  // нет своей версии f().
};

class c4 : public c3 {
public:
  c4() {
      f();      // c2::f
      c2::f();  // c2::f
      c3::f();  // c2::f
      c4::f();  // c2::f
    }
};

int main() {
    c4{};
}

struct c1 {
  ~c1() { f(); }
  virtual void f() { std::cout << "c1::f" << std::endl; }
};

struct c2 : public c1 {};

struct c3 : public c2 {
  void f() override { std::cout << "c3::f" << std::endl; }
};

int main() {
  c3 c;
}

struct s1 {
  virtual void f() { std::cout << "s1::f" << std::endl; }

  s1() {
    this->f(); // (1)
  }

  void call_f() {
    this->f(); // (3)
  }
};

struct s2 : public s1 {
  void f() override { std::cout << "s2::f" << std::endl; }
};

int main() {
  s2 s; // (2)

  s.call_f(); // (4)
}

#include <iostream>

class c1 {
public:
  virtual void f() { std::cout << "c1::f" << std::endl; }
};

class c2 : public c1 {
public:
  void f() override { std::cout << "c2::f" << std::endl;};
};

class c3 : public c2 {
  // нет своей версии f().
};

class c4 : public c3 {
public:
  c4() {
      f();      // c2::f
      c2::f();  // c2::f
      c3::f();  // c2::f
      c4::f();  // c2::f
    }
};

int main() {
    c4{};
}

struct s1 {
  virtual void f() { std::cout << "s1::f" << std::endl; }

  s1() {
    call_f();
  }

  void call_f();
};

// Где-то совсем в другом месте, возможно даже в другой единице трансляции.
void s1::call_f() {
  this->f(); // (3)
}

char convert(char ch)
{
    char table[256] = { некоторые значения для перестановки };
    return table[ch];
}

если позволить динамический вызов, можно легко получить use-after-free

Радуйтесь! Это одно из немногих мест в C++, где вас защитили от неопределенного поведения со временами жизни!