Overriding ofstream operator<< - c++

Question

Why i still have ERROR: exepected an identifier in std::ofstream << val on the line below? msvc.
std::ostream& operator<< (bool val) { m_lock.lock(); std::ofstream << val; m_lock.unlock(); return *this; }
class OfstreamLog : public std::ofstream {
private:
std::mutex m_lock;
public:
OfstreamLog() : std::ofstream() { }
explicit OfstreamLog(const char* filename, ios_base::openmode mode = ios_base::out) : std::ofstream(filename, mode) { }
std::ostream& operator<< (bool val) { m_lock.lock(); std::ofstream << val; m_lock.unlock(); return *this; }
std::ostream& operator<< (short val);
std::ostream& operator<< (unsigned short val);
std::ostream& operator<< (int val);
std::ostream& operator<< (unsigned int val);
std::ostream& operator<< (long val);
std::ostream& operator<< (unsigned long val);
std::ostream& operator<< (float val);
std::ostream& operator<< (double val);
std::ostream& operator<< (long double val);
std::ostream& operator<< (void* val);
std::ostream& operator<< (std::streambuf* sb);
std::ostream& operator<< (std::ostream& (*pf)(std::ostream&));
std::ostream& operator<< (std::ios& (*pf)(std::ios&));
std::ostream& operator<< (ios_base& (*pf)(ios_base&));
};

Answer 1

std::ofstream is a type name. You can't call a nonstatic method or operator for it without any object.
In this case you probably want std::ofstream::operator<<(val); instead of std::ofstream << val;.
Explanation:
When you want to call method of a parent class from method of a child class, you do it like this:
class A
{
void func() {}
};
class B
{
void test()
{
func(); // Like this
}
};
But if child class have method with same name (more precisely, with same signature (it means, same name and argument types)), it will be called instead of parent's one. To explicitly call the method of the parent class, you can use this syntax:
class A {...};
class B
{
void test()
{
A::func(); // Notice `A::`
}
};
Now let's talk about operators. When you want to call an operator, you usually use an object name for it, like object << 10;. But when you want to call operator of a class (or it's parent) from a method of this class, you should use full operator syntax:
class A
{
operator<<(int){}
};
class B
{
void test()
{
operator<<(10); // <-----
*this << 10; // Also you can do it like this
}
};
Now, we combine these two techniques:
If child class have operator with same signature as parent's one and you want to call operator of the parent, you do it like this:
class A {...};
class B
{
void test()
{
A::operator<<(10); // Notice `A::`
*(A*)this << 10; // Also you can do it like this
}
};