Resource-efficient programming (INF205) lab u41: 13th October 2022

1. Module feedback and recommendations

Many thanks for providing your feedback and recommendations for the module in order to keep it on track.

Make sure to log out from your Google account when answering, so that you can remain anonymous.

2. "Rule of five" for tailored containers

The rule of five applies to self-designed containers that rely at least partly on manual memory management for the data of which they have ownership. It states that for such classes, the programmer should implement each of the following, or else they will be restricted in their functionality:

• The destructor; strictly needed, without it there can be a memory leak.
• The copy constructor; if it is not there, copying during initialization of another object will not work correctly.
• The copy assignment operator; without it, copying to a pre-existing (already constructed) object will not work correctly.
• The move constructor; implementing it can speed up storing content in a new object right before an old one is deallocated.
• The move assignment operator; it can speed up moving content from an object that is about to be deallocated into a pre-existing (already constructed) object.

In the "sequence performance" example, all the five methods/operators are implemented for the class DynamicArray. For class SinglyLinkedList and class DoublyLinkedList, only the destructor is implemented. Supplying any of the other four will extend the ways in which objects of these classes can be copied or moved.

Implement at least one of the missing constructors/operators and check that it works by using it for a simple copy/move operation.

3. Graph data structure

The "incidence list graph" example defines three classes:

• class UndirInclistGraphNode: Node of the graph. Properties include an incidence list, implemented as an STL dynamic array (std::vector) of pointers to all the edges to which the node is incident. Nodes are labelled with a string that serves as their unique identifier. This class is not a container; it does not own the edges in the incidence list.
• class UndirInclistGraphEdge: Edge of the graph. Properties include pointers to the two nodes that are incident to the edge (i.e., the two end points of the edge). The edge also has an label, an integer that is here interpreted as the distance between its two incident nodes. This class is not a container; it does not own the two nodes to which it stores the pointers.
• class UndirInclistGraph: This is the graph, a container data structure with ownership of all its nodes and edges.

There are two methods for creating a node or an edge in the graph:

class UndirInclistGraph
{
   …
   UndirInclistGraphEdge* create_edge(std::string node_a_label, int edge_label, std::string node_b_label);
   UndirInclistGraphNode* create_node(std::string node_label);
   …
};

However, there is no method for erasing a node with a given label (if it exists) or for erasing an edge between two nodes with given labels (if it exists). Implement at least one of these methods, taking care that the data structure must continue to work consistently: The graph, its edges, and its nodes.

(See how far you get with one or both of the problems 2 and 3, and submit your code and findings through Canvas - many thanks!)