C++中key使用指针是否可以改变key指向的对象？

在C++中，当你使用指针作为 `std::map` 或 `std::set` 的键时，是否能改变键指向的对象，这涉及到指针的拷贝语义和容器内部的工作机制。理解这一点，我们需要深入分析以下几个方面：

1. C++ 中的拷贝语义与指针

首先，需要明确C++中拷贝一个指针时发生了什么。当你将一个指针赋值给另一个指针时，你复制的是指针本身的值，也就是内存地址。你并没有复制指针所指向的对象。

例如：

```c++
int a = 10;
int ptr1 = &a
int ptr2 = ptr1; // ptr2 现在也指向 a
```

在这个例子中，`ptr1` 和 `ptr2` 都指向同一个 `int` 对象 `a`。如果你修改 `a` 的值，无论是通过 `ptr1` 还是 `ptr2` 都会影响到同一个内存位置：

```c++
ptr1 = 20;
// 现在 ptr2 的值也是 20
```

然而，如果你尝试让 `ptr2` 指向另一个对象：

```c++
int b = 30;
ptr2 = &b
// 现在 ptr1 仍然指向 a，而 ptr2 指向 b
```

这仅仅是改变了 `ptr2` 这个变量存储的地址，它并不影响 `ptr1`。

2. `std::map` 和 `std::set` 的键要求

`std::map` 和 `std::set` 在内部存储键值对（或仅仅是键）时，需要一种机制来确保这些键是可比较的并且在容器生命周期内，键的相对顺序不会改变。这是因为容器会利用这些键来组织数据，例如使用红黑树来保证高效的查找、插入和删除操作。

对于内置类型（如 `int`, `double` 等）或标准库提供的可比较类型，这通常不是问题。但对于自定义类型，你需要提供比较运算符（`operator<`）或一个比较函数。

当你使用指针作为键时，默认情况下，容器会使用指针的地址值进行比较。也就是说，`std::map` 和 `std::set` 会比较指针所存储的内存地址，而不是指针所指向的内容。

3. 使用指针作为键：核心问题

现在我们结合以上两点来回答你的问题：C++ 中 key 使用指针是否可以改变 key 指向的对象？

答案是：可以，但这样做会带来非常严重的潜在问题，并且通常是需要避免的。

让我们分解一下：

容器如何存储指针键？当你将一个指针 `ptr` 插入到 `std::map` 或 `std::set` 中时，容器会将这个指针的值（即它所指向的内存地址）存储起来。它会根据这个地址值进行排序和组织。

修改指针指向的对象：你完全可以像上面 `ptr1` 和 `ptr2` 的例子一样，改变指针所指向的对象。

```c++
include
include

int main() {
int value1 = 10;
int value2 = 20;

int key_ptr = &value1

std::map my_map;
my_map[key_ptr] = "First Value";

// 查找 key_ptr
std::cout << "Found: " << my_map[key_ptr] << std::endl; // 输出: Found: First Value

// 改变 key_ptr 指向的对象
key_ptr = &value2

// 尝试查找 key_ptr (现在指向 value2)
// 注意：这里查找的是新的 key_ptr 的值 (value2 的地址)，
// 而不是原先在 map 中存储的那个地址 (value1 的地址)
if (my_map.count(key_ptr)) {
std::cout << "Found with new pointer value: " << my_map[key_ptr] << std::endl;
} else {
std::cout << "Key pointing to value2 not found in map." << std::endl;
}

// 尝试通过原先存储的地址查找
// 我们需要一种方法来获取原先存储在 map 中的那个地址。
// 直接这样做是困难的，因为我们无法通过 `key_ptr` 获取到 `value1` 的地址了。
// 如果我们仍然有一个指向 value1 的指针：
int original_key_ptr = &value1 // 假设我们有另一个指针指向 value1
if (my_map.count(original_key_ptr)) {
std::cout << "Found with original pointer value: " << my_map[original_key_ptr] << std::endl; // 输出: Found with original pointer value: First Value
}

// 更直接地，如果我们修改了 key_ptr 指向的对象，但 key_ptr 本身没有改变：
int value3 = 30;
int key_ptr_to_modify = &value3
my_map[key_ptr_to_modify] = "Third Value";

std::cout << "Before modification: " << key_ptr_to_modify << std::endl; // 输出 30
if (my_map.count(key_ptr_to_modify)) {
std::cout << "Found before modification: " << my_map[key_ptr_to_modify] << std::endl; // 输出 Third Value
}

// 修改被指针指向的对象
key_ptr_to_modify = 40; // value3 现在是 40

// 查找同一个指针，它指向的对象的值改变了
if (my_map.count(key_ptr_to_modify)) {
std::cout << "Found after modification of pointed object: " << my_map[key_ptr_to_modify] << std::endl; // 输出 Third Value
}

return 0;
}
```

