类型

// Loop never end because |unsigned int| would wrap to |UINT_MAX| when counting
// down beyond 0.
for (auto i = v.size(); i >= 0; --i) {
}

class Person {
  //...
 private:
  static constexpr int32_t kUnspecifiedAge = -1;

  std::string name_{};            // Initialized with an empty string.
  int32_t age_{kUnspecifiedAge};  // Initialized with an constant.
};

// Defined in person.cc, prior to C++17.
constexpr int32_t Person::kUnspecifiedAge;

class Person {
 public:
  Person() = default;  // Use default keyword to generate default constructor.
                       // Provide a default constructor is useful for receiving
                       // values from output parameters.
                       //
                       // Example:
                       //   Person p;
                       //   Status s = LoadPerson(db, key, &p);
                       //   CHECK(s.ok()) << "Failed to load. reason=" << s;

  // Although |name_| & |age_| default value is specified during declaration,
  // the member initializer list would override it when using this constructor.
  Person(std::string name, int32_t age) : name_(std::move(name)), age_(age) {
    // Execute constructor body after member initializer list executed.
    CHECK(!name_.empty());  // Cannot use |name| here because it already moved.
    CHECK_GT(age_, 0);
  }

 private:
  static constexpr int32_t kUnspecifiedAge = -1;

  std::string name_{};            // Initialized with an empty string.
  int32_t age_{kUnspecifiedAge};  // Initialized with an constant.
};

// Defined in person.cc, prior to C++17.
constexpr int32_t Person::kUnspecifiedAge;

class Person {
 public:
  Person() = default;

  // !!! THIS IS AN INCORRECT PRACTICE !!!
  Person(std::string name)
      :  // Expecting |name| valid here, but actually not! UNDEFINED BEHAVIOR!
        id_(absl::StrCat(name, "_", GetNextUniqueId())),
        // The next line would be executed before initializing |id_|.
        name_(std::move(name)) {}

 private:
  std::string name_;
  std::string id_;
};

class File {
 public:
  static constexpr int kInvalidFileDescriptor = -1;

  File() = default;
  explicit File(int fd) : fd_(fd) {}

  // Disable Copy
  // ...

  // Close OS managed resource during destruction.
  // Example:
  //   {
  //     File file(::open(filename, O_RDONLY));
  //     PCHECK(file.valid()) << "Failed to open file '" << filename << "'.";
  //     // Read file contents...
  //   }  // Execute ~File() automatically to close the OS managed resource.
  ~File() {
    if (fd_ != kInvalidFileDescriptor) {
      PCHECK(::close(fd_) == 0) << "Failed to close file.";
    }
  }

 private:
  int fd_{kInvalidFileDescriptor};
};

// Defined in file.cc, prior to C++17.
constexpr int File::kInvalidFileDescriptor;

class HttpClient {
 public:
  static absl::StatusOr<HttpClient> Make(HttpClientOptions options) {
    HttpClient client(std::move(options));
    absl::Status s = client.Init();
    if (!s.ok()) {
      return s;
    }

    return client;
  }

 protected:
  // Construct a |HttpClient| instance, must call |Init()| immediately after
  // creation. Use |explicit| keyword to prevent implicit cast.
  explicit HttpClient(HttpClientOptions options)
      : options_(std::move(options)) {}

  absl::Status Init() { return RefreshOauth2Token(); }

  absl::Status RefreshOauth2Token();

 private:
  HttpClientOptions options_{};
};

class ImplicitCastAllowedInt {
 public:
  ImplicitCastAllowedInt(int value);
};

class ImplicitCastDisallowedInt {
 public:
  explicit ImplicitCastDisallowedInt(int value);
};

void PassImplicitCastAllowedInt(ImplicitCastAllowedInt);
void PassImplicitCastDisallowedInt(ImplicitCastDisallowedInt);

PassImplicitCastAllowedInt(1);  // Implicit cast 1 to ImplicitCastAllowedInt(1)
PassImplicitCastDisallowedInt(1);  // Won't compile!

int a;
int b;
b = a; // Copy the value of `a` to `b`, both `a` and `b` have the same value.

Integer c;
Integer d;
d = c; // Copy the reference from `c` to `d`, both `c` and `d` reference the same value.

// We can copy either the value or the reference of a ValueType.
//
// This is a trivial type. The compiler would generate the default constructor,
// default copy constructor & copy assignment operator, default move constructor
// & move assignment operator, default destructor for it. As a result, it's
// copyable & moveable.
//
// Example:
//   ValueType a;
//   ValueType b = a;   // Allowed to copy the value.
//   ValueType& c = a;  // Allowed to reference the value.
struct ValueType {
  int32_t id;
  std::string name;
};

