Author: sebor
Date: Tue Jul 27 21:00:50 2010
New Revision: 979869
URL: http://svn.apache.org/viewvc?rev=979869&view=rev
Log:
2010-07-27 Martin Sebor <[email protected]>
STDCXX-1047
* stdlibref/basic-string.html: Corrected typos and poor formatting.
Modified:
stdcxx/trunk/doc/stdlibref/basic-string.html
Modified: stdcxx/trunk/doc/stdlibref/basic-string.html
URL:
http://svn.apache.org/viewvc/stdcxx/trunk/doc/stdlibref/basic-string.html?rev=979869&r1=979868&r2=979869&view=diff
==============================================================================
--- stdcxx/trunk/doc/stdlibref/basic-string.html (original)
+++ stdcxx/trunk/doc/stdlibref/basic-string.html Tue Jul 27 21:00:50 2010
@@ -549,7 +549,7 @@ template <class InputIterator>
</TABLE></UL>
</UL>
-<A NAME="sec7"><H3>Destructors</H3></A>
+<A NAME="sec7"><H3>Destructor</H3></A>
<A NAME="idx327"></A><PRE><B>~basic_string</B> ();</PRE>
<UL>
@@ -1117,26 +1117,28 @@ void
<A NAME="sec12"><H3>Nonmember Operators</H3></A>
-<A NAME="idx373"></A><PRE>template<class charT, class traits, class
Allocator>
-basic_string
-<B>operator+</B>(const basic_string& lhs, const basic_string&
rhs);</PRE>
+<A NAME="idx373"></A><PRE>
+template<class charT, class traits, class Allocator>
+basic_string<charT, traits allocator>
+<B>operator+</B>(const basic_string<charT, traits allocator> &lhs,
const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a string of length <SAMP>lhs.size() + rhs.size()</SAMP>, where the
first <SAMP>lhs.size()</SAMP> elements are copies of the elements of
<SAMP>lhs</SAMP>, and the next <SAMP>rhs.size()</SAMP> elements are copies of
the elements of <SAMP>rhs</SAMP>.</P>
</UL>
-<A NAME="idx374"></A><PRE>template<class charT, class traits, class
Allocator>
-basic_string
-<B>operator+</B>(const charT* lhs, const basic_string& rhs);
+<A NAME="idx374"></A><PRE>
+template<class charT, class traits, class Allocator>
+basic_string<charT, traits allocator>
+<B>operator+</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
-basic_string
-<B>operator+</B>(charT lhs, const basic_string& rhs);
+basic_string<charT, traits allocator>
+<B>operator+</B>(charT lhs, const basic_string<charT, traits allocator>
& rhs);
template<class charT, class traits, class Allocator>
-basic_string
-<B>operator+</B>(const basic_string& lhs, const charT* rhs);
+basic_string<charT, traits allocator>
+<B>operator+</B>(const basic_string<charT, traits allocator> &lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
-basic_string
-<B>operator+</B>(const basic_string& lhs, charT rhs);</PRE>
+basic_string<charT, traits allocator>
+<B>operator+</B>(const basic_string<charT, traits allocator> &lhs,
charT rhs);</PRE>
<UL>
<P>Returns a string that represents the concatenation of two string-like
entities. These functions return, respectively:</P>
@@ -1148,21 +1150,23 @@ lhs + basic_string(1, rhs)
</UL>
-<A NAME="idx375"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx375"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator==</B>(const basic_string& lhs,
- const basic_string& rhs);</PRE>
+<B>operator==</B>(const basic_string<charT, traits allocator> &lhs,
+ const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value of <SAMP>true</SAMP> if <SAMP>lhs</SAMP> and
<SAMP>rhs</SAMP> are equal, and <SAMP>false</SAMP> if they are not. Equality is
defined by the <SAMP>compare()</SAMP> member function.</P>
</UL>
-<A NAME="idx376"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx376"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator==</B>(const charT* lhs, const basic_string& rhs);
+<B>operator==</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator==</B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator==</B>(const basic_string<charT, traits allocator> &lhs,
const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value indicating whether <SAMP>lhs</SAMP> and
<SAMP>rhs</SAMP> are equal. Equality is defined by the <SAMP>compare()</SAMP>
member function. These functions return, respectively:</P>
@@ -1172,21 +1176,23 @@ lhs == basic_string(rhs)
</UL>
-<A NAME="idx377"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx377"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator!=</B>(const basic_string& lhs,
- const basic_string& rhs);</PRE>
+<B>operator!=</B>(const basic_string<charT, traits allocator> &lhs,
+ const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value representing the inequality of <SAMP>lhs</SAMP> and
<SAMP>rhs</SAMP>. Inequality is defined by the <SAMP>compare()</SAMP> member
function.</P>
</UL>
-<A NAME="idx378"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx378"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator!=</B>(const charT* lhs, const basic_string& rhs);
+<B>operator!=</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator!=</B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator!=</B>(const basic_string<charT, traits allocator> &lhs,
const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value representing the inequality of <SAMP>lhs</SAMP> and
<SAMP>rhs</SAMP>. Inequality is defined by the <SAMP>compare()</SAMP> member
function. The functions return, respectively:</P>
@@ -1196,20 +1202,22 @@ lhs != basic_string(rhs)
</UL>
-<A NAME="idx379"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx379"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator<</B>(const basic_string& lhs, const basic_string&
rhs);</PRE>
+<B>operator<</B>(const basic_string<charT, traits allocator>
&lhs, const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical less-than
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Less-than is defined by
the <SAMP>compare() </SAMP>member.</P>
</UL>
-<A NAME="idx380"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx380"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator<</B>(const charT* lhs, const basic_string& rhs);
+<B>operator<</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator<</B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator<</B>(const basic_string<charT, traits allocator>
&lhs, const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical less-than
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Less-than is defined by
the<SAMP> compare() </SAMP>member function. These functions return,
respectively:</P>
@@ -1219,20 +1227,22 @@ lhs < basic_string(rhs)
</UL>
-<A NAME="idx381"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx381"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator></B>(const basic_string& lhs, const basic_string&
rhs);</PRE>
+<B>operator></B>(const basic_string<charT, traits allocator>
&lhs, const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical greater-than
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Greater-than is defined
by the<SAMP> compare()</SAMP> member function.</P>
</UL>
-<A NAME="idx382"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx382"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator></B>(const charT* lhs, const basic_string& rhs);
+<B>operator></B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator></B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator></B>(const basic_string<charT, traits allocator>
&lhs, const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical greater-than
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Greater-than is defined
by the <SAMP>compare()</SAMP> member. The functions return, respectively:</P>
@@ -1242,21 +1252,23 @@ lhs > basic_string(rhs)
</UL>
-<A NAME="idx383"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx383"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator<=</B>(const basic_string& lhs,
- const basic_string& rhs);</PRE>
+<B>operator<=</B>(const basic_string<charT, traits allocator>
&lhs,
+ const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical less-than-or-equal
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Less-than-or-equal is
defined by the <SAMP>compare()</SAMP> member function.</P>
</UL>
-<A NAME="idx384"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx384"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator<=</B>(const charT* lhs, const basic_string& rhs);
+<B>operator<=</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator<=</B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator<=</B>(const basic_string<charT, traits allocator>
&lhs, const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical less-than-or-equal
relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>. Less-than-or-equal is
defined by the <SAMP>compare()</SAMP> member function. These functions return,
respectively:</P>
@@ -1266,21 +1278,23 @@ lhs <= basic_string(rhs)
</UL>
-<A NAME="idx385"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx385"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator>=</B>(const basic_string& lhs,
- const basic_string& rhs);</PRE>
+<B>operator>=</B>(const basic_string<charT, traits allocator>
&lhs,
+ const basic_string<charT, traits allocator> &rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical
greater-than-or-equal relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>.
Greater-than-or-equal is defined by the <SAMP>compare()</SAMP> member
function.</P>
</UL>
-<A NAME="idx386"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx386"></A><PRE>
+template<class charT, class traits, class Allocator>
bool
-<B>operator>=</B>(const charT* lhs, const basic_string& rhs);
+<B>operator>=</B>(const charT* lhs, const basic_string<charT, traits
allocator> &rhs);
template<class charT, class traits, class Allocator>
bool
-<B>operator>=</B>(const basic_string& lhs, const charT* rhs);</PRE>
+<B>operator>=</B>(const basic_string<charT, traits allocator>
&lhs, const charT* rhs);</PRE>
<UL>
<P>Returns a boolean value representing the lexicographical
greater-than-or-equal relationship of <SAMP>lhs</SAMP> and <SAMP>rhs</SAMP>.
Greater-than-or-equal is defined by the <SAMP>compare()</SAMP> member. The
functions return, respectively:</P>
@@ -1290,38 +1304,41 @@ lhs >= basic_string(rhs)
</UL>
-<A NAME="idx387"></A><PRE>template <class charT, class traits, class
Allocator>
+<A NAME="idx387"></A><PRE>
+template <class charT, class traits, class Allocator>
void <B>swap</B>(basic_string<charT,traits,Allocator>& a,
- basic_string<charT,traits,Allocator>& b); </PRE>
+ basic_string<charT,traits,Allocator>& b); </PRE>
<UL>
<P>Swaps the contents of <SAMP>a</SAMP> and <SAMP>b</SAMP> by calling
<SAMP>a</SAMP>'s swap function on <SAMP>b</SAMP>.</P>
</UL>
-<A NAME="idx388"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx388"></A><PRE>
+template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
<B>operator>></B>(basic_istream<charT, traits>& is,
- basic_string& str);</PRE>
+ basic_string<charT, traits allocator> &str);</PRE>
<UL>
<P>All elements read from the stream <SAMP>is</SAMP>, except the delimiter,
are placed in <SAMP>str</SAMP>. After the read, the function returns
<SAMP>is</SAMP>.</P>
</UL>
-<A NAME="idx389"></A><PRE>template<class charT, class traits, class
Allocator>
+<A NAME="idx389"></A><PRE>
+template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
<B>operator<<</B>(basic_ostream <charT, traits>& os,
- const<charT, traits allocator> str);</PRE>
+ const basic_string<charT, traits allocator> &str);</PRE>
<UL>
<P>Writes all elements of <SAMP>str</SAMP> to <SAMP>os</SAMP> in order from
first to last. After the write, the function returns <SAMP>os</SAMP>.</P>
</UL>
<A NAME="sec13"><H3>Nonmember Functions</H3></A>
-<A NAME="idx390"></A><PRE>template <class Stream, class charT, class traits,
- class Allocator>
+<A NAME="idx390"></A><PRE>
+template <class Stream, class charT, class traits, class Allocator>
basic_istream<charT, traits>
<B>getline</B>(basic_istream<charT, traits> is,
- <charT, traits allocator> str, charT delim);</PRE>
+ basic_string<charT, traits allocator> &str, charT
delim);</PRE>
<UL>
<P>An unformatted input function that extracts characters from <SAMP>is</SAMP>
into <SAMP>str</SAMP> until <SAMP>npos - 1</SAMP> characters are read, the end
of the input sequence is reached, or the character read is <SAMP>delim</SAMP>.
</P>
</UL>