问题1：当你改变 `key_ptr` 的值时，容器中的键就没有意义了。

在上面的例子中，当你执行 `key_ptr = &value2` 时，`key_ptr` 的值（内存地址）改变了。`std::map` 是根据键的值来查找元素的。原来存储在 map 中的是 `value1` 的地址。当你用新的 `key_ptr`（指向 `value2` 的地址）去查找时，容器会尝试查找 `value2` 的地址，而这个地址根本就没有被插入到 map 中，所以查找会失败。

问题2：当你修改指针指向的对象时，容器内部的排序可能不会被破坏，但你通过原先的指针访问时，获取到的是改变后的值。

如果你不改变指针变量本身的值（即地址），而是修改它所指向的对象的值，那么容器内部的排序机制（基于地址值）不会受到影响。但是，当你通过这个指针去访问 map 中的元素时（例如 `my_map[key_ptr]`），你仍然是通过那个特定的地址来查找的。如果这个地址对应的对象值发生了改变，你可能会因此产生误解，因为你期望的是某个特定值的键，但现在访问的实际值变了。

更深层次的问题：为什么这是个坏主意？

1. 键的稳定性： `std::map` 和 `std::set` 的核心是键的稳定性。这意味着一旦一个键被插入到容器中，它就应该保持其身份，直到被移除。指针作为键，其“身份”就是它存储的内存地址。如果你改变了指针变量的值（即让它指向另一个地址），那么这个“键”实际上已经变成了一个新的键。如果你不小心，可能会丢失对原先键的引用，或者错误地以为可以通过改变指针来修改键。

2. 意图的模糊性：使用指针作为键，很容易混淆“键本身”（指针变量存储的地址）和“键指向的值”。
如果你想基于对象的值进行查找和排序，那么你应该将对象本身（或对象的副本）作为键，而不是指针。
如果你确实需要根据对象的地址进行查找，那么你必须保证在查找期间，你使用的指针变量的值（地址）与插入到容器中的地址是完全一致的。

3. 内存管理风险：如果你使用指针作为键，并且这些指针指向动态分配的内存，你必须非常小心地管理内存的生命周期。如果被指向的对象被释放了，而这个指针还在容器中作为键，那么容器中的这个键就变成了悬空指针。访问悬空指针是未定义行为，极易导致程序崩溃或产生不可预测的结果。

想象一下，你将 `new int(10)` 的地址作为键插入到 map 中。然后你修改了这个指针，让它指向了另一个对象。如果稍后，你释放了原先指向 `new int(10)` 的那块内存，那么你的 map 中可能仍然保存着一个指向已释放内存的地址，这是一个严重的内存安全问题。

推荐的做法

如果你需要将对象关联到某个标识符，或者将对象收集到一个有序的集合中，更健壮的做法是：

使用对象的拷贝作为键：如果你的对象是可拷贝的，并且其值决定了它的身份和排序，那么直接将对象（或其引用/智能指针）作为键是最佳选择。