// We cannot copy the value of a RefrenceType instance.
// We can only copy the reference to a ReferenceType instance.
//
// Example:
//   ReferenceType a(2, "mock_name");
//   ReferenceType b = a;   // !!!DISALLOW!!! Won't compile!
//   ReferenceType& b = a;  // Allowed to reference a ReferenceType instance.
class ReferenceType {
 public:
  ReferenceType(int32_t id, std::string name)
      : id_(id), name_(std::move(name)) {}
  // Make the destructor virtual to allow children override it.
  virtual ~ReferenceType() = default;

  // Disallow copy
  ReferenceType(const ReferenceType&) = delete;
  ReferenceType& operator=(const ReferenceType&) = delete;

  // Allow move, move means steal the content of `other` instance.
  // Don't panic. Would talk about move in following chapters.
  ReferenceType(ReferenceType&& other)
      : id_(other.id_), name_(std::move(other.name_)) {
    other.id_ = 0;
  }
  ReferenceType& operator=(ReferenceType&& other) {
    id_ = other.id_;               // Cannot move int, it's a primitive type.
    other.id_ = 0;                 // Copy then clear the field.
    name_ = std::move(other.name_);  // Move std::string
  }
};

int a = 3;                   // Construct value type on the stack.
Integer b = new Integer(5);  // Construct reference type on the heap.

int a = 3;  // Create on stack.

// Always use smart pointers, never use `new` keyword & `delete` keyword.
// Don't panic. Would talk about it in following sections.
// Check following documents for further details:
// * https://en.cppreference.com/w/cpp/memory
// * https://www.stroustrup.com/C++11FAQ.html#std-unique_ptr
auto b =
    std::make_unique<Integer>(5);  // Create on heap & forbid ownership sharing.
auto c =
    std::make_shared<Integer>(7);  // Create on heap & allow ownership sharing.

// Deprecated
typedef int int32_t;

// Suggest
using int32_t = int;

// Template
template <typename T>
using MyArray = std::vector<T>;

using Orange = int;
using Apple = int;

Apple apple(2);
Orange orange = apple;      // Orange should not be able to become an Apple.
Orange x = orange + apple;  // Shouldn't add Oranges and Apples.
if (orange > apple)
  ;  // Shouldn't compare Apples to Oranges.

void foo(Orange);
void foo(Apple);  // Redefinition.

Integer* b = new Integer(5);
// Calculate with raw pointer b
// ...
delete b;  // !!!DO REMEMBER TO DELETE IT!!!

std::vector<std::unique_ptr<LinkedNode>> nodes;
LinkedNode* head;

auto c = std::make_unique<LinkedNode>("c", /* next */ nullptr);
auto b = std::make_unique<LinkedNode>("b", /* next */ c.get());
auto a = std::make_unique<LinkedNode>("a", /* next */ b.get());
c->set_next(a.get());

head = a.get();

nodes.emplace_back(std::move(c));
nodes.emplace_back(std::move(b));
nodes.emplace_back(std::move(a));

void NotifyUnhealthy();

class MyServiceImpl : public Service {
 public:
  Status Start() override;
  Status Stop() override;

  bool healthy() const override;
  absl::Time last_known_healthy_time() const override;
};

class MyServiceWatchdogServiceImpl : public Service {
 public:
  explicit MyServiceWatchdogServiceImpl(
      std::weak_ptr<MyServiceImpl> weak_my_service)
      : weak_my_service_(std::move(weak_my_service)) {}

  Status Start() override;
  Status Stop() override;

 private:
  void BackgroundTaskEntryPoint();

  std::unique_ptr<std::thread> background_thread_;
  absl::Notification stopping_notification_;

  std::weak_ptr<MyServiceImpl> weak_my_service_;
};

void MyServiceWatchdogServiceImpl::BackgroundTaskEntryPoint() {
  absl::optional<absl::Time> previous_known_healthy_time;
  while (
      !stopping_notification_.WaitForNotificationWithTimeout(kLoopInterval)) {
    std::shared_ptr<MyServiceImpl> shared_my_service = weak_my_service_.lock();
    if (!shared_my_service) {
      // The instance of my_service was destroyed.
      NotifyUnhealthy();
      break;
    }

    if (shared_my_service->healthy()) {
      if (previous_known_healthy_time.has_value() &&
          (shared_my_service->last_known_healthy_time() -
               previous_known_healthy_time.value() >
           kHealthyCheckFailureDuration)) {
        // Healthy state not updated for a while, regard it unhealthy.
        NotifyUnhealthy();
        break;
      }

      previous_known_healthy_time =
          shared_my_service->last_known_healthy_time();
    }
  }
}

