Re: Policy-based class design or inheritance?

Hi all,

suppose we can choose between two approaches:

1) First approach (policy-based class design)

        template <typename OutputPolicy>
        class A {
                ...

        public:
                void print() {
                        OutputPolicy::print("...");
                }
        };

        // Policy class
        class OutputToStderr {
                static void print(const std::string &msg) {
                        std::cerr << msg;
                }
        };

        // other policy classes...

        A<OutputToStderr> a;
        ...
        a.print();

2) Second approach (classic inheritance)

        class A {
                ...

        public:
                virtual void print() = 0;
        }

        class AToStderr : public A {
        public:
                void print() {
                        std::cerr << "...";
                }
        };

        // other AToXXX classes

        AToStderr a;
        ...
        a.print();

Instinctively I tend toward the first approach. Inheritance is
undoubtedly a "pillar" of object-oriented programming, but if possible
I always look for an alternative design. (Inheritance introduces
issues not always obvious: it's really an "is a" model? the base class
should be made abstract? the polymorphic use of the class should be
allowed? the inheritance should be of interface or of implementation?
and so on.)

What alternative do you prefer?

Vincent