Fast templated call back implementation
The functionality you are trying to create already exists in std::function&lt;&gt; using std::bind&lt;&gt; to help.

Comments on the rest of the code:

Here you use emplace back:

  void attach ( CbType cb )
  {
    callbacks_.emplace_back(cb);
  }


Emplace back is usually used when you have the arguments and want to build the object in place using the arguments. By passing the object you are going to just invoke the copy constructor. As a result there is no benefit from using it. Though there is nothing wrong with using it either. Currently I am still working out when to use emplace_back() over push_back() but this is one situation where I would still use push_back().

Also because you pass the argument by value you are copying the object into the function then using the copy constructor to put it in the array resulting in another copy. So here I would pass by reference.

  void attach(CbType const&amp; cb)
  {
    callbacks_.push_back(cb);
  }


Don't use unnecessary casts

broadcast(static_cast&lt;unsigned int&gt;(price*100));

// This is easier to read as:

broadcast(price*100); // double is auto converted to unsigned int


Use standard types:

typedef Callback&lt;void,unsigned int&gt; CbType;

// Replace with:

typedef std::function&lt;void(unsigned int)&gt; CbType;


If you use the standard function then the equivalent to creation becomes much simpler

 p.attach(std::bind(&amp;Strategy::update,this, _1));


Don't use pointers where a reference is a better choice:

Strategy(Pricer*  p) :  p_(p) 


You are passing a pointer and not checking for NULL. Actually the code never checks for NULL so you must use a valid pointer. In this case you may as well pass a reference. If you want to store this internally as a pointer then take its address inside your object.

Strategy(Pricer&amp;  p) :  p_(&amp;p)  // p can never be invalid.