final AtomicLong a = new AtomicLong(3);

AtomicLong* const a = new AtomicLong(3);  // Equal to the Java example,
                                          // The const is against the pointer.

const AtomicLong* b =
    new AtomicLong(5);  // Disallow to modify the internal value of b,
                        // but allow to assign b to a new pointer.
                        // The const is against AtomicLong type.

// Just for example
class AtomicLong {
 public:
  int64_t value() const;          // This is a read-only method, visible for an
                                  // AtomicLong const type.
  void set_value(int64_t value);  // This is not a read-only method, invisible
                                  // for an AtomicLong const type.

 private:
  int64_t value_;
};

constexpr int32_t kTwo = 2;
const int32_t kTwo2 = 2;

enum : int32_t {  // or any other necessary integral type.
  kTwo3 = 2,
};

// Only take the following pattern as a last resort.
#define YOUR_PROJECT_PREFIX_TWO 2

// !!! DON'T DO THIS !!!
constexpr std::string kHelloWorldMessage1 = "Hello World!";

// Do it this way.
constexpr char kHelloWorldMessage2[] = "Hello World!";

// In case you really need std::string or some complex types.
// constants.h
const std::string& GetHelloWorldMessage3();
// constants.cc
const std::string& GetHelloWorldMessage3() {
  static const std::string kHelloWorldMessage3 = "Hello World!";
  return kHelloWorldMessage3;
}

// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
//
// Description:
//   Expands to the equivalent of an inline constexpr instance of the specified
//   `type` and `name`, initialized to the value `init`. If the compiler being
//   used is detected as supporting actual inline variables as a language
//   feature, then the macro expands to an actual inline variable definition.
//
// Requires:
//   `type` is a type that is usable in an extern variable declaration.
//
// Requires: `name` is a valid identifier
//
// Requires:
//   `init` is an expression that can be used in the following definition:
//     constexpr type name = init;
//
// Usage:
//
//   // Equivalent to: `inline constexpr size_t variant_npos = -1;`
//   ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
//
// Differences in implementation:
//   For a direct, language-level inline variable, decltype(name) will be the
//   type that was specified along with const qualification, whereas for
//   emulated inline variables, decltype(name) may be different (in practice
//   it will likely be a reference type).

// Use implicit_cast as a safe version of static_cast or const_cast
// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
// a const pointer to Foo).
// When you use implicit_cast, the compiler checks that the cast is safe.
// Such explicit implicit_casts are necessary in surprisingly many
// situations where C++ demands an exact type match instead of an
// argument type convertible to a target type.
//
// The From type can be inferred, so the preferred syntax for using
// implicit_cast is the same as for static_cast etc.:
//
//   implicit_cast<ToType>(expr)
//
// implicit_cast would have been part of the C++ standard library,
// but the proposal was submitted too late.  It will probably make
// its way into the language in the future.
template<typename To, typename From>
inline To implicit_cast(From const &f) {
  return f;
}

// When you upcast (that is, cast a pointer from type Foo to type
// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
// always succeed.  When you downcast (that is, cast a pointer from
// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
// how do you know the pointer is really of type SubclassOfFoo?  It
// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
// when you downcast, you should use this macro.  In debug mode, we
// use dynamic_cast<> to double-check the downcast is legal (we die
// if it's not).  In normal mode, we do the efficient static_cast<>
// instead.  Thus, it's important to test in debug mode to make sure
// the cast is legal!
//    This is the only place in the code we should use dynamic_cast<>.
// In particular, you SHOULDN'T be using dynamic_cast<> in order to
// do RTTI (eg code like this:
//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
// You should design the code some other way not to need this.

template<typename To, typename From>     // use like this: down_cast<T*>(foo);
inline To down_cast(From* f) {           // so we only accept pointers
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  if (false) {
    implicit_cast<From*, To>(0);
  }

#if !defined(NDEBUG) && YOUR_PROJECT_ENABLED_RTTI
  assert(f == nullptr || dynamic_cast<To>(f) != nullptr);  // RTTI: debug mode only!
#endif
  return static_cast<To>(f);
}

