core.stdcpp.string

D header file for interaction with C++ std::string.

Copyright

License

Distributed under the

Boost Software License 1.0. (See accompanying file LICENSE)

Authors

Guillaume Chatelet

Manu Evans Source: core/stdcpp/string.d

var Default

enum DefaultConstruct

struct basic_string char_traits

fn append assign at insert replace reserve shrink_to_fit swap

Constructors 8

this(const(T)[] str, ref const(allocator_type) al) @nogc

this(const(T)[] str) @nogc

this(const ref basic_string str) @nogc

this(DefaultConstruct) @nogc

this(const(T)[] str, ref const(allocator_type) al) @nogc

this(const(T)[] str) @nogc

this(const(T)[] str, ref const(allocator_type) al) @nogc

this(const(T)[] str) @nogc

Destructors 3

~this() @nogc

Types 3

enumDefaultConstruct

value

structchar_traits(CharT)

Character traits classes specify character properties and provide specific semantics for certain operations on characters and sequences of characters.

Methods

size_t length(const(char_type) * s) static @trusted pure nothrow @nogc

char_type * move(char_type * s1, const char_type * s2, size_t n) static @trusted pure nothrow @nogc

structbasic_string(T, Traits = char_traits!T, Alloc = allocator!T)

D language counterpart to C++ std::basic_string.

C++ reference: https://en.cppreference.com/w/cpp/string/basic_string

Fields

size_type npos

Methods

bool empty() extern(D) @nogc const nothrow @trusted

size_t[2] opSlice(size_t dim : 0)(size_t start, size_t end) extern(D) @nogc const pure nothrow @safe

inout(T) opIndex(size_t index) ref extern(D) @nogc inout pure nothrow @safe

inout(T)[] opIndex(size_t[2] slice) extern(D) @nogc inout pure nothrow @safe

inout(T)[] opIndex() extern(D) @nogc inout pure nothrow @safe

bool opEquals(scope const ref basic_string s) extern(D) @nogc const pure nothrow @safeTwo `basic_string`s are equal if they represent the same sequence of code units.

bool opEquals(scope const T[] s) extern(D) @nogc const pure nothrow @safeditto

int opCmp(scope const ref basic_string rhs) extern(D) @nogc const pure nothrow @safePerforms lexicographical comparison.

int opCmp(scope const T[] rhs) extern(D) @nogc const pure nothrow @safeditto

size_t toHash() extern(D) @nogc const nothrow pure @safeHash to allow `basic_string`s to be used as keys for built-in associative arrays. *The result will generally not be the same as C++ `std::hash<std::basic_string<T>>`.*

void clear() extern(D) @nogc

void resize(size_type n, T c = T(0)) extern(D) @nogc @trusted

inout(T) front() ref extern(D) @nogc inout nothrow @safe

inout(T) back() ref extern(D) @nogc inout nothrow @safe

const(T) * c_str() extern(D) @nogc const nothrow @safe

basic_string opAssign()(auto ref basic_string str) ref extern(D) @nogc

basic_string opAssign(const(T)[] str) ref extern(D) @nogc

basic_string opAssign(T c) ref extern(D) @nogc

basic_string opIndexAssign(T c, size_t index) ref extern(D) @nogc

basic_string opIndexAssign(T c, size_t[2] slice) ref extern(D) @nogc

basic_string opIndexAssign(const(T)[] str, size_t[2] slice) ref extern(D) @nogc

basic_string opIndexAssign(T c) ref extern(D) @nogc

basic_string opIndexAssign(const(T)[] str) ref extern(D) @nogc

basic_string opIndexOpAssign(string op)(T c, size_t index) ref extern(D) @nogc

basic_string opIndexOpAssign(string op)(T c, size_t[2] slice) ref extern(D) @nogc

basic_string opIndexOpAssign(string op)(const(T)[] str, size_t[2] slice) ref extern(D) @nogc

basic_string opIndexOpAssign(string op)(T c) ref extern(D) @nogc

basic_string opIndexOpAssign(string op)(const(T)[] str) ref extern(D) @nogc

basic_string append(T c) ref extern(D) @nogc

basic_string opOpAssign(string op : "~")(const(T)[] str) ref extern(D) @nogc

basic_string opOpAssign(string op : "~")(T c) ref extern(D) @nogc

basic_string insert(size_type pos, ref const(basic_string) str) ref extern(D) @nogc

basic_string insert(size_type pos, ref const(basic_string) str, size_type subpos, size_type sublen) ref extern(D) @nogc @trusted

basic_string insert(S : size_type)(S pos, const(T) * s) ref extern(D) @nogc

basic_string insert(size_type pos, const(T)[] s) ref extern(D) @nogc

basic_string erase(size_type pos = 0) ref extern(D) @nogc

basic_string erase(size_type pos, size_type len) ref extern(D) @nogc

basic_string replace()(size_type pos, size_type len, auto ref basic_string str) ref extern(D) @nogc

basic_string replace()(size_type pos,  size_type len,  auto  ref  basic_string str,
                             size_type subpos,  size_type sublen = npos)

ref extern(D) @nogc

basic_string replace(size_type pos, size_type len, const(value_type)[] s) ref extern(D) @nogc

basic_string replace(S : size_type)(S pos, size_type len, const(value_type) * s) ref extern(D) @nogc

void push_back(T c) extern(D) @nogc @trusted

void pop_back() extern(D) @nogc

Constructors

this()MSVC allocates on default initialisation in debug, which can't be modelled by D `struct`

Functions 12

fninout(T) at(size_type i) ref @nogc inout nothrow @trusted

fnbasic_string assign(const(T)[] str) ref @nogc

fnbasic_string assign(const ref basic_string str) ref @nogc

fnbasic_string append(const(T)[] str) ref @nogc

fnbasic_string append(size_type n, T c) ref @nogc

fnvoid reserve(size_type _Newcap = 0) @nogc

fnvoid shrink_to_fit() @nogc

fnbasic_string insert(size_type pos, const(T) * s, size_type n) ref @nogc

fnbasic_string insert(size_type pos, size_type n, T c) ref @nogc

fnbasic_string replace(size_type pos, size_type len, const(T) * s, size_type slen) ref @nogc

fnbasic_string replace(size_type _Off, size_type _N0, size_type _Count, T _Ch) ref @nogc

fnvoid swap(ref basic_string _Right) @nogc

Variables 1

enumvarDefault = DefaultConstruct()

Constructor argument for default construction