What is the point of clog?

Is it possible to redirect clog, cerr, cout, stdin, stdout, and/or stderr?

Yes. You want the rdbuf function.

ofstream ofs("logfile");
cout.rdbuf(ofs.rdbuf());
cout << "Goes to file." << endl;

Is the only difference between clog and cerr the buffering?

As far as I know, yes.

If you're in a posix shell environment (I'm really thinking of bash), you can redirect any file descriptor to any other file descriptor, so to redirect, you can just:

$ myprogram 2>&5 

to redirect stderr to the file represented by fd=5.

Edit: on second thought, I like @Konrad Rudolph's answer about redirection better. rdbuf() is a more coherent and portable way to do it.

As for logging, well...I start with the Boost library for all things C++ that isn't in the std library. Behold: Boost Logging v2

Edit: Boost Logging is not part of the Boost Libraries; it has been reviewed, but not accepted.

Edit: 2 years later, back in May 2010, Boost did accept a logging library, now called Boost.Log.

Of course, there are alternatives:

• Log4Cpp (a log4j-style API for C++)
• Log4Cxx (Apache-sponsored log4j-style API)
• Pantheios (defunct? last time I tried I couldn't get it to build on a recent compiler)
• Google's GLog (hat-tip @SuperElectric)

There's also the Windows Event logger.

And a couple of articles that may be of use:

• Logging in C++ (Dr. Dobbs)
• Logging and Tracing Simplified (Sun)

Since there are several answers here about redirection, I will add this nice gem I stumbled across recently about redirection:

#include <fstream>
#include <iostream>

class redirecter
{
public:
    redirecter(std::ostream & dst, std::ostream & src)
        : src(src), sbuf(src.rdbuf(dst.rdbuf())) {}
    ~redirecter() { src.rdbuf(sbuf); }
private:
    std::ostream & src;
    std::streambuf * const sbuf;
};

void hello_world()
{
    std::cout << "Hello, world!\n";
}

int main()
{
    std::ofstream log("hello-world.log");
    redirecter redirect(log, std::cout);
    hello_world();
    return 0;
}

It's basically a redirection class that allows you to redirect any two streams, and restore it when you're finished.