SP>std::unique_ptr<Foo> f;
f->>foo();
SP>

AudioRtpSender::AudioRtpSender(rtc::Thread* worker_thread,
                               const std::string& id,
                               StatsCollector* stats,
                               SetStreamsObserver* set_streams_observer)
    : RtpSenderBase(worker_thread, id, set_streams_observer),
      stats_(stats),
      dtmf_sender_proxy_(DtmfSenderProxy::Create(
          rtc::Thread::Current(),
          DtmfSender::Create(rtc::Thread::Current(), this))),
      sink_adapter_(new LocalAudioSinkAdapter()) {}

Examples include use after free (UAF), double-free, use before initialization, and use after move (UAM). Temporal safety violations often look like type confusion. For example, the program mistakenly uses a recently-freed Dog object as if it were a Cat object

std::unique_ptr<Foo> f;
f->foo();

std::unique_ptr<Foo> f;
f->foo();

Foo * f;
f->foo();

SP>как минимум гистограмма распределения ошибок. Статистика занятная. Особенно посмотреть на процент data race и процент статей и докладов, как их обходить Я конечно понимаю, что это интереснее, чем проблема протухших ссылок, но тенденция занятная.

SP>std::unique_ptr<Foo> f;
f->>foo();
SP>

... safe_ptr::operator ->()
{
  if ( nullptr == m_ptr )
  {
     m_ptr = new T{};
  }
  return m_ptr;
}

unique_ptr<SomeObj> obj;
obj.map(&SomeObj::SomeMethod).map_empty(logError);

return isValue || intOpt ? *intOpt : 0;

SP>unique_ptr<SomeObj> obj;
SP>obj.map(&SomeObj::SomeMethod).map_empty(logError);
SP>

std::unique_ptr<SomeObj> ptr = ...;
assert(nullptr != ptr);

template <class T>
class MyUniquePtr
{
  ....
    std::unique_ptr<T>& operator -> ()
    { 
       if ( nullptr == m_ptr )
       {
          throw std::runtime_error("null ptr"); 
       }
       return m_ptr;
    }
  private:
    std::unique_ptr<T> m_ptr;
};