#include <iostream>

namespace p {

struct Hello {
  template<class S>
  void operator()(S &out) const {
    out << "Hallo";
  }
};

struct Space {
  template<class S>
  void operator()(S &out) const {
    out << " ";
  }
};

struct World {
  template<class S>
  void operator()(S &out) const {
    out << "Welt";
  }
};

struct Quote {
  template<class S>
  void operator()(S &out) const {
    out << '!';
  }
};

struct NewLine {
  template<class S>
  void operator()(S &out) const {
    out << '\n';
  }
};

}

template<
  class Stream,
  class Hello = p::Hello,
  class Space = p::Space,
  class World = p::World,
  class Quote = p::Quote,
  class NewLine = p::NewLine
> void printHello(

  Stream &out,
  Hello hello = Hello(),
  Space space = Space(),
  World world = World(),
  Quote quote = Quote(),
  NewLine nl  = NewLine() )
{
  hello(out);
  space(out);
  world(out);
  quote(out);
  nl(out);
}

int main()
{
  printHello(std::cout);
}

Kritik?

#include <iostream>
#include <boost/signals2/signal.hpp>

struct Hello
{
  void operator()() const
  {
    std::cout << "Hello";
  }
};

struct World
{
  void operator()() const
  {
    std::cout << ", World!" << std::endl;
  }
};

struct GoodMorning
{
  void operator()() const
  {
    std::cout << "... and good morning!" << std::endl;
  }
};

int main()
{
  boost::signals2::signal<void ()> sig;

  sig.connect(1, World()); 
  sig.connect(0, Hello());

  sig.connect(GoodMorning());

  sig();

  return 0;
}

ist dann auch fast genauso von boost übernommen worden

Greetz

#include <iostream>
int main()
{
std::cout<<"hello world!"<<std:endl; return 0;
}

(ungetestet)