#include <iostream>
    #include <vector>
    using namespace std;
    class Component
    { 
        public:
        virtual void traverse() = 0;
    };
    class Leaf: public Component
    {
        int value;
        public:
        Leaf(int val)
        {
            value = val;
        }
        void traverse()
        {
            cout << value << ' ';
        }
    };
    class Composite: public Component
    {
        vector < Component * > children;
        public:
        void add(Component *ele)
        {
            children.push_back(ele);
        }
        void traverse()
        {
            for (int i = 0; i < children.size(); i++)
                children[i]->traverse();
        }
    };
    int main()
    {
        Composite containers[4];
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < 3; j++)
                containers[i].add(new Leaf(i *3+j));
            for (int k = 1; k < 4; k++)
                containers[0].add(&(containers[k]));
            for (int p = 0; p < 4; p++)
            {
                containers[p].traverse();
            }
    }

    #include <iostream>
    #include <vector>
    #include <iterator>
    #include <stddef.h>
    using namespace std;
    template<class myType>
    class SimpleContainer
    {
        public:
        SimpleContainer(size_t xDim, size_t yDim, myType const& defaultValue)
        : objectData(xDim * yDim, defaultValue)
        , xSize(xDim)
        , ySize(yDim)
        {
        }
        myType& operator()(size_t x, size_t y)
        {
            return objectData[y * xSize + x];
        }
        myType const& operator()(size_t x, size_t y) const 
        {
            return objectData[y * xSize + x];
        }
        int getSize()
        {
            return objectData.size();
        }
        void inputEntireVector(vector<myType> inputVector)
        {
            objectData.swap(inputVector);
        }
        void printContainer(ostream& stream)
        {
            copy(objectData.begin(), objectData.end(),
            ostream_iterator<myType>(stream, ""/*No Space*/));
        }
        private:
        vector<myType> objectData;
        size_t  xSize;
        size_t  ySize;
    };
    template<class myType>
    inline ostream& operator<<(ostream& stream, SimpleContainer<myType>& object)
    {
        object.printContainer(stream);
        return stream;
    }
    void sampleContainerInterfacing();
    int main()
    {
        sampleContainerInterfacing();
        return 0;
    }
    void sampleContainerInterfacing()
    {
        static int const ConsoleWidth  = 80;
        static int const ConsoleHeight = 25;
        size_t width  = ConsoleWidth;
        size_t height = ConsoleHeight;
        SimpleContainer<int> mySimpleContainer(width, height, 0);
        cout << mySimpleContainer.getSize() << endl;
        mySimpleContainer(0, 0) = 5;
    }