小编myo*_*dpa的帖子

android中fontFamily和typeFace有什么区别？当然,我阅读了android开发者网站上的所有描述,但我还不清楚.

根据两个词的一般含义,它应该是相同的含义.但是在android xml属性(textview ...)中,它有两个属性.这让我非常困惑.

据我所知.... fontFamily和typeFace是一组相同的字体.(Roboto,Arial)字体是fontFamily的特定字体.(Roboto-18pt-Bold,Arial-10pt-Italic)

我错过了什么？

我正在阅读 C++ concurrency in action 2。它为无锁堆栈引入了拆分引用计数。

一种可能的技术涉及对每个节点使用不是一个而是两个引用计数：内部计数和外部计数。这些值的总和就是对节点的引用总数。外部计数与指向节点的指针一起保存，每次读取指针时都会增加。当阅读器完成节点时，它会减少内部计数。读取指针的简单操作将在完成时使外部计数增加一，内部计数减一。

上面的短语解释了拆分引用计数的简要概念。听起来外部计数总是增加而内部计数总是减少。

当不再需要外部计数/指针配对时（节点不再能从多个线程可访问的位置访问），内部计数增加外部计数值减一，并丢弃外部计数器。一旦内部计数等于零，就没有对节点的未完成引用，可以安全地删除它。使用原子操作更新共享数据仍然很重要。现在让我们看看一个无锁堆栈的实现，它使用这种技术来确保只有在安全的情况下才回收节点。

但是在上面的短语中，当节点不再可访问时，内部计数应该增加外部计数的值减一。我对这个解释感到非常困惑。

(1) 使用内部和外部计数的确切目的是什么？

(2) 为什么它需要两个引用计数而不是一个？

编辑：我从书中添加了下面的示例代码。

template <typename T>
class lock_free_stack {
 private:
  struct node;
  struct counted_node_ptr {
    int external_count;
    node* ptr;
  };
  struct node {
    std::shared_ptr<T> data;
    std::atomic<int> internal_count;
    counted_node_ptr next;
    node(T const& data_)
        : data(std::make_shared<T>(data_)), internal_count(0) {}
  };
  std::atomic<counted_node_ptr> head;

  void increase_head_count(counted_node_ptr& old_counter) {
    counted_node_ptr new_counter;
    do {
      new_counter = old_counter;
      ++new_counter.external_count;
    } while (!head.compare_exchange_strong(old_counter, new_counter,
                                           std::memory_order_acquire,
                                           std::memory_order_relaxed));
    old_counter.external_count = new_counter.external_count;
  }

 public:
  ~lock_free_stack() {
    while (pop())
      ;
  } …

为什么不std::hash<const std::string>专门研究std？

它会导致编译错误，例如

std::unordered_map<const std::string, int> m;
m.insert(std::make_pair("Foo", 1)); //error
m["Bar"] = 2; // also error

这有什么原因吗？

std::deque 是否是连续的内存容器？

Scott Meyers 的著名著作《Effective STL》如下所述

连续内存容器（也称为基于数组的容器）将其元素存储在一个或多个（动态分配的）内存块中，每个块保存多个容器元素。如果插入新元素或删除现有元素，同一内存块中的其他元素必须向上或向下移动，以便为新元素腾出空间或填充以前被擦除元素占用的空间。这种移动会影响性能（参见第 5 条和第 14 条）和异常安全（我们很快就会看到）。标准的连续内存容器是向量、字符串和双端队列。非标准绳索也是连续内存容器。

但你可以在 cppreference.com 找到相反的解释

与 std::vector 不同，双端队列的元素不是连续存储的：典型的实现使用一系列单独分配的固定大小数组，并进行额外的簿记，这意味着与向量相比，对双端队列的索引访问必须执行两次指针取消引用索引访问仅执行一项。

哪一个是真的？

我正在阅读高效的 Android 线程，其中说

最好使用静态内部类，而不是使用带有外部类引用的嵌套类，因为它们仅引用全局类对象而不引用实例对象。这只是减轻了泄漏，因为在线程执行时，静态内部类对其他实例对象的所有显式引用仍然有效。

但我不清楚为什么它会减轻泄漏。如果静态内部类对其他实例对象的所有显式引用都处于活动状态，那么这不是与上述解释相反的内存泄漏原因吗？

我已经知道自动移动不会与从右值参考输入返回值的函数一起唤醒。但为什么？

下面是自动移动不起作用的示例代码。

Widget makeWidget(Widget&& w) {
  ....
  return w; // Compiler copies w. not move it.
}

如果函数输入来自按值复制，则自动移动有效。

Widget makeWidget(Widget w) {
  ....
  return w; // Compiler moves w. not copy it.
}

我能明白是什么is_constructible_v<std::string, std::string&&>。但什么is_constructible_v<std::string&&, std::string&&>意思呢？

is_constructible_v<std::string, std::string&&>和 和有什么区别is_constructible_v<std::string&&, std::string&&>？

我认为这is_constructible_v<std::string&&, std::string&&>意味着从右值构造右值。但我不清楚是什么constructing rvalue意思。如果 T 是可构造的，那么它的构造函数总是可以用作右值。这就是构建右值的意义吗？