examples: C++11: Use auto.

Author: murraycu

example/accum-compile-times.cpp

@@ -69,12 +69,10 @@ main()
   file_dep_graph2 g(input_begin, input_end, n_vertices);
 #endif
 
-  typedef property_map < file_dep_graph2, vertex_name_t >::type name_map_t;
-  typedef property_map < file_dep_graph2, vertex_compile_cost_t >::type
-    compile_cost_map_t;
-
-  name_map_t name_map = get(vertex_name, g);
-  compile_cost_map_t compile_cost_map = get(vertex_compile_cost, g);
+  auto name_map = get(vertex_name, g);
+  auto compile_cost_map = get(vertex_compile_cost, g);
+  auto distance_map = get(vertex_distance, g);
+  auto color_map = get(vertex_color, g);
 
   std::ifstream name_in("makefile-target-names.dat");
   std::ifstream compile_cost_in("target-compile-costs.dat");

example/actor_clustering.cpp

@@ -50,21 +50,21 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
     // Map from the actor numbers on this line to the actor vertices
     typedef tokenizer<char_separator<char> > Tok;
     Tok tok(line, char_separator<char>(" "));
-    for (Tok::iterator id = tok.begin(); id != tok.end(); ++id) {
-      int actor_id = lexical_cast<int>(*id);
-      std::map<int, Vertex>::iterator v = actors.find(actor_id);
+    for (const auto& id : tok) {
+      auto actor_id = lexical_cast<int>(id);
+      auto v = actors.find(actor_id);
       if (v == actors.end()) {
-        Vertex new_vertex = add_vertex(Actor(actor_id), g);
+        auto new_vertex = add_vertex(Actor(actor_id), g);
         actors[actor_id] = new_vertex;
         actors_in_movie.push_back(new_vertex);
       } else {
         actors_in_movie.push_back(v->second);
       }
     }
 
-    for (std::vector<Vertex>::iterator i = actors_in_movie.begin();
+    for (auto i = actors_in_movie.begin();
          i != actors_in_movie.end(); ++i) {
-      for (std::vector<Vertex>::iterator j = i + 1; 
+      for (auto j = i + 1;
            j != actors_in_movie.end(); ++j) {
         if (!edge(*i, *j, g).second) add_edge(*i, *j, g);
       }
@@ -78,14 +78,12 @@ write_pajek_graph(std::ostream& out, const Graph& g,
                   VertexIndexMap vertex_index, VertexNameMap vertex_name)
 {
   out << "*Vertices " << num_vertices(g) << '\n';
-  typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
-  for (vertex_iterator v = vertices(g).first; v != vertices(g).second; ++v) {
+  for (auto v = vertices(g).first; v != vertices(g).second; ++v) {
     out << get(vertex_index, *v)+1 << " \"" << get(vertex_name, *v) << "\"\n";
   }
 
   out << "*Edges\n";
-  typedef typename graph_traits<Graph>::edge_iterator edge_iterator;
-  for (edge_iterator e = edges(g).first; e != edges(g).second; ++e) {
+  for (auto e = edges(g).first; e != edges(g).second; ++e) {
     out << get(vertex_index, source(*e, g))+1 << ' ' 
         << get(vertex_index, target(*e, g))+1 << " 1.0\n"; // HACK!
   }

example/adjacency_list.cpp

@@ -59,10 +59,8 @@ int main(int , char* [])
   const int V = 5;
   Graph g(V);
 
-  property_map<Graph, std::size_t VertexProperties::*>::type 
-    id = get(&VertexProperties::index, g);
-  property_map<Graph, std::string EdgeProperties::*>::type 
-    name = get(&EdgeProperties::name, g);
+  auto id = get(&VertexProperties::index, g);
+  auto name = get(&EdgeProperties::name, g);
 
   boost::graph_traits<Graph>::vertex_iterator vi, viend;
   int vnum = 0;

example/astar-cities.cpp

@@ -81,8 +81,8 @@ class distance_heuristic : public astar_heuristic<Graph, CostType>
     : m_location(l), m_goal(goal) {}
   CostType operator()(Vertex u)
   {
-    CostType dx = m_location[m_goal].x - m_location[u].x;
-    CostType dy = m_location[m_goal].y - m_location[u].y;
+    auto dx = m_location[m_goal].x - m_location[u].x;
+    auto dy = m_location[m_goal].y - m_location[u].y;
     return ::sqrt(dx * dx + dy * dy);
   }
 private:
@@ -160,7 +160,7 @@ int main(int argc, char **argv)
 
   // create graph
   mygraph_t g(N);
-  WeightMap weightmap = get(edge_weight, g);
+  auto weightmap = get(edge_weight, g);
   for(std::size_t j = 0; j < num_edges; ++j) {
     edge_descriptor e; bool inserted;
     boost::tie(e, inserted) = add_edge(edge_array[j].first,
@@ -171,8 +171,8 @@ int main(int argc, char **argv)
 
   // pick random start/goal
   boost::mt19937 gen(time(0));
-  vertex start = random_vertex(g, gen);
-  vertex goal = random_vertex(g, gen);
+  auto start = random_vertex(g, gen);
+  auto goal = random_vertex(g, gen);
 
 
   cout << "Start vertex: " << name[start] << endl;
@@ -202,14 +202,14 @@ int main(int argc, char **argv)
 
   } catch(found_goal fg) { // found a path to the goal
     list<vertex> shortest_path;
-    for(vertex v = goal;; v = p[v]) {
+    for(auto v = goal;; v = p[v]) {
       shortest_path.push_front(v);
       if(p[v] == v)
         break;
     }
     cout << "Shortest path from " << name[start] << " to "
          << name[goal] << ": ";
-    list<vertex>::iterator spi = shortest_path.begin();
+    auto spi = shortest_path.begin();
     cout << name[start];
     for(++spi; spi != shortest_path.end(); ++spi)
       cout << " -> " << name[*spi];

example/astar_maze.cpp

@@ -178,8 +178,8 @@ bool maze::solve() {
   dist_map distance;
   boost::associative_property_map<dist_map> dist_pmap(distance);
 
-  vertex_descriptor s = source();
-  vertex_descriptor g = goal();
+  auto s = source();
+  auto g = goal();
   euclidean_heuristic heuristic(g);
   astar_goal_visitor visitor(g);
 
@@ -192,7 +192,7 @@ bool maze::solve() {
   } catch(found_goal fg) {
     // Walk backwards from the goal through the predecessor chain adding
     // vertices to the solution path.
-    for (vertex_descriptor u = g; u != s; u = predecessor[u])
+    for (auto u = g; u != s; u = predecessor[u])
       m_solution.insert(u);
     m_solution.insert(s);
     m_solution_length = distance[g];
@@ -256,9 +256,9 @@ std::size_t random_int(std::size_t a, std::size_t b) {
 // Generate a maze with a random assignment of barriers.
 maze random_maze(std::size_t x, std::size_t y) {
   maze m(x, y);
-  vertices_size_type n = num_vertices(m.m_grid);
-  vertex_descriptor s = m.source();
-  vertex_descriptor g = m.goal();
+  auto n = num_vertices(m.m_grid);
+  auto s = m.source();
+  auto g = m.goal();
   // One quarter of the cells in the maze should be barriers.
   int barriers = n/4;
   while (barriers > 0) {
@@ -267,7 +267,7 @@ maze random_maze(std::size_t x, std::size_t y) {
     // Walls range up to one quarter the dimension length in this direction.
     vertices_size_type wall = random_int(1, m.length(direction)/4);
     // Create the wall while decrementing the total barrier count.
-    vertex_descriptor u = vertex(random_int(0, n-1), m.m_grid);
+    auto u = vertex(random_int(0, n-1), m.m_grid);
     while (wall) {
       // Start and goal spaces should never be barriers.
       if (u != s && u != g) {
@@ -277,7 +277,7 @@ maze random_maze(std::size_t x, std::size_t y) {
           barriers--;
         }
       }
-      vertex_descriptor v = m.m_grid.next(u, direction);
+      auto v = m.m_grid.next(u, direction);
       // Stop creating this wall if we reached the maze's edge.
       if (u == v)
         break;

example/bellman-example.cpp

@@ -27,8 +27,7 @@ struct edge_writer
     void operator() (std::ostream & out, const Edge & e) const
   {
     out << "[label=\"" << get(edge_weight, m_g, e) << "\"";
-    typename graph_traits < Graph >::vertex_descriptor
-      u = source(e, m_g), v = target(e, m_g);
+    auto u = source(e, m_g), v = target(e, m_g);
     if (m_parent[v] == u)
         out << ", color=\"black\"";
     else
@@ -71,8 +70,7 @@ main()
   Graph g(edge_array, edge_array + n_edges, N);
 #endif
   graph_traits < Graph >::edge_iterator ei, ei_end;
-  property_map<Graph, int EdgeProperties::*>::type 
-    weight_pmap = get(&EdgeProperties::weight, g);
+  auto weight_pmap = get(&EdgeProperties::weight, g);
   int i = 0;
   for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
     weight_pmap[*ei] = weight[i];
@@ -109,9 +107,8 @@ main()
 
   {
     for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
-      graph_traits < Graph >::edge_descriptor e = *ei;
-      graph_traits < Graph >::vertex_descriptor
-        u = source(e, g), v = target(e, g);
+      auto e = *ei;
+      auto u = source(e, g), v = target(e, g);
       // VC++ doesn't like the 3-argument get function, so here
       // we workaround by using 2-nested get()'s.
       dot_file << name[u] << " -> " << name[v]

example/bfs-example2.cpp

@@ -69,7 +69,7 @@ main()
 
   Size time = 0;
   typedef property_map<graph_t, std::size_t VertexProps::*>::type dtime_map_t;
-  dtime_map_t dtime_map = get(&VertexProps::discover_time, g);
+  auto dtime_map = get(&VertexProps::discover_time, g);
   bfs_time_visitor < dtime_map_t > vis(dtime_map, time);
   breadth_first_search(g, vertex(s, g), color_map(get(&VertexProps::color, g)).
     visitor(vis));

example/bfs-name-printer.cpp

@@ -17,16 +17,15 @@ void
 build_router_network(Graph & g, VertexNameMap name_map,
                      TransDelayMap delay_map)
 {
-  typename graph_traits < Graph >::vertex_descriptor a, b, c, d, e;
-  a = add_vertex(g);
+  auto a = add_vertex(g);
   name_map[a] = 'a';
-  b = add_vertex(g);
+  auto b = add_vertex(g);
   name_map[b] = 'b';
-  c = add_vertex(g);
+  auto c = add_vertex(g);
   name_map[c] = 'c';
-  d = add_vertex(g);
+  auto d = add_vertex(g);
   name_map[d] = 'd';
-  e = add_vertex(g);
+  auto e = add_vertex(g);
   name_map[e] = 'e';
 
   typename graph_traits<Graph>::edge_descriptor ed;
@@ -79,13 +78,13 @@ main()
   typedef adjacency_list < listS, vecS, directedS, VP, EP> graph_t;
   graph_t g;
 
-  property_map<graph_t, char VP::*>::type name_map = get(&VP::name, g);
-  property_map<graph_t, double EP::*>::type delay_map = get(&EP::weight, g);
+  auto name_map = get(&VP::name, g);
+  auto delay_map = get(&EP::weight, g);
 
   build_router_network(g, name_map, delay_map);
 
   typedef property_map<graph_t, char VP::*>::type VertexNameMap;
-  graph_traits<graph_t>::vertex_descriptor a = *vertices(g).first;
+  auto a = *vertices(g).first;
   bfs_name_printer<VertexNameMap> vis(name_map);
   std::cout << "BFS vertex discover order: ";
   breadth_first_search(g, a, visitor(vis));

example/bfs.cpp

@@ -129,7 +129,7 @@ int main(int , char* [])
   std::fill_n(d, 5, 0);
 
   // The source vertex
-  Vertex s = *(boost::vertices(G).first);
+  auto s = *(boost::vertices(G).first);
   p[s] = s;
   boost::breadth_first_search
     (G, s, 

example/bfs_neighbor.cpp

@@ -123,7 +123,7 @@ int main(int , char* [])
   std::fill_n(d, 5, 0);
 
   // The source vertex
-  Vertex s = *(boost::vertices(G).first);
+  auto s = *(boost::vertices(G).first);
   p[s] = s;
   boost::neighbor_breadth_first_search
     (G, s,