제 5 장: `string' 데이터 유형

C++는 흔한 문제들에 대하여 다양한 해결책을 제공한다. 이 편의기능들은 대부분 표준 템플릿 라이브러리에 포함되거나 또는 총칭 알고리즘으로 구현되어 있다 (제 19장).

C++ 프로그래머가 끊임없이 개발하는 편의기능 중에서 텍스트를 조작하는 기능은 거의 string이라고 부르는 라이브러리에 포함되어 있다. C 프로그래밍 언어는 기본적인 문자열을 지원한다. C의 NTBS를 기반으로 그 위에 수 많은 코드가 구축되어 왔다 (NTBS (널-종료 바이트 문자열, 또한 NTB 문자열도) 문자열 연속으로서 가장 마지막 원소의 값이 0이다. 즉, 종료 널 문자로 정의되어 있다. 연속열에서 값을 0으로 가지는 다른 문자는 없다.).

C++는 텍스트를 처리하기 위하여 std::string 유형을 제공한다. C++에서는 NTB 문자열을 조작하는 전통적인 C 라이브러리 함수보다는 string 객체를 사용한다. C 프로그램에서 많은 문제들은 버퍼 범람과 경계 에러 그리고 할당 문제 때문에 야기되며 추적해 들어가 보면 대부분 전통적인 C 문자열 라이브러리 함수를 부적절하게 사용했기 때문임을 알 수 있다. C++ 문자열 객체를 사용하면 이런 문제들을 대부분 피할 수 있다.

실제로 string 객체는 클래스 유형의 변수이며 그런 의미에서 cin과 cout 같은 스트림 객체와 비교된다. 이 절은 string 유형의 객체를 다룬다. 그 정의와 사용법에 초점을 둔다. string 객체를 사용할 때 멤버 함수 구문을 사용하는 것이 보통이다.

        stringVariable.operation(argumentList)

예를 들어 string1과 string2가 std::string 유형의 변수이면

        string1.compare(string2)

두 문자열을 비교할 수 있다.

일반적인 멤버 함수 말고도 string 클래스는 연산자(operator)도 광범위하게 제공한다. 예를 들어 할당 연산자(=)와 비교 연산자(==)가 있다. 연산자는 코드를 이해하기 쉽게 해 주고 비교용 멤버 함수보다 더 많이 사용된다. 다음과 같이 작성하는 것보다는

    if (string1.compare(string2) == 0)

다음과 같이 사용하는 것이 보통이다.

    if (string1 == string2)

string 유형의 객체를 정의하고 사용하려면 소스에 <string> 헤더를 포함해야 한다. 단순히 문자열 유형을 선언(declare)하는 정도라면 iosfwd 헤더를 포함해도 된다.

std::string외에도 다음과 같은 문자열 유형이 정의되어 있다.

std::wstring, wchar_t 문자로 구성된 문자열 유형;
std::u16string, char16_t 문자로 구성된 문자열 유형;
std::u32string, char32_t 문자로 구성된 문자열 유형.

5.1: 문자열 연산

문자열 연산 중에 문자열 안의 인덱스를 돌려주는 연산이 있다. 적절한 인덱스를 발견하지 못하면 string::npos 값을 돌려준다. 이 값은 string::size_type 유형의 상징적 값으로서 (실용적 목적으로) unsigned int이다.

string 객체를 인자로 받는 모든 string 멤버는 char const * (NTBS) 인자도 받는다. 이것은 string 객체를 받는 연산자들에도 적용된다.

어떤 string 멤버는 반복자(iterator)를 사용한다. 반복자는 18.2절에 정식으로 소개한다. 반복자를 사용하는 멤버 함수는 다음 절에 나열한다 (5.2). 그러나 반복자 개념 자체는 이 장에 더 이상 다루지 않는다.

string 클래스는 많은 멤버와 연산자를 지원한다. 간략하게 그의 능력을 이 절에 개관해 보고 다음 절에서 더 자세하게 다루겠다. 요약해 말하면 C++가 문자열을 처리하는 능력은 대단히 뛰어나기 때문에 C 라이브러리에 의존하여 텍스트를 처리해야 할 이유가 거의 없다. C++ 문자열은 필요한 모든 메모리 관리를 처리하고 그리하여 C 프로그램에서 문제의 근원이 되는 메모리 관련 문제를 뿌리뽑을 수 있다. 그렇지만 string에는 그에 상응하는 대가가 따른다. 문자열 클래스의 광범위한 능력 때문에 오히려 메모리 문제가 더 심각해질 수도 있다. 그의 모든 특징을 배우고 익히기가 어려울 뿐더러 결국 예상한 모든 것이 다 갖추어져 있는 것도 아니라는 사실을 알게 될 것이다. 예를 들어 std::string은 대소문자를 구별해 비교하지 못한다. 생각보다 구현하기도 그렇게 쉽지 않다. 분명히 있기는 하지만 약간 은밀한 것도 있어서 이 시점에서 거기에 파고 들기에는 좀 이른 감이 있다. 대신에 C의 표준 라이브러리가 유용한 기능을 제공한다는 사실을 깨닫기를 바란다. 우리는 이미 그 한계를 잘 알고 있고 함정을 잘 피할 수도 있다. 그래서 지금 당장은 다음과 같이 std::string 객체인 str1과 str2 두 문자열의 내용을 대소문자를 구별하여 전통적으로 비교하는 것이면 충분하다.

    strcasecmp(str1.c_str(), str2.c_str());

string 클래스는 다음 기능을 제공한다.

초기화:
문자열 객체를 정의하면 언제나 적절하게 초기화된다. 다른 말로 언제나 유효한 상태에 있다. string 클래스는 빈 채로 초기화되거나 아니면 기존의 텍스트가 초기화에 이용될 수도 있다.
할당:
문자열에 새로운 값을 줄 수 있다. 새 값은 멤버 함수를 사용하여 할당할(assign) 수 있지만 평범한 할당 연산자(=)를 사용해도 된다. 게다가 문자열 버퍼에 할당하는 것도 지원한다.
변환:
문자열 객체의 내용을 부분적으로 또는 전체적으로 C 문자열처럼 번역할 수 있지만 그 문자열의 내용은 또한 일련의 날 이진 바이트로 처리할 수도 있어서 반드시 값이-0인 문자로 종료할 필요가 없다. 게다가 평범한 문자와 C 문자열을 std::string을 받는 곳에 사용할 수 있는 경우도 많다.
분해:
문자열에 저장된 문자는 친숙한 인덱스 연산자([ ])를 사용하여 개별적으로 접근할 수 있어서 문자열 가운데에 있는 정보에 접근하거나 변경할 수 있다.
비교:
친숙한 논리 비교 연산자 ==, !=, <, <=, > 그리고 >=를 사용하여 C의 문자열(NTB 문자열)과 비교할 수 있다. 또한 더 세심하게 비교를 수행하는 멤버 함수가 있다.
변경:
문자열의 내용을 여러가지 방식으로 변경할 수 있다. 문자열 객체에 정보를 추가하는 연산자가 있고, 문자열 가운데에 정보를 삽입하는 연산자 또는 문자열의 내용을 (부분적으로) 교체하거나 삭제하는 연산자가 있다.
교체:
문자열의 교체 능력 덕분에 바이트 단위로 복사할 필요없이 근본적으로 두 문자열 객체의 내용을 교환할 수 있다.
탐색:
문자열 객체 안 특징 위치에서 시작해 문자의 위치나 문자 집합 또는 일련의 문자들을 검색할 수 있으며 정방향이나 역방향으로 검색할 수 있다.
편의기능:
몇가지 자잘한 편의기능이 제공된다. 문자열이 비어 있는지 아니면 그 길이가 얼마나 되는지 질의해 볼 수 있다. 그러나 문자열 객체는 길이가 바뀌기도 한다.
stream I/O:
스트림으로부터 문자열을 추출하거나 삽입할 수 있다. 평범한 문자열 추출 말고도 텍스트 파일 한 줄을 버퍼 범람의 위험없이 읽어 들일 수 있다. 추출과 삽입은 스트림에 기반하기 때문에 I/O 기능은 장치에 얽매이지 않는다.

5.2: std::string 참조

이 절은 문자열 멤버와 문자열 관련 연산을 다룬다. 각각의 항은 문자열의 초기화와 반복자 그리고 연산자와 멤버 함수를 다룬다. 다음은 이 절에 사용되는 전문 용어이다.

객체(object)는 언제나 문자열(string)-객체를 뜻한다.
따로 언급하지 않는 한, 인자(argument)는 언제나 string const & 아니면 char const *이다. 인자(argument)의 내용은 그 인자를 처리하더라도 절대 바뀌지 않는다.
opos는 object 문자열 안에서의 상대 주소를 가리킨다.
apos는 인자(argument) 안에서의 상대 주소를 가리킨다.
on은 object 안의 문자의 갯수를 나타낸다 (opos에서 시작됨);
an은 인자(argument) 안의 문자의 갯수를 나타낸다 (apos에서 시작됨).

opos와 apos 모두 기존의 상대 주소를 가리켜야 한다. 그렇지 않으면 예외가 발생한다 (제 10장). 대조적으로 an과 on은 실제 문자의 갯수를 초과해도 된다. 이 경우 가능한 문자만 고려할 뿐이다.

많은 멤버가 on과 an 그리고 apos에 대하여 기본값이 선언되어 있다. 어떤 멤버는 opos에도 기본값을 선언한다. 기본 상대주소 값은 0이다. on과 an의 기본값은 string::npos이며 이 값은 `요구한 문자의 갯수를 넘어 문자열의 끝에 도달함'이라고 이해하면 된다.

