Technically, private inheritance should be used for "implementation inheritance" and public used for "interface inheritance".

For example, many of my classes inherit from NonCopyable (below) in order to disable their copy-constructor and assignment operator.

class NonCopyable
{
public:
	NonCopyable(){}
private:
	NonCopyable( const NonCopyable& );
	NonCopyable& operator=( const NonCopyable& );
};

class Example : NonCopyable
{
public:
	Example(int i=0) : foo(i) {}
private:
	int foo;
};

Now, I could've written "class Example : public NonCopyable", and the code would work just the same... but public inheritance is designed to express an "is a" relationship between classes, and in this case, I'm not trying to say that Example is a NonCopyable, I'm just trying to say that I want to re-use the implementation of NonCopyable inside Example.

With public-inheritance / interface-inheritance / is-a, you're promising to follow certain OOP rules, such as the LSP, where an algorithm that works on the base-class / interface type, will continue to work as expected if any derived type is used instead. In this case, I don't want anyone to go and write functions that take a "NonCopyable*" as input, so that detail is hidden with private/implementation inheritance instead.