template<typename To, typename From>    // use like this: down_cast<T&>(foo);
inline To down_cast(From& f) {
  typedef typename std::remove_reference<To>::type* ToAsPointer;
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  if (false) {
    implicit_cast<From*, ToAsPointer>(0);
  }

#if !defined(NDEBUG) && YOUR_PROJECT_ENABLED_RTTI
  // RTTI: debug mode only!
  assert(dynamic_cast<ToAsPointer>(&f) != nullptr);
#endif
  return *static_cast<ToAsPointer>(&f);
}

// bit_cast<Dest,Source> is a template function that implements the equivalent
// of "*reinterpret_cast<Dest*>(&source)".  We need this in very low-level
// functions like the protobuf library and fast math support.
//
//   float f = 3.14159265358979;
//   int i = bit_cast<int32_t>(f);
//   // i = 0x40490fdb
//
// The classical address-casting method is:
//
//   // WRONG
//   float f = 3.14159265358979;            // WRONG
//   int i = *reinterpret_cast<int*>(&f);   // WRONG
//
// The address-casting method actually produces undefined behavior according to
// the ISO C++98 specification, section 3.10 ("basic.lval"), paragraph 15.
// (This did not substantially change in C++11.)  Roughly, this section says: if
// an object in memory has one type, and a program accesses it with a different
// type, then the result is undefined behavior for most values of "different
// type".
//
// This is true for any cast syntax, either *(int*)&f or
// *reinterpret_cast<int*>(&f).  And it is particularly true for conversions
// between integral lvalues and floating-point lvalues.
//
// The purpose of this paragraph is to allow optimizing compilers to assume that
// expressions with different types refer to different memory.  Compilers are
// known to take advantage of this.  So a non-conforming program quietly
// produces wildly incorrect output.
//
// The problem is not the use of reinterpret_cast.  The problem is type punning:
// holding an object in memory of one type and reading its bits back using a
// different type.
//
// The C++ standard is more subtle and complex than this, but that is the basic
// idea.
//
// Anyways ...
//
// bit_cast<> calls memcpy() which is blessed by the standard, especially by the
// example in section 3.9 .  Also, of course, bit_cast<> wraps up the nasty
// logic in one place.
//
// Fortunately memcpy() is very fast.  In optimized mode, compilers replace
// calls to memcpy() with inline object code when the size argument is a
// compile-time constant.  On a 32-bit system, memcpy(d,s,4) compiles to one
// load and one store, and memcpy(d,s,8) compiles to two loads and two stores.
template <class Dest, class Source>
inline Dest bit_cast(const Source& source) {
  static_assert(sizeof(Dest) == sizeof(Source),
                "bit_cast requires source and destination to be the same size");
  static_assert(base::is_trivially_copyable<Dest>::value,
                "bit_cast requires the destination type to be copyable");
  static_assert(base::is_trivially_copyable<Source>::value,
                "bit_cast requires the source type to be copyable");

  Dest dest;
  memcpy(&dest, &source, sizeof(dest));
  return dest;
}

std::unique_ptr<Animal> MakeAnimal();

std::shared_ptr<Animal> animal = MakeAnimal();

std::unique_ptr<Animal> uniq_animal = MakeAnimal();
std::shared_ptr<Animal> shared_animal = std::move(uniq_animal);

std::shared_ptr<Animal> animal_dog = MakeDog();
std::shared_ptr<Dog> dog = std::static_pointer_cast<Dog>(animal_dog);

double d = 7.9;
int i = d;    // bad: narrowing: i becomes 7
i = (int) d;  // bad: we're going to claim this is still not explicit enough

class IntType {
 public:
  explicit IntType(int v);
  // ...
};

double d = 7.9;
IntType i1(d);  // bad: narrowing
IntType i2{d};  // Won't compile!
int i = d;      // bad: narrowing
int i{d};       // Won't compile!

double d = 7.9;

// If you included GSL in your project
// https://github.com/microsoft/GSL
int i = gsl::narrow_cast<int>(d);

// Make your version of narrow_cast
// narrow_cast(): a searchable way to do narrowing casts of values
template <class T, class U>
constexpr T narrow_cast(U&& u) noexcept {
  return static_cast<T>(std::forward<U>(u));
}

// static_cast if neither include GSL nor make your version of narrow_cast
int i2 = static_cast<int>(d);

public <T> java.util.List<T> fromArrayToList(T[] a) {
    return java.util.Arrays.stream(a).collect(java.util.stream.Collectors.toList());
}

