std::basic_string<CharT,Traits,Allocator>::basic_string

If InputIt does not satisfy the requirements of LegacyInputIterator, overload (3) is called instead with arguments static_cast<size_type>(first), last and alloc.

(until C++11)

This overload participates in overload resolution only if InputIt satisfies the requirements of LegacyInputIterator.

If CharT is not EmplaceConstructible into std::basic_string <CharT> from *first, the behavior is undefined.

(since C++11)

5) Constructs a string with the contents of the range rg. Each iterator in rg is dereferenced exactly once.

If CharT is not EmplaceConstructible into std::basic_string <CharT> from *ranges::begin (rg), the behavior is undefined.

6) Constructs a string with the contents of the range [s, s + count).

If [s, s + count) is not a valid range, the behavior is undefined.

7) Equivalent to basic_string(s, Traits::length(s), alloc).

This overload participates in overload resolution only if Allocator satisfies the requirements of Allocator.

(since C++17)

8) std::basic_string cannot be constructed from nullptr.

9) Implicitly converts t to a string view sv as if by std::basic_string_view <CharT, Traits> sv = t;, then constructs a string as if by basic_string(sv.data(), sv.size(), alloc).

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.

10) Implicitly converts t to a string view sv as if by std::basic_string_view <CharT, Traits> sv = t;, then constructs a string as if by basic_string(sv.substr(pos, n), alloc).

This overload participates in overload resolution only if std::is_convertible_v <const StringViewLike&,
std::basic_string_view <CharT, Traits>> is true.

11-18) Constructs a string with (part of) the contents of other. If the type of other is basic_string&&, when the construction finishes, other is in a valid but unspecified state.

11) The copy constructor.

The allocator is obtained as if by calling std::allocator_traits <Allocator>::
select_on_container_copy_construction
(other.get_allocator()).

(since C++11)

12) The move constructor. The allocator is obtained by move construction from other.get_allocator().

13) Same as the copy constructor, except that alloc is used as the allocator.

If CharT is not CopyInsertable into std::basic_string <CharT>, the behavior is undefined.

14) Same as the move constructor, except that alloc is used as the allocator.

If CharT is not MoveInsertable into std::basic_string <CharT>, the behavior is undefined.

15,16) Constructs a string with the contents of the range [other.data() + pos, other.data() + other.size()).

17,18) Constructs a string with the contents of the range [other.data() + pos, other.data() + (pos + std::min (count, other.size() - pos))).

19) Equivalent to basic_string(ilist.begin(), ilist.end()).

#include <cassert>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
 
int main()
{
 std::cout << "1) string(); ";
 std::string s1;
 assert (s1.empty() && (s1.length() == 0) && (s1.size() == 0));
 std::cout << "s1.capacity(): " << s1.capacity() << '\n'; // unspecified
 
 std::cout << "3) string(size_type count, CharT ch): ";
 std::string s2(4, '=');
 std::cout << std::quoted (s2) << '\n'; // "===="
 
 std::cout << "4) string(InputIt first, InputIt last): ";
 char mutable_c_str[] = "another C-style string";
 std::string s4(std::begin (mutable_c_str) + 8, std::end (mutable_c_str) - 1);
 std::cout << std::quoted (s4) << '\n'; // "C-style string"
 
 std::cout << "6) string(CharT const* s, size_type count): ";
 std::string s6("C-style string", 7);
 std::cout << std::quoted (s6) << '\n'; // "C-style", i.e. [0, 7)
 
 std::cout << "7) string(CharT const* s): ";
 std::string s7("C-style0円string");
 std::cout << std::quoted (s7) << '\n'; // "C-style"
 
 std::cout << "11) string(string&): ";
 std::string const other11("Exemplar");
 std::string s11(other11);
 std::cout << std::quoted (s11) << '\n'; // "Exemplar"
 
 std::cout << "12) string(string&&): ";
 std::string s12(std::string ("C++ by ") + std::string ("example"));
 std::cout << std::quoted (s12) << '\n'; // "C++ by example"
 
 std::cout << "15) string(const string& other, size_type pos): ";
 std::string const other15("Mutatis Mutandis");
 std::string s15(other15, 8);
 std::cout << std::quoted (s15) << '\n'; // "Mutandis", i.e. [8, 16)
 
 std::cout << "17) string(const string& other, size_type pos, size_type count): ";
 std::string const other17("Exemplary");
 std::string s17(other17, 0, other17.length() - 1);
 std::cout << std::quoted (s17) << '\n'; // "Exemplar"
 
 std::cout << "19) string(std::initializer_list<CharT>): ";
 std::string s19({'C', '-', 's', 't', 'y', 'l', 'e'});
 std::cout << std::quoted (s19) << '\n'; // "C-style"
}

Possible output:

1) string(); s1.capacity(): 15
3) string(size_type count, CharT ch): "===="
4) string(InputIt first, InputIt last): "C-style string"
6) string(CharT const* s, size_type count): "C-style"
7) string(CharT const* s): "C-style"
11) string(string&): "Exemplar"
12) string(string&&): "C++ by example"
15) string(const string& other, size_type pos): "Mutandis"
17) string(const string& other, size_type pos, size_type count): "Exemplar"
19) string(std::initializer_list<CharT>): "C-style"

[edit] Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
LWG 301	C++98	overload (4) did not use the parameter alloc if `InputIt` is an integral type	use that parameter
LWG 438	C++98	overload (4) would only call overload (3) if `InputIt` is an integral type	calls overload (3) if `InputIt` is not an LegacyInputIterator
LWG 847	C++98	there was no exception safety guarantee	added strong exception safety guarantee
LWG 2193	C++11	the default constructor is explicit	made non-explicit
LWG 2235	C++98	s could be a null pointer value	the behavior is undefined in this case
LWG 2250	C++98	the behavior of overload (17) was undefined if pos > other.size() is true	always throws an exception in this case
LWG 2583	C++98	there was no way to supply an allocator for overload (17)	added overload (15)
LWG 2946	C++17	overload (9) causes ambiguity in some cases	avoided by making it a template
LWG 3076	C++17	overloads (3,7) might cause ambiguities in class template argument deduction	constrained
LWG 3111 (P1148R0)	C++98	the resolution of LWG issue 2235 made the behavior of basic_string(nullptr, 0) undefined	the behavior is well- defined in this case^[1]

↑ [nullptr, nullptr + 0) is a valid empty range, because adding zero to a null pointer value is also well-defined (the result is still a null pointer value).