小编Bri*_*ian的帖子

当有人说"X服务器在/ dev/tty7上运行"时,我有几个问题.我对它是如何工作做了一些猜测,我希望有人可以告诉我以下陈述是真是假.

• / dev/tty7通常是Xorg的控制终端.
• 尽管tty7是Xorg的控制终端,但它并没有以任何有意义的方式"控制"Xorg.
• Xorg通过轮询/ dev/input/...或类似的东西直接接收键盘和鼠标输入,而不是通过从/ dev/tty7读取.尽管如此,/ dev/tty7还会接收击键,您可以通过在终端仿真器中运行"xxd -p/dev/tty7"来查看(例如).
• Xorg使用一些特定于硬件的接口在屏幕上绘图,例如驱动程序创建的某个设备文件,或内存的I/O映射区域,而不是写入/ dev/tty7.
• 当Xorg设置视频模式时,tty驱动程序会自动停止在屏幕上绘图.这就是为什么当你按一个键或将一个字符串回显到/ dev/tty7时,你看不到它出现在屏幕上.
• 即使tty7在后台,Xorg也会通过/ dev/events接收键盘和鼠标输入,但除非tty7在前台,否则它会忽略它.
• 无论Xorg在屏幕上绘制什么,只有当tty7在前景时才会在显示器上显示.
• 当Xorg初始化视频(设置视频模式等)时,这是因为tty7在前台,设置在tty7而不是其他终端上生效.

谢谢!

参见,例如, http ://en.cppreference.com/w/cpp/container/map/erase

在C++ 03中有三个重载:

void erase( iterator pos );
void erase( iterator first, iterator last );
size_type erase( const key_type& key );

在C++ 11中,第一和第二过载改变为采取const_iterator,使得它们可与任一被调用iterator或const_iterator.第一次重载也通过在删除之后将迭代器返回到元素来改进:

iterator erase( const_iterator pos );
void erase( const_iterator first, const_iterator last );
size_type erase( const key_type& key );

在C++ 17中,重新引入了非const重载:

iterator erase( const_iterator pos );
iterator erase( iterator pos );
void erase( const_iterator first, const_iterator last );
size_type erase( const key_type& key );

为什么需要这个？它不加入为不等erase,也不是为insert …

考虑以下示例：

struct Parent
{
    Parent ();

    Parent (const Parent &);
};

struct Child : public Parent
{
    using Parent::Parent;
};

Parent p;

Child c (p);

这是从以下问题中得出的：为什么“继承的构造函数不是从相同或派生类型的表达式初始化的候选对象”？

最初的问题是关于C ++ 11的。在C ++ 11中，有一些措辞阻止Child获取采用以下内容的构造函数const Parent&：

对于继承的构造函数候选集中的每个非模板构造函数，除了没有参数的构造函数或具有单个参数的复制/移动构造函数之外，除非具有用户声明的构造函数，否则该构造函数将隐式声明为具有相同的构造函数特性类中出现使用声明的相同签名。

N4429极大地改变了继承构造函数的规范，并被认为可追溯到C ++ 11（我认为？）。N4429的目的是使基类构造函数看起来像是派生类构造函数一样可见，而不是声明委派给基类构造函数的派生类构造函数。在N4429的第一个版本中，有以下措词，保留了C ++ 11的限制：

当using声明声明类从基类继承构造函数时，基类的默认构造函数，复制构造函数和move构造函数（如果有）将从引入的声明集中排除。

但是，在本文的更新版本P0136R0中，该措辞不再存在，并且没有给出原因的解释。该文件再次进行了修订，然后被合并为标准。因此，在C ++ 17中，我看不到任何阻止上述代码编译的规则。

尽管如此，GCC和Clang都拒绝了它。lang声：

继承的构造方法不是从相同或派生类型的表达式初始化的候选对象

但是，我无法在标准中找到类似这样的内容。

这段代码在C ++ 17中格式错误吗？如果是这样，为什么？

From:重载char*和std :: string是否安全？

#include <string>
#include <iostream>
void foo(std::string str) {
  std::cout << "std::string\n";
}

void foo(char* str) {
  std::cout << "char*\n";
}

int main(int argc, char *argv[]) {
  foo("Hello");
}

上面的代码在编译时打印"char*" g++-4.9.0 -ansi -pedantic -std=c++11.

我觉得这是不正确的,因为字符串文字的类型是" n的 数组const char",并且不应该const char*用它初始化非,因此std::string应该选择重载.gcc是否违反了标准？

问题:是否有可能通过将其参数传递给内部constexpr函数(可能带有某种"完美转发")来评估函数内部的常量表达式？例:

constexpr size_t foo(char const* string_literal) {
    return /*some valid recursive black magic*/;
}

