Object oriented graphs implementation in c++

Question

I have to implement a simulation of the WWW on c++ using graphs, where the nodes are Webpages and the directed edges are URLs.

In school, in our level, we are still starting in Object Oriented Programming, so they proposed to implement using the adjacency lists and adjacency matrices, but I don't like them, for they are memory monsters and very limited.

Question:
Can you propose another Data Structure (preferably Object Oriented stuff) that uses pointers (as edges) to other nodes, and where I can dynamically generate as many edges as I like???

I have read this but I haven't find anything helpful : Object Oriented implementation of graph data structures

Answer 1

Honestly trying to represent this in just one data structure will end up being pretty inefficient. In reality you have a smaller list of domain registrars which provide the lookup. Something more accurate than a single dumb graph would be:

#include <iostream>
#include <memory>
#include <map>
#include <vector>
#include <string>
#include <set>

class Webpage;
class Registrar : public std::enable_shared_from_this<Registrar> {
public:
    std::shared_ptr<Webpage> resolve(const std::string &url);
private:
    std::map<std::string, std::shared_ptr<Webpage>> pages;
};

class Webpage {
public:
    Webpage(std::shared_ptr<Registrar> registrar, const std::string &url) :
        registrar(registrar),
        url(url){
    }

    std::shared_ptr<Webpage> addLink(const std::string &url){
        links.push_back(url);
        return registrar->resolve(url);
    }

    std::vector<std::shared_ptr<Webpage>> resolvePageLinks(){
        std::vector<std::shared_ptr<Webpage>> pages;
        for (auto &linkUrl : links){
            pages.push_back(registrar->resolve(linkUrl));
        }
        return pages;
    }

    std::string getUrl() const{
        return url;
    }
private:
    std::string url;
    std::shared_ptr<Registrar> registrar;
    std::vector<std::string> links;
};

std::shared_ptr<Webpage> Registrar::resolve(const std::string &url){
    auto found = pages.find(url);
    if (found != pages.end()){
        return found->second;
    }
    else{
        auto webpage = std::make_shared<Webpage>(shared_from_this(), url);
        pages.insert({url, webpage});
        return webpage;
    }
}

void printPageHierarchy(std::shared_ptr<Webpage> current, int depth, std::set<std::shared_ptr<Webpage>> &visited){
    std::cout << std::string(3*depth, ' ');
    std::cout << current->getUrl() << std::endl;
    if (visited.find(current) == visited.end()){
        visited.insert(current);
        ++depth;
        for (auto page : current->resolvePageLinks()){
            printPageHierarchy(page, depth, visited);
        }
    }else{
        std::cout << std::string(3*depth, ' ');
        std::cout << "..." << std::endl;
    }
}

void printPageHierarchy(std::shared_ptr<Webpage> current){
    std::set<std::shared_ptr<Webpage>> visited;
    printPageHierarchy(current, 0, visited);
}

int main(){
    auto registrar = std::make_shared<Registrar>();
    auto site1 = registrar->resolve("site1.com");
    site1->addLink("site2.com");
    site1->addLink("site3.com")->addLink("site4.com")->addLink("site1.com");
    std::cout << "From site1.com:" << std::endl;    
    printPageHierarchy(site1);

    std::cout << "_____________\nFrom site3.com:" << std::endl;
    printPageHierarchy(registrar->resolve("site3.com"));
}

This is pretty simplistic, and obviously minimal. Your question makes it a little unclear what exactly your requirements actually are.