std::basic_string::basic_string
From cppreference.com
< cpp | string | basic string
(1) | ||
explicit basic_string( const Allocator& alloc = Allocator() );
|
(until C++14) | |
basic_string() : basic_string( Allocator() ) {}
explicit basic_string( const Allocator& alloc ); |
(since C++14) | |
basic_string( size_type count,
CharT ch, |
(2) | |
basic_string( const basic_string& other,
size_type pos, |
(3) | |
basic_string( const CharT* s,
size_type count, |
(4) | |
basic_string( const CharT* s,
const Allocator& alloc = Allocator() ); |
(5) | |
template< class InputIt >
basic_string( InputIt first, InputIt last, |
(6) | |
basic_string( const basic_string& other );
|
(7) | |
basic_string( const basic_string& other, const Allocator& alloc );
|
(7) | (since C++11) |
basic_string( basic_string&& other );
|
(8) | (since C++11) |
basic_string( basic_string&& other, const Allocator& alloc );
|
(8) | (since C++11) |
basic_string( std::initializer_list<CharT> init,
const Allocator& alloc = Allocator() ); |
(9) | (since C++11) |
Constructs new string from a variety of data sources and optionally using user supplied allocator alloc
.
1) Default constructor. Constructs empty string (zero size and unspecified capacity)
2) Constructs the string with
count
copies of character ch
. The behavior is undefined if count >= npos
3) Constructs the string with a substring
[pos, pos+count)
of other
. If the requested substring lasts past the end of the string, or if count == npos, the resulting substring is [pos, size())
.
4) Constructs the string with the first
count
characters of character string pointed to by s
. s
can contain null characters. The behavior is undefined if s
does not point at an array of at least count
elements of CharT
.
5) Constructs the string with the contents initialized with a copy of the null-terminated character string pointed to by
s
. The length of the string is determined by the first null character. The behavior is undefined if s
does not point at an array of at least Traits::length(s)+1 elements of CharT
.
6) Constructs the string with the contents of the range
[first, last)
.
This overload has the same effect as overload (2) if InputIt is an integral type. |
(until C++11) |
This overload only participates in overload resolution if InputIt satisfies InputIterator . |
(since C++11) |
7) Copy constructor. Constructs the string with the copy of the contents of
other
.
8) Move constructor. Constructs the string with the contents of
other
using move semantics. other
is left in valid, but unspecified state.
9) Constructs the string with the contents of the initializer list
init
.
Contents |
[edit] Parameters
alloc | - | allocator to use for all memory allocations of this string |
count | - | size of the resulting string |
ch | - | value to initialize the string with |
first, last | - | range to copy the characters from |
s | - | pointer to a character string to use as source to initialize the string with |
other | - | another string to use as source to initialize the string with |
init | - | initializer list to initialize the string with |
[edit] Complexity
1) constant
2-4) linear in
count
5) linear in length of
s
6) linear in distance between
first
and last
7) linear in size of
other
8) constant. If
alloc
is given and alloc != other.get_allocator(), then linear
9) linear in size of
init
[edit] Exceptions
1)
noexcept specification:
noexcept(noexcept(Allocator()))
|
(since C++17) |
8) Throws nothing if alloc == str.get_allocator()
|
(until C++14) |
8)
noexcept specification:
noexcept |
(since C++14) |
[edit] Example
Run this code
#include <iostream> #include <cassert> #include <iterator> #include <string> int main() { { // string::string() std::string s; assert(s.empty() && (s.length() == 0) && (s.size() == 0)); } { // string::string(size_type count, charT ch) std::string s(4, '='); std::cout << s << '\n'; // "====" } { std::string const other("Exemplary"); // string::string(string const& other, size_type pos, size_type count) std::string s(other, 0, other.length()-1); std::cout << s << '\n'; // "Exemplar" } { // string::string(charT const* s, size_type count) std::string s("C-style string", 7); std::cout << s << '\n'; // "C-style" } { // string::string(charT const* s) std::string s("C-style\0string"); std::cout << s << '\n'; // "C-style" } { char mutable_c_str[] = "another C-style string"; // string::string(InputIt first, InputIt last) std::string s(std::begin(mutable_c_str)+8, std::end(mutable_c_str)-1); std::cout << s << '\n'; // "C-style string" } { std::string const other("Exemplar"); std::string s(other); std::cout << s << '\n'; // "Exemplar" } { // string::string(string&& str) std::string s(std::string("C++ by ") + std::string("example")); std::cout << s << '\n'; // "C++ by example" } { // string(std::initializer_list<charT> ilist) std::string s({ 'C', '-', 's', 't', 'y', 'l', 'e' }); std::cout << s << '\n'; // "C-style" } }
Output:
==== Exemplar C-style C-style C-style string Exemplar C++ by example C-style
[edit] See also
assign characters to a string (public member function) |
|
assigns values to the string (public member function) |