The document describes implementing a directory tree structure in C++. It includes class definitions for TreeNode and Directory, which represent nodes in the tree. Methods are defined for traversing the tree in different orders (pre-order, post-order, in-order) and performing actions on nodes during traversal. A makeDirectoryTree function builds a tree by traversing a real directory structure on disk.

1. Implementing a basic directory-tree structure that is derived from a base tree structure.
#ifndef SRC_TREENODE_HPP_
#define SRC_TREENODE_HPP_
#include
#include
//#define USE_OSS
#ifndef USE_OSS
#define OUT std::cout
#else
#include
extern std::ostringstream oss;
#define OUT oss
#endif
namespace ensc251 {
static unsigned count = 0;
class TreeNode;
typedef TreeNode* (TreeNode::*action_func)(void);
typedef void (TreeNode::*traverse_func)(const TreeNode*);
class TreeNode
{
typedef std::vector TreeNodePVect;
protected:
TreeNodePVect childPVector;
public:
TreeNode() {};
TreeNode(const TreeNode& nodeToCopy) {
// ***** this needs work *****
if (nodeToCopy.childPVector.size())
add_childP(nodeToCopy.childPVector[0]->clone());
}
virtual TreeNode* clone() const { return new TreeNode(*this); };
virtual ~TreeNode() {
// do not modify this insertion on OUT
OUT << "Destroying TreeNode with " << childPVector.size() << " children."<< std::endl;

2. // ***** Complete this member function *****
}
void swap(TreeNode & other) // the swap member function (should never fail!)
{
// ***** fill this in if desired *****
}
TreeNode & operator = (TreeNode other) // note: argument passed by value, copy made!
{
// ***** Complete this code *****
return *this; // by convention, always return *this
}
void add_childP(TreeNode* child) { /* ***** Complete this member function ***** */ }
void add_children(const TreeNodePVect& childPV) { childPVector.insert(childPVector.end(),
childPV.begin(), childPV.end()); }
const TreeNodePVect& get_children() const { return childPVector; }
TreeNode* traverse_children_post_order(traverse_func tf, action_func af)
{
for(auto childP : childPVector) {
(childP->*tf)(this); // traverse child's children using tf
}
return (this->*af)();
}
TreeNode* traverse_children_pre_order(traverse_func tf, action_func af)
{
// ***** Complete this member function *****
}
TreeNode* traverse_children_in_order(traverse_func tf, action_func af)
{
// ***** Complete this member function *****
}
TreeNode* count_action()
{
count++;
return nullptr;
}

3. void count_traverse(const TreeNode*)
{
traverse_children_post_order(count_traverse, count_action);
}
void reset_count() { count = 0; }
unsigned get_count() const { return count; }
};
}
#endif /* SRC_TREENODE_HPP_ */
#include "makeDirectoryTree.hpp"
using namespace std;
int doStuff()
{
// call function to build directory tree in memory
auto root_dir1P = make_directory_tree(".", "test_dir");
if (root_dir1P) {
root_dir1P->print_traverse(nullptr);
OUT << endl;
root_dir1P->reset_count();
root_dir1P->count_traverse(nullptr);
OUT << "Count is " << root_dir1P->get_count() << " " << endl;
auto root_dir2 = Directory(*root_dir1P); // copy construction
root_dir2.print_traverse(nullptr);
OUT << endl;
auto root_dir3P = make_directory_tree("test_dir", "Lectures");
if (root_dir3P) {
root_dir2 = *root_dir3P; // overloaded copy assignment operation
OUT << endl;
delete root_dir3P;
OUT << endl;
}
root_dir2.print_traverse(nullptr);
OUT << endl;
delete root_dir1P;
OUT << endl;
} // destructor for root_dir2 called.

4. OUT << endl;
return 0;
}
// don't remove the below line.
#ifndef DONT_RUN_MAIN
int main()
{
int rv = doStuff();
#ifdef USE_OSS
std::string s = oss.str();
cout << s << endl;
#endif
return rv;
}
#endif
/* End of dirTree.cpp file */
* makeDirectoryTree.cpp
#include
#include
#include // for find
#include "makeDirectoryTree.hpp"
// The below function may be replaced. Don't worry about trying to understand
// this version.
// traverse directories on the filesystem starting at a certain point and build
// a directory tree in memory
Directory *make_directory_tree(const std::string& path, const std::string& dir_name)
{
using namespace std;
static vector ignore_list = {".",".."};
auto newPath = path + "" + dir_name;
DIR *dir;
if ((dir = opendir(newPath.c_str())) == nullptr)
{
OUT << newPath.c_str() << " Error while opening " << newPath << endl;
return nullptr;
}

5. auto new_entity = new Directory(dir_name);
struct dirent *dptr;
while ((dptr = readdir(dir)))
{
if(find(ignore_list.begin(), ignore_list.end(), dptr->d_name) != ignore_list.end())
continue;
auto fullPath = newPath + "" + dptr->d_name;
struct stat filestat;
stat(fullPath.c_str(), &filestat);
if(S_ISDIR(filestat.st_mode))
{
auto node = make_directory_tree(newPath, dptr->d_name);
if (!node)
// add directory with no files or subdirs in case of permission problem
node = new Directory(dptr->d_name);
new_entity->add_childP(node);
}
else {
new_entity->add_file(dptr->d_name);
}
}
return new_entity;
}
/*
* makeDirectoryTree.hpp
#ifndef SRC_MAKEDIRECTORYTREE_HPP_
#define SRC_MAKEDIRECTORYTREE_HPP_
#include "Directory.hpp"
Directory *make_directory_tree(const std::string& path, const std::string& dir_name)
;
#endif /* SRC_MAKEDIRECTORYTREE_HPP_ */
#include "TreeNode.hpp"
#ifdef USE_OSS
std::ostringstream oss;
#define OUT oss
#endif

6. #ifndef SRC_DIRECTORY_HPP_
#define SRC_DIRECTORY_HPP_
#include "TreeNode.hpp"
#include
#include
#include
class Directory : public ensc251::TreeNode
{
typedef std::vector stringVect;
private:
std::string dir_name;
stringVect file_names;
public:
Directory(std::string m_dir_name): dir_name(m_dir_name) {}
Directory(std::string m_dir_name, stringVect m_file_names): dir_name(m_dir_name),
file_names(m_file_names) {}
virtual Directory* clone() const { /* ***** Complete this member function ***** */ };
void set_dir_name(const std::string& m_dir_name){ /* ***** Complete this member function
***** */ }
const std::string & get_dir_name() { return dir_name; }
void add_file(const std::string& m_fileName) { /* ***** Complete this member function
***** */ }
void add_multiple_files(const stringVect& m_files) { file_names.insert(file_names.end(),
m_files.begin(), m_files.end()); }
const stringVect & get_files() const { return file_names; }
TreeNode* print_action()
{
// Do not modify insertion on OUT in this member function!
OUT << std::setw(20) << dir_name+"t|" << " ";
OUT << this->childPVector.size() << " ";
for (auto file : file_names)
{
OUT << " -" << file;
}
OUT << std::endl;

7. return nullptr;
}
void print_traverse(const TreeNode*)
{
// ***** this needs work *****
// ***** encode the rules in the instructions
traverse_children_post_order(
static_cast(print_traverse),
static_cast(print_action));
}
};
#endif /* SRC_DIRECTORY_HPP_ */
Solution
Step 1: You get the assembly code reference, particularly you will need to know which
mnemonic corresponds to which machine code