Fatal编程技术网
  • cplusplus/
  • C++ std:：字符串复制构造函数seg错误

C++ std:：字符串复制构造函数seg错误

c++ string

C++ std:：字符串复制构造函数seg错误,c++,string,segmentation-fault,C++,String,Segmentation Fault,构造结构时会发生这种情况，我的代码： 在这一行：回溯： 任何帮助都是徒劳的 对不起，我无法复制代码在这里，所以我张贴在任何其他网站；（使用调试器并获取堆栈跟踪 问题几乎肯定是将一个坏的C字符串传递到std:：string构造函数中。可能指针无效，或者C字符串没有终止，构造函数读取到受保护的内存中 但是如果没有更多的信息，我无法判断错误是什么。调试器应该立即指出它 另外，您的Socket包含一个指针，但只定义了构造函数和析构函数。您还需要一个复制构造函数和赋值运算符。如果这两个操作不应该发生，则将

构造结构时会发生这种情况，我的代码： 在这一行：回溯： 任何帮助都是徒劳的
对不起，我无法复制代码在这里，所以我张贴在任何其他网站；（

使用调试器并获取堆栈跟踪

问题几乎肯定是将一个坏的C字符串传递到std:：string构造函数中。可能指针无效，或者C字符串没有终止，构造函数读取到受保护的内存中

但是如果没有更多的信息，我无法判断错误是什么。调试器应该立即指出它

另外，您的
Socket
包含一个指针，但只定义了构造函数和析构函数。您还需要一个复制构造函数和赋值运算符。如果这两个操作不应该发生，则将它们定义为
private
，而不进行任何实现

另外，我从您的回溯中看到，这是一个旧版本的GCC。这个版本可能没有使std:：string在多线程程序中安全使用的修复程序。我不知道它是什么时候修复的，但是一些旧版本的libstdc++库没有锁定字符串上的引用计数，并且可能在不同的时间崩溃读取将释放字符串内存，同时也将写入该内存。

使用调试器并获取堆栈跟踪

问题几乎肯定是将一个坏的C字符串传递到std:：string构造函数中。可能指针无效，或者C字符串没有终止，构造函数读取到受保护的内存中

但是如果没有更多的信息，我无法判断错误是什么。调试器应该立即指出它

另外，您的
Socket
包含一个指针，但只定义了构造函数和析构函数。您还需要一个复制构造函数和赋值运算符。如果这两个操作不应该发生，则将它们定义为
private
，而不进行任何实现

另外，我从您的回溯中看到，这是一个旧版本的GCC。这个版本可能没有使std:：string在多线程程序中安全使用的修复程序。我不知道它是什么时候修复的，但是一些旧版本的libstdc++库没有锁定字符串上的引用计数，并且可能在不同的时间崩溃读取将释放字符串内存，同时写入该内存。

我将您的代码放在这里，以便能够对其进行编辑：

#ifdef _WIN32
    #define _WIN32_WINNT 0x0501
#endif

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <sstream>
#include <string>

#ifdef assert
    #undef assert
#endif

#define assert(x)\
    if (!x) { \
        std::clog << "[Error - __FUNCTION__] Asseration to: " << #x << " failed. line: " << __LINE__ << ", file: " << __FILE__ << "." << std::endl;\
        std::exit(100);\
    }

template<typename _Tp>
inline std::string toString(_Tp __p)
{
    std::stringstream ss;
    ss << __p;
    std::string ret;
    ss >> ret;
    return ret;
}

struct Proxy;

typedef std::vector<Proxy*> ProxyVec;

struct Proxy
{
    std::string name;
    uint32_t port;
};

ProxyVec loadProxies(const std::string& fileName)
{
    std::FILE *f = fopen(fileName.c_str(), "r");
    if (!f) {
        std::clog << "[Error - loadProxies] Cannot open: " << fileName << "." << std::endl;
        delete f;
        f = NULL;
        return ProxyVec();
    }

    char buffer[1024];
    ProxyVec ret;
    int32_t __n = 0;
    while (fgets(buffer, sizeof(buffer), f)) {
        ++__n;
        std::string str(buffer);
        if (str.find("\n") != std::string::npos)
            str = str.substr(0, str.length()-1);

        if (str.find("\r") != std::string::npos)
            str = str.substr(0, str.length()-1);

        size_t sep = str.rfind(":");
        if (sep == std::string::npos) {
            std::clog << "[Error - loadProxies] Cannot load proxy #" << __n << "." << std::endl;
            continue;
        }

        std::string hostname = str.substr(0, sep);
        uint32_t port = static_cast<uint32_t>(std::atoi(str.substr(sep+1, str.length()-sep).c_str()));
        std::clog << "Loading proxy: " << hostname << ":" << port << "." << std::endl;
        Proxy proxy;
        proxy.name = hostname;
        proxy.port = port;
        ret.push_back(&proxy);
    }
    std::clog << "Loaded: " << __n << " proxies." << std::endl;
    return ret;
}

