Vwwxrf

What can be done better? My future plans is to implement algorithms such as: DFS, BFS, Prims, Dijkstra, Kruskal, ...

Faults I know of:

• Not implementing rule of five

Vertex.h:

#pragma once

#include <iostream>
#include <unordered_map>

template<typename T>
class Vertex

public:
 Vertex(const T& value);
 ~Vertex();

 const T& value() const;

 void add_edge_in(Vertex<T>* dest, int weight);
 void add_edge_out(Vertex<T>* dest, int weight);
 void remove_edge_in(Vertex<T>* dest);
 void remove_edge_out(Vertex<T>* dest);
private:
 template<typename T> friend std::ostream& operator<<(std::ostream& out, const Vertex<T>& rhs);

 const T value_;
 std::unordered_map<Vertex<T>*, int> edges_in_;
 std::unordered_map<Vertex<T>*, int> edges_out_;
;

template<typename T>
Vertex<T>::Vertex(const T& value)
 : value_(value)



/*
 Removes all edges associated with this vertex
*/
template<typename T>
Vertex<T>::~Vertex<T>()

 for (auto edge : edges_in_)
 
 Vertex<T>* dest = edge.first;
 dest->remove_edge_in(this);
 
 for (auto edge : edges_out_)
 
 Vertex<T>* dest = edge.first;
 dest->remove_edge_out(this);
 


template<typename T>
const T& Vertex<T>::value() const

 return value_;


template<typename T>
void Vertex<T>::add_edge_in(Vertex<T>* dest, int weight)

 edges_in_.insert( dest, weight );


template<typename T>
void Vertex<T>::add_edge_out(Vertex<T>* dest, int weight)

 edges_out_.insert( dest, weight );


template<typename T>
void Vertex<T>::remove_edge_in(Vertex<T>* dest)

 edges_in_.erase(dest);


template<typename T>
void Vertex<T>::remove_edge_out(Vertex<T>* dest)

 edges_out_.erase(dest);


template<typename T>
std::ostream& operator<<(std::ostream& out, const Vertex<T>& rhs)

 out << "[" << rhs.value_ << "]:";
 out << "rn";
 out << "rnt EDGES_IN = ";
 for (auto edge : rhs.edges_in_)
 
 out << " (" << edge.first->value_ << ", " << edge.second << ")";
 
 out << " ,";
 out << "rnt EDGES_OUT = ";
 for (auto edge : rhs.edges_out_)
 
 out << " (" << edge.first->value_ << ", " << edge.second << ")";
 
 out << " ";
 out << "rn;";
 return out;

Graph.h:

#pragma once

#include "Vertex.h"
#include <iostream>
#include <vector>

template<typename T>
class Graph

public:
 Graph(const bool directed);
 ~Graph();

 void print() const;
 bool is_directed() const;

 void add_vertex(const T&);
 void remove_vertex(const T&);
 void add_edge(const T&, const T&, int weight);
 void remove_edge(const T&, const T&);
private:
 Vertex<T>* get_vertex(const T&);

 std::vector<Vertex<T>*> graph_;
 const bool directed_;
;

template<typename T>
Graph<T>::Graph(const bool directed)
 : directed_(directed)



template<typename T>
Graph<T>::~Graph()

 for (Vertex<T>* v : graph_)
 
 delete v;
 


template<typename T>
void Graph<T>::print() const

 for (Vertex<T>* v : graph_)
 
 std::cout << *v << std::endl;
 


template<typename T>
bool Graph<T>::is_directed() const

 return directed_;


template<typename T>
void Graph<T>::add_vertex(const T& value)

 graph_.push_back(new Vertex<T>(value));
 return;


template<typename T>
void Graph<T>::remove_vertex(const T& value)

 for (auto it = graph_.begin(); it != graph_.end(); ++it)
 
 if ((*it)->value() == value)
 
 delete *it;
 graph_.erase(it);
 return;
 
 


template<typename T>
void Graph<T>::add_edge(const T& src_value, const T& dest_value, int weight)

 Vertex<T>* src = get_vertex(src_value);
 Vertex<T>* dest = get_vertex(dest_value);

 src->add_edge_out(dest, weight);
 dest->add_edge_in(src, weight);

 if (!directed_)
 
 src->add_edge_in(dest, weight);
 dest->add_edge_out(src, weight);
 


template<typename T>
void Graph<T>::remove_edge(const T& src_value, const T& dest_value)

 Vertex<T>* src = get_vertex(src_value);
 Vertex<T>* dest = get_vertex(dest_value);

 src->remove_edge_out(dest);
 dest->remove_edge_in(src);

 if (!directed_)
 
 src->remove_edge_in(dest);
 dest->remove_edge_out(src);
 


template<typename T>
Vertex<T>* Graph<T>::get_vertex(const T& value)

 for (Vertex<T>* v : graph_)
 
 if (v->value() == value)
 
 return v;
 
 
 return nullptr;