Overall very good.

Only some minor pointers.

A look at some things to do differently

Namespaces

• Put your code in your own namespace.
• Include the namespace in the macro guard.

Only include headers you need.

#include <iostream>

It does not look like you need any stream functionality in the header file. Even if you did you should use the stream forward headers #include <iosfwd>in header file and use #include <iostream> includes in the source file.

Ownership semantics.

Ownership is about showing who is responsible for deleting a dynamic object. The trouble with pointers is that there is no ownership associated with them so using them is dangerous.

City *next;
City *previous;

Here I believe you are using it correctly. But I would make that clear by at least commenting it. That will make your intention be obvious.

B.Stroustroup and H.Sutter are trying to introduce the concept of Views which are non owning pointers.

GSL::view

But this is still just at the idea state but will (probably) become part of how modern C++ will be written in the future.

Always Initialize members

City(){}; // Note: that ';' is not required.

Here you default initialize your members. Default initialization of pointers does nothing and leaves then in an indeterminate state.

Use Initializer list to initialize members

If you don't initialize members in the initializer list then they will be initialized using the default constructor before the body of the constructor is entered.

SO in this constructor.

City(std::string initName, City *initNext, City *initPrevious, std::string initMessage)
{
    cityName = initName;
    next = initNext;
    previous = initPrevious;
    message = initMessage;
}

You first initialize the cityName and message using the default constructor. Then you use the assignment operator to copy the parameters into the members. This can be in-effecient. So prefer to use the initializer list so that members are constructed in the correct state as much as possible.

City(std::string initName, City *initNext, City *initPrevious, std::string initMessage)
    : cityName(initName)
    , message(initMessage)
    , next(initNext)
    , previous(initPrevious)
{}

Rule of Three

This is a simple rule. That states if you define the copy constructor assignment operator or destructor then you probably need to define all three.

Consider this code:

CommunicationNetwork    networkOne;
CommunicationNetwork    networkTwo(networkOne);  // Copy using the copy constructor.

You did not define the copy constructor. But the compiler generates a default copy constructor, assignment operator, destructor and default constructor. So the above code will compile. When pointers are involved the default version does not always work the way you want (hence the above rule). Please look up details in other questions but the short story this will lead to double delete as these object go out of scope.

Pass by const reference rather than value

void addCity(std::string, std::string);

Here you are making a copy of the parameters (both strings) each time you call this method. Strings are expensive to copy.

Style: * and & are part of the type

In C++ (different from C) the type qualifiers are traditionally placed next to the type not the variable.

City    obj;            // obj  is a "City"
City*   loop = nullptr; // loop is a "City pointer"
City&   next = obj;     // next is a "City reference"

Use operator<< to print the object.

Its OK to have your own print function (printNetwork()). Just also add an output operator.

But you should be able to specialize it by passing an output stream (even if the default is std::cout). Also printing the object should not modify the object so the print method should be const.

class CommunicationNetwork
{
    public:
        void printNetwork(std::ostream& out = std::cout) const;
        friend std::ostream& operator<<(std::ostream& out, CommunicationNetwork const& data)
        {
            data.printNetwork(out);
            return out;
        }
};

Don't use this.

using namespace std;

Please read. Why is “using namespace std;” considered bad practice?.

Your List design.

Using a sentinel (which seems to be what you are doing) is a very good idea for a doubly linked list because it actually reduces the complexity of writing the list code (because you don't have to test for NULL (there is always a sentinel)). But You are also testing for NULL so this leads me to suspect that you are doing it wrong.

There are several examples on code review how to do it correctly.

Prefer nullptr

Since C++11 the use of NULL has been deprecated in favor of using nullptr. It provides a type safe way of defining a null pointer.

Prefer "\n" over std::endl

They both add a \n character to the stream. But std::endl will also flush the stream. This is usually not what you want. Humans are very bad a deciding when t flush the stream and the default behaviour for flushing is very close to optimal. Let the code work out the optimal times when to flush. Also if it needs to flush (ie before reading input from std::cin) this is also done automatically.

Don't use Magic Values

void CommunicationNetwork::addCity(string prevCity,
                   string newCity)

Having prevCity have a special magic value of "First" is going to get you in trouble. I would use something else. Probably a specific function.

Prefer for(;;) over while()

Prefer the for loop over the while loop. Especially when you have a move next that can be put into the for condition rather than at the end of a statement block that may be a long way from the test condition.

Code Review

I would simplify some of the methods in CommunicationNetwork.

// Assuming correct Sentinal.
// Head and tail are the same element (the list is circular).
// The head element is not a member that holds data.
CommunicationNetwork::CommunicationNetwork()
    : head(new City)
{
    // The head is the sentinel. It is not part of the data.
    // The list id circular.
    // Because the list is circular, The head is the tail.

    head->next = head->prev = &head;
}
void CommunicationNetwork::~CommunicationNetwork()
{
    deleteNetwork();
    delete head;
}
void CommunicationNetwork::addCity(string const& prevCity, string const& newCity)
{
    City*  prevCity = find(prevCity);
    if (prevCity != nullptr) {
        addCityAfter(prevCity, newCity);
    }
}
void CommunicationNetwork::addCityAtFront(string const& newCity)
{
    addCityAfter(head, newCity);
}
void CommunicationNetwork::addCityAfter(City* prev, std::string const& city)
{
    City*  newValue  = newCity(city, prev->next, prev, "");
    prev->next->prev = newValue;
    prev->next       = newValue;
}
void CommunicationNetwork::deleteCity(string city)
{
    City*  city = find(prevCity);
    if (city != nullptr) {

        city->prev->next = city->next;
        city->next->prev = city->prev;
        delete city;
    }
}
void CommunicationNetwork::deleteNetwork()
{
    City* next;
    for(City* loop = head->next; loop != head; loop = next) {

         next = loop->next;
         delete loop;
    }
    // Because this is a public function we do need to leave the object
    // in a valid state with the sentinel still in place.
    head->next = head->prev = &head;
}
void CommunicationNetwork::find(string const& city)
{
    for(City* loop = head->next; loop != head; loop = loop->next) {
        if (loop->cityName == city) {
            return loop;
        }
    }
    return nullptr;
}