更改为 std::vector 导致分段错误

【问题标题】：changing to std::vector causing segmentation fault更改为 std::vector 导致分段错误
【发布时间】：2021-03-16 16:31:20
【问题描述】：

你好，所以我有一个使用 new 关键字分配内存的结构，我想通过使用 std::vector 来删除，所以我确实喜欢这个

在更改为 std::vector 之前

BYTE* packPlayerMoving(PlayerMoving* dataStruct)
{
    BYTE* data = new BYTE[56];
    for (int i = 0; i < 56; i++)
    {
        data[i] = 0;
    }
    memcpy(data, &dataStruct->packetType, 4);
    memcpy(data + 4, &dataStruct->netID, 4);
    memcpy(data + 12, &dataStruct->characterState, 4);
    memcpy(data + 20, &dataStruct->plantingTree, 4);
    memcpy(data + 24, &dataStruct->x, 4);
    memcpy(data + 28, &dataStruct->y, 4);
    memcpy(data + 32, &dataStruct->XSpeed, 4);
    memcpy(data + 36, &dataStruct->YSpeed, 4);
    memcpy(data + 44, &dataStruct->punchX, 4);
    memcpy(data + 48, &dataStruct->punchY, 4);
    return data;
}

void SendPacketRaw(int a1, void *packetData, size_t packetDataSize, void *a4, ENetPeer* peer, int packetFlag)
{
    ENetPacket *p;

    if (peer) // check if we have it setup
    {
        if (a1 == 4 && *((BYTE *)packetData + 12) & 8)
        {
            p = enet_packet_create(0, packetDataSize + *((DWORD *)packetData + 13) + 5, packetFlag);
            int four = 4;
            memcpy(p->data, &four, 4);
            memcpy((char *)p->data + 4, packetData, packetDataSize);
            memcpy((char *)p->data + packetDataSize + 4, a4, *((DWORD *)packetData + 13));
            enet_peer_send(peer, 0, p);
        }
        else
        {
            p = enet_packet_create(0, packetDataSize + 5, packetFlag);
            memcpy(p->data, &a1, 4);
            memcpy((char *)p->data + 4, packetData, packetDataSize);
            enet_peer_send(peer, 0, p);
        }
    }
    delete (char*)packetData;
}

改成std::vector后

std::vector<BYTE> packPlayerMoving(PlayerMoving *dataStruct)
{
    std::vector<BYTE> data(56);
    memcpy(&data[0], &dataStruct->packetType, 4);
    memcpy(&data[4], &dataStruct->netID, 4);
    memcpy(&data[12], &dataStruct->characterState, 4);
    memcpy(&data[20], &dataStruct->plantingTree, 4);
    memcpy(&data[24], &dataStruct->x, 4);
    memcpy(&data[28], &dataStruct->y, 4);
    memcpy(&data[32], &dataStruct->XSpeed, 4);
    memcpy(&data[36], &dataStruct->YSpeed, 4);
    memcpy(&data[44], &dataStruct->punchX, 4);
    memcpy(&data[48], &dataStruct->punchY, 4);
    return data;
}

void SendPacketRaw(int a1, std::vector<BYTE> packetData, size_t packetDataSize, void *a4, ENetPeer *peer, int packetFlag)
{
    ENetPacket *p;

    if (peer) // check if we have it setup
    {
        if (a1 == 4 && *(&packetData[12]) & 8)
        {
            p = enet_packet_create(0, packetDataSize + *(&packetData[13]) + 5, packetFlag);
            int four = 4;
            memcpy(p->data, &four, 4);
            memcpy((char *)p->data + 4, &packetData[0], packetDataSize);
            void * a4 = 0;
            memcpy((char *)p->data + packetDataSize + 4,  a4, *(&packetData[13]));
            enet_peer_send(peer, 0, p);
        }
        else
        {
            p = enet_packet_create(0, packetDataSize + 5, packetFlag);
            memcpy(p->data, &a1, 4);
            memcpy((char *)p->data + 4, &packetData[0], packetDataSize);
            enet_peer_send(peer, 0, p);
        }
    }
}

我就是这样使用的：

SendPacketRaw(4, packPlayerMoving(&data), 56, 0, currentPeer, ENET_PACKET_FLAG_RELIABLE);

好的，所以我的问题是在我将它转换为 std::vector 之前它工作正常，没有问题 但是在我转换它之后我开始出现分段错误我做错了什么？

这里是 valgrind 输出

