(2025-2) Introduction to programming(2) 3. Strings, Vectors, and Arrays

수업일: 2025-09-16

목표: 문자열 다루기(문자 분류/대소문자 변환), 안전한 인덱싱(size_type), 범위기반 for(값/참조), vector(동적 배열/반복자/용량), 배열·포인터 선언 해석, C-스타일 문자열 상호운용을 직관적으로 이해하고 안전하게 코딩한다.

---

0) 큰 그림 한 장 요약

• string = 안전한 “글자 상자(동적 길이)”; 길이는 부호 없는 정수
• 문자 처리 = <cctype>: isalpha/isdigit/ispunct + tolower/toupper
• 반복 = 범위기반 for (값 복사 ↔ 참조) / 전통 for (인덱스는 size_type)
• vector = “늘어나는 배열”; push_back, 용량(capacity), 반복자
• 배열/포인터 = 선언 해석(괄호 결합), 포인터 산술, end 관용구
• 상호운용 = string.c_str() ↔ const char* (수명 주의)

---

1) 문자열(string)과 문자 처리: “문장을 재료로 가공하기”

1-1. string이 안전한 이유

• C 문자열(char*)은 길이/경계 오류에 취약.
• std::string은 길이 정보를 내부에 갖고 있어 경계 검사와 자동 메모리 관리가 쉬움.

+---------------------+
|  'H' 'e' 'l' 'l' 'o' |
+---------------------+
 size()=5, empty()? false

1-2. 문장부호 세기 & 대문자 변환 (두 가지 순회법 비교)

#include <iostream>
#include <string>
#include <cctype>   // 문자 분류/변환
using namespace std;

int main() {
    string s = "Hello, World!!!";

    // [A] 값으로 순회(원본 불변)
    size_t punct_cnt = 0;
    for (char c : s) { // c는 복사본
        if (ispunct(static_cast<unsigned char>(c)))
            ++punct_cnt;
    }
    cout << "punct=" << punct_cnt << "\\n"; // 4

    // [B] 참조로 순회(원본 수정)
    for (char& c : s) {
        c = static_cast<char>(toupper(static_cast<unsigned char>(c)));
    }
    cout << s << "\\n"; // HELLO, WORLD!!!
}

왜 unsigned char로 캐스팅하나요?

• toupper/ispunct는 문자 코드가 음수일 때 동작이 미정의일 수 있어요.
• 관례적으로 static_cast<unsigned char>(c)로 안전 보정!

1-3. s[i] vs s.at(i) (안전성 차이)

string s = "hi";
cout << s[5];     // ❌ 미정의동작(크래시/쓰레기 출력)
cout << s.at(5);  // 예외 throw (out_of_range) → 잡아서 처리 가능

• 성능이 중요하지 않다면 초보 단계에서 at()가 더 안전.

---

2) 안전한 인덱싱: decltype(s.size())와 string::size_type

2-1. 왜 굳이 size_type를 쓰나?

• string::size()는 부호 없는 정수(보통 size_t)를 반환.
• 인덱스/길이 변수도 같은 족보로 쓰면 경고/오류/비교함정을 줄임.

string s = "hello";
if (!s.empty()) {
    decltype(s.size()) i = 0;  // string::size_type과 동일
    s[i] = static_cast<char>(toupper((unsigned char)s[i]));
}

2-2. 빈 문자열 안전 패턴

if (!s.empty()) {
    // s[0] 접근 OK
}

• 빈 문자열에서 s[0]은 절대 금지 → 미정의동작.

---

3) 범위기반 for: “값 복사 vs 참조” 눈으로 보기

3-1. 값 복사 → 원본 불변

string s = "abc";
for (char c : s) c = 'X'; // 복사본만 바뀜
cout << s;                // "abc"

3-2. 참조 → 원본 수정

string s = "abc";
for (char& c : s) c = 'X'; // 원본 수정
cout << s;                 // "XXX"

규칙:

• 읽기만 할 거면 const char& (불필요한 복사 방지)
• 수정할 거면 char&
• 값 복사는 간단하지만 원본 안 바뀜에 유의

---

4) 전통 for + 인덱스: hexdigits 예제로 감 잡기

#include <iostream>
#include <string>
using namespace std;

