我一直在尝试理解C++ 中的存储重用。想象一下，我们有一个a带有重要析构函数的对象，其存储通过放置 new 表达式重用：
struct A {
~A() { std::cout << "~A()" << std::endl; }
};
struct B: A {};
A* a = new A; // lifetime of *a begins
A* b = new(a) B; // storage reuse, lifetime of *b begins
如果一个对象的生命周期结束后，在该对象占用的存储空间被重用或释放之前，在原对象占用的存储位置上创建一个新的对象，一个指向原对象的指针，一个指向该对象的引用引用原始对象，或者原始对象的名称将自动引用新对象，并且一旦新对象的生命周期开始，如果原始对象是透明可替换的（请参阅如下）由新对象。
由于在我的示例中，当我们重用它占用的存储空间时，它的生命周期*a尚未结束，因此我们无法应用该规则。那么什么规则描述了我的案例中的行为呢？
我在Windows上使用Paramiko来访问远程SFTP服务器.我需要在远程路径上做一些工作,比如os.path.join,os.path.commonprefix等等.由于我的主机平台是Windows,所有路径操作都带有\分隔符,但我需要POSIX风格的路径.
有没有办法在Windows上使用Python内置的POSIX路径操作？
如何在Python中使用实现继承，即实现继承的基类的public属性x和protected属性_x变成__x派生类的私有属性？
换句话说，在派生类中：
x或受保护属性_x应该像往常一样分别查找x或_x分别，除了它应该跳过实现继承的基类；__x应该__x像往常一样查找，除了它应该查找x而_x不是__x实现继承的基类。在 C++ 中，实现继承是通过private在派生类的基类声明中使用访问说明符来实现的，而更常见的接口继承是通过使用public访问说明符来实现的：
class A: public B, private C, private D, public E { /* class body */ };
例如，需要实现继承来实现依赖于类继承的类适配器设计模式（不要与依赖于对象组合的对象适配器设计模式混淆）并包括将类的接口转换为类的接口。通过使用继承抽象类的接口和类的实现的类来创建抽象类（参见Erich Gamma等人的设计模式一书）：AdapteeTargetAdapterTargetAdaptee …
我知道临时对象的生命周期在创建它的完整表达式处或之前结束，除非它绑定到引用，在这种情况下，它的生命周期将扩展到引用的生命周期，这给了我们一个下限临时对象的存储持续时间结束。
Python 库生成的 HTTP 请求消息中的HTTP/1.1 强制 Host 头字段在requests哪里？
import requests
response = requests.get("https://www.google.com/")
print(response.request.headers)
输出这个：
{'User-Agent': 'python-requests/2.22.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}
这篇文章是关于术语“浅拷贝”和“深拷贝”的正确用法，特别是在谈论复制不包含任何引用的对象时。这个问题并不意味着（也不应该）基于意见，除非确实就这个话题没有达成共识。我已将这个问题标记为 C，但它可能与语言无关，除非这些术语在该上下文中的含义对于特定语言有明确定义，但对于其他语言没有明确定义。
术语“浅拷贝”和“深拷贝”在复制带有引用的对象时常用，以指定副本是否完整（独立于原始对象）。
但是，我也看到在没有引用的情况下复制对象时使用的这个术语，这两个术语的意思完全相同，不需要区分。到目前为止，我还没有找到一个简明的定义来涵盖这些术语的这种特殊用法。
Stack Overflow 上给出的定义（在标签浅拷贝和深拷贝中）：
浅拷贝包含指向原始变量的链接（内存中的地址）。浅拷贝的变化反映在原始对象上。
深拷贝复制指向的对象或变量，以便目标（被分配的对象）接收其自己的本地副本。
在这些定义下，没有引用的对象副本将是深度副本。
维基百科上给出的定义（在文章对象复制中）：
复制对象的一种方法是浅拷贝。在这种情况下，会创建一个新对象 B，并将 A 的字段值复制到 B。这也称为逐字段复制、逐字段复制或字段复制。如果字段值是对对象的引用（例如，内存地址），则它复制该引用，因此引用与 A 相同的对象，如果字段值是原始类型，则它复制原始类型的值。在没有原始类型的语言（其中一切都是对象）中，副本 B 的所有字段都是对与原始 A 的字段相同的对象的引用。因此被引用的对象是共享的，因此如果这些对象之一被修改（从 A或 B)，变化在另一个中是可见的。浅拷贝很简单而且通常很便宜，因为它们通常可以通过简单地精确复制位来实现。
另一种方法是深拷贝，这意味着字段被取消引用：不是对正在复制的对象的引用，而是为任何被引用的对象创建新的副本对象，并将对这些对象的引用放置在 B 中。结果与浅拷贝给出的结果不同因为副本 B 引用的对象与 A 引用的对象不同，并且是独立的。由于需要创建额外的对象，深拷贝更昂贵，并且由于引用可能形成复杂的图，因此可能更加复杂。
在这些定义下，没有引用的对象副本将是浅拷贝。
我认为这两个术语都不合适，因为“浅拷贝”意味着复制不完整，而“深拷贝”意味着复制需要某种特殊处理（或高成本）。由于复制一个没有引用的对象既完整又不需要任何特殊处理，我认为这两个术语都不应该使用。然而，这篇文章不是关于我的想法，而是编程社区当前的共识（如果有的话）。
当我复制一个没有引用的对象时，是否会被考虑
部分深拷贝是否有一个好的术语，其中一些字段是浅拷贝而其他字段是深拷贝？
我试图理解RFC 7230中提到的TCP 重置问题： HTTP/1.1 Message Syntax and Routing , \xc2\xa7 6.6：
\n\n\n6.6. 拆除
\n连接头字段（第 6.1 节）提供了一个“关闭”连接选项，当发送方希望在当前请求/响应对之后关闭连接时，应发送该选项。
\n
因此 HTTP/1.1 具有持久连接，这意味着可以在同一个连接上发送多个 HTTP 请求/响应对。
\n\n\n发送“关闭”连接选项的客户端不得在该连接上发送\n进一步的请求（在包含“关闭”的请求之后），并且\n必须在读取与此请求相对应的最终响应消息\n后关闭连接。
\n接收“关闭”连接选项的服务器必须在发送包含“关闭”的请求的最终响应后启动连接关闭（见下文）。服务器应该在该连接上的最终响应中发送“关闭”连接选项。服务器不得处理该连接上收到的任何进一步的请求。
\n
因此，客户端Connection: close通过在最后一个 HTTP请求中添加标头字段来发出关闭连接的信号，并且只有在收到确认服务器收到请求的 HTTP 响应后才会关闭连接。
\n\n发送“关闭”连接选项的服务器必须在发送包含“关闭”的响应后启动连接的关闭（见下文）。服务器不得处理该连接上收到的任何进一步的请求。
\n接收“关闭”连接选项的客户端必须停止在该连接上发送\n请求，并在读取\n包含“关闭”的响应消息后关闭连接；如果在连接上发送了额外的管道请求，客户端不应该假设它们将由服务器处理。
\n
因此，服务器Connection: close通过将标头字段添加到最后一个 HTTP响应来发出将关闭连接的信号，然后关闭连接。但是只有在收到确认客户端收到 HTTP 响应的消息后才关闭连接？
\n\n如果服务器立即关闭 TCP 连接，\n则存在客户端无法读取最后\nHTTP 响应的重大风险。如果服务器在完全关闭的连接中从客户端接收到其他数据，例如客户端在收到服务器响应之前发送的另一个请求，则服务器的 TCP 堆栈将发送一个重置数据包到客户端; 不幸的是，重置数据包可能会在客户端的 HTTP 解析器读取和解释客户端未确认的输入缓冲区之前将其擦除。
\n
因此，在服务器发起关闭连接的情况下，如果服务器在向初始 …
默认情况下，插槽是可写的：
>>> class A: __slots__ = ('x',)
...
>>> list(vars(A))
['__module__', '__slots__', 'x', '__doc__']
>>> vars(A)['x']
<member 'x' of 'A' objects>
>>> a = A()
>>> a.x = 'foo'
>>> del a.x
如何创建只读插槽，像插槽'__thisclass__'，'__self__'和'__self_class__'之类的super？
>>> list(vars(super))
['__repr__', '__getattribute__', '__get__', '__init__', '__new__',
'__thisclass__', '__self__', '__self_class__', '__doc__']
>>> vars(super)['__thisclass__']
<member '__thisclass__' of 'super' objects>
>>> s = super(int, 123)
>>> s.__thisclass__ = float
Traceback (most recent call last):
File "<stdin>", line …我试图理解C++ 中的放置新表达式。
\n这个 Stack Overflow 答案指出，这T* p = new T(arg);相当于
void* place = operator new(sizeof(T)); // storage allocation\nT* p = new(place) T(arg); // object construction\n这delete p;相当于
p->~T(); // object destruction\noperator delete(p); // storage deallocation\n为什么我们需要在对象构造中放置 new 表达式T* p = new(place) T(arg);，\xe2\x80\x99t 与以下等价吗？
T* p = (T*) place;\n*p = T(arg);\nc++ placement-new dynamic-memory-allocation object-construction
以下陈述是否正确？
它们基于[dcl.init.general/6]（粗体强调我的）：
对类型的对象或引用进行零初始化
T意味着：
- 如果是标量类型，则该对象被初始化为通过将整数文字（零）转换为;
T获得的值。0T- 如果
T是（可能是 cv 限定的）非联合类类型，则其填充位初始化为零位，并且每个非静态数据成员、每个非虚拟基类子对象，并且如果该对象不是基类子对象，每个虚拟基类子对象都是零初始化的；- 如果
T是（可能是 cv 限定的）联合类型，则其填充位被初始化为零位，并且对象的第一个非静态命名数据成员被零初始化；- 如果
T是数组类型，则每个元素都初始化为零；- 如果
T是引用类型，则不执行初始化。
以及[dcl.init.general/7]（粗体强调我的）：
默认初始化类型的对象
T意味着：
- 如果
T是（可能是 cv 限定的）类类型 ([class])，则考虑构造函数。枚举适用的构造函数 ([over.match.ctor])，并通过重载决策 ([over.match]) 选择最适合初始化器的构造函数。()使用空参数列表调用如此选择的构造函数来初始化对象。- 如果
T是数组类型，则每个元素都默认初始化。- 否则，不执行初始化。
在阅读 Python\xe2\x80\x99s执行模型文档时，我意识到 Python\xe2\x80\x99s 自由变量似乎没有严格的后期绑定属性，其中任何代码块中发生的名称绑定都可以用于名称解析。事实上，执行：
\ndef f():\n return x\n\ndef g():\n x = 0\n return f()\n\nprint(g())\n提高：
\nNameError: name \'x\' is not defined\n它们具有相当松散的后期绑定属性，其中只有在引入自由变量的代码块的外部代码块中发生的名称绑定才能用于名称解析。确实执行
\nNameError: name \'x\' is not defined\n印刷：
\n0\n与严格的后期绑定属性相比，松散的后期绑定属性有哪些优点和缺点？
\n比较关系（=、?、<、>、? 和 ?）之间的以下数学关系始终有效，因此在 Python 中默认实现（除了 2 个联合关系，这似乎是任意的，这也是本文的原因）：
以下比较关系之间的关系仅对总订单有效，因此在Python中默认不实现（但用户可以functools.total_ordering通过Python标准库提供的类装饰器方便地实现它们）：
为什么 Python 只缺少上面的 2 个联合关系（“？是联合 < 和 =" 和“？是 > 和 =" 的联合）？
它应该提供的默认实现__le__来讲__lt__和__eq__，和的默认实现__ge__来讲__gt__和__eq__（性能，但可能是在C，像，像这些__ne__）：
def __le__(self, other):
result_1 = self.__lt__(other)
result_2 = self.__eq__(other)
if result_1 is not NotImplemented and …python ×6
c++ ×4
http ×2
adapter ×1
c ×1
deep-copy ×1
http-headers ×1
inheritance ×1
late-binding ×1
path ×1
posix ×1
relationship ×1
shallow-copy ×1
slots ×1
sockets ×1
super ×1
tcp ×1
terminology ×1
windows ×1