Пользоваться Сетевой библиотекой Библиотеки/Узла Графика или Записать Мое Собственное?

Возможно, я смогу дать небольшое руководство по BGL.

Библиотека очень гибкая. Цена этого в том, что синтаксис может быть очень причудливым, чтобы учесть все возможности. Тем не менее, он достаточно гибкий, чтобы простые вещи можно было делать просто.

К сожалению, документация по усилению идет полным ходом, предоставляя описание только полной сложности, без намека на то, насколько простыми могут быть вещи.

( «Любая достаточно продвинутая технология неотличима от магии» - Артур Кларк. Он должен был сказать следующее: «Любая продвинутая технология, достаточно плохо задокументированная, неотличима от магии»

Подумайте:

typedef property_map<Graph, vertex_index_t>::type IndexMap;
IndexMap index = get(vertex_index, g);
typedef graph_traits<Graph>::vertex_iterator vertex_iter;
std::pair<vertex_iter, vertex_iter> vp;
for (vp = vertices(g); vp.first != vp.second; ++vp.first) {
   std::cout << index[*vp.first] <<  " ";
}

Вот как тур "предлагает распечатать список вершин графа. Однако небольшое исследование показывает, что вершина - это не более чем целочисленный индекс, и код можно значительно упростить до

for (int v = *vertices(g).first; v != *vertices(g).second; ++v)
    std::cout << v << " ";

. Возможно, есть некоторые волшебные вещи, которые не могут быть достигнуты с помощью этого упрощенного кода, но для повседневного использования разумно и радикально удалите синтаксис, инкрустирующий BGL, чтобы вы могли видеть, что вы кодируете.

Иногда сложный синтаксис не может быть удален. (Или, возможно, я просто не заметил основную истину). Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

и код можно значительно упростить до

for (int v = *vertices(g).first; v != *vertices(g).second; ++v)
    std::cout << v << " ";

. Возможно, есть некоторые волшебные вещи, которых нельзя достичь с помощью этого упрощенного кода, но для повседневного использования разумно резко сократить синтаксис, инкрустирующий BGL, чтобы вы могли видеть, что вы кодируете.

Иногда сложный синтаксис невозможно удалить. (Или, возможно, я просто не заметил скрытой правды). Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

и код можно значительно упростить до

for (int v = *vertices(g).first; v != *vertices(g).second; ++v)
    std::cout << v << " ";

. Возможно, есть некоторые волшебные вещи, которых нельзя достичь с помощью этого упрощенного кода, но для повседневного использования разумно радикально сократить синтаксис, инкрустирующий BGL, чтобы вы могли видеть, что вы кодируете.

Иногда сложный синтаксис невозможно удалить. (Или, возможно, я просто не заметил скрытой правды). Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

но для повседневного использования разумно резко сократить синтаксис, инкрустирующий BGL, чтобы вы могли видеть, что вы кодируете.

Иногда сложный синтаксис невозможно удалить. (Или, возможно, я просто не заметил основную истину). Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

но для повседневного использования разумно резко сократить синтаксис, инкрустирующий BGL, чтобы вы могли видеть, что вы кодируете.

Иногда сложный синтаксис невозможно удалить. (Или, возможно, я просто не заметил скрытой правды). Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.

Затем я обычно использую небольшую служебную функцию, чтобы инкапсулировать сложность и держать ее подальше от алгоритма, над которым я работаю.

Например, мне часто нужно перебирать дочерние элементы вершины

vector<int> getVertexChildren( int v )
{
    vector<int> vc;
    typedef std::pair<graph_traits<graph_t>::out_edge_iterator, graph_traits<graph_t>::out_edge_iterator> out_edge_iter_pair_t;
    for( out_edge_iter_pair_t ep = out_edges(v,m_tree);
        ep.first != ep.second; ++(ep.first))
    {
        vc.push_back( target( *ep.first, m_tree ) );
    }
    return vc;
}
#define FOR_ALL_CHILDREN( v ) vector<int> vc=getVertexChildren(v); BOOST_FOR_EACH( int child, vc )

Суть в следующем: go вперед и используйте BGL. Его можно упростить, чтобы делать простые вещи, но как только вы научитесь его использовать, вся огромная гибкость будет доступна, когда вам это нужно.