• ISO/IEC: Working Draft, Standard for Programming Language C++ (PDF, 2011)
• cplusplus.com: Standard C++ Library reference

• Stack Overflow
• CodeProject
• Embedded Artistry
• Internal Pointers
• nextptr
• Bartek's coding blog
• Rainer Grimm: Modernes C++

• Bjarne Stroustrup and Herb Sutter: C++ Core Guidelines
• CERT: SEI CERT C++ Coding Standard
• Google C++ Style Guide

• Marius Bancila: Ten C++11 Features Every C++ Developer Should Use
• Vatroslav Bodrozic: Top 10 Most Common C++ Mistakes That Developers Make
• Deb Haldar: Top 25 C++ API design mistakes and how to avoid them
• Deb Haldar: Top 15 C++ Exception handling mistakes and how to avoid them
• Deb Haldar: Top 20 C++ multithreading mistakes and how to avoid them

• David Kieras: Using C++11’s Smart Pointers (PDF, 2016)
• Szalwinski, Chris: Smart Pointers
• Brian Overland: Be Smart About C++11 Smart Pointers
• Bartlomiej Filipek: Custom Deleters for C++ Smart Pointers
• Phillip Johnston: std::shared_ptr and shared_from_this

• Alex Allain: Move semantics and rvalue references in C++11
• Thomas Becker: C++ Rvalue References Explained
• Stack Overflow: What is move semantics?
• Stack Overflow: How do I pass a unique_ptr argument to a constructor or a function?

• Petr Zemek: Pros and Cons of Alternative Function Syntax in C++
• Jonathan Boccara: STL Function objects: Stateless is Stressless
• Davis Vigneault: Callbacks in C++11
• Alex Allain: Programs as Data: Function Pointers¹⁾
• Alex Allain: Functors: Function Objects in C++
• Alex Allain: Lambda Functions in C++11 - the Definitive Guide
• Sandor Dargo: Lambda Expressions in C++
• Hitesh Kumar: Capture *this in lambda expression: Timeline of change

• Stack Overflow: How does scope-locking work?
• cppreference.com: std::lock_guard (since C++11)
• cppreference.com: std::scoped_lock (since C++17)

• Concurrency in C++11
• Stack Overflow: What exactly is std::atomic?

• Andrzej Krzemieński: Using noexcept

• David Bacon et al.: The "Double-Checked Locking is Broken" Declaration
• Scott Meyers and Andrei Alexandrescu: C++ and the Perils of Double-Checked Locking (PDF, 2004)
• Hongbo Zhang: Double-Checked Locking is Broken
• Jeff Preshing: Double-Checked Locking is Fixed In C++11

• Stack Overflow: Shared pointers to a singleton do not recognize each other
• Stack Overflow: C++ Singleton design pattern
• RIP Tutorial: Lazy Initialization
• Rainer Grimm: Thread-Safe In itialization of a Singleton

A thread-safe method (guaranteed since C++11, see here) using a static instance of class CFoo (Meyers singleton):

class CFoo {
public:
  static CFoo& getInstance()
  {
    static CFoo instance;
    return instance;
  }
};

A thread-safe method using C++11 smart pointers for creation of an singleton instance of class CFoo:

#include <mutex>  // std::mutex
#include <memory> // std::weak_ptr, std::shared_ptr
 
using std;
 
static weak_ptr<CFoo> s_pFoo; // singleton instance pointer
static mutex s_lock;          // singleton instance lock
 
shared_ptr<CFoo> CFoo::getInstance()
{
  lock_guard<mutex> lock(s_lock);
  shared_ptr<CFoo> pInstance = s_pFoo.lock();
 
  if (!pInstance)
  {
    pInstance = make_shared<CFoo>(); // create shared smart pointer
    s_pFoo = pInstance;              // replace (set) managed object
  } // if
 
  return pInstance;
} // getInstance()

See Jeff Preshing: Double-Checked Locking is Fixed In C++11.