```c++
include
include
include // for std::shared_ptr

struct MyData {
int value;
std::string name;

// 需要提供 operator< 来让 std::map 使用
bool operator<(const MyData& other) const {
return value < other.value; // 以 value 为排序依据
}
};

int main() {
std::map data_map;
MyData d1 = {10, "Apple"};
MyData d2 = {20, "Banana"};

data_map[d1] = 100;
data_map[d2] = 200;

// 查找时使用 MyData 对象
MyData search_key = {10, "Apple"};
if (data_map.count(search_key)) {
std::cout << "Found: " << data_map[search_key] << std::endl; // 输出: Found: 100
}

// 改变 d1 的值不会影响 map，因为 map 存储的是 d1 的拷贝
d1.value = 15;
d1.name = "Orange";

// 再次查找 d1 (现在是 {15, "Orange"})
if (data_map.count(d1)) {
// 不会找到，因为 map 中存储的是旧的 {10, "Apple"}
std::cout << "Found after modifying d1: " << data_map[d1] << std::endl;
} else {
std::cout << "Key {15, "Orange"} not found." << std::endl; // 输出: Key {15, "Orange"} not found.
}

return 0;
}
```

使用智能指针作为键：如果你确实需要指向某个对象，并且希望容器拥有其生命周期的一部分或者共享其所有权，那么使用 `std::shared_ptr` 或 `std::unique_ptr`（如果你能妥善处理其移动语义）作为键会是更好的选择。容器会比较智能指针内部存储的地址。

```c++
include
include
include

struct BigObject {
int id;
// ...
};

int main() {
// 使用 shared_ptr 作为键
std::map, std::string> object_map;

auto obj1 = std::make_shared();
obj1>id = 1;
object_map[obj1] = "Object One";

auto obj2 = std::make_shared();
obj2>id = 2;
object_map[obj2] = "Object Two";

// obj1 和 obj2 指向不同的对象，所以 map 会区分它们

// 尝试修改 obj1 指向的对象的内容
obj1>id = 10;

// 查找 obj1。由于 shared_ptr 的地址没有变，查找仍然会成功。
// map 会返回与该地址关联的值 "Object One"。
// 但是，如果你的比较函数是基于 obj1 的成员（例如 id）而不是指针本身，
// 并且你期望根据 id 来查找，那就会有问题了。
// 但是 std::shared_ptr 作为键时，比较的是原始指针地址。
if (object_map.count(obj1)) {
std::cout << "Found object via obj1 (modified id): " << object_map[obj1] << std::endl; // 输出: Found object via obj1 (modified id): Object One
}

// 如果你想让 map 根据对象的内容来排序和查找，你需要在 map 的模板参数中提供一个自定义的比较器。
// 例如：
// struct CompareBigObject {
// bool operator()(const std::shared_ptr& a, const std::shared_ptr& b) const {
// return a>id < b>id; // 根据 id 比较
// }
// };
// std::map, std::string, CompareBigObject> object_map_by_id;

return 0;
}
```

总结

直接使用裸指针（raw pointers）作为 `std::map` 或 `std::set` 的键，并且期望在不改变指针变量本身的值（即它存储的地址）的情况下修改它指向的对象，是技术上可行，但极其危险且不推荐的。这样做会严重违反容器对键的稳定性要求，容易导致未定义行为、内存泄漏以及难以调试的错误。

请记住：当你使用指针作为键时，容器比较的是指针的地址值。一旦这个地址值发生改变（即指针指向了新的内存位置），容器内部的查找机制就会失效。如果你修改的是指针指向的对象内容，而指针本身地址不变，那么容器内部的排序不会乱，你也能通过该指针找到元素，但这种做法仍可能因值与“键”身份的混淆而导致逻辑错误。最佳实践是使用对象的拷贝或智能指针作为键，并始终关注内存的生命周期。

网友意见

其实关键的问题在于：map/set需要的是一个稳定的比较。这里的“稳定”的含义就是不管实际保存的对象怎么改变，对于map/set中任意两个对象，A>B或者!(A>B)这个关系必须贯穿于对象在map/set中的整个生存期。

如果你能在对象改变前后，再逻辑层面确保这个“稳定的比较”是可行的，那剩下的无非就就是一些代码技巧了：既然你已经重载了key的operator <，那其实很好办，在这里抹平你的改变前后的差异就行了。

如果在逻辑层面无法保证你的改变前后的“稳定”，那唯一的做法是在改变前先把对象从map/set中删掉，然后再插入改变后的对象。

类似的话题

C++中key使用指针是否可以改变key指向的对象？

