Re: Deriving my own stream class
Hello,
Dan Smithers wrote:
I want to write my own class derived from the ostream class.
I have been getting errors with my templates:
First, I get an error writing a nested template. If I leave the
function definition inside template class definition (commented out at
//1) then it compiles and runs fine, but if I declare and define the
function separately (at //2).
See the corrections below. I've tried to omit the friends where
possible. I have introduce a new public member.
Is the following syntax supported by g++?
template<typename charT, typename Traits>
template<typename T>
as I get the compiler error
"mystream.cpp:47: error: too many template-parameter-lists"
This happens with template methods of template classes only, you want to
write a free template function, so this should be one list, just
include the typename T in the first list.
I can't get the use_facet command to work (commented out at //3) as I
no longer have visibility of ostr for getloc and can't call it on my
derived class. Is there another way of achieving this?
This is due to two-phase lookup. The ostr at that place was not declared
anyway, but just using getloc() within the stream class does not work
either, it has to be this->getloc() to tell the compiler that the
function will be available at instantiation of the template.
I can't get the manipulator function / object combination to compile.
"mystream_test.cpp:11: error: no matching function for call to
?setfmt(const char [6])?"
Do I need to explicitly qualify the template?
Yes, you have without more changes. The problem is that the template
parameters for the output osmanip instance cannot be derived from input
parameters alone. The input is always const char*. You probably will
have to use a common osmanip for all streams and distinguish the
streams your manipulator can act on dynamically.
Finally, the compiler seems to get confused by the output operator in
the manipulator (at //4) and issues the following warning:
"mystream.h:41: warning: friend declaration ?Ostream&
operator<<(Ostream&, const osmanip<Ostream, Arg>&)? declares a
non-template function
mystream.h:41: warning: (if this is not what you intended, make sure
the function template has already been declared and add <> after the
function name here) -Wno-non-template-friend disables this warning"
Are these problems due to my own misunderstanding of templates?
Some I think yes. I have some feeling your are following manuals for
some pre-standard compiler or streams library. You can expect that some
things do not work out of the box.
There have been books written just on getting the stuff with streams and
locales right, there are cans full of worms and lots of errors to get
easily caught by. There are existing libraries for logging I would
consider first before rolling my own.
I have put all your code into one file with a few comments and tried to
get it running, see below.
I hope some of the experts on this can help if I have missed something,
especially on getting the manipulator right without the need to
qualify.
HTH,
Bernd Strieder
################################################################
// mystream.h
#include <iostream>
#ifndef __MY_STREAM_H
#define __MY_STREAM_H
template <typename charT, typename Traits=std::char_traits<charT> >
class CMyStream;
template <typename charT, typename Traits >
class CMyStream : virtual public std::basic_ostream<charT, Traits>
{
public:
charT *m_fmt;
public:
// constructor
CMyStream(std::basic_ostream<charT, Traits>& ostr, const char *fmt);
// destructor
~CMyStream();
// change format string
std::basic_ostream<charT, Traits>& format(const char *fmt);
// retrieve format string
charT *format() const;
};
template <class Ostream, class Arg>
class osmanip;
template <class Ostream, class Arg>
Ostream&
operator<< (Ostream& ostr, const osmanip<Ostream, Arg>& manip);
template <class Ostream, class Arg>
class osmanip {
public:
osmanip(Ostream& (*pf)(Ostream&, Arg), Arg arg);
Ostream& manipulate(Ostream&) const;
protected:
Ostream& (*pf_)(Ostream&, Arg);
Arg arg_;
};
template <class charT, class Traits>
inline std::basic_ostream<charT,Traits>&
sfmt(std::basic_ostream<charT,Traits>& ostr, const char* f);
template <class charT, class Traits>
inline osmanip<std::basic_ostream<charT, Traits>, const char*>
setfmt(const char* fmt);
//#include "mystream.cpp"`
#endif /* __MY_STREAM_H */
// mystream.cpp
//#include "mystream.h"
#ifndef __MY_STREAM_CPP
#define __MY_STREAM_CPP
using std::basic_ostream;
using std::use_facet;
using std::ctype;
template <typename charT, typename Traits>
CMyStream<charT, Traits>::CMyStream(basic_ostream<charT, Traits>& ostr,
const char *fmt = "log")
: std::ostream(ostr.rdbuf())
{
m_fmt = new charT[strlen(fmt)];
use_facet<ctype<charT> >(ostr.getloc()).widen(fmt, fmt+strlen(fmt),
m_fmt);
}
template <typename charT, typename Traits>
CMyStream<charT, Traits>::~CMyStream()
{
delete[] m_fmt;
}
template <typename charT, typename Traits>
basic_ostream<charT, Traits>&
CMyStream<charT, Traits>::format(const char *fmt)
{
delete[] m_fmt;
m_fmt = new charT[strlen(fmt)];
use_facet<ctype<charT> >(this->getloc()).widen(fmt, fmt+strlen(fmt),
m_fmt); //3
return *this;
}
template <typename charT, typename Traits>
charT *
CMyStream<charT, Traits>::format() const
{
charT *p = new charT[Traits::length(m_fmt)];
Traits::copy(p, m_fmt, Traits::length(m_fmt));
return p;
}
template <typename T, typename charT, typename Traits>
CMyStream<charT, Traits>& operator<<(CMyStream<charT, Traits>& ostr, //2
T val)
{
(basic_ostream<charT, Traits>&)ostr << ostr.m_fmt << " ";
(basic_ostream<charT, Traits>&)ostr << val;
return ostr;
}
template <class Ostream, class Arg>
osmanip<Ostream, Arg>::osmanip(Ostream& (*pf)(Ostream&, Arg), Arg arg)
: pf_(pf) , arg_(arg)
{
;
}
template <class Ostream, class Arg>
Ostream&
osmanip<Ostream, Arg>::manipulate(Ostream& ostr) const
{
return (*pf_)(ostr,arg_);
}
//4
template <class Ostream, class Arg>
Ostream& operator<< (Ostream& ostr, const osmanip<Ostream, Arg>& manip)
{
// (*manip.pf_)(ostr,manip.arg_);
// return ostr;
return manip.manipulate(ostr);
}
template <class charT, class Traits>
inline basic_ostream<charT,Traits>&
sfmt(basic_ostream<charT,Traits>& ostr, const char* f)
{
CMyStream<charT,Traits>* p;
try {
p = dynamic_cast<CMyStream<charT,Traits>*>(&ostr);
}
catch (std::bad_cast) {
return ostr;
}
p->format(f);
return ostr;
}
template <class charT,class Traits>
inline osmanip<basic_ostream<charT, Traits>,const char*>
setfmt(const char* fmt)
{
return osmanip<basic_ostream<charT,Traits>,const char*>(sfmt,fmt);
}
#endif /* __MY_STREAM_CPP */
// mystream_test.cpp
//#include "mystream.h"
int
main(int argc, char *argv[])
{
CMyStream<char> strm(std::cout);
strm << "Hello World!" << std::endl;
strm << "123 " << 123 << std::endl;
strm << setfmt<char, std::char_traits<char> >("ERROR") << "Byeee" <<
std::endl;
return 0;
}