int main() {
    const string hex = "0123456789ABCDEF"; // 길이 16
    int n;
    while (cin >> n) {
        if (0 <= n && n < static_cast<int>(hex.size()))
            cout << hex[n] << ' ';
        else
            cout << "(?) ";
    }
}

핵심

• 인덱스 범위 체크는 반드시
• hex.size()는 부호 없는 정수 → 비교 시 캐스팅으로 의도를 명확히

---

5) vector 한 번에 잡기: “늘어나는 배열”

5-1. 핵심 조작

#include <vector>
using namespace std;

vector<int> v;        // 크기 0
v.push_back(10);      // [10]
v.push_back(20);      // [10,20]

vector<int> a(3, 7);  // [7,7,7]  (크기 지정 + 채우기)
vector<int> b{1,2,3}; // 리스트 초기화

5-2. size vs capacity (그림)

logical size (size):  [  0  1  2  ]  = 3
physical capacity:    [  0  1  2  3  4  5  ]  = 6 (추가 여유)

• size() = 실제 원소 수
• capacity() = 재할당 없이 담을 수 있는 최대 원소 수
• 많이 넣을 계획이면 reserve로 미리 확보

vector<int> v;
v.reserve(1000);   // 1000개 정도 들어갈 예정
for (int i=0;i<1000;++i) v.push_back(i);

5-3. 반복자와 수정(값/참조)

vector<int> v{1,2,3};
for (int x : v) x *= 2;     // 복사 → 원본 안 변함
for (int& x : v) x *= 2;    // 참조 → [2,4,6]

5-4. 반복자 무효화(invalidation) 주의

• push_back/insert 중 재할당(capacity 증가) 이 발생하면 기존 반복자/참조/포인터가 무효화될 수 있음.
• 안전 패턴:
  • 가능한 한 reserve()로 재할당을 줄임
  • 재할당 가능성이 있는 조작 후에는 반복자 다시 얻기

---

6) 반복자(iterator) 제대로 사용하기

#include <vector>
#include <string>
#include <iostream>
using namespace std;

int main() {
    vector<string> words = {"a", "bb", "ccc"};

    // 쓰기 가능한 반복자
    for (auto it = words.begin(); it != words.end(); ++it) {
        if (!it->empty()) {              // (*it).empty()와 같음
            (*it)[0] = toupper((unsigned char)(*it)[0]);
        }
    }

    // 읽기 전용 반복자
    for (auto it = words.cbegin(); it != words.cend(); ++it) {
        cout << *it << ' ';
    }
}

요점

• it : 원소에 대한 참조(역참조)
• it->member : (*it).member 축약
• cbegin/cend : 읽기 전용 뷰 (함부로 바꾸지 않겠다는 약속)

---

7) 임의 접근(랜덤 엑세스) 반복자: +n, n, 차이 계산

vector<int> v{10,20,30,40,50};
auto it = v.begin();
cout << *(it + 2) << "\\n"; // 30
*(it + 3) = 999;
auto dist = (v.end() - v.begin()); // 5 (원소 개수)

• string/vector는 랜덤 엑세스 가능(배열처럼 더하기/빼기)
• list는 불가(양방향만)

---

8) 배열과 포인터 선언 해석: 괄호 결합 규칙만 알면 끝

8-1. 두 선언의 차이 (자주 낚이는 포인트)

int (*pa)[10];  // 'int[10]' 배열을 가리키는 '포인터'
int* ap[10];    // 'int*' (포인터) 10개로 이루어진 '배열'

• 읽는 법: 식별자 주변에서 괄호 우선 → 그 다음 []/ 결합

8-2. 배열 ↔ 포인터 decay와 산술

int arr[3] = {10,20,30};
int* p = arr;           // = &arr[0]
*(p + 1) = 99;          // arr[1] = 99

8-3. end 관용구 (마지막 다음 위치)

int* beg = arr;               // &arr[0]
int* last = arr + 3;          // end(마지막 다음)
for (int* it = beg; it != last; ++it) {
    // *it 사용
}

---

9) string ↔ C-스타일 문자열: 다리 놓기

#include <string>
#include <cstdio>
using namespace std;

int main() {
    string s = "hello";
    const char* c = s.c_str();      // C 함수에 전달 가능
    // printf("%s\\n", c);

    // 반대 방향
    const char* name = "minji";     // 리터럴(읽기 전용)
    string t(name);                 // string으로 복사
}