在C++中，当你使用指针作为 `std::map` 或 `std::set` 的键时，是否能改变键指向的对象，这涉及到指针的拷贝语义和容器内部的工作机制。理解这一点，我们需要深入分析以下几个方面：1. C++ 中的拷贝语义与指针首先，需要明确C++中拷贝一个指针时发生了什么。当你将一个指针赋值给另一.............
C++ 中的基类为何在析构函数中添加 virtual？

在 C++ 中，为基类添加 `virtual` 关键字到析构函数是一个非常重要且普遍的实践，尤其是在涉及多态（polymorphism）的场景下。这背后有着深刻的内存管理和对象生命周期管理的原理。核心问题：为什么需要虚析构函数？当你在 C++ 中使用指针指向一个派生类对象，而这个指针的类型是基类指针.............
c++ 中结构体中的变量读写速度为什么比普通变量快?

结构体变量的读写速度并不比普通变量快。这是一个常见的误解。事实上，在很多情况下，访问结构体成员的开销会比直接访问普通变量稍微大一些，而不是更小。要详细解释这一点，我们需要深入理解 C++ 中的变量、内存模型以及编译器的工作方式。 1. 普通变量的读写首先，我们来看看一个简单的普通变量，例如：``.............
C++中 unsigned t = 2147483647 + 1 + 1; 是 UB 还是 ID？

在C++中，表达式 `unsigned t = 2147483647 + 1 + 1;` 的求值过程，既不是UB（Undefined Behavior），也不是ID（ImplementationDefined Behavior），而是一个有明确定义的整数溢出（Integer Overflow）行为。.............
C++中，自定义函数写在main之前更好，还是之后更好？

关于C++自定义函数写在 `main` 函数之前还是之后的问题，这涉及到C++的编译和链接过程，以及我们编写代码时的可读性和维护性。理解这一点，对你写出更健壮、更易于理解的代码非常有帮助。总的来说，将自定义函数写在 `main` 函数之前通常是更推荐的做法，尤其是对于项目中主要的、被 `main`.............
C++ 中，std::atomic 是真正的「原子」吗？

在 C++ 中讨论 `std::atomic` 是否是“真正的原子”时，我们需要拨开表面的术语，深入理解其底层含义和实际应用。答案并非一个简单的“是”或“否”，而是取决于你对“原子”的理解以及在什么上下文中去考量。首先，让我们明确一下在并发编程领域，“原子性”（Atomicity）通常指的是一个操作.............
C++中函数返回的过程是什么样的？

在C++中，函数返回并不是一个简单地“跳出去”的操作，它涉及到多个步骤，并且与值的传递方式、调用栈以及编译器优化等因素紧密相关。我们来详细拆解一下这个过程，力求还原真实的执行场景。核心概念：调用栈 (Call Stack)要理解函数返回，就必须先理解调用栈。当你调用一个函数时，程序会在调用栈上为这个.............
C++中如何将string类型转换为int类型？

在 C++ 中，将 `std::string` 类型转换为 `int` 类型有几种常见且强大的方法。理解它们的原理和适用场景对于编写健壮的代码至关重要。下面我将详细介绍几种常用的方法，并分析它们的优缺点：方法一：使用 `std::stoi` (C++11 及以后版本)这是最推荐的方法，因为它提.............
c++ 中明明有vector了为什么还要有stack？

vector 和 stack 在 C++ 中都有各自的用处，它们虽然都属于序列容器，但设计目标和侧重点不同。可以这么理解：vector 就像一个可以随意伸缩的储物空间，你可以按照任何顺序往里面放东西，也可以随时拿出任何一个东西。而 stack 就像一个堆叠的盘子，你只能在最上面放盘子，也只能从最上面.............
C++中怎么区分char和数值？

在C++中，区分 `char` 和数值（如 `int`, `float`, `double` 等）是编程中的基本概念，但理解其背后的机制能帮助你写出更健壮的代码。首先，我们需要明确一点：在C++底层，`char` 类型本质上也是一种整数类型。它通常用来存储单个字符的ASCII码值或其他编码标准下的数.............
c++中能否判断一个指针指向栈还是堆？

