The header <iosfwd> is used for forward declarations of template classes.

The non-standard header <stringfwd> is used for forward declarations of string class objects.

Overview of Streams and String Forward Declarations.

The ANSI/ISO standard calls for forward declarations of input and output streams for basic input and output, basic input and basic output. This is for both normal and wide character formats.

Metrowerks Standard Library includes a forward declaration of string objects.

Header <iosfwd>

The header <iosfwd> is used for forward declarations of template classes.

Header <iosfwd> Synopsis:

namespace std {
template<class charT> struct char_traits;
template<class T> class allocator;
// for MSL IO 
template <class charT, class traits = char_traits<charT> >
class basic_ios;

template <class charT, class traits = char_traits<charT> >
class basic_streambuf;

template <class charT, class traits = char_traits<charT> >
class basic_istream;

template <class charT, class traits = char_traits<charT> >
class basic_ostream;

template <class charT, class traits = char_traits<charT> >
class basic_iostream;

template <class charT, class traits = char_traits<charT>, 
	class Allocator = allocator<charT> >
class basic_stringbuf;

template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
class basic_istringstream;

template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
class basic_ostringstream;

template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
class basic_stringstream;

template <class charT, class traits = char_traits<charT> >
class basic_filebuf;

template <class charT, class traits = char_traits<charT> >
class basic_ifstream;

template <class charT, class traits = char_traits<charT> >
class basic_ofstream;

template <class charT, class traits = char_traits<charT> >
class basic_fstream;

template <class charT, class traits = char_traits<charT> >
class istreambuf_iterator;

template <class charT, class traits = char_traits<charT> >
class ostreambuf_iterator;

template <> struct char_traits<char>;

typedef basic_ios<char, char_traits<char> > ios;

typedef basic_streambuf<char, char_traits<char> > streambuf;
typedef basic_istream<char, char_traits<char> >   istream;
typedef basic_ostream<char, char_traits<char> >   ostream;
typedef basic_iostream<char, char_traits<char> >  iostream;

typedef basic_stringbuf<char, char_traits<char>, allocator<char> >    
	stringbuf;
typedef basic_istringstream<char, char_traits<char>,
	allocator<char> > istringstream;
typedef basic_ostringstream<char, char_traits<char>,
	allocator<char> > ostringstream;
typedef basic_stringstream<char, char_traits<char>, 
	allocator<char> > stringstream;

typedef basic_filebuf<char, char_traits<char> >  filebuf;
typedef basic_ifstream<char, char_traits<char> > ifstream;
typedef basic_ofstream<char, char_traits<char> > ofstream;
typedef basic_fstream<char, char_traits<char> >  fstream;

// for MSL wide character support

template <> struct char_traits<wchar_t>;

typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;

typedef basic_streambuf<wchar_t, char_traits<wchar_t> > wstreambuf;
typedef basic_istream<wchar_t, char_traits<wchar_t> >   wistream;
typedef basic_ostream<wchar_t, char_traits<wchar_t> >   wostream;
typedef basic_iostream<wchar_t, char_traits<wchar_t> >  wiostream;

typedef basic_stringbuf<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> >     wstringbuf;
typedef basic_istringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wistringstream;
typedef basic_ostringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wostringstream;
typedef basic_stringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> >  wstringstream;

typedef basic_filebuf<wchar_t, char_traits<wchar_t> >  wfilebuf;
typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
typedef basic_fstream<wchar_t, char_traits<wchar_t> >  wfstream;

//end wide character support and end MSL IO 

template <class state> class fpos;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
typedef long streamoff;
	} // namespace std

The template class basic_ios<charT, traits> serves as a base class for class basic_istream and basic_ostream.

The class ios is an instantiation of basic_ios specialized by the type char.

The class wios is an instantiation of basic_ios specialized by the type wchar_t.

Header <stringfwd>

This non-standard header can be used to forward declare basic_string (much like <iosfwd> forward declares streams). There is also a <stringfwd.h> that forward declares basic_string and places it into the global namespace.

WARNING!

The header <stringfwd> is a non standard header.

namespace std { // Optional
template <class T>  class allocator;
template<class charT>  struct char_traits;
template <class charT, class traits, class Allocator> 
class basic_string;
typedef basic_string <char, char_traits<char>, allocator<char> > 
string;
typedef basic_string 
<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > 
wstring;
}

Including <stringfwd> allows you to use a string object.

Example of <stringfwd> Inclusion of std::string:

#include <stringfwd>
class MyClass
{
....
     std::string* my_string_ptr;
};

The headers <stringfwd.h> and <string> can be used in combination to place string into the global namespace, much like is done with other <name.h> headers. The header <string.h> does not work because that is a standard C header.

Example of Stringfwd usage:

#include <stringfwd.h>
#include <string>
int main()
{
	string a("Hi");  // no std:: required
	return 0;
}