class Socket
{
    public:
        Socket(boost::asio::io_service& service, const std::string& host, 
            const std::string& port, const std::string& targetHost, const std::string& targetPort);
        ~Socket();

        void write(const std::string& message);
        std::string receivedData() const;
        bool connected() const;
        void receive();
        void handle();

    private:
        struct SocketData
        {
            SocketData(boost::asio::io_service& service, const std::string& _host, const std::string& _port,
                const std::string& _targetHost, const std::string& _targetPort):
                socket(service),
                write(service),
                read(service),
                resolver(service),
                buffers(),
                host(_host),
                port(_port),
                targetHost(_targetHost),
                targetPort(_targetPort),
                connected(false)
            {
            }
            boost::asio::ip::tcp::socket socket;
            boost::asio::io_service::strand write, read;
            boost::asio::ip::tcp::resolver resolver;
            boost::array<char, 1024> buffers;
            std::string host, port;
            std::string targetHost, targetPort;
            bool connected;
        };
            // FIXME: Use shared_ptr instead.
        SocketData* d;

    protected:
        //handle resolve func
        void handle_resolve(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle connection func
        void handle_connect(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle write func
        void handle_write(const boost::system::error_code&, size_t);

        //handle read func
        void handle_read(const boost::system::error_code&, size_t);

    private:
        void connectionThread();
};

Socket::Socket(boost::asio::io_service& service, const std::string& host, const std::string& port,
    const std::string& targetHost, const std::string& targetPort)
    : d(new SocketData(service, host, port, targetHost, targetPort))
{
    boost::thread thread(boost::bind(&Socket::connectionThread, this));
    // FIXME: This function is blocking. The constructur will never exit.
    //        Use thread_group.join_all() as last line in main() instead.
    thread.join();
}

Socket::~Socket()
{
    d->socket.close();
    delete d;
    d = NULL;
}

void Socket::connectionThread()
{
    if (!d)
        return;

    if (d->connected)
        return;

    boost::asio::ip::tcp::resolver::query query(d->host, d->port);
    d->resolver.async_resolve(query,
        boost::bind(&Socket::handle_resolve, this,
            boost::asio::placeholders::error,
                boost::asio::placeholders::iterator));
}

void Socket::handle_resolve(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        boost::asio::ip::tcp::endpoint iter = *ep_iter;
        d->socket.async_connect(iter,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Socket::handle_resolve] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_connect(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        std::cout << "[Notice - Socket::handle_connect] Connected to host." << std::endl;
        d->connected = true;
        write("CONNECT " + d->targetHost + ":" + d->targetPort + " HTTP/1.1\r\n\r\n");
        receive();
    } else if (ep_iter != boost::asio::ip::tcp::resolver::iterator()) {
        d->socket.close();
        boost::asio::ip::tcp::endpoint ep = *ep_iter;
        d->socket.async_connect(ep,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Server::handle_connect] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_write(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
}

void Socket::handle_read(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
    std::cout << receivedData() << std::endl;
    receive();
}

void Socket::write(const std::string& message)
{
    boost::asio::async_write(d->socket, boost::asio::buffer(message),
        d->write.wrap(
            boost::bind(&Socket::handle_write, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

std::string Socket::receivedData() const
{
    return std::string(d->buffers.data());
}

void Socket::receive()
{
    d->socket.async_read_some(boost::asio::buffer(d->buffers),
        d->read.wrap(
            boost::bind(&Socket::handle_read, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

void Socket::handle()
{
    assert(!d->targetHost.empty());
    assert(!d->targetPort.empty());

    std::string str(d->buffers.data());
    std::clog << "Received: " << str << "." << std::endl;
    if (str.substr(0, 4) == "PING")
        write("PO" + str.substr(2) + "\r\n");
    else if (str.find("MODE") != std::string::npos)
        write("JOIN #OTland\r\n");
    else if (str.find("JOIN") != std::string::npos)
        write("PRIVMSG #OTland :Hello\r\n");
}

bool Socket::connected() const
{
    return d->connected;
}

void handler(const std::string& fileName, const std::string& host, const std::string& port, uint32_t threads);

int main(int argc, char **argv)
{
    if (argc < 5) {
        std::clog << "[Error - main] Usage: " << argv[0] << " <proxy_file> <host> <port> <threads>" << std::endl;
        return 1;
    }

    std::string file(argv[1]);
    std::string host(argv[2]);
    std::string port(argv[3]);
    uint32_t threads = static_cast<uint32_t>(std::atoi(argv[4]));
    if (!threads)
        threads = 1;

    for (uint32_t __i = 0; __i < threads; ++__i)
            // FIXME: Use the thread.join() there.
        handler(file, host, port, threads);
}

typedef std::vector<Socket*> SocketVec;

void handler(const std::string& fileName, const std::string& host,
    const std::string& port, uint32_t threads)
{
    assert(!fileName.empty());
    assert(!host.empty());
    assert(!port.empty());

    ProxyVec proxies = loadProxies(fileName);
    assert(proxies.size());

    SocketVec sockets;
    for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
        boost::asio::io_service io;
        Socket socket(io, (*it)->name, toString((*it)->port), host, port);
            // FIXME: socket is a local variable and it's address is invalid outside
            //        this loop -> memory leak -> seg-fault.
        sockets.push_back(&socket);
    }

    for (SocketVec::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
        if (!(*it)->connected())
            continue;

        (*it)->handle();
    }
    // FIXME: I'm not sure if I understand this architecture. A new thread is
    //        started with this function as handler ? Who waits until this new created
    //        thread is finished ? Where is the join() ?
    (void) new boost::thread(boost::bind(handler, fileName, host, port, threads));
}

\ifdef\u WIN32
#定义_WIN32_WINNT 0x0501
#恩迪夫
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#ifdef断言
#未定义断言
#恩迪夫
#定义断言（x）\
如果（！x）{\

std:：clog我将您的代码放在这里，以便能够对其进行编辑：


#ifdef _WIN32
    #define _WIN32_WINNT 0x0501
#endif

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <sstream>
#include <string>

#ifdef assert
    #undef assert
#endif

#define assert(x)\
    if (!x) { \
        std::clog << "[Error - __FUNCTION__] Asseration to: " << #x << " failed. line: " << __LINE__ << ", file: " << __FILE__ << "." << std::endl;\
        std::exit(100);\
    }

template<typename _Tp>
inline std::string toString(_Tp __p)
{
    std::stringstream ss;
    ss << __p;
    std::string ret;
    ss >> ret;
    return ret;
}

struct Proxy;

typedef std::vector<Proxy*> ProxyVec;

struct Proxy
{
    std::string name;
    uint32_t port;
};

ProxyVec loadProxies(const std::string& fileName)
{
    std::FILE *f = fopen(fileName.c_str(), "r");
    if (!f) {
        std::clog << "[Error - loadProxies] Cannot open: " << fileName << "." << std::endl;
        delete f;
        f = NULL;
        return ProxyVec();
    }

    char buffer[1024];
    ProxyVec ret;
    int32_t __n = 0;
    while (fgets(buffer, sizeof(buffer), f)) {
        ++__n;
        std::string str(buffer);
        if (str.find("\n") != std::string::npos)
            str = str.substr(0, str.length()-1);

        if (str.find("\r") != std::string::npos)
            str = str.substr(0, str.length()-1);

        size_t sep = str.rfind(":");
        if (sep == std::string::npos) {
            std::clog << "[Error - loadProxies] Cannot load proxy #" << __n << "." << std::endl;
            continue;
        }

        std::string hostname = str.substr(0, sep);
        uint32_t port = static_cast<uint32_t>(std::atoi(str.substr(sep+1, str.length()-sep).c_str()));
        std::clog << "Loading proxy: " << hostname << ":" << port << "." << std::endl;
        Proxy proxy;
        proxy.name = hostname;
        proxy.port = port;
        ret.push_back(&proxy);
    }
    std::clog << "Loaded: " << __n << " proxies." << std::endl;
    return ret;
}

class Socket
{
    public:
        Socket(boost::asio::io_service& service, const std::string& host, 
            const std::string& port, const std::string& targetHost, const std::string& targetPort);
        ~Socket();

        void write(const std::string& message);
        std::string receivedData() const;
        bool connected() const;
        void receive();
        void handle();

    private:
        struct SocketData
        {
            SocketData(boost::asio::io_service& service, const std::string& _host, const std::string& _port,
                const std::string& _targetHost, const std::string& _targetPort):
                socket(service),
                write(service),
                read(service),
                resolver(service),
                buffers(),
                host(_host),
                port(_port),
                targetHost(_targetHost),
                targetPort(_targetPort),
                connected(false)
            {
            }
            boost::asio::ip::tcp::socket socket;
            boost::asio::io_service::strand write, read;
            boost::asio::ip::tcp::resolver resolver;
            boost::array<char, 1024> buffers;
            std::string host, port;
            std::string targetHost, targetPort;
            bool connected;
        };
            // FIXME: Use shared_ptr instead.
        SocketData* d;

    protected:
        //handle resolve func
        void handle_resolve(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle connection func
        void handle_connect(const boost::system::error_code&,
            boost::asio::ip::tcp::resolver::iterator);

        //handle write func
        void handle_write(const boost::system::error_code&, size_t);

        //handle read func
        void handle_read(const boost::system::error_code&, size_t);

    private:
        void connectionThread();
};

Socket::Socket(boost::asio::io_service& service, const std::string& host, const std::string& port,
    const std::string& targetHost, const std::string& targetPort)
    : d(new SocketData(service, host, port, targetHost, targetPort))
{
    boost::thread thread(boost::bind(&Socket::connectionThread, this));
    // FIXME: This function is blocking. The constructur will never exit.
    //        Use thread_group.join_all() as last line in main() instead.
    thread.join();
}

Socket::~Socket()
{
    d->socket.close();
    delete d;
    d = NULL;
}

void Socket::connectionThread()
{
    if (!d)
        return;

    if (d->connected)
        return;

    boost::asio::ip::tcp::resolver::query query(d->host, d->port);
    d->resolver.async_resolve(query,
        boost::bind(&Socket::handle_resolve, this,
            boost::asio::placeholders::error,
                boost::asio::placeholders::iterator));
}

void Socket::handle_resolve(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        boost::asio::ip::tcp::endpoint iter = *ep_iter;
        d->socket.async_connect(iter,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Socket::handle_resolve] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_connect(const boost::system::error_code& e,
    boost::asio::ip::tcp::resolver::iterator ep_iter)
{
    if (!e) {
        std::cout << "[Notice - Socket::handle_connect] Connected to host." << std::endl;
        d->connected = true;
        write("CONNECT " + d->targetHost + ":" + d->targetPort + " HTTP/1.1\r\n\r\n");
        receive();
    } else if (ep_iter != boost::asio::ip::tcp::resolver::iterator()) {
        d->socket.close();
        boost::asio::ip::tcp::endpoint ep = *ep_iter;
        d->socket.async_connect(ep,
            boost::bind(&Socket::handle_connect, this,
                boost::asio::placeholders::error, ++ep_iter));
    } else {
        std::clog << "[Error - Server::handle_connect] " << e.message() << "." << std::endl;
    }
}

void Socket::handle_write(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
}

void Socket::handle_read(const boost::system::error_code& e,
    size_t bytes)
{
    assert(!e || bytes < 0);
    std::cout << receivedData() << std::endl;
    receive();
}

void Socket::write(const std::string& message)
{
    boost::asio::async_write(d->socket, boost::asio::buffer(message),
        d->write.wrap(
            boost::bind(&Socket::handle_write, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

std::string Socket::receivedData() const
{
    return std::string(d->buffers.data());
}

void Socket::receive()
{
    d->socket.async_read_some(boost::asio::buffer(d->buffers),
        d->read.wrap(
            boost::bind(&Socket::handle_read, this,
                boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred)));
}

void Socket::handle()
{
    assert(!d->targetHost.empty());
    assert(!d->targetPort.empty());

    std::string str(d->buffers.data());
    std::clog << "Received: " << str << "." << std::endl;
    if (str.substr(0, 4) == "PING")
        write("PO" + str.substr(2) + "\r\n");
    else if (str.find("MODE") != std::string::npos)
        write("JOIN #OTland\r\n");
    else if (str.find("JOIN") != std::string::npos)
        write("PRIVMSG #OTland :Hello\r\n");
}

bool Socket::connected() const
{
    return d->connected;
}

void handler(const std::string& fileName, const std::string& host, const std::string& port, uint32_t threads);

int main(int argc, char **argv)
{
    if (argc < 5) {
        std::clog << "[Error - main] Usage: " << argv[0] << " <proxy_file> <host> <port> <threads>" << std::endl;
        return 1;
    }

    std::string file(argv[1]);
    std::string host(argv[2]);
    std::string port(argv[3]);
    uint32_t threads = static_cast<uint32_t>(std::atoi(argv[4]));
    if (!threads)
        threads = 1;

    for (uint32_t __i = 0; __i < threads; ++__i)
            // FIXME: Use the thread.join() there.
        handler(file, host, port, threads);
}

typedef std::vector<Socket*> SocketVec;

void handler(const std::string& fileName, const std::string& host,
    const std::string& port, uint32_t threads)
{
    assert(!fileName.empty());
    assert(!host.empty());
    assert(!port.empty());

    ProxyVec proxies = loadProxies(fileName);
    assert(proxies.size());

    SocketVec sockets;
    for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
        boost::asio::io_service io;
        Socket socket(io, (*it)->name, toString((*it)->port), host, port);
            // FIXME: socket is a local variable and it's address is invalid outside
            //        this loop -> memory leak -> seg-fault.
        sockets.push_back(&socket);
    }

    for (SocketVec::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
        if (!(*it)->connected())
            continue;

        (*it)->handle();
    }
    // FIXME: I'm not sure if I understand this architecture. A new thread is
    //        started with this function as handler ? Who waits until this new created
    //        thread is finished ? Where is the join() ?
    (void) new boost::thread(boost::bind(handler, fileName, host, port, threads));
}



\ifdef\u WIN32
#定义_WIN32_WINNT 0x0501
#恩迪夫
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#ifdef断言
#未定义断言
#恩迪夫
#定义断言（x）\
如果（！x）{\

std:：clog我不认为这是您唯一的问题，但是在
处理程序
中的这段代码中，您正在堆栈上创建
套接字
对象。您创建的每个
套接字
对象都将在
for
循环结束时销毁。这意味着
套接字
向量中的对象是无效的对象这样做还可能损坏内存堆，从而产生您看到的错误


SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(&socket);
}


将此更改为：


SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket* socket = new Socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(socket);
}



我不认为这是您唯一的问题，但在
handler
中的这段代码中，您正在堆栈上创建
Socket
对象。您创建的每个
Socket
对象都将在
for
循环结束时销毁。这意味着
sockets
向量中的对象是无效对象。是否执行这还可能损坏内存堆，导致出现您看到的错误


SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(&socket);
}


将此更改为：


SocketVec sockets;
for (ProxyVec::const_iterator it = proxies.begin(); it != proxies.end(); ++it) {
    boost::asio::io_service io;
    Socket* socket = new Socket(io, (*it)->name, toString((*it)->port), host, port);
    sockets.push_back(socket);
}



这个答案本来是一个评论来回答，但是在看过你的代码之后，我觉得必须给出一个完整的答案。你真的需要仔细地看一看并了解它们是如何工作的。特别注意异步的例子，看起来你并没有掌握对象生命周期的概念以及处理程序是如何工作的。特别是，在跳转到多个线程之前，你应该掌握单线程程序。当你克服了这一点，你应该使用一个线程池来调用
io_服务：：run
，而不是每个线程使用
io_服务
。它最终会让你的程序的逻辑更容易理解

您还应该研究一下，您的代码中有很多错误，比如：


==19853== Invalid read of size 4
==19853==    at 0x10000D0E4: handler(std::string const&, std::string const&, std::string const&, unsigned int) (in ./a.out)
==19853==    by 0x10000D5E6: main (in ./a.out)
==19853==  Address 0x7fff5fbff398 is not stack'd, malloc'd or (recently) free'd



这个答案本来是一个评论来回答，但是在看过你的代码之后，我觉得必须给出一个完整的答案。你真的需要仔细地看一看并了解它们是如何工作的。特别注意异步的例子，看起来你并没有掌握对象生命周期的概念以及处理程序是如何工作的。特别是，在跳转到多个线程之前，你应该掌握单线程程序。当你克服了这一点，你应该使用一个线程池来调用
io_服务：：run
，而不是每个线程使用
io_服务
。它最终会让你的程序的逻辑更容易理解

您还应该研究一下，您的代码中有很多错误，比如：


==19853== Invalid read of size 4
==19853==    at 0x10000D0E4: handler(std::string const&, std::string const&, std::string const&, unsigned int) (in ./a.out)
==19853==    by 0x10000D5E6: main (in ./a.out)
==19853==  Address 0x7fff5fbff398 is not stack'd, malloc'd or (recently) free'd



@Fall:您可以使用-O0-g重新生成以便我们可以在回溯中看到字符串的值吗？或者至少转到第4帧并打印出每个函数参数的值。@Fall:您最近的回溯没有帮助。它仍然不会显示参数值。您的GDB版本可能不会自动执行此操作。请转到第4帧（键入“帧4”）和打印服务、主机、端口等@Zyn Lynx:抱歉，没有看到您的消息，以下是输出：@fall:您的最新消息没有帮助。那里没有打印信息。@fall:您可以使用-O0-g重新生成，以便我们可以看到回溯中字符串的值吗？