template <typename T>
std::vector<T> fromArrayToList(const T* arr, int64_t size) {
  return std::vector<T>(arr, arr + size);
}

public interface List<E> {
    void add(E x);
    Iterator<E> iterator();
}

template <typename T>
class List {
 public:
  virtual ~List() = default;

  virtual void Add(T element) = 0;
  template <typename Iterator>
  Iterator iterator() const;  // Placeholder; real Iterator type omitted.
};

// vector.h
template <typename T>
class FixedArray {
 public:
  // omitted: constructor, destructor, copy/move, etc.

  void resize(int32_t new_size);

 private:
  std::unique_ptr<T[]> data_;
  int32_t size_;
};

#include "vector.inc"  // NOLINT

// vector.inc
template <typename T>
void FixedArray<T>::resize(int32_t new_size) {
  // ...
}

public <T extends Number> List<T> fromArrayToList(T[] a) {
    ...
}

template <typename T>
std::vector<T> fromArrayToList(const T* arr, int64_t size) {
  static_assert(std::is_integral<T>::value, "|T| must be an integral type.");
  return std::vector<T>(arr, arr + size);
}

// If the |cond| satisfied, the |std::enable_if<cond>::type| is a |void|, else
// invalid to evaluate it. So |typename std::enable_if<cond>::type*| is either
// |void*| or invalid.
//
// |template <void* ignored = nullptr>| is another usage of C++ template. We
// won't introduce it in this article. Just use it as an idiom here.
template <typename T,
          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
std::vector<T> fromArrayToList(const T* arr, int64_t size) {
  return std::vector<T>(arr, arr + size);
}

// Another useful idiom is |absl::void_t<decltype(...your complex
// condition...)>|
//
// template <typename Container, typename Element, typename = void>
// struct HasFindWithNpos : std::false_type {};
//
// template <typename Container, typename Element>
// struct HasFindWithNpos<
//     Container, Element,
//     absl::void_t<decltype(std::declval<const Container&>().find(
//                               std::declval<const Element&>()) !=
//                           Container::npos)>> : std::true_type {};

// 基本的 old-style 与 scoped-enum 对比示例
// Deprecated style.
enum Fruit {
  FRUIT_UNSPECIFIED = 0,
  FRUIT_APPLE = 1,
};

// |FRUIT_UNSPECIFIED| is visible.

// Suggested style. The only difference is |class| keyword.
enum class FruitNew {
  kUnspecified = 0,
  kApple = 1,
};

// |kUnspecified| is invisible. You need to reference it as
// |FruitNew::kUnspecified|.

enum FruitChar : char { /* omitted */ };

enum Animal64 : int64_t { /* omitted */ };

class HeaderOnlyClass {
  enum { kDefaultAnswer = 42 };

 public:
  // ...

 private:
  int answer_{kDefaultAnswer};
};

union UnionStorage {
  int32_t n;      // occupies 4 bytes
  uint16_t s[2];  // occupies 4 bytes
  uint8_t c;      // occupies 1 byte
};  // the whole union occupies 4 bytes

enum class UnionStorageDataType {
  kUnspecified = 0,
  kInt32 = 1,
  kUint16Array = 2,
  kUint8 = 3,
};

struct UnionStorage {
  UnionStorageDataType data_type;
  union {
    int32_t n;
    uint16_t s[2];
    uint8_t c;
  } data;
};

using UnionStorage =
    absl::variant<absl::monostate /* for empty case */, uint64_t, std::string,
                  double, std::vector<MyClass>>;

UnionStorage s{3.14};
double* d = absl::get_if<double>(&s);

absl::optional<Pie> MakePie() {
  bool failed = /* ... */;
  if (failed) {
    return absl::nullopt;
  }

  return Pie();
}

Consumer<String> c = s -> System.out.println(s);
Predicate<String> p = s -> s.isEmpty();
// Function, BiFunction, ...

std::function<void(absl::string_view)> c = [](absl::string_view s) {
  LOG(INFO) << s;
};
std::function<bool(absl::string_view)> p = [](absl::string_view s) {
  return s.empty();
};

std::function<Status(int64_t /* id */, absl::string_view /* name */, Gender)>
    f = [](int64_t id, absl::string_view name, Gender gender) {
      // ...
    };

MoveOnlyInt v(1);
auto lambda = [v = std::move(v)]() { LOG(INFO) << v.value(); };
std::function<void()> f = [lambda = std::make_shared<decltype(lambda)>(
                               std::move(lambda))]() { lambda(); };