I have been learning C++ for the past few weeks, and I made my first try with policy classes. Ultimately my goal is to use policy classes to manufacture wrapper classes on an `std::vector`. Part of what the wrapper class does is generate a custom allocator class that depends on the policy classes.

That's the inspiration for what I have below, which is a widget maker that makes widgets with a printing function that depends on the templated inputs.

Printing policy classes:

    template <class T>
    struct Chatty
    {
      static void logVal(T val){
        std::cout << val << std::endl;
      }
      static void logS(std::string s){
        std::cout << s << std::endl;
      }
    };
       
    template <class T>
    struct Silent
    {
      static void logVal(T val){}
      static void logS(std::string s){}
    };

**`Widget`**:

    class Widget {
    public:
      int x;
      int y;
      std::function<void(std::string)> print;
      Widget()
        :x(0), y(0), print([](std::string){})
      {};
    };

**`WidgetManager`**:

    template < template <class Created> class CreationPolicy, template <class Created> class LoggingPolicy>
    class WidgetManager : public CreationPolicy<Widget>, public LoggingPolicy<Widget>
    {
    public:
      WidgetManager() {};
      static Widget* doAll(){
        Widget* w = WidgetManager::Create();
        std::function<void(std::string)> f1 = WidgetManager::logS;
        w->print = WidgetManager::logS;
        return w;
      }
    };

I would appreciate feedback on all aspects of the code, but I also have two specific questions:

1. My biggest concern: **is there a better way to assign functions to the Widgets I am making?** For example, perhaps I could directly assign member functions of `Widget`s from my `WidgetManager`, but then I'd have to bind the `WidgetMaker`'s `static` functions to individual instances of `Widget`s, which seems like more overhead. What's best performance-wise?
2. I am sure `WidgetManager::doAll()` is not the way to go, but I am struggling to **find another way to call functions from various policies all together**. What's a better way to do this?