chrome中的C++11新特性

Chromium中的C++11新特性

• 1. auto
• 2. decltype
• 3. trailing return type
• 4. default
• 5. delete
• 6. final
• 7. override
• 8. rvalue references
• 9. move constructors and move assignment operators
• 10. scoped enums
• 11. constexpr
• 12. list initialization
• 13. delegating constructors
• 14. inherited constructors
• 15. nullptr
• 16. type aliases
• 17. variadic templates
• 18. lambda expressions
• 19. noexcept specifier and noexcept operator
• 20. alignof and alignas
• 21. std::unique_ptr
• 22. range-for (based on a Boost library)
• 23. static_assert (based on a Boost library)
• 24. explicit
• 25. std::atomic
• 26. std::call_once
• 27. std::condition_variable
  参考文献

auto

// src\cc\trees\layer_tree_host_impl.cc
bool LayerTreeHostImpl::IsCurrentlyScrollingViewport() const {
   
  auto* node = CurrentlyScrollingNode();
  if (!node)
    return false;
  if (!viewport()->MainScrollLayer())
    return false;
  return node->id == viewport()->MainScrollLayer()->scroll_tree_index();
}

// src\cc\trees\layer_tree_host_impl_unittest.cc
static void ExpectClearedScrollDeltasRecursive(LayerImpl* root) {
   
  for (auto* layer : *root->layer_tree_impl())
    ASSERT_EQ(ScrollDelta(layer), gfx::Vector2d());
}

decltype

// src\base\bind_internal.h
template <typename T>
decltype(auto) Unwrap(T&& o) {
   
  return Unwrapper<T>::Unwrap(std::forward<T>(o));
}

trailing return type

// src\base\trace_event\memory_usage_estimator.h
template <class T>
auto EstimateMemoryUsage(const T& object)
    -> decltype(object.EstimateMemoryUsage());

default

// src\base\callback.h
template <typename R, typename... Args>
class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
   
 public:
  using RunType = R(Args...);
  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
                                  internal::PassingTraitsType<Args>...);

  constexpr RepeatingCallback() = default;

  explicit RepeatingCallback(internal::BindStateBase* bind_state)
      : internal::CallbackBaseCopyable(bind_state) {
   }

  // Copyable and movable.
  RepeatingCallback(const RepeatingCallback&) = default;
  RepeatingCallback& operator=(const RepeatingCallback&) = default;
  RepeatingCallback(RepeatingCallback&&) noexcept = default;
  RepeatingCallback& operator=(RepeatingCallback&&) noexcept = default;

  bool Equals(const RepeatingCallback& other) const {
   
    return EqualsInternal(other);
  }

  R Run(Args... args) const & {
   
    PolymorphicInvoke f =
        reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke());
    return f(this->bind_state_.get(), std::forward<Args>(args)...);
  }

  R Run(Args... args) && {
   
    // Move the callback instance into a local variable before the invocation,
    // that ensures the internal state is cleared after the invocation.
    // It's not safe to touch |this| after the invocation, since running the
    // bound function may destroy |this|.
    RepeatingCallback cb = std::move(*this);
    PolymorphicInvoke f =
        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
  }
};

delete

// src\base\callback.h
template <typename R, typename... Args>
class OnceCallback<R(Args...)> : public internal::CallbackBase {
   
 public:
  using RunType = R(Args...);
  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
                                  internal::PassingTraitsType<Args>...);

  constexpr OnceCallback() = default;

  explicit OnceCallback(internal::BindStateBase* bind_state)
      : internal::CallbackBase(bind_state) {
   }

  OnceCallback(const OnceCallback&) = delete;
  OnceCallback& operator=(const OnceCallback&) = delete;

  OnceCallback(OnceCallback&&) noexcept = default;
  OnceCallback& operator=(OnceCallback&&) noexcept = default;

  OnceCallback(RepeatingCallback<RunType> other)
      : internal::CallbackBase(std::move(other)) {
   }

  OnceCallback& operator=(RepeatingCallback<RunType> other) {
   
    static_cast<internal::CallbackBase&>(*this) = std::move(other);
    return *this;
  }