Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
std::basic_string::append(3)  C++ Standard Libary std::basic_string::append(3)

NAME
       std::basic_string::append - std::basic_string::append

Synopsis
	  basic_string&	append(	size_type count, CharT	 (1) (constexpr	since
	  ch );						     C++20)
	  basic_string&	append(	const basic_string& str	 (2) (constexpr	since
	  );						     C++20)
	  basic_string&	append(	const basic_string& str,
				size_type	     pos,	     size_type
       (until C++14)
	  count	);
	  basic_string&	     append(	  const	      basic_string&	  str,
       (since C++14)
				size_type	     pos,	     size_type
       (constexpr since
	  count			 =		     npos		    );
       C++20)
	  basic_string&	   append(    const    CharT*	 s,		   (4)
       (constexpr since
	  size_type			     count			    );
       C++20)
	  basic_string&	   append(    const   CharT*   s   );		   (5)
       (constexpr since
									      C++20)
	  template<		  class		      InputIt		     >
       (constexpr since
	  basic_string&	   append(    InputIt	 first,	   InputIt	   (6)
       C++20)
	  last );					 (3)
	  basic_string&						       append(
       (since C++11)
	  std::initializer_list<CharT>	    ilist      );		   (7)
       (constexpr since
									      C++20)
	  template<		class		  StringViewLike	     >
       (since C++17)
	  basic_string&	   append(    const    StringViewLike&	  t	   (8)
       (constexpr since
	  );
       C++20)
	  template< class StringViewLike >
									      (since
       C++17)
	  basic_string&	  append(    const    StringViewLike&	 t,	   (9)
       (constexpr since
									      C++20)
				size_type pos, size_type
	  count	= npos );

	  Appends additional characters	to the string.

	  1) Appends count copies of character ch.
	  2) Appends string str.
	  3) Appends a substring [pos, pos + count) of str.
	    *  If the requested	substring lasts	past the end of	the string, or
       if count	==
	      npos, the	appended substring is [pos, size()).
	    * If pos > str.size(), std::out_of_range is	thrown.
	  4) Appends characters	in the range [s, s + count).  This  range  can
       contain null
	  characters.
	  If [s, s + count) is not a valid range, the behavior is undefined.
	  5)  Appends the null-terminated character string pointed to by s, as
       if by append(s,
	  Traits::length(s)).
	  6) Appends characters	in the range [first, last).

	  This overload	has the	same effect as overload	(1) if InputIt	is  an
       (until C++11)
	  integral type.
	  This	overload  only	participates in	overload resolution if InputIt
       (since C++11)
	  qualifies as a LegacyInputIterator.

	  7) Appends characters	from the initializer list ilist.
	  8) Implicitly	converts t to a	string	view  sv  as  if  by  std::ba-
       sic_string_view<CharT,
	  Traits>  sv  =  t;, then appends all characters from sv as if	by ap-
       pend(sv.data(),
	  sv.size()).
	  This overload	participates in	overload resolution only if
	  std::is_convertible_v<const StringViewLike&,
				std::basic_string_view<CharT, Traits>> is true
       and
	  std::is_convertible_v<const StringViewLike&, const CharT*> is	false.
	  9) Implicitly	converts t to a	string	view  sv  as  if  by  std::ba-
       sic_string_view<CharT,
	  Traits>  sv =	t;, then appends the characters	from the subview [pos,
       pos + count) of
	  sv.
	    * If the requested subview extends past the	end of sv, or if count
       == npos,	the
	      appended subview is [pos,	sv.size()).
	    * If pos >=	sv.size(), std::out_of_range is	thrown.
	  This overload	participates in	overload resolution only if
	  std::is_convertible_v<const StringViewLike&,
				std::basic_string_view<CharT, Traits>> is true
       and
	  std::is_convertible_v<const StringViewLike&, const CharT*> is	false.

Parameters
	  count	      -	number of characters to	append
	  pos	      -	the index of the first character to append
	  ch	      -	character value	to append
	  first, last -	range of characters to append
	  str	      -	string to append
	  s	      -	pointer	to the character string	to append
	  ilist	      -	initializer list with the characters to	append
	  t	      -	object convertible to std::basic_string_view with  the
       characters to
			append

Return value
	  *this

Complexity
	  There	are no standard	complexity guarantees, typical implementations
       behave similar
	  to std::vector::insert().

Exceptions
	  If  the  operation  would  result  in	 size()	 >  max_size(),	throws
       std::length_error.

	  If an	exception is thrown for	any reason, this function has  no  ef-
       fect (strong
	  exception safety guarantee).

Example
       // Run this code

	#include <iostream>
	#include <string>

	int main()
	{
	    std::basic_string<char> str	= "string";
	    const char*	cptr = "C-string";
	    const char carr[] =	"Two and one";

	    std::string	output;

	    // 1) Append a char	3 times.
	    // Notice, this is the only	overload accepting chars.
	    output.append(3, '*');
	    std::cout << "1) " << output << '\n';

	    // 2) Append a whole string
	    output.append(str);
	    std::cout << "2) " << output << '\n';

	    // 3) Append part of a string (last	3 letters, in this case)
	    output.append(str, 3, 3);
	    std::cout << "3) " << output << '\n';

	    // 4) Append part of a C-string
	    //	Notice,	because	`append` returns *this,	we can chain calls to-
       gether
	    output.append(1, ' ').append(carr, 4);
	    std::cout << "4) " << output << '\n';

	    // 5) Append a whole C-string
	    output.append(cptr);
	    std::cout << "5) " << output << '\n';

	    // 6) Append range
	    output.append(&carr[3], std::end(carr));
	    std::cout << "6) " << output << '\n';

	    // 7) Append initializer list
	    output.append({' ',	'l', 'i', 's', 't'});
	    std::cout << "7) " << output << '\n';
	}

Output:
	1) ***
	2) ***string
	3) ***stringing
	4) ***stringing	Two
	5) ***stringing	Two C-string
	6) ***stringing	Two C-string and one
	7) ***stringing	Two C-string and one list

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	   Applied to	    Behavior as	published	       Correct
       behavior
	  LWG 847  C++98      there was	no exception safety	 added	strong
       exception safety
			      guarantee				 guarantee
	  LWG  2946  C++17	 overload (8) causes ambiguity in   avoided by
       making it a
			      some cases			 template

See also
	  append_range appends a range of characters to	the end
	  (C++23)      (public member function)
	  operator+=   appends characters to the end
		       (public member function)
	  strcat       concatenates two	strings
		       (function)
	  strncat      concatenates a certain  amount  of  characters  of  two
       strings
		       (function)
	  wcscat       appends a copy of one wide string to another
		       (function)
		       appends	a  certain  amount of wide characters from one
       wide string to
	  wcsncat      another
		       (function)

http://cppreference.com		  2024.06.10	  std::basic_string::append(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::basic_string::append&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help