考虑以下 Python 程序，其步骤如下：

1) 初始化两个列表A和B。

2）我们分配A = B。这个操作的时间复杂度是O(1)。

3）我们将一个新列表分配给B，该列表不会改变A。

A = [1, 2, 3]
B = [7, 8]
# A contains [1, 2, 3]
# B contains [7, 8]

#------------------------------------

A = B
# A contains [7, 8]
# B contains [7, 8]
# time complexity: O(1)

#------------------------------------

B = [55, 66, 77, 88]
# A still contains [7, 8]
# B now contains [55, 66, 77, 88]

现在，我想在 C++ 中做类似的事情，其中​​ A 和 B 是向量：

1) 初始化两个向量A和B。

2）我们分配A = B。根据以下公式，该操作的时间复杂度为O(n)en.cppreference.com http://en.cppreference.com/w/cpp/container/vector/operator%3D.

3）我们将一个新列表分配给B，该列表不会改变A。

vector<int> A = {1, 2, 3};
vector<int> B = {7, 8};
// A contains [1, 2, 3]
// B contains [7, 8]


A = B;   
// A contains [7, 8]
// B contains [7, 8]
// time complexity: O(n)


B = {55, 66, 77, 88};
// A still contains [7, 8]
// B now contains [55, 66, 77, 88]

我的问题

Python 和 C++ 程序之间的区别在于步骤 2) 的时间复杂度，其中我们分配 A = B。

• 在 Python 中，它需要 O(1) 时间，因为我们只更改引用。然后 A“指向”B，即 A 和 B 都是对同一对象的引用。
• 在 C++ 中，需要 O(n) 时间，因为 B 的内容被复制到 A。A 并不“指向”与 B 相同的对象。

有没有办法让C++中的向量A在O(1)时间内指向向量B？

注意：我对 C++ 不太熟悉，所以我什至不知道将 A 和 B 视为对 C++ 中向量对象的引用是否有效。

因为你不使用价值B将其分配给之后A（之后直接分配给它）您可以利用 C++11 移动语义：

vector<int> A = {1, 2, 3};
vector<int> B = {7, 8};
A = std::move(B);
// O(1), see below
// B is in indeterminate but usable state now (probably empty).

B = {55, 66, 77, 88};
// A still contains [7, 8]
// B now contains [55, 66, 77, 88]

移动赋值运算符的时间复杂度为：

恒定，除非std::allocator_traits<allocator_type>::propagate_on_container_move_assignment() is false并且分配器比较不相等（在这种情况下 线性）。

source http://en.cppreference.com/w/cpp/container/vector/operator%3D.