void bar(char const* string_literal) {
    // works fine
    constexpr auto a = foo("Definitely string literal.");
    // compile error: "string_literal" is not a constant expression
    constexpr auto b = foo(string_literal);
}

template<typename T>
void baz(T&& string_literal) {
    // doesn't compile as well with the same error
    constexpr auto b = foo(std::forward<T>(string_literal));
}

int main() {
    // gonna do this, wont compile due to errors mentioned above
    bar("Definitely …

W3C验证器说:"此时元素输入不允许属性大小."

<input type="file" name="foo" size="40" />

在HTML5中指定文件输入宽度的正确方法是什么？

派生类可以在其ctor-initializer中调用受保护的基类构造函数,但仅适用于其自己的基类子对象,而不是其他地方:

class Base {
  protected:
    Base() {}
};

class Derived : Base {
  Base b;
  public:
    Derived(): Base(),    // OK
               b() {      // error
        Base b2;          // error
    }
};

标准对此有何看法？这是[class.protected]/1:

当非静态数据成员或非静态成员函数是其命名类的受保护成员时,将应用超出第11章中所述之外的其他访问检查(11.2)如前所述,授予对受保护成员的访问权限,因为引用发生在朋友或某个类的成员中C.如果访问要形成指向成员的指针(5.3.1),则嵌套名称说明符应表示C或派生自的类C.所有其他访问都涉及(可能是隐式的)对象表达式(5.2.5).在这种情况下,对象表达式C的类应该是派生自的类C.[ 例子: ......

调用构造函数时是否涉及对象表达式？没有,有吗？那么标准中的哪个位置描述了受保护的基类构造函数的访问控制？

[expr.const]/2的注释 2意味着如果我们有一个变量o：

\n

the full-expression of its initialization is a constant expression when interpreted as a constant-expression, except that if o is an object, that full-expression may also invoke constexpr constructors for o and its subobjects even if those objects are of non-literal class types

\n

then:

\n

Within this evaluation, std\xe2\x80\x8b::\xe2\x80\x8bis_\xc2\xadconstant_\xc2\xadevaluated() [...] returns true.

\n

Consider:

#include <type_traits>\nint main() {\n    int x = std::is_constant_evaluated();\n    return x;\n}\n

This program …

假设一个非泛型 lambda 出现在模板化实体中，如下面的代码所示：

template <class T, auto F = [](T x) { *x; }>
void foo(T t) {}

void foo(...) {}

int main() {
    foo(42);
}

[expr.prim.lambda.closure]/2与此处相关：

闭包类型在包含相应lambda 表达式的最小块作用域、类作用域或命名空间作用域中声明。[...]

因此，在替换 into 期间foo<int>，在全局范围内声明了 lambda 闭包类型，并且其函数调用运算符不是模板。该 lambda 闭包类型是一个模板化实体 ( [temp.pre]/8.5 )，因此它的函数调用运算符 ([temp.pre]/8.3) 也是如此。但后者既不是函数模板专业化，也不是类模板专业化的成员，对于后者，将发生隐式实例化，如[temp.inst]/5中所述。

最直接的解读就是上面代码中的lambda函数调用操作符并不受按需实例化的影响；它只是与闭包类型同时定义。这似乎与 GCC 拒绝上述代码的情况一致。另一种可能的解释是，它的目的是像函数模板专门化一样根据需要进行实例化，并且措辞上存在疏忽；这将使上面的代码格式良好，可以被foo<int>调用。Clang 似乎不同意这两种解释。它调用foo(...)，就好像另一个重载在直接上下文中发生替换失败一样（这对我来说似乎是错误的；lambda 表达式不在直接上下文中）。

根据C ++ 17标准[temp.point] / 4，重点是

对于类模板专业化，类成员模板专业化或对类模板的类成员的专业化，如果该专业化是隐式实例化的，因为该专业化是从另一个模板专业化内部引用的，则如果引用该专业化的上下文取决于在模板参数上，并且如果未在封闭模板的实例化之前实例化专门化，则实例化点紧接在封闭模板的实例化点之前。否则，此类专门化的实例化点紧接在引用该专门化的名称空间范围声明或定义之前。

我不懂如何解释这句话。在其他地方，当描述模板中的名称查找时，该标准指的是“实例上下文”和“定义上下文”。此处，“上下文”一词似乎表示源文本中的特定点，它决定了可见名称的集合。在这里，我不确定“上下文”的含义是否相同。如果那是什么意思，我不确定依赖模板参数对它意味着什么。这是否意味着它在模板内部，还是具体意味着在编译器决定实例化所讨论的专业化时，封闭模板中仍然存在一些未绑定的模板参数？

例子将不胜感激。