String 컨테이너
vector 컨테이너와 비슷한 시퀀스 컨테이너이며 배열 기반 컨테이너의 범주에 속한다.
string:char형식의 문자를 관리하기 위한basic_string<char>wstring: 유니코드 문자(wchar_t)를 관리하기 위한basic_string<wchar_t>
String 관련 표
✅ 멤버 정의 형식
| 이름 | 설명 |
|---|---|
allocator_type | 메모리 할당자 타입 |
const_iterator | 읽기 전용 순방향 반복자 타입 |
const_pointer | 읽기 전용 포인터 타입 |
const_reference | 읽기 전용 참조 타입 |
const_reverse_iterator | 읽기 전용 역방향 반복자 타입 |
difference_type | 반복자 간 차이 표현 타입 (보통 ptrdiff_t) |
iterator | 순방향 반복자 타입 |
npos | 찾을 수 없음을 나타내는 상수 (-1) |
pointer | 포인터 타입 |
reference | 참조 타입 |
reverse_iterator | 역방향 반복자 타입 |
size_type | 크기 표현 타입 (보통 size_t) |
traits_type | 문자 특성 traits |
value_type | 문자 타입 (보통 char) |
✅ 생성자
| 형식 | 설명 |
|---|---|
string s | 기본 생성자 |
string s(sz) | C-style 문자열 sz로 초기화 |
string s(sz, n) | 문자열 sz의 앞 n개 문자로 초기화 |
string s(iter1, iter2) | 반복자 구간으로 초기화 |
string s(p1, p2) | 포인터 구간 [p1, p2)로 초기화 |
✅ 멤버 함수
| 형식 | 설명 |
|---|---|
s.append(sz) | 문자열 끝에 sz를 추가 |
s.assign(sz) | sz로 문자열을 대체 |
s.at(i) | 인덱스 i의 문자 반환, 범위 검사함 |
p = s.begin() | 문자열의 시작 반복자 반환 |
p = s.end() | 문자열의 끝 반복자 반환 |
s.c_str() | C-style 문자열 포인터 반환 |
n = s.capacity() | 현재 할당된 저장 용량 반환 |
s.clear() | 문자열을 비움 |
s.compare(s2) | 문자열 s2와 비교 (<0, =0, >0 반환) |
s.copy(buf, n) | 앞에서 n개의 문자만 복사 |
s.data() | 내부 버퍼의 포인터 반환 (널 종료 X) |
s.empty() | 문자열이 비었는지 여부 확인 |
q.erase(b) | 반복자 b 위치 문자 제거 |
q.erase(b, e) | 반복자 범위 [b, e) 문자 제거 |
s.find(c) | 문자 c를 찾아 위치 반환 (없으면 npos) |
s.insert(n, sz) | 위치 n에 문자열 sz 삽입 |
s.length() | 문자열 길이 반환 |
n = s.max_size() | 가능한 최대 문자열 크기 반환 |
s.push_back(c) | 문자 c를 끝에 추가 |
p = s.rbegin() | 역방향 시작 반복자 반환 |
p = s.rend() | 역방향 끝 반복자 반환 |
s.replace(pos, n, sz) | 위치 pos부터 n개를 sz로 교체 |
s.reserve(n) | 최소 n 크기만큼 메모리 확보 |
s.resize(n) | 크기를 n으로 조정 |
s.rfind(c) | 뒤에서 c를 찾아 위치 반환 |
s.size() | 문자열 길이 반환 (length()와 동일) |
s2 = s.substr(pos) | pos부터 끝까지 부분 문자열 생성 |
s.swap(s2) | 문자열 s와 s2를 교환 |
✅ 연산자
| 형식 | 설명 |
|---|---|
s[i] | 인덱스 i의 문자 반환 (범위 검사 X) |
s += s2 | 문자열 s2를 뒤에 추가 |
s + s2 | 두 문자열을 더한 새 문자열 반환 |
s = s2 | 문자열 대입 |
out << s | 출력 스트림에 문자열 출력 (cout << s) |
in >> s | 입력 스트림에서 문자열 입력 (cin >> s) |
getline(in, s) | 한 줄 전체를 입력받아 s에 저장 |
📌 string 생성자
int main()
{
string s1;
cout << "s1 : " << s1 << endl; // 빈 문자열
string s2 = "ABCDE";
cout << "s2 : " << s2 << endl; // ABCDE
string s3("ABC", 1);
cout << "s3 : " << s3 << endl; // A
string s4(5, 'A');
cout << "s4 : " << s4 << endl; // AAAAA
// --------------------------------------
string t = "BABY";
string s5(t.begin(), t.end()); // [begin(), end()) 반복자 범위
cout << "s5 : " << s5 << endl; // BABY
const char* p1 = "CAKE";
const char* p2 = p1 + 4;
string s6(p1, p2); // [*p1, *p2) 포인터 범위
cout << "s6 : " << s6 << endl; // CAKE
}📌 문자열 추가
➡ append()
| 사용 예시 | 설명 |
|---|---|
s1.append(str); | 다른 std::string 전체를 붙임 |
s1.append("PLUS"); | C-style 문자열 전체를 붙임 (\0까지) |
s1.append(str, startIndex, count); | str의 startIndex부터 count개 문자를 붙임 |
s1.append("PLUS", count); | C-style 문자열에서 앞 count개 문자만 붙임 |
s1.append(repeatCount, 'A'); | 문자 'A'를 repeatCount만큼 반복해서 붙임 |
s1.append(beginIt, endIt); | 반복자 구간 [beginIt, endIt)의 문자들을 붙임 |
s2.append(startPtr, endPtr); | 포인터 구간 [startPtr, endPtr)의 문자들을 붙임 |
✅ append()는 부분 문자열도 덧붙일 수 있고, 전체 문자열도 덧붙일 수 있다.
➡ += 연산자와의 차이점이다! += 연산자는 전체 문자열만 덧붙일 수 있다.
int main()
{
string plustext = "PLUS";
string s1 = "A";
s1.append(plustext); // APLUS
s1.append("PLUS"); // APLUS
s1.append(plustext, 2, 4); // AUS
s1.append("PLUS", 2); // APL
s1.append(5, 'A'); // AAAAAA
s1.append(plustext.begin(), plustext.end()); // APLUS
// ------------------------------
string plustext2 = "plus";
const char* p1 = "plus";
const char* p2 = p1 + 4;
string s2 = "M";
s2.append(p1, p2); // Mplus
}➡ +=
전체 문자열을 추가할 때 사용 ➡ 부분 문자열 불가
int main()
{
string plustext3 = "TEXT";
string s3 = "O";
s3 += plustext3; // OTEXT
s3 += "TEXT"; // OTEXT
}➡ push_back()
int main()
{
string plustext3 = "TEXT";
string s3 = "O";
for (char & c : plustext3)
{
s3.push_back(c); // OTEXT
}
for (string::iterator iter = plustext3.begin(); iter != plustext3.end(); iter++)
{
s3.push_back(*iter); // OTEXT
}
}➡ insert()
가리키는 인덱스 원소의 앞쪽에 삽입된다.
➡ 즉, 내가 [1]위치에 원소를 삽입하려 한다면 삽입한 문자열이 [1]부터 들어가있게 보인다.
| 사용 예시 | 설명 |
|---|---|
s.insert(1, "OOO") | insert(삽입 위치, C문자열 전체) |
s.insert(1, "OOO", 1) | insert(삽입 위치, C문자열, 글자 수) |
s.insert(1, t) | insert(삽입 위치, 문자열 전체) |
s.insert(1, t, 0, 1) | insert(삽입 위치, 문자열, 시작, 길이) |
s.insert(1, 3, 'O') | insert(삽입 위치, 반복 횟수, 문자) |
s.insert(s.begin() + 1, 'X') | insert(반복자 위치, 문자) |
s.insert(s.begin() + 1, 3, 'X') | insert(반복자 위치, 반복 횟수, 문자) |
s.insert(s.begin() + 1, t.begin(), t.end()) | insert(반복자 위치, 반복자 범위) |
int main()
{
string s = "ABC";
string t = "OOO";
s.insert(1, "OOO"); // AOOOBC
s.insert(1, "OOO", 1); // AOBC
s.insert(1, t); // AOOOBC
s.insert(1, t, 0, 1); // AOBC
s.insert(1, 3, 'O'); // AOOOBC
s.insert(begin()+1); // 삽입할 값을 넣지 않으면 빈 문자열(공백) 추가
}📌 문자열 할당
➡ assign()
| 사용 예시 | 설명 |
|---|---|
s1.assign(str); | 다른 std::string 전체를 복사하여 덮어씀 |
s1.assign("PLUS"); | C-style 문자열 전체를 복사하여 덮어씀 (\0까지) |
s1.assign(str, startIndex, count); | str의 startIndex부터 count개 문자를 복사하여 설정 |
s1.assign("PLUS", count); | C-style 문자열 앞에서 count개 문자를 복사하여 설정 |
s1.assign(repeatCount, 'A'); | 문자 'A'를 repeatCount만큼 반복하여 설정 |
s1.assign(beginIt, endIt); | 반복자 구간 [beginIt, endIt)의 문자들을 복사하여 설정 |
s2.assign(startPtr, endPtr); | 포인터 구간 [startPtr, endPtr)의 문자들을 복사하여 설정 |
부분 문자열 할당
int main()
{
string plustext = "PLUS";
string s1 = "A";
s1.assign(plustext); // PLUS
s1.assign("PLUS"); // PLUS
s1.assign(plustext, 2, 4); // US
s1.assign("PLUS", 2); // PL
s1.assign(5, 'A'); // AAAAA
s1.assign(plustext.begin(), plustext.end()); // PLUS
// ------------------------------
string plustext2 = "plus";
const char* p1 = "plus";
const char* p2 = p1 + 4;
string s2 = "M";
s2.assign(p1, p2); // plus
}➡ =
대입 연산자(=)는 전체 문자열을 할당할 때 사용
int main()
{
string plustext3 = "TEXT";
string s3 = "O";
s3 = plustext3; // TEXT
s3 = "TEXT"; // TEXT
}📌 \0 포함 여부
➡ c_str() & data()
c_str()➡ '\0' 문자를 포함한 문자열로 반환한다.data()➡ '\0' 문자을 포함하지 않는 문자 배열을 반환한다.
✅ 두 멤버 함수 모두 const char* 형식을 반환한다!
int main()
{
string s = "ABCD";
const char* p1 = s.c_str();
const char* p2 = s.data();
cout << "\0문자 포함 : " << p1 << endl;
cout << "\0문자 포함하지 않음 : " << p2 << endl;
}📌 문자열 비교
➡ compare()
사전순으로 비교하여 -1, 0, 1중에서 하나의 값을 반환한다.
➡ 사전순 비교는 문자열이 더 작은 것이나, 사전 상 더 앞에오는 문자 순서를 말한다.
➡ 사전순으로 작은 것이 대상이 더 작다는 것!!
비교 대상이 크다면 -1
비교 대상이 작다면 +1
비교 대상과 같다면 0 반환
| 사용 예시 | 비교 설명 | 비교 대상 |
|---|---|---|
s1.compare(s2) | s1 전체 vs s2 전체 | s2 |
s1.compare(pos, len, s2) | s1.pos위치 + len개 vs s2 전체 | s2 전체 |
s1.compare(p1, n1, s2, p2, n2) | s1.p1시작 위치, n1 비교할 길이 vs s2.p2시작 위치, 'n2' 비교할 길이 | s2 [ p2 + n2까지의 길이 ] |
s1.compare(sz) | s1 전체 vs sz 전체 | s2 전체 |
s1.compare(pos, len, sz) | s1.pos위치 + len개 vs s2 전체 | s2 |
s1.compare(pos, len, sz, n) | s1.pos위치, len개 vs s2, 'n' 비교할 길이 | s2 [ n개의 길이 만큼 ] |
int main()
{
string s1 = "ABCDE";
string s2 = "ABCDO";
const char* sz = "ABCAA";
s1.compare(s2); // s1 < s2 = -1
s1.compare(0, 4, s2); // s1 < s2 = -1
s1.compare(0, 4, s2, 0, 4); // s1 == s2 = 0
s1.compare(sz); // s1 > sz = 1
s1.compare(0, 1, sz); // s1 < sz = -1
s1.compare(0, 3, sz, 3); // s1 == s2 = 0
} 📌 문자열 복사
➡ copy()
copy()는 끝에 '\0'문자를 포함하지 않는다.
int main()
{
string str = "HELLO";
char buffer[10]; // 복사 대상 버퍼
size_t copied = str.copy(buffer, 3, 1); // str[1]부터 3개 문자 복사 → "ELL"
buffer[copied] = '\0'; // 꼭 null 종료 문자 추가!
cout << "복사된 문자: " << buffer << endl; // 출력: ELL
}
📌 문자열 찾기
➡ find() & rfind() & string::npos
문자나 문자열을 찾을 수 있다.
➡ 만약 찾았다면 첫 번째 문자의 인덱스를 반환한다.
➡ 찾지 못했다면 string::npos = -1을 반환한다.
🔹 find()
| 예시 | 설명 |
|---|---|
s.find('A') | 문자 'A'를 앞에서부터 찾음 |
s.find("ABC") | 문자열 "ABC"를 앞에서부터 찾음 |
s.find('A', 2) | 인덱스 2부터 시작해서 'A' 찾음 |
s.find("ABC", 1) | 인덱스 1부터 "ABC" 찾음 |
🔹 rfind()
| 예시 | 설명 |
|---|---|
s.rfind('A') | 문자 'A'를 뒤에서부터 찾음 |
s.rfind("ABC") | 문자열 "ABC"를 뒤에서부터 찾음 |
s.rfind('A', 5) | 인덱스 5부터 거꾸로 'A' 찾음 |
s.rfind("ABC", 6) | 인덱스 6부터 거꾸로 "ABC" 찾음 |
🔹 이외의 find들
| 함수 | 역할 |
|---|---|
find() | 특정 문자열이나 문자를 처음 찾음 |
find_first_of(chars) | chars 중 하나라도 처음 나오는 위치 |
find_first_not_of(chars) | chars에 포함되지 않는 첫 위치 |
find_last_of(chars) | chars 중 하나라도 가장 마지막 위치 |
find_last_not_of(chars) | chars에 포함되지 않는 마지막 위치 |
🔸 find() & rfind() 예시
int main()
{
string s = "ABCABC";
cout << s.find('B'); // 1
cout << s.rfind('B'); // 4
cout << s.find('C', 4); // 5
cout << s.find("ABC"); // 0
cout << s.rfind("ABC"); // 3
cout << s.rfind('C', 4); // 2
}🔸 find_first_not_of 예시
해당되는 것이 없다면 npos (-1)을 반환한다.
string s = " hello";
size_t pos = s.find_first_not_of(" "); // 공백 아닌 첫 위치
if (pos != string::npos)
cout << "처음 공백 아닌 문자: " << s[pos] << ", 위치: " << pos << endl;
// 출력: h, 위치: 3
📌 문자열 교체
➡ replace()
문자나 문자열을 교체할 때 사용된다.
| 사용 예시 | 설명 |
|---|---|
s.replace(pos, count, "OOO") | replace(시작 위치, 교체할 길이, C문자열) |
s.replace(pos, count, "OOO", n) | replace(시작 위치, 교체할 길이, C문자열, 앞 n글자만) |
s.replace(pos, count, t) | replace(시작 위치, 교체할 길이, 문자열) |
s.replace(pos, count, t, t_pos, t_len) | replace(시작 위치, 교체할 길이, 문자열 일부) |
s.replace(pos, count, n, 'O') | replace(시작 위치, 교체할 길이, 문자 'O'를 n번 반복) |
s.replace(it1, it2, "OOO") | replace(반복자 범위, C문자열) |
s.replace(it1, it2, n, 'O') | replace(반복자 범위, 문자 'O'를 n번 삽입) |
s.replace(it1, it2, t.begin(), t.end()) | replace(반복자 범위, 반복자 범위로 교체) |
int main()
{
string s1 = "OOOOO";
string s2 = "ABC";
s1.replace(0, 3, "ABC"); // ABCOO
s1.replace(0, 3, s2); // ABCOO
s1.replace(0, 4, "ABC", 2); // ABO
s1.replace(0, 1, s2, 0, 1); // AOOOO
s1.replace(0, 4, 4, 'A'); // AAAAO
s1.replace(s1.begin(), s1.end(), s2); // ABC
s1.replace(s1.begin(), s1.end(), "ABC"); // ABC
s1.replace(s1.begin(), s1.begin() + 1, s2.begin(), s2.begin() + 1); // AOOOO
cout << s1;
}📌 문자열 추출
➡ substr()
string 객체의 일부 문자열을 추출 할 때 사용한다.
✅ substr(0) & substr(0, string::npos)
➡ 문자열의 처음부터 마지막 문자까지의 부분 문자열을 가리킨다.
🟥 substr(pos, len);
➡ len이 문자열의 끝을 넘어가더라도 자동으로 남은 문자열만 반환한다.
➡ 아래의 코드처럼 s1의 범위를 넘어간 6을 작성하였지만, s4에는 가능한 문자열만 저장된다.
string s1 = "ABCDE";
string s4 = s1.substr(0, 6); // s4 : ABCDE| 사용 예시 | 설명 |
|---|---|
s1.substr(0) | substr(시작 위치) → 끝까지 복사 |
s1.substr(0, string::npos) | substr(시작, 최대 길이) → 끝까지 복사 |
s1.substr(0, 2) | substr(시작, 길이) → "AB" 추출 |
s1.substr(3, string::npos) | substr(3부터 끝까지) → "DE" 추출 |
int main()
{
string s1 = "ABCDE";
string s2 = s1.substr(0); // ABCDE
string s3 = s1.substr(0, string::npos); // ABCDE
string s4 = s1.substr(0, 2); // AB
string s5 = s1.substr(3, string::npos); // DE
}📌 문자열 입력
➡ getline()
| 사용 예시 | 설명 |
|---|---|
getline(cin, s) | 표준 입력에서 한 줄 전체 입력 받기 |
getline(file, s) | 파일 입력 스트림에서 한 줄 읽기 |
getline(cin, s, '#') | # 문자 전까지 입력 받기 (종료 문자 지정) |
int main()
{
string s;
getline(cin, s); // \n (줄바꿈)까지 입력받기
getline(cin, s, '\n'); // 종료 문자 전까지 입력받기 -> 종료 문자 지정
}
뉴비 개발자