수명 이슈(중요)

• c_str()는 s가 살아 있고, 내용이 바뀌지 않는 동안만 유효.
• s.push_back('!') 같은 변경이 일어나면, c는 더 이상 유효하지 않을 수 있음.

---

10) 입출력 자주 터지는 함정: >> 다음 getline

string token, line;
cin >> token;  // 여기서 개행문자(\\n)가 버퍼에 남음
// 바로 getline을 호출하면 빈 줄을 읽을 수 있음
cin.ignore(numeric_limits<streamsize>::max(), '\\n'); // 남은 줄 비우기
getline(cin, line);

외워두기: >> 뒤엔 ignore(...) 하고 getline.

---

11) 의사코드로 감각 잡기

11-1. 문장부호 세기 (의사코드)

count := 0
문자열 s의 각 문자 c에 대해:
    c가 문장부호면 count := count + 1
count 출력

11-2. 대문자 변환 (의사코드)

문자열 s의 각 문자 c에 대해 (참조로 순회):
    c := 대문자(c)
s 출력

---

12) 미니 실습(손으로 쳐보기)

(A) 각 단어의 첫 글자를 대문자로

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

int main() {
    string line;
    getline(cin, line);

    bool newWord = true;
    for (char& c : line) {
        if (isspace((unsigned char)c)) {
            newWord = true;
        } else {
            if (newWord) c = (char)toupper((unsigned char)c);
            newWord = false;
        }
    }
    cout << line << "\\n";
}

(B) 숫자만 추출해 합계 구하기

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

int main() {
    string s; getline(cin, s);
    long long sum = 0, cur = 0; bool inNum = false;

    for (char ch : s) {
        if (isdigit((unsigned char)ch)) {
            inNum = true;
            cur = cur * 10 + (ch - '0');
        } else {
            if (inNum) { sum += cur; cur = 0; inNum = false; }
        }
    }
    if (inNum) sum += cur;
    cout << sum << "\\n";
}

---

13) 예상문제(시험형) & 빠른 답

Q1. vector에서 push_back 후 기존 반복자가 무효화될 수 있는 이유?

A. 재할당(capacity 확장) 시 내부 버퍼가 새로 할당되어, 이전 메모리를 가리키던 반복자/참조/포인터가 죽기 때문.

Q2. 아래 선언을 말로 설명하라: int (*p)[10];

A. “int 10개짜리 배열을 가리키는 포인터.”

Q3. 왜 toupper(c) 전에 (unsigned char)c로 캐스팅하나?

A. 음수 코드값으로 호출 시 미정의 가능 → 안전 보정.

Q4. string 인덱스 변수 타입은 무엇을 권장?

A. decltype(s.size()) 또는 string::size_type (부호 없는 정수, 구현 독립).

Q5. >> 뒤 getline이 빈 줄을 읽는 이유와 해결책?

A. 입력 버퍼에 남아 있던 개행문자 때문. cin.ignore(...)로 비우고 getline.

---

14) 체크리스트 (스스로 점검)

• [ ] string 길이/인덱스는 부호 없는 정수로.
• [ ] toupper/ispunct 호출 전 unsigned char 캐스팅.
• [ ] 범위기반 for: 값/참조 차이 체감.
• [ ] vector: size/capacity/reserve 개념 이해.
• [ ] 재할당 후 반복자 무효화 주의.
• [ ] 배열/포인터 선언을 괄호 결합 규칙으로 해석 가능.
• [ ] c_str() 수명 규칙 숙지.
• [ ] >> + getline 섞을 땐 ignore 패턴.

---

15) 연습예제

// 1) 안전한 대문자 변환
for (char& c : s) c = (char)toupper((unsigned char)c);

// 2) 안전한 인덱스
for (decltype(s.size()) i = 0; i < s.size(); ++i) { /* ... */ }

// 3) vector 미지수 입력 모으기
vector<int> v; v.reserve(1000);
for (int x; cin >> x; ) v.push_back(x);

// 4) 반복자로 접근/수정
for (auto it = v.begin(); it != v.end(); ++it) *it += 1;

// 5) 배열의 end 관용구
int arr[5]; int* beg = arr; int* last = arr + 5;

// 6) 선언 해석 예
int (*pa)[10]; // 배열 포인터
int* ap[10];   // 포인터 배열