GIDForums  

Go Back   GIDForums > Computer Programming Forums > C++ Forum
Reload this Page Need help to analyze string header in C++
User Name
Password
Register FAQ Members List Calendar Search Today's Posts Mark Forums Read

 
 
Thread Tools Search this Thread Rate Thread
  #1  
Old 05-Dec-2007, 09:11
harikumar001 harikumar001 is offline
New Member
  
Join Date: Mar 2007
Posts: 4
harikumar001 is on a distinguished road

Need help to analyze string header in C++

Hi all,
I need to analyze the string header file in C++
Below given is the string header file.I do not understand certain aspects. Cud someone pls take a look at the header below and add ur comments in the code briefing out what the code is doing.
Wud be very helpful for me if anybody can do so.googling didnt help much.Thanks in advance
----------------------------------------------------------------------------
CPP / C++ / C Code:
// string standard header
 
#if _MSC_VER > 1000
#pragma once
#endif
 
#ifndef _STRING_
#define _STRING_
#include <istream>
 
#ifdef _MSC_VER
#pragma pack(push,8)
#endif /* _MSC_VER */
_STD_BEGIN
// basic_string TEMPLATE OPERATORS
template<class _E, class _Tr, class _A> inline
basic_string<_E, _Tr, _A> __cdecl operator+(
const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
basic_string<_E, _Tr, _A> __cdecl operator+(const _E *_L,
const basic_string<_E, _Tr, _A>& _R)
{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
basic_string<_E, _Tr, _A> __cdecl operator+(
const _E _L, const basic_string<_E, _Tr, _A>& _R)
{return (basic_string<_E, _Tr, _A>(1, _L) += _R); }
template<class _E, class _Tr, class _A> inline
basic_string<_E, _Tr, _A> __cdecl operator+(
const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
basic_string<_E, _Tr, _A> __cdecl operator+(
const basic_string<_E, _Tr, _A>& _L, const _E _R)
{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator==(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_L.compare(_R) == 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator==(const _E * _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_R.compare(_L) == 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator==(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (_L.compare(_R) == 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator!=(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator!=(const _E *_L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator!=(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_L.compare(_R) < 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<(const _E * _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_R.compare(_L) > 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (_L.compare(_R) < 0); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>(const _E * _L,
const basic_string<_E, _Tr, _A>& _R)
{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<=(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<=(const _E * _L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator<=(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>=(const basic_string<_E, _Tr, _A>& _L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_L < _R)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>=(const _E * _L,
const basic_string<_E, _Tr, _A>& _R)
{return (!(_L < _R)); }
template<class _E, class _Tr, class _A> inline
bool __cdecl operator>=(const basic_string<_E, _Tr, _A>& _L,
const _E *_R)
{return (!(_L < _R)); }
// basic_string INSERTERS AND EXTRACTORS
template<class _E, class _Tr, class _A> inline
basic_istream<_E, _Tr>& __cdecl operator>>(
basic_istream<_E, _Tr>& _I,
basic_string<_E, _Tr, _A>& _X)
{typedef ctype<_E> _Ctype;
typedef basic_istream<_E, _Tr> _Myis;
ios_base::iostate _St = ios_base::goodbit;
bool _Chg = false;
_X.erase();
const _Myis::sentry _Ok(_I);
if (_Ok)
{const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
_TRY_IO_BEGIN
_A::size_type _N = 0 < _I.width()
&& _I.width() < _X.max_size()
? _I.width() : _X.max_size();
_Tr::int_type _C = _I.rdbuf()->sgetc();
for (; 0 < --_N; _C = _I.rdbuf()->snextc())
if(_Tr::eq_int_type(_Tr::eof(), _C))
{_St |= ios_base::eofbit;
break; }
else if (_Fac.is(_Ctype::space,
_Tr::to_char_type(_C)))
break;
else
{_X.append(1, _Tr::to_char_type(_C));
_Chg = true; }
_CATCH_IO_(_I); }
_I.width(0);
if (!_Chg)
_St |= ios_base::failbit;
_I.setstate(_St);
return (_I); }
template<class _E, class _Tr, class _A> inline
basic_istream<_E, _Tr>& __cdecl getline(basic_istream<_E, _Tr>& _I,
basic_string<_E, _Tr, _A>& _X)
{return (getline(_I, _X, _I.widen('\n'))); }
template<class _E, class _Tr, class _A> inline
basic_istream<_E, _Tr>& __cdecl getline(basic_istream<_E, _Tr>& _I,
basic_string<_E, _Tr, _A>& _X, const _E _D)
{typedef basic_istream<_E, _Tr> _Myis;
ios_base::iostate _St = ios_base::goodbit;
bool _Chg = false;
_X.erase();
const _Myis::sentry _Ok(_I, true);
if (_Ok)
{_TRY_IO_BEGIN
_Tr::int_type _C = _I.rdbuf()->sgetc();
for (; ; _C = _I.rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
{_St |= ios_base::eofbit;
break; }
else if (_Tr::eq((_E)_C, _D))
{_Chg = true;
_I.rdbuf()->snextc();
break; }
else if (_X.max_size() <= _X.size())
{_St |= ios_base::failbit;
break; }
else
_X += _Tr::to_char_type(_C), _Chg = true;
_CATCH_IO_(_I); }
if (!_Chg)
_St |= ios_base::failbit;
_I.setstate(_St);
return (_I); }
template<class _E, class _Tr, class _A> inline
basic_ostream<_E, _Tr>& __cdecl operator<<(
basic_ostream<_E, _Tr>& _O,
const basic_string<_E, _Tr, _A>& _X)
{
_O << _X.c_str();
return (_O); }
 
 
#ifdef _DLL
#pragma warning(disable:4231) /* the extern before template is a non-standard extension */
 
extern template class _CRTIMP
basic_string<char, char_traits<char>, allocator<char> > __cdecl operator+(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template class _CRTIMP
basic_string<char, char_traits<char>, allocator<char> > __cdecl operator+(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template class _CRTIMP
basic_string<char, char_traits<char>, allocator<char> > __cdecl operator+(
const char, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template class _CRTIMP
basic_string<char, char_traits<char>, allocator<char> > __cdecl operator+(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template class _CRTIMP
basic_string<char, char_traits<char>, allocator<char> > __cdecl operator+(
const basic_string<char, char_traits<char>, allocator<char> >&, const char);
extern template _CRTIMP bool __cdecl operator==(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator==(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator==(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template _CRTIMP bool __cdecl operator!=(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator!=(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator!=(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template _CRTIMP bool __cdecl operator<(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator<(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator<(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template _CRTIMP bool __cdecl operator>(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator>(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator>(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template _CRTIMP bool __cdecl operator<=(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator<=(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator<=(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template _CRTIMP bool __cdecl operator>=(
const basic_string<char, char_traits<char>, allocator<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator>=(
const char *, const basic_string<char, char_traits<char>, allocator<char> >&);
extern template _CRTIMP bool __cdecl operator>=(
const basic_string<char, char_traits<char>, allocator<char> >&, const char *);
extern template class _CRTIMP
basic_istream<char, char_traits<char> >& __cdecl operator>>(
basic_istream<char, char_traits<char> >&,
basic_string<char, char_traits<char>, allocator<char> >&);
extern template class _CRTIMP
basic_istream<char, char_traits<char> >& __cdecl getline(
basic_istream<char, char_traits<char> >&,
basic_string<char, char_traits<char>, allocator<char> >&);
extern template class _CRTIMP
basic_istream<char, char_traits<char> >& __cdecl getline(
basic_istream<char, char_traits<char> >&,
basic_string<char, char_traits<char>, allocator<char> >&, const char);
extern template class _CRTIMP
basic_ostream<char, char_traits<char> >& __cdecl operator<<(
basic_ostream<char, char_traits<char> >&,
const basic_string<char, char_traits<char>, allocator<char> >&);
 
extern template class _CRTIMP
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > __cdecl operator+(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template class _CRTIMP
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > __cdecl operator+(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template class _CRTIMP
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > __cdecl operator+(
const wchar_t, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template class _CRTIMP
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > __cdecl operator+(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template class _CRTIMP
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > __cdecl operator+(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t);
extern template _CRTIMP bool __cdecl operator==(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator==(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator==(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template _CRTIMP bool __cdecl operator!=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator!=(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator!=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template _CRTIMP bool __cdecl operator<(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator<(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator<(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template _CRTIMP bool __cdecl operator>(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator>(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator>(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template _CRTIMP bool __cdecl operator<=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator<=(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator<=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template _CRTIMP bool __cdecl operator>=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator>=(
const wchar_t *, const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template _CRTIMP bool __cdecl operator>=(
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t *);
extern template class _CRTIMP
basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl operator>>(
basic_istream<wchar_t, char_traits<wchar_t> >&,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template class _CRTIMP
basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl getline(
basic_istream<wchar_t, char_traits<wchar_t> >&,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
extern template class _CRTIMP
basic_istream<wchar_t, char_traits<wchar_t> >& __cdecl getline(
basic_istream<wchar_t, char_traits<wchar_t> >&,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&, const wchar_t);
extern template class _CRTIMP
basic_ostream<wchar_t, char_traits<wchar_t> >& __cdecl operator<<(
basic_ostream<wchar_t, char_traits<wchar_t> >&,
const basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&);
 
#pragma warning(default:4231) /* restore previous warning */
#endif // _DLL
 
_STD_END
#ifdef _MSC_VER
#pragma pack(pop)
#endif /* _MSC_VER */
 
#endif /* _STRING */
 
/*
* Copyright (c) 1994 by P.J. Plauger. ALL RIGHTS RESERVED.
* Consult your license regarding permissions and restrictions.
*/
Last edited by admin II : 05-Dec-2007 at 10:35. Reason: Please surround your C++ code with [cpp] your code [/cpp]
  #2  
Old 05-Dec-2007, 11:08
Gamer_2k4's Avatar
Gamer_2k4 Gamer_2k4 is offline
Member
  
Join Date: Apr 2005
Location: Wisconsin
Posts: 117
Gamer_2k4 will become famous soon enough

Re: Need help to analyze string header in C++

Why do you need to know how each line of code works? The purpose of encapsulation is to allow you to use methods WITHOUT knowing how they work. If you just want to learn how to use the string functions, take a look here:
http://www.cplusplus.com/reference/string/string/
__________________
Gamer_2k4
 
 
« Previous Thread | Next Thread »

Recent GIDBlogOnce again, no time for hobbies by crystalattice

Thread Tools Search this Thread
Search this Thread:

Advanced Search
Rate This Thread
Rate This Thread:

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts
vB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Forum Jump

Similar Threads
Thread Thread Starter Forum Replies Last Post
Read a .html file, check that file for links salemite C Programming Language 10 17-Jan-2008 08:56
Multiple questions for C++ project devster420 C++ Forum 1 20-Apr-2007 22:26
Message Class TransformedBG C++ Forum 5 29-Nov-2006 22:28
variables return to previous value after i try to set them nasaiya MS Visual C++ / MFC Forum 2 14-Jun-2005 01:43
Help wit my source code compiler errors Krandygrl00 C++ Forum 1 06-Jun-2005 09:14

Network Sites: GIDNetwork · GIDWebHosts · GIDSearch · Learning Journal by J de Silva, The

All times are GMT -6. The time now is 17:21.

Contact Us - GIDForums™ - Archive - Top

vBulletin, Copyright © 2000 - 2009, Jelsoft Enterprises Ltd.