Index: src/lemon/bfs.h
===================================================================
--- src/lemon/bfs.h	(revision 1359)
+++ src/lemon/bfs.h	(revision 1367)
@@ -87,5 +87,5 @@
     ///\param G is the graph, to which
     ///we would like to define the \ref ProcessedMap
-    static ProcessedMap *createProcessedMap(const GR &G)
+    static ProcessedMap *createProcessedMap(const GR &)
     {
       return new ProcessedMap();
@@ -770,5 +770,5 @@
     ///\param G is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient to initialize
-    static PredMap *createPredMap(const GR &G) 
+    static PredMap *createPredMap(const GR &) 
     {
       return new PredMap();
@@ -803,5 +803,5 @@
     ///\param G is the graph, to which
     ///we would like to define the \ref ProcessedMap
-    static ProcessedMap *createProcessedMap(const GR &G)
+    static ProcessedMap *createProcessedMap(const GR &)
     {
       return new ProcessedMap();
@@ -832,5 +832,5 @@
     ///This function instantiates a \ref DistMap. 
     ///\param G is the graph, to which we would like to define the \ref DistMap
-    static DistMap *createDistMap(const GR &G)
+    static DistMap *createDistMap(const GR &)
     {
       return new DistMap();
@@ -989,5 +989,5 @@
     struct DefPredMapBase : public Base {
       typedef T PredMap;
-      static PredMap *createPredMap(const Graph &G) { return 0; };
+      static PredMap *createPredMap(const Graph &) { return 0; };
       DefPredMapBase(const TR &b) : TR(b) {}
     };
@@ -1010,5 +1010,5 @@
     struct DefReachedMapBase : public Base {
       typedef T ReachedMap;
-      static ReachedMap *createReachedMap(const Graph &G) { return 0; };
+      static ReachedMap *createReachedMap(const Graph &) { return 0; };
       DefReachedMapBase(const TR &b) : TR(b) {}
     };
@@ -1031,5 +1031,5 @@
     struct DefProcessedMapBase : public Base {
       typedef T ProcessedMap;
-      static ProcessedMap *createProcessedMap(const Graph &G) { return 0; };
+      static ProcessedMap *createProcessedMap(const Graph &) { return 0; };
       DefProcessedMapBase(const TR &b) : TR(b) {}
     };
@@ -1072,5 +1072,5 @@
     struct DefDistMapBase : public Base {
       typedef T DistMap;
-      static DistMap *createDistMap(const Graph &G) { return 0; };
+      static DistMap *createDistMap(const Graph &) { return 0; };
       DefDistMapBase(const TR &b) : TR(b) {}
     };
Index: src/lemon/concept/graph.h
===================================================================
--- src/lemon/concept/graph.h	(revision 1359)
+++ src/lemon/concept/graph.h	(revision 1367)
@@ -186,5 +186,5 @@
 	/// Copy constructor.
 	///
-	NodeIt(const NodeIt&) { }
+	NodeIt(const NodeIt& n) : Node(n) { }
 	/// Invalid constructor \& conversion.
 
@@ -196,5 +196,5 @@
 	/// Sets the iterator to the first node of \c g.
 	///
-	NodeIt(const StaticGraph& g) { }
+	NodeIt(const StaticGraph&) { }
 	/// Node -> NodeIt conversion.
 
@@ -268,5 +268,5 @@
 	/// Copy constructor.
 	///
-	OutEdgeIt(const OutEdgeIt&) { }
+	OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 
@@ -280,5 +280,5 @@
 	///@param n the node
 	///@param g the graph
-	OutEdgeIt(const StaticGraph& g, const Node& n) { }
+	OutEdgeIt(const StaticGraph&, const Node&) { }
 	/// Edge -> OutEdgeIt conversion
 
@@ -317,5 +317,5 @@
 	/// Copy constructor.
 	///
-	InEdgeIt(const InEdgeIt&) { }
+	InEdgeIt(const InEdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 
@@ -329,5 +329,5 @@
 	///@param n the node
 	///@param g the graph
-	InEdgeIt(const StaticGraph& g, const Node& n) { }
+	InEdgeIt(const StaticGraph&, const Node&) { }
 	/// Edge -> InEdgeIt conversion
 
@@ -335,5 +335,5 @@
 	/// This feature necessitates that each time we 
 	/// iterate the edge-set, the iteration order is the same.
-	InEdgeIt(const StaticGraph& g, const Edge& n) { }
+	InEdgeIt(const StaticGraph&, const Edge&) { }
 	/// Next incoming edge
 
@@ -362,5 +362,5 @@
 	/// Copy constructor.
 	///
-	EdgeIt(const EdgeIt&) { }
+	EdgeIt(const EdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 
@@ -373,5 +373,5 @@
 	/// node
 	///@param g the graph
-	EdgeIt(const StaticGraph& g) { }
+	EdgeIt(const StaticGraph&) { }
 	/// Edge -> EdgeIt conversion
 
@@ -414,5 +414,5 @@
 
 	///Copy constructor
-	NodeMap(const NodeMap&) { }
+	NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
 	///Assignment operator
 	NodeMap& operator=(const NodeMap&) { return *this; }
@@ -437,5 +437,5 @@
 	EdgeMap(const StaticGraph&, T) { }
 	///Copy constructor
-	EdgeMap(const EdgeMap&) { }
+	EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
 	///Assignment operator
 	EdgeMap& operator=(const EdgeMap&) { return *this; }
@@ -471,5 +471,5 @@
       ///and target node \c t.
       ///\return the new edge.
-      Edge addEdge(Node s, Node t) { return INVALID; }
+      Edge addEdge(Node, Node) { return INVALID; }
     
       /// Resets the graph.
@@ -501,10 +501,10 @@
       /// Deletes node \c n node.
       ///
-      void erase(Node n) { }
+      void erase(Node) { }
       /// Deletes an edge.
 
       /// Deletes edge \c e edge.
       ///
-      void erase(Edge e) { }
+      void erase(Edge) { }
 
       template <typename _Graph>
Index: src/lemon/concept/graph_component.h
===================================================================
--- src/lemon/concept/graph_component.h	(revision 1359)
+++ src/lemon/concept/graph_component.h	(revision 1367)
@@ -305,5 +305,5 @@
       /// If the graph does not contain node with the given id
       /// then the result of the function is undetermined. 
-      Node fromId(int id, Node) const { return INVALID;}
+      Node fromId(int , Node) const { return INVALID;}
 
       /// \brief Gives back an unique integer id for the Edge. 
@@ -318,5 +318,5 @@
       /// If the graph does not contain edge with the given id
       /// then the result of the function is undetermined. 
-      Edge fromId(int id, Edge) const { return INVALID;}
+      Edge fromId(int, Edge) const { return INVALID;}
 
       template <typename _Graph>
@@ -399,5 +399,5 @@
       /// Adds a new Edge connects the two Nodes to the graph.
       ///
-      Edge addEdge(const Node& from, const Node& to) {
+      Edge addEdge(const Node&, const Node&) {
 	return INVALID;
       }
@@ -746,5 +746,5 @@
       ///
       /// Copy Constructor.
-      GraphMap(const GraphMap&) {}
+      GraphMap(const GraphMap& gm) :ReadWriteMap<Item, _Value>(gm) {}
       
       /// \brief Assign operator.
@@ -810,5 +810,5 @@
 	///
 	/// Copy Constructor.
-	NodeMap(const NodeMap&) {}
+	NodeMap(const NodeMap& nm) : GraphMap<Graph, Node, _Value>(nm) {}
 
 	/// \brief Assign operator.
@@ -840,5 +840,5 @@
 	///
 	/// Copy Constructor.
-	EdgeMap(const EdgeMap&) {}
+	EdgeMap(const EdgeMap& em) :GraphMap<Graph, Edge, _Value>(em) {}
 
 	/// \brief Assign operator.
@@ -918,5 +918,5 @@
       ///
       /// Add an edge to the graph and notify the observers.
-      Edge addEdge(const Node& from, const Node& to) {
+      Edge addEdge(const Node&, const Node&) {
 	return INVALID;
       }
Index: src/lemon/concept/maps.h
===================================================================
--- src/lemon/concept/maps.h	(revision 1359)
+++ src/lemon/concept/maps.h	(revision 1367)
@@ -77,5 +77,5 @@
 
       /// Sets the value associated with a key.
-      void set(const Key &k,const Value &t) {}
+      void set(const Key &,const Value &) {}
 
       ///Default constructor
@@ -115,7 +115,7 @@
 
       /// Returns the value associated with a key.
-      Value operator[](const Key &k) const {return Value();}
+      Value operator[](const Key &) const {return Value();}
       /// Sets the value associated with a key.
-      void set(const Key &k,const Value &t) {}
+      void set(const Key & ,const Value &) {}
 
       template<typename _ReadWriteMap>
Index: src/lemon/concept/path.h
===================================================================
--- src/lemon/concept/path.h	(revision 1359)
+++ src/lemon/concept/path.h	(revision 1367)
@@ -55,5 +55,5 @@
       /// \param _G The graph in which the path is.
       ///
-      Path(const Graph &_G) {}
+      Path(const Graph &) {}
 
       /// Length of the path.
@@ -87,5 +87,5 @@
       /// Returns node iterator pointing to the target node of the
       /// given edge iterator.
-      NodeIt target(const EdgeIt& e) const {return INVALID;}
+      NodeIt target(const EdgeIt&) const {return INVALID;}
 
       /// \brief The source of an edge.
@@ -93,5 +93,5 @@
       /// Returns node iterator pointing to the source node of the
       /// given edge iterator.
-      NodeIt source(const EdgeIt& e) const {return INVALID;}
+      NodeIt source(const EdgeIt&) const {return INVALID;}
 
 
@@ -113,5 +113,5 @@
 	EdgeIt(Invalid) {}
 	/// Constructor with starting point
-	EdgeIt(const Path &_p) {}
+	EdgeIt(const Path &) {}
 
 	operator GraphEdge () const {}
@@ -121,7 +121,7 @@
 
 	/// Comparison operator
-	bool operator==(const EdgeIt& e) const {return true;}
-	/// Comparison operator
-	bool operator!=(const EdgeIt& e) const {return true;}
+	bool operator==(const EdgeIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const EdgeIt&) const {return true;}
 // 	/// Comparison operator
 //      /// \todo It is not clear what is the "natural" ordering.
@@ -145,5 +145,5 @@
 	NodeIt(Invalid) {}
 	/// Constructor with starting point
-	NodeIt(const Path &_p) {}
+	NodeIt(const Path &) {}
 
 	///Conversion to Graph::Node
@@ -153,7 +153,7 @@
 
 	/// Comparison operator
-	bool operator==(const NodeIt& e) const {return true;}
-	/// Comparison operator
-	bool operator!=(const NodeIt& e) const {return true;}
+	bool operator==(const NodeIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const NodeIt&) const {return true;}
 // 	/// Comparison operator
 //      /// \todo It is not clear what is the "natural" ordering.
@@ -202,5 +202,5 @@
 	///If the path is empty, you \em must call \ref setStartNode() before
 	///the first use of \ref pushFront().
-	void pushFront(const GraphEdge& e) {}
+	void pushFront(const GraphEdge&) {}
 
 	///Push a new edge to the back of the path
@@ -209,5 +209,5 @@
 	///If the path is empty, you \em must call \ref setStartNode() before
 	///the first use of \ref pushBack().
-	void pushBack(const GraphEdge& e) {}
+	void pushBack(const GraphEdge&) {}
 
 	///Commit the changes to the path.
@@ -219,5 +219,5 @@
 	///to add to the front of the path,
 	///using this function you may speed up the building.
-	void reserveFront(size_t r) {}
+	void reserveFront(size_t) {}
 	///Reserve (back) storage for the builder in advance.
 
@@ -225,5 +225,5 @@
 	///to add to the back of the path,
 	///using this function you may speed up the building.
-	void reserveBack(size_t r) {}
+	void reserveBack(size_t) {}
       };
     };
Index: src/lemon/concept/undir_graph.h
===================================================================
--- src/lemon/concept/undir_graph.h	(revision 1359)
+++ src/lemon/concept/undir_graph.h	(revision 1367)
@@ -47,5 +47,5 @@
 
       /// \e
-      UndirGraphEdge(const UndirGraphEdge&) {}
+      UndirGraphEdge(const UndirGraphEdge& e) : UndirGraph::UndirEdge(e) {}
 
       /// \e
@@ -470,5 +470,5 @@
       ///
       /// Returns the base node of the iterator
-      Node baseNode(IncEdgeIt e) const {
+      Node baseNode(IncEdgeIt) const {
 	return INVALID;
       }
@@ -476,5 +476,5 @@
       ///
       /// Returns the running node of the iterator
-      Node runningNode(IncEdgeIt e) const {
+      Node runningNode(IncEdgeIt) const {
 	return INVALID;
       }
Index: src/lemon/dfs.h
===================================================================
--- src/lemon/dfs.h	(revision 1359)
+++ src/lemon/dfs.h	(revision 1367)
@@ -87,5 +87,5 @@
     ///\param G is the graph, to which
     ///we would like to define the \ref ProcessedMap
-    static ProcessedMap *createProcessedMap(const GR &G)
+    static ProcessedMap *createProcessedMap(const GR &)
     {
       return new ProcessedMap();
@@ -777,5 +777,5 @@
     ///\param G is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient to initialize
-    static PredMap *createPredMap(const GR &G) 
+    static PredMap *createPredMap(const GR &) 
     {
       return new PredMap();
@@ -810,5 +810,5 @@
     ///\param G is the graph, to which
     ///we would like to define the \ref ProcessedMap
-    static ProcessedMap *createProcessedMap(const GR &G)
+    static ProcessedMap *createProcessedMap(const GR &)
     {
       return new ProcessedMap();
@@ -839,5 +839,5 @@
     ///This function instantiates a \ref DistMap. 
     ///\param G is the graph, to which we would like to define the \ref DistMap
-    static DistMap *createDistMap(const GR &G)
+    static DistMap *createDistMap(const GR &)
     {
       return new DistMap();
@@ -995,5 +995,5 @@
     struct DefPredMapBase : public Base {
       typedef T PredMap;
-      static PredMap *createPredMap(const Graph &G) { return 0; };
+      static PredMap *createPredMap(const Graph &) { return 0; };
       DefPredMapBase(const TR &b) : TR(b) {}
     };
@@ -1016,5 +1016,5 @@
     struct DefReachedMapBase : public Base {
       typedef T ReachedMap;
-      static ReachedMap *createReachedMap(const Graph &G) { return 0; };
+      static ReachedMap *createReachedMap(const Graph &) { return 0; };
       DefReachedMapBase(const TR &b) : TR(b) {}
     };
@@ -1037,5 +1037,5 @@
     struct DefProcessedMapBase : public Base {
       typedef T ProcessedMap;
-      static ProcessedMap *createProcessedMap(const Graph &G) { return 0; };
+      static ProcessedMap *createProcessedMap(const Graph &) { return 0; };
       DefProcessedMapBase(const TR &b) : TR(b) {}
     };
@@ -1078,5 +1078,5 @@
     struct DefDistMapBase : public Base {
       typedef T DistMap;
-      static DistMap *createDistMap(const Graph &G) { return 0; };
+      static DistMap *createDistMap(const Graph &) { return 0; };
       DefDistMapBase(const TR &b) : TR(b) {}
     };
Index: src/lemon/dijkstra.h
===================================================================
--- src/lemon/dijkstra.h	(revision 1366)
+++ src/lemon/dijkstra.h	(revision 1367)
@@ -788,5 +788,5 @@
     ///\param G is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient for the initialization
-    static PredMap *createPredMap(const GR &G) 
+    static PredMap *createPredMap(const GR &) 
     {
       return new PredMap();
@@ -806,5 +806,5 @@
     ///\param G is the graph, to which
     ///we would like to define the \ref ProcessedMap
-    static ProcessedMap *createProcessedMap(const GR &G)
+    static ProcessedMap *createProcessedMap(const GR &)
     {
       return new ProcessedMap();
@@ -820,5 +820,5 @@
     ///This function instantiates a \ref DistMap. 
     ///\param G is the graph, to which we would like to define the \ref DistMap
-    static DistMap *createDistMap(const GR &G)
+    static DistMap *createDistMap(const GR &)
     {
       return new DistMap();
@@ -975,5 +975,5 @@
     struct DefPredMapBase : public Base {
       typedef T PredMap;
-      static PredMap *createPredMap(const Graph &G) { return 0; };
+      static PredMap *createPredMap(const Graph &) { return 0; };
       DefPredMapBase(const TR &b) : TR(b) {}
     };
@@ -1016,5 +1016,5 @@
     struct DefDistMapBase : public Base {
       typedef T DistMap;
-      static DistMap *createDistMap(const Graph &G) { return 0; };
+      static DistMap *createDistMap(const Graph &) { return 0; };
       DefDistMapBase(const TR &b) : TR(b) {}
     };
Index: src/lemon/graph_to_eps.h
===================================================================
--- src/lemon/graph_to_eps.h	(revision 1366)
+++ src/lemon/graph_to_eps.h	(revision 1367)
@@ -364,8 +364,8 @@
     bool operator()(Edge a,Edge b) const 
     {
-      Node ai=min(g.source(a),g.target(a));
-      Node aa=max(g.source(a),g.target(a));
-      Node bi=min(g.source(b),g.target(b));
-      Node ba=max(g.source(b),g.target(b));
+      Node ai=std::min(g.source(a),g.target(a));
+      Node aa=std::max(g.source(a),g.target(a));
+      Node bi=std::min(g.source(b),g.target(b));
+      Node ba=std::max(g.source(b),g.target(b));
       return ai<bi ||
 	(ai==bi && (aa < ba || 
Index: src/test/undir_graph_test.cc
===================================================================
--- src/test/undir_graph_test.cc	(revision 1307)
+++ src/test/undir_graph_test.cc	(revision 1367)
@@ -57,24 +57,24 @@
   typedef typename Graph::EdgeIt EdgeIt;
 
-  cout << "Nodes" << endl;
+  std::cout << "Nodes" << std::endl;
   int i=0;
   for(NodeIt it(g); it!=INVALID; ++it, ++i) {
-    cout << "  " << i << ": " << g.id(it) << endl;
+    std::cout << "  " << i << ": " << g.id(it) << std::endl;
   }
 
-  cout << "UndirEdge" << endl;
+  std::cout << "UndirEdge" << std::endl;
   i=0;
   for(UEdgeIt it(g); it!=INVALID; ++it, ++i) {
-    cout << "  " << i << ": " << g.id(it) 
+    std::cout << "  " << i << ": " << g.id(it) 
 	 << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it)) 
-	 << ")" << endl;
+	 << ")" << std::endl;
   }
 
-  cout << "Edge" << endl;
+  std::cout << "Edge" << std::endl;
   i=0;
   for(EdgeIt it(g); it!=INVALID; ++it, ++i) {
-    cout << "  " << i << ": " << g.id(it)
+    std::cout << "  " << i << ": " << g.id(it)
 	 << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it)) 
-	 << ")" << endl;
+	 << ")" << std::endl;
   }
 
