Boost :: Regex Segfault (я думаю)

Question

У меня проблема с некоторым кодом на C++, который я запускаю. В принципе, он отлично работает с большинством входов, но с определенными входами он отключается после возврата моей основной функции. Это было ... озадачительно. Я остановил бег на Segfault, чтобы получить трассировку стеки, и он вернулся в этом:

#0 malloc_consolidate() at /build/eglibc-oGUzwX/eglibc-2.19/malloc/malloc.c:4151 
#1 _int_free() at /build/eglibc-oGUzwX/eglibc-2.19/malloc/malloc.c:4057 
#2 boost::re_detail::mem_block_cache::~mem_block_cache()() at /usr/lib/x86_64-linux-gnu/libboost_regex.so.1.54.0 
#3 __cxa_finalize() at /build/eglibc-oGUzwX/eglibc-2.19/stdlib/cxa_finalize.c:56 
#4 ??() at /usr/lib/x86_64-linux-gnu/libboost_regex.so.1.54.0 
#5 ??() at 
#6 _dl_fini() at /build/eglibc-oGUzwX/eglibc-2.19/elf/dl-fini.c:252 

Это заставил меня думать, что я должен делать что-то с повышающим регулярным выражением, но я не могу за жизнь мне выясните это. То, как я использую регулярное выражение, заключается в том, что пользователи могут вводить пучок строк. Эти строки могут быть обычным текстом, или они могут быть регулярными выражениями. Из-за этого я в основном взаимодействую со всеми входами в качестве регулярных выражений. Но что, если пользователь дал строку, которая была предназначена как простой текст, но имела символ, который может быть интерпретирован по-разному как регулярное выражение? То, что я делаю, - это пройти через строки ввода обычного текста и избежать всех этих символов.

Вот код, с которым я работаю. Это моя основная:

int 
main(int argc, char * argv[]) 
{ 

    // Process input arguments 
    // The desired input is numVertices (int), graph density (double between 0 and 1), halfLoss (double), total loss (double), 
    // position expanse (double, m), velocity expanse (double, m/s) 
    int num_vertices; 
    double graph_density ; 
    double half_loss; 
    double total_loss; 
    double position_expanse; 
    double velocity_expanse; 

    if (argc == 1) 
    { 
     num_vertices = 48; 
     graph_density = 1; 
     half_loss = 200000; 
     total_loss = 400000; 
     position_expanse = 400000; 
     velocity_expanse = 10000; 
    } 
    else 
    { 
     if (argc != 7) 
     { 
      std::cerr << "Need 6 input arguments" << std::endl; 
      return 1; 
     } 

     std::istringstream ss(argv[1]); 
     num_vertices; 
     if (!(ss >> num_vertices)) 
      std::cerr << "First input must be an integer" << std::endl; 

     graph_density = read_double_input(argv[2]); 
     half_loss = read_double_input(argv[3]); 
     total_loss = read_double_input(argv[4]); 
     position_expanse = read_double_input(argv[5]); 
     velocity_expanse = read_double_input(argv[6]); 
    } 

    // Determine how many edges to create 
    int num_edges = (int) ((graph_density * num_vertices * (num_vertices - 1)) + 0.5); 

    // Create the edges 
    int edges_created = 0; 
    std::set<std::pair<int, int> > edge_set; 
    while (edge_set.size() < num_edges) 
    { 

     // Pick a random start vertex and end vertex 
     int start_vertex = rand() % num_vertices; 
     int end_vertex = rand() % num_vertices; 

     // Make sure the start and end vertices are not equal 
     while (start_vertex == end_vertex) 
     { 
      end_vertex = rand() % num_vertices; 
     } 

     // Insert the new edge into our set of edges 
     edge_set.insert(std::pair<int, int>(start_vertex, end_vertex)); 

    } 

    // Create connection handler 
    ConnectionHandler conn_handler; 

    // Create lists for from and to vertices 
    std::vector<std::string> from_list; 
    std::vector<std::string> to_list; 

    // Add connections to from and to lists 
    for (std::set<std::pair<int, int> >::const_iterator edge_it = edge_set.begin(), end_it = edge_set.end(); edge_it != end_it; ++edge_it) 
    { 
     int start_vertex = edge_it->first; 
     int end_vertex = edge_it->second; 
     from_list.push_back("Radio" + int_to_string(start_vertex)); 
     to_list.push_back("Radio" + int_to_string(end_vertex)); 
    } 

    // Read the list into the connection handler 
    conn_handler.read_connection_list(true, from_list, to_list);  
    return 0; 

} 