==12418== Conditional jump or move depends on uninitialised value(s)
==12418==    at 0x1189D7: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:172)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418== 
==12418== Conditional jump or move depends on uninitialised value(s)
==12418==    at 0x1450E7: enet_packet_create (in /home/cmd/Desktop/PRC++/server)
==12418==    by 0x118A20: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:174)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418== 
==12418== Conditional jump or move depends on uninitialised value(s)
==12418==    at 0x48429FA: memmove (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12418==    by 0x118AA8: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:179)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418== 
==12418== Conditional jump or move depends on uninitialised value(s)
==12418==    at 0x4842BA1: memmove (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12418==    by 0x118AA8: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:179)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418== 
==12418== Conditional jump or move depends on uninitialised value(s)
==12418==    at 0x4842B0E: memmove (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12418==    by 0x118AA8: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:179)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418== 
==12418== Invalid read of size 2
==12418==    at 0x4842B30: memmove (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12418==    by 0x118AA8: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:179)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418==  Address 0x0 is not stack'd, malloc'd or (recently) free'd
==12418== 
==12418== 
==12418== Process terminating with default action of signal 11 (SIGSEGV)
==12418==  Access not within mapped region at address 0x0
==12418==    at 0x4842B30: memmove (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==12418==    by 0x118AA8: SendPacketRaw(int, std::vector<unsigned char, std::allocator<unsigned char> >, unsigned long, void*, _ENetPeer*, int) (utils.cpp:179)
==12418==    by 0x11E337: Nothing(_ENetPeer*, int, int) (worlds.cpp:405)
==12418==    by 0x1208AD: Events::Recieve(_ENetHost*, _ENetPacket*, _ENetPeer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (events.cpp:315)
==12418==    by 0x123BDB: Run() (main.cpp:62)
==12418==    by 0x123C85: main (main.cpp:87)
==12418==  If you believe this happened as a result of a stack
==12418==  overflow in your program's main thread (unlikely but
==12418==  possible), you can try to increase the size of the
==12418==  main thread stack using the --main-stacksize= flag.
==12418==  The main thread stack size used in this run was 8388608.
==12418== 
==12418== HEAP SUMMARY:
==12418==     in use at exit: 11,557,918 bytes in 22,893 blocks
==12418==   total heap usage: 94,578 allocs, 71,685 frees, 29,567,151 bytes allocated
==12418== 
==12418== LEAK SUMMARY:
==12418==    definitely lost: 1,312 bytes in 4 blocks
==12418==    indirectly lost: 5,711 bytes in 17 blocks
==12418==      possibly lost: 224 bytes in 2 blocks
==12418==    still reachable: 11,550,671 bytes in 22,870 blocks
==12418==         suppressed: 0 bytes in 0 blocks
==12418== Rerun with --leak-check=full to see details of leaked memory
==12418== 
==12418== Use --track-origins=yes to see where uninitialised values come from
==12418== For lists of detected and suppressed errors, rerun with: -s
==12418== ERROR SUMMARY: 45563 errors from 34 contexts (suppressed: 0 from 0)
Segmentation fault (core dumped)

【问题讨论】：

  • 如果您使用new BYTE[] 分配，您需要使用delete [] (BYTE*) 解除分配，但这不是您的问题
  • BYTE* data = new BYTE[56]; vs std::vector&lt;BYTE&gt; data(64);：为什么不同的数字？
  • 我的建议是花 20 分钟时间学习如何使用调试器。从长远来看，它将为您节省许多时间。另外，如果你要成为一名程序员，如果你不能调试代码，你就不会成功。
  • 第一个中的 *((DWORD *)packetData + 13) 与第二个中的 *(&amp;packetData[13]) 不同。
  • 另一个谜团是为什么你分配了 56 个字节却只使用了其中的 52 个。

标签： c++ c++11 segmentation-fault


【解决方案1】：

*((DWORD *)packetData + 13) 在您的第一个版本中读取第 13 个 DWORD（在字节索引 52 处）。

*(&amp;packetData[13]) 在您的第二个版本中读取第 13 个字节。

整个代码有点乱，所以我不愿意仅仅把这个问题写在纸上，但是将第二个版本改为：

*(((DWORD *)packetData.data())+13) 应该修复它。

【讨论】：

    【解决方案2】：

    在您的原始代码中，在您的 SendPacketRaw() 函数中，您正在删除传递给它的 packetData 指针参数，而在此修改后的版本中，第二个参数 packetData 是一个向量，它继续包含一些函数结束后的数据SendPacketRaw()。

    我不确定你的SendPacketRaw() 函数的使用以及管理它的第二个参数应该维护的内存的逻辑，但我有一种直觉，这是 Valgrind 不高兴的主要原因。

    所以我建议您首先将第二个矢量参数 packetData 作为参考传递，并在完成函数之前对其进行清理。

    void SendPacketRaw(int a1, std::vector<BYTE> &packetData, size_t packetDataSize, void *a4, ENetPeer *peer, int packetFlag)
{
    ENetPacket *p;

    if (peer) // check if we have it setup
    {
        if (a1 == 4 && *(&packetData[12]) & 8)
        {
            p = enet_packet_create(0, packetDataSize + *(&packetData[13]) + 5, packetFlag);
            int four = 4;
            memcpy(p->data, &four, 4);
            memcpy((char *)p->data + 4, &packetData[0], packetDataSize);
            void * a4 = 0;
            memcpy((char *)p->data + packetDataSize + 4,  a4, *(&packetData[13]));
            enet_peer_send(peer, 0, p);
        }
        else
        {
            p = enet_packet_create(0, packetDataSize + 5, packetFlag);
            memcpy(p->data, &a1, 4);
            memcpy((char *)p->data + 4, &packetData[0], packetDataSize);
            enet_peer_send(peer, 0, p);
        }
    }
    
    packetData.clear();
}

    【讨论】：

    • 当我尝试评论这一行时 //memcpy((char *)p->data + packetDataSize + 4, a4, packetData[13]);我不再遇到分段错误，但它会影响工作
    • @cmdocmd 请先尝试我建议的解决方案，然后告诉我是否可以。
    • std::vector::clear() 可以，但没有义务释放内部缓冲区
    • @cmdocmd，您是否将&amp; 标记放在第二个向量参数前面以通过引用传递它？
    【解决方案3】：

    我想我在您的代码中看到了一个主要错误，std::vector&lt;BYTE&gt; data ，在 &amp;data[0] 如果您使用地址运算符，您将获得对象地址，因为[] 是矢量类的运算符。所以你可能想使用data.data() 它会返回一个原始指针，在memcpy() 之前执行此操作
    ps：我的第一个答案

    【讨论】：

    猜你喜欢
    • 2022-01-06
    • 2015-11-15
    • 2017-03-26
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2021-06-14
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多
    热门标签
    Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode