插入指针数组时覆盖原有结果的技术问题排查请求

嘿，咱们来拆解下你遇到的问题：你的Add函数直接把传入的char*指针赋值给contact结构体的成员，这就埋下了隐患——如果这些指针指向的是临时内存（比如栈上的局部数组、重复利用的缓冲区），那么当后续操作覆盖这块内存时，之前存在contacts数组里的指针就会指向被修改后的内容，看起来就像旧数据被“清除”了。

举个实际场景的例子：

char tempName[20];
strcpy(tempName, "Alice");
Add(tempName, ...); // 这里contacts[0].name指向tempName数组
strcpy(tempName, "Bob"); // 覆盖tempName的内容
Add(tempName, ...); // contacts[1].name也指向tempName
// 这时候你查contacts[0].name，会发现它变成"Bob"了，根本不是之前的Alice！

本质上是多个contact实例共享了同一块内存区域，一旦这块内存被修改，所有指向它的指针都会看到变化。

最推荐的解决方案：用C++的std::string替代char* #

std::string会自动管理内存，帮你保存字符串的副本，彻底避免指针共享的问题。修改后的代码会简洁又安全：

#include <iostream>
#include <string>
using namespace std;

// C++里struct不需要typedef，直接定义即可
struct Contact {
    string name;
    string number;
    string birthday;
    string email;
    string memo;
};

// 用动态数组存放联系人，或者更推荐用vector（后面会说）
Contact* contacts;
int total = 0;

void initDB() {
    contacts = new Contact[50001];
}

// 用const引用传递参数，避免不必要的拷贝
void Add(const string& name, const string& number, const string& birthday, const string& email, const string& memo) {
    contacts[total].name = name;
    contacts[total].number = number;
    contacts[total].birthday = birthday;
    contacts[total].email = email;
    contacts[total].memo = memo;
    total++;
}

int main() {
    initDB();
    
    // 直接传入字符串字面量或者局部数组都没问题
    Add("Alice", "123456", "1990-01-01", "alice@example.com", "Friend");
    Add("Bob", "654321", "1991-02-02", "bob@example.com", "Colleague");
    
    // 现在访问旧数据完全正常
    cout << contacts[0].name << endl; // 输出Alice
    cout << contacts[1].name << endl; // 输出Bob
    
    // 记得释放动态数组的内存
    delete[] contacts;
    return 0;
}

进阶优化：用std::vector替代手动动态数组 #

如果想彻底告别手动内存管理，用std::vector来存放联系人是更好的选择——它会自动扩容、管理内存，连initDB函数都可以省掉：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct Contact {
    string name;
    string number;
    string birthday;
    string email;
    string memo;
};

// 直接用vector，无需手动初始化
vector<Contact> contacts;

void Add(const string& name, const string& number, const string& birthday, const string& email, const string& memo) {
    // 直接把新联系人push_back进去，vector自动处理内存
    contacts.push_back({name, number, birthday, email, memo});
}

int main() {
    Add("Alice", "123456", "1990-01-01", "alice@example.com", "Friend");
    Add("Bob", "654321", "1991-02-02", "bob@example.com", "Colleague");
    
    // 访问方式和数组一样，而且不用手动释放内存
    cout << contacts[0].name << endl;
    cout << contacts[1].name << endl;
    
    return 0;
}

这种方式几乎不会出现内存泄漏或者指针错误，是C++里管理动态集合的标准做法。

如果你坚持用char*：手动分配内存并复制字符串 #

要是你必须保留char*的用法，那就要在Add函数里为每个字符串单独分配内存，然后把传入的内容复制进去，确保每个contact实例拥有独立的内存区域：

#include <iostream>
#include <cstring>
using namespace std;

typedef struct contact {
    char *name;
    char *number;
    char *birthday;
    char *email;
    char *memo;
} contact;

contact *contacts;
int total=0;

void initDB() {
    contacts = new contact[50001];
    // 初始化所有指针为nullptr，避免野指针
    for(int i=0; i<50001; i++){
        contacts[i].name = nullptr;
        contacts[i].number = nullptr;
        contacts[i].birthday = nullptr;
        contacts[i].email = nullptr;
        contacts[i].memo = nullptr;
    }
}

// 辅助函数：复制字符串并分配内存
char* copyString(const char* src) {
    if(src == nullptr) return nullptr;
    // 计算字符串长度+1（存'\0'）
    char* dest = new char[strlen(src) + 1];
    strcpy(dest, src);
    return dest;
}

void Add(char *name,char *number,char *birthday,char *email,char *memo) {
    contacts[total].name = copyString(name);
    contacts[total].number = copyString(number);
    contacts[total].birthday = copyString(birthday);
    contacts[total].email = copyString(email);
    contacts[total].memo = copyString(memo);
    total++;
}

// 必须写销毁函数，释放所有分配的内存，避免内存泄漏
void destroyDB() {
    for(int i=0; i<total; i++){
        delete[] contacts[i].name;
        delete[] contacts[i].number;
        delete[] contacts[i].birthday;
        delete[] contacts[i].email;
        delete[] contacts[i].memo;
    }
    delete[] contacts;
}

int main() {
    initDB();
    
    char tempName[20];
    strcpy(tempName, "Alice");
    Add(tempName, "123456", "1990-01-01", "alice@example.com", "Friend");
    strcpy(tempName, "Bob");
    Add(tempName, "654321", "1991-02-02", "bob@example.com", "Colleague");
    
    // 现在旧数据不会被覆盖了
    cout << contacts[0].name << endl; // 输出Alice
    cout << contacts[1].name << endl; // 输出Bob
    
    // 一定要调用销毁函数释放内存
    destroyDB();
    return 0;
}

这种方式需要格外注意内存管理，必须在程序结束前调用destroyDB释放所有分配的内存，否则会造成内存泄漏。

内容的提问来源于stack exchange，提问作者orbit