迭代器模式

迭代器模式 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

using namespace std;


struct MenuItem {
    string name;
    string description;
    bool vegetarian;
    double price;

    MenuItem(string name,
             string description,
             bool vegetarian,
             double price)
    {
        this->name = name;
        this->description = description;
        this->vegetarian = vegetarian;
        this->price = price;
    }

    string getName() {
        return name;
    }

    string getDescription() {
        return description;
    }

    double getPrice() {
        return price;
    }

    bool isVegetarian() {
        return vegetarian;
    }
    string toString() {
        ostringstream oss;
        oss << name << ", $" << price << "\n   " << description;
        return oss.str();
    }
};

struct Iterator {
    virtual bool hasNext() = 0;
    virtual MenuItem *next() = 0;
};

struct Menu {
    virtual Iterator *createIterator() = 0;
};


struct DinerMenuIterator : public Iterator {
public:
    DinerMenuIterator(MenuItem **items) {
        position = 0;
        this->items = items;
    }

    MenuItem *next() {
        MenuItem *menuItem = items[position];
        position = position + 1;
        return menuItem;
    }

    bool hasNext() {
        if (position >= 6) {
            return false;
        } else {
            return true;
        }
    }
private:
    MenuItem **items;
    int position;
};


struct DinerMenu : public Menu {
public:
    DinerMenu() {
        numberOfItems = 0;
        addItem("Vegetarian BLT",
            "(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
        addItem("BLT",
            "Bacon with lettuce & tomato on whole wheat", false, 2.99);
        addItem("Soup of the day",
            "Soup of the day, with a side of potato salad", false, 3.29);
        addItem("Hotdog",
            "A hot dog, with saurkraut, relish, onions, topped with cheese",
            false, 3.05);
        addItem("Steamed Veggies and Brown Rice",
            "Steamed vegetables over brown rice", true, 3.99);
        addItem("Pasta",
            "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
            true, 3.89);
    }

    addItem(string name, string description,
            bool vegetarian, double price)
    {
        MenuItem *menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            cout << "Sorry, menu is full!  Can't add item to menu" << endl;
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems = numberOfItems + 1;
        }
    }

    MenuItem *getMenuItems() {
        return *menuItems;
    }

    virtual Iterator *createIterator() {
        return new DinerMenuIterator(menuItems);
    }
private:
    static const int MAX_ITEMS = 6;
    int numberOfItems;
    MenuItem *menuItems[MAX_ITEMS];
};


struct PancakeHouseMenuIterator : public Iterator {
public:
    PancakeHouseMenuIterator(vector<MenuItem *> items) {
        position = 0;
        this->items = items;
    }

    MenuItem *next() {
        MenuItem *menuItem = items[position];
        position = position + 1;
        return menuItem;
    }

    bool hasNext() {
        if (position >= items.size()) {
            return false;
        } else {
            return true;
        }
    }
private:
    vector<MenuItem *> items;
    int position;
};


struct PancakeHouseMenu : public Menu {
public:
    PancakeHouseMenu() {
        addItem("K&B's Pancake Breakfast",
            "Pancakes with scrambled eggs, and toast",
            true,
            2.99);

        addItem("Regular Pancake Breakfast",
            "Pancakes with fried eggs, sausage",
            false,
            2.99);

        addItem("Blueberry Pancakes",
            "Pancakes made with fresh blueberries",
            true,
            3.49);

        addItem("Waffles",
            "Waffles, with your choice of blueberries or strawberries",
            true,
            3.59);
    }

    addItem(string name, string description,
            bool vegetarian, double price)
    {
        MenuItem *menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.push_back(menuItem);
    }

    vector<MenuItem *> getMenuItems() {
        return menuItems;
    }

    virtual Iterator *createIterator() {
        return new PancakeHouseMenuIterator(menuItems);
    }

    string toString() {
        return "Objectville Pancake House Menu";
    }
private:
    vector<MenuItem *> menuItems;
};

struct Waitress {
public:
    Waitress(Menu *pancakeHouseMenu, Menu *dinerMenu) {
        this->pancakeHouseMenu = pancakeHouseMenu;
        this->dinerMenu = dinerMenu;
    }

    printMenu() {
        Iterator *pancakeIterator = pancakeHouseMenu->createIterator();
        Iterator *dinerIterator = dinerMenu->createIterator();
        cout << "MENU\n----\nBREAKFAST" << endl;
        printMenu(pancakeIterator);
        cout << "\nLUNCH" << endl;
        printMenu(dinerIterator);
    }

    printMenu(Iterator *iterator) {
        while (iterator->hasNext()) {
            MenuItem *menuItem = (MenuItem *)iterator->next();
            cout << menuItem->getName() << ", ";
            cout << menuItem->getPrice() << " -- ";
            cout << menuItem->getDescription() << endl;
        }
    }
private:
    Menu *pancakeHouseMenu;
    Menu *dinerMenu;
};

int main(int argc, char **argv)
{
    PancakeHouseMenu *pancakeHouseMenu = new PancakeHouseMenu();
    DinerMenu *dinerMenu = new DinerMenu();
    Waitress *waitress = new Waitress(pancakeHouseMenu, dinerMenu);

    waitress->printMenu();
}