Десять возможностей C++11, которые должен использовать каждый C++ разработчик

B::f — это просто другой метод с тем же именем, перегруженный, а не переопределенный

И снова это две перегруженные, а не переопределенные функции

foo(std::shared_ptr<int>(new int(42)), seed());

class B 
{
public:
   virtual void f(int) = 0;
};

class D : public B
{
public:
   virtual void f(int) override {std::cout << "D::f" << std::endl;}
};

Ключевое слово virtual опционально и поэтому немного затрудняло чтение кода, заставляя вечно возвращаться в вершину иерархии наследования, чтобы посмотреть объявлен ли виртуальным тот или иной метод

assert(this != &temp); // assert if this is not a temporary

if(this != &temp)
{
  // 1. освобождаем ресурсы, занятые этим объектом
  _buffer = nullptr;
  // 2. берем данные из temp
  _size = temp._size;
  _buffer = std::move(temp._buffer);
  _name = std::move(temp._name);
  // 3. присванивание чего-либо temp будет препятствовать тому, чтобы деструктор
  // освободил ресурсы, ранее занимаемые этим объектом
  // temp._buffer = nullptr; <-- нет необходимости из-за использования std::move
  temp._size = 0; // <-- в этом, соответственно, тоже нет необходимости
}
return *this;

Buffer& operator=(Buffer copy)
{
     swap(*this, copy);
     return *this;
}
// ...
void swap(Buffer& first, Buffer& second) noexcept
{
     using std::swap;
     swap(first._name  , second._name);
     swap(first._size  , second._size);
     swap(first._buffer, second._buffer);
}

auto fib = [&fib](int n) -> int {return n < 2 ? 1 : fib(n-1) + fib(n-2);};

Они больше не экспортируют свои перечисляемые значения в окружающую область видимости, больше не преобразуются неявно в целый тип и могут иметь определенный пользователем тип (эта опция так же добавлена и для «традиционных» перечислений").

#include <iostream>

enum class __enum : int { one = 0 };

int main () {
    std::cout << static_cast<int>(class __enum::one) << std::endl;
    
    return 0;
}

#include <iostream>
 
union __union final {
    const int i;
};
 
int main ()  {
    using foo = const union ::__union;
    foo un = { .i =  0 };
 
    std::cout << un.i << std::endl;
 
    return 0; 
}

struct  __struct final {
    __struct (const value&&) = default;
    __struct (const value&) = delete;
};

#include <iostream>
 
constexpr int foo() {
    return 1;
}
 
int main() {
    int array[foo() + 1] = {0, 1};    
 
    std::cout << std::boolalpha << (array[0] < array[1]) << std::endl;
 
    return 0;
}

namespace std {
	template <typename __type, typename ...__arguments>
		inline std::unique_ptr<__type> make_unique_helper (std::false_type, __arguments &&...arguments)
		{
		  return std::unique_ptr<__type>(new __type(std::forward<__arguments>(arguments)...));
		}
	
	template <typename __type, typename ...__arguments>
		inline std::unique_ptr<__type> make_unique_helper (std::true_type, __arguments &&...arguments)
		{
			using unique = typename std::remove_extent<__type>::type;
	
			return std::unique_ptr<__type>(new unique[sizeof...(__arguments)] {
				std::forward<__arguments>(arguments)...
			});
		}
	
	template <typename __type, typename ...__arguments>
		inline std::unique_ptr<__type> make_unique (__arguments &&...arguments) {
			return make_unique_helper<__type>(std::is_array<__type>(),
				std::forward<__arguments>(arguments)...);
		}
}

template <typename T>
struct find_equal : std::binary_function <T, T, bool>
{
	find_equal(const T &value) : value(value) {};

	bool operator()(const T &left, const T &right) const {
		return left == value && right == value;
	}

	private:
		T value;
};

file.erase(std::unique(file.begin(), file.end(), ::find_equal<char>(' ')), file.end());

file.erase(std::unique(file.begin(), file.end(), [](const char &left, const char &right) {
     return left == value && right == value;
}), file.end());

Функция, объявленная как final, не может быть переопределена функцией F::f() — в этом случае, она переопределяет метод базового класса (В) для класса D.