끝에서 연산을 시작하여 문자열 객체의 내용을 거꾸로 처리하는 멤버에 대하여 opos의 기본 값은 그 객체의 마지막 문자의 인덱스이고 on은 기본값으로 opos + 1과 동등하며 opos에서 끝나는 부문자열의 길이를 나타낸다.

아래에 제시하는 멤버 함수를 개관해 보면 이 모든 매개변수가 따로 언급하지 않는 한, 기본값을 받는다고 요약해도 좋을 것이다. 물론 함수가 기존의 인자들을 넘어서서 인자를 더 요구하면 기본 인자 값은 사용할 수 없다.

어떤 멤버 함수는 첫 인자가 char const * 유형이기를 기대한다. 그러나 그렇지 않다고 할지라도 매개변수가 std::string으로 정의되어 있다면 첫 인자는 언제든지 char const * 유형이 될 수 있다.

여러 멤버 함수가 반복자(iterator)를 받는다. 18.2절에 반복자(iterator)의 기술적 측면을 다루겠지만 이 시점에는 무시해도 읽는 흐름을 깨지 않는다. apos와 opos처럼 반복자도 문자열 객체의 내용 안에서 기존의 위치 또는 기존의 문자 범위를 가리켜야 한다.

인덱스를 계산하는 모든 string 멤버 함수는 실패하면 미리 정의된 string::npos를 돌려준다.

