da3408dcb7
Changes to be committed: new file: Graph.cpp 1) Moved the actual declarations of functions from Graph.h into this file 2) Added get_p_edges() which will get all the edges from a specified point p 3) Added add_edge() which adds an edge between two points (start and end) modified: graph.h 1) Created initial function, constructor, and deconstructor declarations 2) Defined Point structure 3) Defined Edge structure modified: main.cpp 1) Removed any old code from my last project. I am starting clean on this file.
96 lines
2.9 KiB
C++
96 lines
2.9 KiB
C++
#include "Graph.h"
|
|
|
|
// Begin : Construction & Deconstruction
|
|
|
|
/** Constructor
|
|
* Creates a new Graph object
|
|
*
|
|
* @param max_points : Maximum number of points in the Graph
|
|
* @param max_edges : Maximum number of edges in the GRAPH (not the point)
|
|
*/
|
|
Graph::Graph(size_t max_points, size_t max_edges) noexcept
|
|
{
|
|
all_points = new(std::nothrow) Point[max_points] {};
|
|
all_edges = new(std::nothrow) Edge[max_edges] {};
|
|
|
|
if(all_points && all_edges)
|
|
{
|
|
p_capacity = max_points;
|
|
e_capacity = max_edges;
|
|
}
|
|
}
|
|
|
|
/**Deconstruction
|
|
* NOTE on the '~Graph()':
|
|
* The ~ flags this block as a deconstructor. It makes it so this runs before the object is removed from memory preventing memory leaks
|
|
* Find the memory buffers pointed to by all_points and all_edges, and mark that memory as available for other programs to use.
|
|
*
|
|
*/
|
|
Graph::~Graph()
|
|
{
|
|
delete[] all_points;
|
|
delete[] all_edges;
|
|
}
|
|
|
|
/** Move Constructor
|
|
* Instructions to move the current graph object from one memory location to another without copying
|
|
*/
|
|
Graph::Graph(Graph&& other) noexcept
|
|
: all_points(std::exchange(other.all_points, nullptr)),
|
|
all_edges(std::exchange(other.all_edges, nullptr)),
|
|
p_capacity(std::exchange(other.p_capacity, 0)),
|
|
e_capacity(std::exchange(other.e_capacity, 0)) {}
|
|
// End : Construction & Deconstruction
|
|
|
|
|
|
// Begin : Getters
|
|
|
|
/** Getter Function: get_p_edges
|
|
* Gets the address of the first edge for Point P at index p_index
|
|
*
|
|
* @param p_index : The index (int) of the point
|
|
* @returns Edge* : the address of the first edge for p_index
|
|
* */
|
|
Edge* Graph::get_p_edges(int p_index) noexcept
|
|
{
|
|
//Checking for for index validity and that the point has edges
|
|
if(p_index < 0 || (size_t)p_index >= p_capacity) return nullptr;
|
|
|
|
//assigning the start_point_index to be the first_edge in the points array of edges
|
|
//if it's negative one, there are not edges assigned
|
|
int start_point_index = all_points[p_index].first_edge;
|
|
if(start_point_index == -1) return nullptr;
|
|
|
|
//if there are edges it returns the address of the first edge so that the user can iterate through them like an array
|
|
return &all_edges[start_point_index];
|
|
}
|
|
|
|
|
|
|
|
// Begin : Setters
|
|
/** add_edge
|
|
* Adds an edge between two points
|
|
*
|
|
* @param start_point_index : the index of the starting point
|
|
* @param end_point_index : the index of the ending point
|
|
*
|
|
**/
|
|
void Graph::add_edge(int start_point_index, int end_point_index) noexcept
|
|
{
|
|
if (next_possible_edge >= e_capacity) return; // Buffer full
|
|
|
|
// 1. If this is the first edge for this point, record the start index
|
|
if (all_points[start_point_index].e_count == 0)
|
|
{
|
|
all_points[end_point_index].first_edge = next_possible_edge;
|
|
}
|
|
|
|
// 2. Place the edge in the flat buffer
|
|
all_edges[next_possible_edge].target_point = end_point_index;
|
|
|
|
// 3. Update counters
|
|
all_points[start_point_index].e_count++;
|
|
next_possible_edge++;
|
|
}
|
|
|
|
// End : Setters
|