在C++中，我们不能直接“判断”一个指针指向的是栈（stack）还是堆（heap）。这种判断本身在很多情况下是不明确的，而且C++标准并没有提供直接的运行时机制来做到这一点。不过，我们可以通过一些间接的思考和观察来理解这个问题，并解释为什么直接判断很困难，以及我们通常是如何“知道”一个指针指向哪里。.............
C++中除以2和右移1有什么区别？

在 C++ 中，对整数进行除以 2 和右移 1 看起来很相似，它们都能将数字“减半”。但实际上，它们在底层执行机制、对负数和浮点数的影响，以及一些细微之处存在显著差异。我们来深入剖析一下。除以 2 (`/ 2`)：标准的算术运算在 C++ 中，`a / 2` 是一个标准的算术除法运算。它遵循正常的.............
c#中虽然异步和多线程是两码事，但是是否异步微软提供的async函数内部还是多线程去实现的？

在 C 中，`async` 和 `await` 关键字提供了一种优雅的方式来编写异步代码，但它们并非直接等同于多线程。理解这一点至关重要。异步并非强制多线程，但常常借助它首先，我们要明确一个核心概念：异步编程的本质是为了提高程序的响应性和吞吐量，而不是简单地将任务并行执行。异步的目的是让程序在等待.............
C# 中加入 F# 中的那种管道运算符 “|>” 会怎么样？

如果 C 真的引入了类似 F 那样的管道运算符 “|>”，这无疑会是一场不小的革新，尤其是在函数式编程风格日益受到重视的今天。那么，它会带来什么变化？我们的代码会变成什么样？首先，我们得理解 F 中的管道运算符 `|>` 是做什么的。简单来说，它就是将一个表达式的结果作为另一个函数调用的第一个参数传.............
c#中没有友元类那么这种设计是否不太合理，如何修改才能得到更好的方案？

在C中确实不存在Java或C++那样的“友元类”（friend class）机制。这常常让习惯了这种特性的开发者感到不适应，甚至认为这种设计“不太合理”。但实际上，C的设计哲学侧重于封装和明确的接口，友元类这种打破封装的特性并非是其追求的目标。那么，这种设计真的“不合理”吗？或者说，我们是否可以找到.............
C++中delete this是对象先析构还是delete语句先返回？

在C++中，当你在一个对象的成员函数内部执行 `delete this;` 时，对象的析构函数会先被调用，然后 `delete` 操作才会完成，并将内存释放。让我们来详细拆解一下这个过程，避免任何可能引起误解的地方。核心机制：`delete this;` 的工作原理`delete this;` 这.............
c++中超出char、int范围的整数怎么存储？

在 C++ 中处理超出标准 `char`、`int` 等基本数据类型表示范围的整数，其实并不是一个“存储”的问题，而是一个选择更合适数据类型的问题。C++ 为我们提供了多种整数类型，每种类型都有其固定的存储大小和取值范围。当我们需要处理的数值超出了某个类型的默认范围时，我们就需要选用更大的类型来容纳.............
c++中指针的作用是什么呢？单纯的用引用不可以吗？

在 C++ 编程中，指针和引用都是用来间接访问内存中数据的强大工具，但它们扮演的角色以及使用方式却各有侧重。很多人会疑惑，既然有了引用，为什么还需要指针呢？我们来深入聊聊这个问题。指针：内存地址的直接操纵者简单来说，指针是一个变量，它存储的是另一个变量的内存地址。你可以想象一个房间的门牌号，这个门.............
c中struct 为什么可以在数据结构这样用？

在C语言中，`struct`（结构体）之所以能成为构建复杂数据结构的基石，在于它提供了将不同类型的数据成员组合成一个单一逻辑单元的能力。这就像我们在现实生活中将不同零散的物品（姓名、年龄、学号等）打包成一个“学生”的概念一样。让我们一层层剥开，看看`struct`是如何做到这一点的，以及它在数据结构.............
C++中开多个数组和用struct封装起来哪个速度更快？

您好！关于C++中开辟多个数组与使用结构体封装哪个速度更快这个问题，这取决于具体的应用场景和您的编码方式。我来详细为您分析一下，并尽量还原成一篇自然、有深度的技术探讨文章。多个独立数组 vs. 结构体封装：性能的权衡与选择在C++编程中，当我们需要管理一组相关联的数据时，我们通常会面临两个主要的选.............