C++14 표준은 s라는 기호상수 접미사를 제공한다. 이 접미사는 ("hello world"와 같이) 문자열 기호상수가 사용될 때 std::string 상수라는 사실을 나타낸다. using namespace std를 선언한 후에, 꼭 찝어 말해 다음과 같이 using namespace std::literals::string_literals로 선언한 후에 사용할 수 있다. std::string 객체의 문맥에서 사용될 때는 문자열 기호상수 접미사는 거의 필요하지 않지만 auto 키워드와 함께 사용될 때는 편리하다. 예를 들어 auto str = "hello world"s는 std::string str을 정의하는 반면에 기호상수 접미사를 생략하면 char const *로 정의된다.

5.2.1: 초기화자

문자열 객체를 정의하고 나면 유효한 상태에 있다는 보장을 할 수 있다. 정의 시간에 문자열 객체는 다음 중 한 가지 방식으로 초기화된다. 다음 string 생성자를 사용할 수 있다.

string object:
object를 빈 문자열로 초기화한다. 인자를 지정하지 않고 string을 정의해도 된다.
string object(string::size_type count, char ch):
object를 count개의 ch 문자로 초기화한다. 약점이 있다: 이 생성자를 이용해 문자열 객체를 초기화하려면 활괄호 변형을 사용하지 마라. 초기화 리스트 생성자를 선택하는 실수를 하지 않으려면 아래에 보여주는 생성자를 사용하라.
string object(string const &argument):
object를 argument로 초기화한다.
string object(std::string const &argument, string::size_type apos, string::size_type an):
object를 argument의 내용으로 apos 인덱스 위치부터 시작하여 최대 an개의 argument 문자로 초기화한다.
string object(InputIterator begin, InputIterator end):
object를 두 InputIterators 사이에 정의된 문자 범위로 초기화한다.
string object(std::initializer_list<char> chars):
초기화 리스트에 지정된 문자로 object를 초기화한다. 활괄호 초기화를 사용하면 직접적으로 초기화할 수도 있다. 다음은 두 가지 형태를 보여주는 예이다:
```
string str1({'h', 'e', 'l', 'l', 'o'});
string str2{ 'h', 'e', 'l', 'l', 'o' };
```

string(std::initializer_list<char>)으로 문자열을 생성하는 방법이 있다. 초기화 리스트(initializer_list)로 std::string 객체를 생성한다. string oops{ 1, 'x' }와 같이 지정하면 문자 두개를 원소로 가진 문자열을 구성한다. 아스키 코드로 하나는 1이고 다른 하나는 'x'이다. x 문자 한 개로 구성된 문자열이 전혀 아님을 주의하라. std::string(size_t count, char c)을 의도할 때 활괄호로 초기화하지 않도록 주의하라.

5.2.2: 반복자

반복자에 관한 자세한 내용은 18.2절을 참고하라. 반복자를 짧게 소개하면 반복자는 마치 포인터처럼 행위한다. 반복자는 포인터를 요구하는 상황에 자주 사용된다. 반복자는 한 쌍으로 한 범위의 개체를 정의한다. begin-반복자는 첫 개체를 가리키고 end-반복자는 범위를 벗어나 마지막 개체를 넘어선 곳을 가리킨다. 둘 사이의 차이는 반복자-범위에 있는 개체의 갯수와 같다.

반복자는 총칭 알고리즘의 문맥에서 중요한 역할을 한다 (제 19장). std::string 클래스에는 다음 반복자 유형이 정의되어 있다.

string::iterator 그리고 string::const_iterator:
이 반복자들은 정방향 반복자이다. const_iterator는 string const 객체가 돌려준다. 평범한 iterator는 비-const 문자열 객체가 돌려준다. 반복자(iterator)가 가리키는 문자들을 변경할 수 있다.
string::reverse_iterator 그리고 string::reverse_const_iterator:
이 반복자들도 정방향 반복자(forward iterator) 이지만 증가시키면 이전 문자로 이동한다. 그 외에 각각 string::iterator와 string::const_iterator에 비교된다.

5.2.3: 연산자