Этот код имеет этот объект ConnectionHandler, который я создал. Вот заголовок для этого:

#ifndef CLCSIM_CONNECTIONHANDLER_HPP_ 
#define CLCSIM_CONNECTIONHANDLER_HPP_ 

#include <models/network/NetworkTypes.hpp> 
#include <generated/xsd/NetworkModelInterfaceConfig.hpp> 

namespace clcsim 
{ 

typedef std::map<std::string, std::set<std::string> > ConnectionFilter; 

class ConnectionHandler 
{ 

public: 

    ConnectionHandler(); 
    ~ConnectionHandler(); 

    void read_connection_list(const bool is_white_list, const std::vector<std::string> &from_radios, const std::vector<std::string> &to_radios); 


private: 

    ConnectionFilter filter_; 
    std::set<std::string> from_list_; 
    std::set<std::string> to_list_; 
    bool is_white_list_; 

}; 

} // namespace clcsim 

#endif // CLCSIM_CONNECTIONHANDLER_HPP_ 

А вот источник:

#include <models/network/ConnectionHandler.hpp> 
#include <oasis/framework/exceptions/ConfigurationException.h> 
#include <boost/regex.hpp> 

namespace clcsim 
{ 

ConnectionHandler:: 
ConnectionHandler() 
{ 
} 

ConnectionHandler:: 
~ConnectionHandler() 
{ 
    std::cout << "Destructing conn handler" << std::endl; 
} 

void 
ConnectionHandler:: 
read_connection_list(
    const bool is_white_list, 
    const std::vector<std::string> &from_radios, 
    const std::vector<std::string> &to_radios) 
{ 

    std::cout << "Reading the connection list" << std::endl; 

    // Make sure the size of both the input vectors are the same 
    std::size_t from_radio_size = from_radios.size(); 
    std::size_t to_radio_size = to_radios.size(); 
    if (from_radio_size != to_radio_size) 
    { 
     throw ofs::ConfigurationException("Error while initializing the " 
              "Network model: " 
              "Connections in from/to lists don't align" 
             ); 
    } 

    // Create a regular expression/replacement to find all characters in a non-regular expression 
    // that would be interpreted as special characters in a regular expression. Replace them with 
    // escape characters 
    const boost::regex esc("[.$|()\\[\\]{}*+?\\\\]"); 
    const std::string rep("\\\\&"); 

    // Iterate through the specified connections 
    for (int i = 0; i < from_radio_size; ++i) 
    { 

     std::string from_string = boost::regex_replace(from_radios[i], esc, rep, boost::match_default | boost::format_sed); 
     std::string to_string = boost::regex_replace(to_radios[i], esc, rep, boost::match_default | boost::format_sed); 
     //std::cout << "From " << from_string << " to " << to_string << std::endl; 
     filter_[from_string].insert(to_string); 
     //filter_[from_radios.at(i)].insert(to_radios.at(i)); 
    } 

    std::cout << "Got here" << std::endl; 

} 


} // namespace clcsim 

Извините за столько кода.

Я видел похожие потоки, связанные с segfaults с boost :: regex. В этих примерах у пользователей был действительно простой код, который только что создавал регулярное выражение и соответствовал ему, и столкнулся с ошибкой. Оказалось, что проблема связана с версией Boost. Я попытался проверить, могу ли я воспроизвести подобные ошибки, но эти простые примеры работали отлично для меня. Так что ... я довольно тупой. Я бы очень признателен за любую помощь!

Answer 1

Чтобы удалить это из списка «Без ответа», я отправлю ответ, который был указан в комментариях, а не здесь. ОП определил, что предложение о том, что Boost связано с eglibc, действительно противоречило остальной части кода, связанного с glibc. Таким образом, ОП обнаружил, что модернизация своей ОС так, что связанные с eglibc библиотеки больше не использовались, устранила проблему.