string 객체는 멤버 함수로 조작할 수 있지만 연산자로도 조작할 수 있다. 연산자를 사용하면 코드 모습이 더 자연스럽다. 연산자를 사용할 수 있고 멤버 함수와 기능이 같을 경우는 사실상 언제나 연산자를 사용한다.

다음의 연산자들을 string 객체에 사용할 수 있다 (예제에서 `객체'와 `인자'는 기존의 std::string 객체를 가리킨다).

평범한 할당:
C 또는 C++ 문자열을 string 객체에 할당할 수 있다. 할당 연산자는 왼쪽의 피 연산자를 돌려준다. 예제:
```
object =  argument;
object = "C string";
object = 'x';
object = 120;       // object = 'x'와 같다.
```
추가:
산술 추가 할당 연산자와 덧셈 연산자는 텍스트를 string 객체에 추가한다. 반영 할당 연산자는 자신의 왼쪽 피연산자를 돌려주고 덧셈 연산자는 그의 결과를 임시 문자열 객체 안에 돌려준다. 덧셈 연산자를 사용할 때 왼쪽 피연산자 아니면 오른쪽 피연산자는 반드시 std::string 객체가 되어야 한다. 다른 피연산자는 char 유형 즉, C 문자열 또는 C++ 문자열이면 된다. 예를 들어:
```
object += argument;
object += "hello";
object += 'x';      // 병합 표현식 가능

argument + otherArgument;   // 두개의 std::string  객체
argument + "hello";         // +를 사용할 때는 적어도 하나는
"hello" + argument;         // std::string이어야 한다.
argument + 'a';             // 병합 표현식 가능
'a' + argument;
```
인덱스 연산자:
인덱스 연산자를 사용하면 object의 문자들을 하나하나 열람할 수 있다. 또는 const 문자열 객체가 아니라면 새 값을 문자에 할당할 수 있다. 범위 점검은 하지 않는다. 범위 점검을 하려면 at() 멤버 함수를 사용하면 된다. 이 연산자는 char & 또는 char const &를 돌려준다. 예제:
```
object[3] = argument[5];
```
논리 비교 연산자:
논리 비교 연산자를 두 개의 문자열 객체 또는 하나의 문자열 객체와 C 문자열에 적용하여 내용을 비교할 수 있다. 이 연산자들은 bool 값을 돌려준다. ==, !=, >, >=, <, 그리고 <= 연산자를 사용할 수 있다. 우선순위 연산자는 사전식으로 ASCII 문자 배치 순서로 내용을 비교한다. 예를 들어:
```
object == object;           // true
object != (object + 'x');   // true
object <= (object + 'x');   // true
```
스트림 연산자:
삽입-연산자를 사용하여 string 객체를 ostream에 삽입할 수 있다 (3.1.4항). 추출-연산자를 사용하면 문자열 객체를 istream으로부터 추출할 수 있다. 추출 연산자는 기본으로 먼저 모든 공백 문자들을 무시하고 다음에 잇따르는 모든 비-공백 문자들을 istream으로부터 추출한다. 문자열 대신에 문자 배열도 추출할 수 있지만 문자열 객체를 사용하는 편이 명백하게 장점이 있다. 목표 문자열 객체는 필요한 문자의 갯수에 맞게 자동으로 크기가 조정된다. 예를 들어:
```
cin >> object;
cout << object;
```

5.2.4: 멤버 함수

std::string 클래스는 많은 멤버 함수가 있다. 추가로 제공되는 비-멤버 함수도 문자열 클래스의 일부로 간주해야 한다. 이 함수들을 모두 아래에 알파벳 순서로 나열하였다.

상징적인 string::npos 값이 문자열 클래스에 정의되어 있다. 이 값은 멤버 함수가 문자열 오프셋 위치를 돌려줄 때 `발견하지 못한 인덱스'를 나타낸다. 예를 들어 문자 'x'가 들어 있지 않은 문자열 객체에 `object.find('x')'를 호출하면 (아래 참고) npos가 반환된다. 요청한 위치가 존재하지 않기 때문이다.

C 문자열에서 NTBS의 끝을 가리키는 마지막 0-바이트는 C++ 문자열의 일부분으로 간주되지 않는다. 그래서 C 문자열의 문자들을 담고 있는 문자열 객체에서 0을 찾으면 멤버 함수는 length()가 아니라 npos를 돌려준다.

다음은 문자열 객체에 작동하는 표준 함수들이다. 매개변수로 size_t를 언급하면 string::size_type 유형의 매개변수로 이해해도 된다. 그러나 기본 인자 값이 정의되어 있지 않을 경우는 제외한다. size_type 유형은 string::size_type로 읽어야 한다. size_type라고 지정하면 5.2절에 언급된 기본 인자 값이 적용된다. 인용부호를 붙인 함수는 모두 std::string 클래스의 멤버 함수이다. 단, 따로 언급하면 예외이다.

char &at(size_t opos):
지정된 위치의 문자에 대한 참조가 반환된다. string const 객체로 호출하면 char const &가 반환된다. 이 멤버 함수는 범위를 벗어났는지 점검한다. 유효하지 않은 인덱스를 건네면 예외를 일으킨다 (기본값으로 프로그램을 종료시킨다).
string &append(InputIterator begin, InputIterator end):
begin부터 end까지 범위의 문자가 현재 문자열 객체에 추가된다.
string &append(string const &argument, size_type apos, size_type an):
argument (또는 부문자열)이 현재 문자열 객체에 추가된다.
string &append(char const *argument, size_type an):
argument에서 앞쪽 an개의 문자가 문자열 객체에 추가된다.
string &append(size_type n, char ch):
ch 문자 n개가 현재 문자열 객체에 추가된다.
string &assign(string const &argument, size_type apos, size_type an):
argument (또는 부문자열)이 문자열 객체에 할당된다. argument는 유형이 char const *이고 인자가 또 하나 더 주어지면 두 번째 인자는 an을 초기화할 값으로 이해된다. 0을 사용하여 apos를 초기화한다.
string &assign(size_type n, char ch):
n개의 ch 문자가 현재 문자열 객체에 할당된다.
char &back():
문자열 객체에 저장된 마지막 char를 가리키는 참조를 돌려준다. 빈 문자열일 경우 그 결과는 정의되어 있지 않다.
string::iterator begin():
현재 문자열 객체의 첫 문자를 가리키는 반복자를 돌려준다. const 문자열 객체이면 const_iterator가 반환된다.
size_type capacity() const:
현재 문자열 객체에 저장할 수 있는 문자의 갯수를 돌려준다. 크기를 다시 조정할 필요가 없다.
string::const_iterator cbegin():
현재 문자열 객체의 첫 문자를 가리키는 const_iterator를 돌려준다.
string::const_iterator cend():
현재 문자열 객체의 마지막을 가리키는 const_iterator를 돌려준다.
int compare(string const &argument) const:
현재 문자열 객체에 저장된 텍스트와 argument에 저장된 텍스트를 비교한다. ASCII 문자 대조 순서를 이용하여 사전 순서로 비교한다. 내용이 일치하면 0을 돌려주고 문자열 객체의 텍스트가 argument의 텍스트보다 앞에 오면 음의 값이 반환된다. 뒤에 오면 양의 값이 반환된다.
int compare(size_t opos, size_t on, string const &argument) const:
현재 문자열 객체에 저장된 텍스트의 부문자열을 argument에 저장된 텍스트와 비교한다. opos에서 시작해 최대 on 개의 문자를 argument의 텍스트와 비교한다.
int compare(size_t opos, size_t on, string const &argument, size_type apos, size_type an):
현재 문자열 객체에 저장된 텍스트의 부문자열을 argument에 저장된 부문자열과 비교한다. opos에서 시작해 최대 on 개의 문자를 argument의 apos에서 시작해 최대 an 개의 문자와 비교한다. 이 경우 argument는 반드시 문자열 객체이어야 한다.
int compare(size_t opos, size_t on, char const *argument, size_t an):
현재 문자열 객체에 저장된 텍스트의 부문자열을 argument에 저장된 텍스트의 부문자열과 비교한다. 현재 문자열 객체의 opos에서 시작해 최대 on개의 문자를 argument에서 최대 an 개의 문자와 비교한다. argument는 적어도 an 개의 문자가 있어야 한다. 문자는 값에 상관이 없다. 값이 0인 문자도 특별한 의미가 없다.
size_t copy(char *argument, size_t on, size_type opos) const:
현재 문자열 객체의 내용이 (부분적으로) argument 안에 복사된다. 복사된 실제 갯수가 반환된다. 두 번째 인자는 복사할 문자의 갯수를 지정하기 때문에 필수이다. 사본 문자열에 값이 0인 문자를 추가하지는 않지만 다음과 같은 상용구를 이용해 추가할 수 있다.
```
    argument[object.copy(argument, string::npos)] = 0;
```
물론, 프로그래머는 값이 0인 바이트를 추가로 수용할 만큼 argument의 크기가 충분히 큰지 확인해야 한다.
string::const_reverse_iterator crbegin():
현재 문자열 객체의 마지막 문자를 가리키는 const_reverse_iterator를 돌려준다.
string::const_reverse_iterator crend():
현재 문자열 객체의 시작을 가리키는 const_reverse_iterator를 돌려준다.
char const *c_str() const:
현재 문자열 객체의 내용을 NTBS로 돌려준다.
char const *data() const:
현재 문자열 객체의 날 내용을 돌려준다. 이 멤버 함수는 NTBS를 돌려주지 않는다 (c_str은 NTBS를 돌려준다). 현재 문자열 객체에 저장된 정보를 종류에 상관없이 열람할 수 있다. 예를 들어 일련의 0-바이트들도 열람이 가능하다.
```
    string s(2, 0);
    cout << static_cast<int>(s.data()[1]) << '\n';
```
bool empty() const:
현재 문자열 객체에 데이터가 없으면 true가 반환된다.
string::iterator end():
현재 문자열 객체의 마지막 문자를 넘어서서 반환된 위치를 가리키는 반복자이다. const 문자열 객체라면 const_iterator 가 반환된다.
string &erase(size_type opos, size_type on):
현재 문자열 객체에 저장된 정보의 (부) 문자열이 삭제된다.
string::iterator erase(string::iterator begin, string::iterator end):
end 매개변수는 선택적이다. 생략되면 현재 객체의 end 멤버가 돌려주는 값이 사용된다. begin 반복자와 end 반복자로 정의된 범위의 문자들이 삭제된다. begin 반복자가 반환된다. 이 반복자는 마지막으로 삭제된 문자 바로 다음의 위치를 가리킨다.
size_t find(string const &argument, size_type opos) const:
현재 문자열 객체에서 argument가 발견된 첫 번째 인덱스가 반환된다.
size_t find(char const *argument, size_type opos, size_type an) const:
현재 문자열 객체에서 argument가 발견된 첫 번째 인덱스가 반환된다. 이 세 인자 모두 지정되면 첫 인자는 반드시 char const *가 되어야 한다.
size_t find(char ch, size_type opos) const:
현재 문자열 객체에서 ch가 발견된 첫 번째 인덱스를 돌려준다.
size_t find_first_of(string const &argument, size_type opos) const:
현재 문자열 객체에서 argument 안의 문자가 발견된 첫 인덱스를 돌려준다.
size_type find_first_of(char const *argument, size_type opos, size_type an) const:
현재 문자열 객체에서 argument 안의 문자가 발견된 첫 번째 인덱스를 돌려준다. opos를 지정하면 현재 문자열 객체에서 argument 검색을 시작해야 할 첫 번째 인덱스를 가리킨다. 생략하면, 문자열 객체를 전부 스캔한다. an을 제공하면 char const * 인자에서 검색에 사용해야 할 문자의 갯수를 가리킨다. argument부터 시작하는 부문자열을 정의한다. 생략하면 argument의 문자를 모두 사용한다.
size_type find_first_of(char ch, size_type opos):
현재 문자열 객체에서 ch 문자가 발견된 첫 번째 인덱스를 반환한다.
size_t find_first_not_of(char ch, size_type opos) const:
현재 문자열 객체에서 ch 말고 다른 문자가 발견된 첫 번째 인덱스를 돌려준다.
size_t find_last_of(string const &argument, size_type opos) const:
현재 문자열 객체에서 argument 안의 문자가 발견된 마지막 인덱스를 돌려준다.
size_type find_last_of(char const *argument, size_type opos, size_type an) const:
현재 문자열 객체에서 argument 인자의 문자가 발견된 마지막 인덱스를 돌려준다. opos가 제공되면 현재 문자열 객체에서 argument의 검색을 시작할 마지막 인덱스를 가리킨다. 생략하면 문자열 객체를 전부 스캔한다. an을 제공하면 char const * 인자에서 검색에 사용해야 할 문자의 갯수를 가리킨다. argument의 처음부터 시작하는 부문자열을 정의한다. 생략하면 argument의 문자를 모두 스캔한다.
size_type find_last_of(char ch, size_type opos):
현재 문자열 객체에서 ch 문자가 발견된 마지막 인덱스를 돌려준다.
size_t find_last_not_of(string const &argument, size_type opos) const:
현재 문자열 객체에서 argument 안의 문자가 나타나지 않은 마지막 인덱스를 돌려준다.
char &front():
문자열 객체 안에 저장된 첫 번째 char를 가리키는 참조점을 돌려준다. 빈 문자열이라면 그 결과가 어떨지 정의되어 있지 않다.
allocator_type get_allocator():
std::string 클래스의 할당자를 돌려준다.
istream &std::getline(istream &istr, string &object, char delimiter = '\n'):
주의: 이 함수는 string 클래스의 멤버 함수가 아니다.
텍스트 한 줄을 istr로부터 읽는다. delimiter를 만날 때까지 (또는 스트림의 끝이 될 때까지, 어느 쪽이든 먼저 도달할 때까지) 모든 문자를 istr로부터 읽어서 object에 저장한다. 구분자를 만나면 스트림으로부터 제거되지만 line에 저장되지 않는다.
구분자가 발견되지 않으면 istr.eof가 true를 돌려준다 (6.3.1항). 스트림은 bool 값으로 번역이 가능하므로 (6.3.1항) 다음과 같이 스트림으로부터 모든 줄을 연속적으로 line 문자열 객체 안으로 읽어 들이는 상용구가 자주 사용된다.
```
    while (getline(istr, line))
        process(line);
```
마지막 줄의 내용은 최종적으로 object에도 할당된다. 구분자로 끝나든 말든 상관이 없다.
string &insert(size_t opos, string const &argument, size_type apos, size_type an):
argument의 (부)문자열이 현재 문자열 객체의 인덱스 위치 opos에 삽입된다. apos와 an에 대한 인자는 둘 다 제공하든지 아니면 둘 다 생략해야 한다.
string &insert(size_t opos, char const *argument, size_type an):
(char const * 유형의) argument가 현재 문자열 객체의 인덱스 opos에 삽입된다.
string &insert(size_t opos, size_t count, char ch):
count개의 ch 문자가 현재 문자열 객체의 인덱스 opos에 삽입된다.
string::iterator insert(string::iterator begin, char ch):
ch 문자가 현재 객체에서 begin 반복자가 가리키는 위치에 삽입된다. begin 반복자를 돌려준다.
string::iterator insert(string::iterator begin, size_t count, char ch):
count 개의 ch 문자가 현재 문자열 객체에서 begin반복자가 가리키는 위치에 삽입된다. begin 반복자를 돌려준다.
string::iterator insert(string::iterator begin, InputIterator abegin, InputIterator aend):
abegin과 aend로 정의된 입력 반복자 범위의 문자들이 현재 문자열 객체에서 begin반복자가 가리키는 위치에 삽입된다. begin 반복자를 돌려준다.
size_t length() const:
현재 문자열 객체에 저장된 문자의 갯수를 돌려준다.
size_t max_size() const:
현재 문자열 객체에 저장할 수 있는 문자의 최대 갯수를 돌려준다.
void pop_back():
문자열 객체에서 마지막 문자가 제거된다.
void push_back(char ch):
ch 문자를 문자열 객체 뒤에 덧붙인다.
string::reverse_iterator rbegin():
현재 문자열 객체의 마지막 문자를 가리키는 역방향 반복자를 돌려준다. const 문자열 객체라면 reverse_const_iterator가 반환된다.
string::iterator rend():
현재 문자열 객체의 첫 문자 바로 앞 위치를 가리키는 역방향 반복자를 돌려준다. const 문자열 객체라면 reverse_const_iterator가 반환된다.
string &replace(size_t opos, size_t on, string const &argument, size_type apos, size_type an):
object의 (부) 문자열이 argument의 문자로 교체된다. on이 0이면 argument가 object에서 opos 위치에 삽입된다.
string &replace(size_t opos, size_t on, char const *argument, size_type an):
object에서 일련의 객체들이 char const * 인자의 앞쪽 an개의 문자로 교체된다.
string &replace(size_t opos, size_t on, size_type count, char ch):
현재 문자열 객체에서 on 개의 문자가 opos 인덱스 위치부터 시작하여 count 개의 ch 문자로 교체된다.
string &replace(string::iterator begin, string::iterator end, string const &argument):
현재 문자열 객체에서 begin부터 end까지 반복자로 정의된 일련의 문자가 argument로 교체된다. argument가 char const *이면 추가 인자 an이 사용된다. argument에서 교체에 사용될 문자의 갯수를 지정한다.
string &replace(string::iterator begin, string::iterator end, size_type count, char ch):
현재 문자열 객체에서 begin부터 end까지 반복자로 정의된 갯수의 문자가 count 개의 ch 문자로 교체된다.
string &replace(string::iterator begin, string::iterator end, InputIterator abegin, InputIterator aend):
현재 문자열 객체에서 begin부터 end까지 반복자로 정의된 일련의 문자가 abegin과 aend 입력 반복자 범위에 정의된 문자로 교체된다.
void reserve(size_t request):
현재 문자열의 가용능력이 최소한 request로 바뀐다. 이 멤버 함수를 호출하면 capacity의 반환 값은 적어도 request이다. capacity가 돌려주는 값보다 더 작은 값을 지정하면 무시된다. max_size가 반환하는 값보다 request가 더 크면 std::length_error 예외가 일어난다 (std::length_error는 stdexcept 헤더에 정의되어 있다). reserve()를 호출하면 문자열의 가용능력을 재정의하는 효과가 있다. 실제로 메모리를 더 확보하는 것은 아니다. 이 사실은 문자열의 at() 멤버가 capacity가 아니라 size를 초과하는 문자에 접근을 시도할 때 에러를 던지는 것을 보면 알 수 있다.
void resize(size_t size, char ch = 0):
현재 문자열 객체의 크기가 size개의 문자로 조정된다. 문자열 객체가 현재 크기보다 더 커지면 추가 문자들은 ch로 초기화된다. 크기가 줄어들면 높은 자리의 문자들이 잘려 나간다.
size_t rfind(string const &argument, size_type opos) const:
현재 문자열 객체에서 argument가 발견된 마지막 위치를 돌려준다. 검색은 현재 객체의 오프셋 opos부터 역방향으로 처음까지 계속된다.
size_t rfind(char const *argument, size_type opos, size_type an) const:
현재 문자열 객체에서 argument가 발견된 마지막 인덱스를 돌려준다. 현재 객체의 오프셋 opos부터 역방향으로 처음까지 검색은 계속된다. an 매개변수는 찾을 argument 부문자열의 길이를 지정한다. argument의 처음부터 계산된다.
size_t rfind(char ch, size_type opos)const:
현재 문자열 객체에서 ch가 발견된 마지막 위치를 돌려준다. 현재 객체의 오프셋 opos으로부터 역방향으로 처음까지 검색이 계속된다.
void shrink_to_fit():
벡터에 할당된 메모리의 양을 현재 크기만큼 줄인다. 선택적이기 때문에 구현자는 이 요구조건을 무시하거나 아니면 최적화해도 된다. `크기에 맞게 줄이기' 연산의 결과를 보장하기 위해 다음 상용구를 사용할 수 있다.
```
    string(stringObject).swap(stringObject)
```
size_t size() const:
현재 문자열 객체 안에 저장된 문자의 갯수를 돌려준다. 이 멤버는 length()와 동의어이다.
string substr(size_type opos, size_type on) const:
현재 문자열 객체의 인덱스 opos에서 시작하여 최대 on개의 문자를 잘라 부문자열을 돌려준다.
void swap(string &argument):
현재 문자열 객체의 내용이 argument의 내용과 교체된다. 이 멤버에 대하여 argument는 반드시 문자열 객체가 되어야 하며 char const *가 되면 안된다.

5.2.5: 변환 함수

std::string 객체를 생성하고 처리하는 문자열 변환 함수를 아래에 알파벳 순서로 나열하였다. 클래스가 있는 멤버 함수가 아니다. std 이름 공간에 자유 함수로 선언되어 있다. <string> 헤더를 먼저 포함시켜야 사용할 수 있다.

float stof(std::string const &str, size_t *pos = 0):
str에서 맨 앞에 있는 공간문자는 무시한다. 다음으로 잇따르는 문자들을 float 값으로 변환해 돌려준다.
- 십진 부동 소수점 상수:
  - 선택적으로 + 또는 - 문자
  - 일련의 십진 수, 안에 소수점 문자 하나를 포함할 수 있다.
  - 선택적으로 e 또는 E 문자, 다음에 선택적으로 - 또는 + 문자, 그 다음에 일련의 십진 수가 따른다.
- 십육진 부동 소수점 상수:
  - 선택적인 + 또는 - 문자
  - 0x 또는 0X
  - 일련의 십육진 수, 안에 소수점 하나를 포함할 수 있다.
  - 선택적으로 p 또는 P 문자, 다음에 선택적으로 - 또는+ 문자, 그 다음에 일련의 십육진 수가 따른다.
- 무한대 표현:
  - 선택적으로 + 또는 - 문자
  - 단어로 inf 또는 infinity (대소문자 구별 없음)
- `숫자가 아닌' 표현:
  - 선택적으로 + 또는 - 문자
  - 단어 nan 또는 nan(알파벳숫자 연속열) (nan은 대소문자 구별 없음), 결과적으로 NaN 부동 소수점 값이 된다.
pos != 0이면 str에서 변환하지 못한 첫 문자의 인덱스가 *pos에 반환된다. str의 문자들을 float로 변환하지 못하면 std::invalid_argument 예외가 일어난다. 변환된 값이 float 값의 범위를 넘어서면 std::out_of_range 예외가 일어난다.
double stod(std::string const &str, size_t *pos = 0):
변환은 stof에 기술된 바와 같이 수행되지만 이제는 double 유형의 값으로 변환된다.
double stold(std::string const &str, size_t *pos = 0):
stof에 기술된 것처럼 변환을 수행하지만 long double 유형의 값으로 변환된다.
int stoi(std::string const &str, size_t *pos = 0, int base = 10):
str에서 앞쪽의 공간문자들은 무시된다. 다음으로 base가 지정된 숫자 시스템에서 숫치 상수를 나타내는 모든 문자들을 int 값으로 변환해 돌려준다. 선택적으로 + 또는 - 문자가 숫자 앞에 올 수 있다. 0으로 시작하는 값은 자동으로 팔진수로 번역된다. 값이 0x 또는 0X로 시작하면 십육진수로 번역된다. base의 값은 범위가 2에서 36 사이가 되어야 한다. pos != 0이면 str에서 변환하지 못한 첫 문자의 인덱스를 *pos에 돌려준다. str의 문자들을 int로 변환하지 못하면 std::invalid_argument 예외가 일어난다. 변환된 값이 int 값의 범위를 넘어서면 std::out_of_range 예외가 일어난다.
다음은 그 사용법이다.
```
int value = stoi(string(" -123"));  // 값 -123 할당
value = stoi(string(" 123"), 0, 5); // 값 38 할당
```
long stol(std::string const &str, size_t *pos = 0, int base = 10):
stoi에 기술된대로 변환하지만 이제는 long 값으로 변환한다.
long long stoll(std::string const &str, size_t *pos = 0, int base = 10):
stoi에 기술된대로 변환하지만 이제는 long long 유형의 값으로 변환한다.
unsigned long stoul(std::string const &str, size_t *pos = 0, int base = 10):
stoi에 기술된대로 변환하지만 (앞에 + 또는 - 문자를 허용하지 않으며), 이제는 unsigned long 유형의 값으로 변환한다.
unsigned long long stoull(std::string const &str, size_t *pos = 0, int base = 10):
stoul에 기술된대로 변환하지만 이제는 unsigned long long 유형의 값으로 변환한다.
std::string to_string(Type value):
유형은 다음 int, long, long long, unsigned, unsigned long, unsigned long long, float, double 또는 long double중 하나가 된다. 인자의 값은 텍스트 표현으로 변환하여 std::string 값으로 돌려준다.
std::string to_wstring(Type value):
to_string에 기술된 것처럼 변환하여 std::wstring의 값을 돌려준다.