LV12 string 클래스 구현해보기

char str[] = "Hello"; // 문자 배열로 문자열 표현 char* ptr = "World"; // 포인터로 문자열 표현

char str[10] = "Hello"; // "Hello"는 5글자인데 10칸을 미리 할당해야 함 // 나중에 더 긴 문자열을 넣으려면? 불가능!

char str1[20] = "Hello"; char str2[] = " World"; strcat(str1, str2); // 복잡한 함수 사용 필요

int len = strlen(str); // 함수 호출 필요

std::string str = "Hello"; str += " World"; // 간단한 연결! int len = str.length(); // 길이도 간단하게!

private: char* mStr; // 1️⃣ 실제 문자열 데이터 int mSize; // 2️⃣ 현재 문자열 길이 int mCapacity; // 3️⃣ 할당된 메모리 크기

// 예시 mStr = new char[15]; // 15칸짜리 공간 확보 // mStr이 가리키는 메모리: [H][e][l][l][o][\0][ ][ ][ ]...

// "Hello"를 저장했다면 mSize = 5; // 5글자

// "Hello"(5글자)를 위해 15칸을 할당했다면 mCapacity = 15; // 나머지 10칸은 여유 공간

// 여유 공간이 없다면: string str = "Hello"; // 5칸 할당 str += " "; // 1칸 더 필요 → 새로 6칸 할당 str += "W"; // 1칸 더 필요 → 새로 7칸 할당 str += "o"; // 1칸 더 필요 → 새로 8칸 할당 // 매번 새로 할당하면 느려요! // 여유 공간이 있다면: string str = "Hello"; // 15칸 할당 (여유 10칸) str += " World"; // 여유 공간 사용 → 새로 할당 안 함!

ya::string str("Hello"); // 이 순간 생성자 호출!

string(const char* str) { mSize = strlen(str); // 1️⃣ 길이 계산 mCapacity = (mSize * 2) + (mSize / 2); // 2️⃣ 여유 공간 계산 mStr = new char[mCapacity]; // 3️⃣ 메모리 할당 memset(mStr, 0, mCapacity); // 4️⃣ 메모리 초기화 memcpy(mStr, str, mSize + 1); // 5️⃣ 문자열 복사 }

mSize = strlen(str);

mCapacity = (mSize * 2) + (mSize / 2);

// 예시: "Hello" (5글자) mCapacity = (5 * 2) + (5 / 2) = 10 + 2 = 12칸 // 예시: "Hello World" (11글자) mCapacity = (11 * 2) + (11 / 2) = 22 + 5 = 27칸

mStr = new char[mCapacity];

memset(mStr, 0, mCapacity);

memcpy(mStr, str, mSize + 1);

// "Hello" 복사 시 str : [H][e][l][l][o][\0] ↓ ↓ ↓ ↓ ↓ ↓ mStr : [H][e][l][l][o][\0][0][0][0][0][0][0]

ya::string str("Hello");

~string() { delete[] mStr; // 1️⃣ 메모리 해제 mStr = nullptr; // 2️⃣ 포인터 초기화 }

{ ya::string str("Hello"); // 생성자: new로 메모리 할당 // str 사용... } // 이 중괄호를 벗어나면 str 객체 소멸 // 소멸자: delete로 메모리 해제 필요!

// 소멸자가 없다면: void test() { ya::string str1("Hello"); // 메모리 할당 ya::string str2("World"); // 메모리 할당 ya::string str3("!!!!"); // 메모리 할당 } // 함수 종료 → 메모리가 해제 안 됨 → 메모리 누수! // 소멸자가 있다면: void test() { ya::string str1("Hello"); // 메모리 할당 ya::string str2("World"); // 메모리 할당 ya::string str3("!!!!"); // 메모리 할당 } // 함수 종료 → 소멸자 자동 호출 → 메모리 해제 완료!

delete[] mStr; // ✅ 배열 할당(new[])에는 delete[] 사용 delete mStr; // ❌ 잘못된 사용! 일부만 해제됨

ya::string str("Hello"); str += " World"; // "Hello World"가 됨

void operator+= (const char* str) { int len = strlen(str); // 1️⃣ 추가할 문자열 길이 int newSize = mSize + len; // 2️⃣ 새로운 전체 길이 // 3️⃣ 용량 체크 및 재할당 if (newSize >= mCapacity) { mCapacity = (newSize * 2) + (newSize / 2); char* newStr = new char[mCapacity]; memset(newStr, 0, mCapacity); memcpy(newStr, mStr, mSize); delete[] mStr; mStr = nullptr; mStr = newStr; } // 4️⃣ 문자열 추가 memcpy(mStr + mSize, str, len + 1); mSize = newSize; }

int len = strlen(str);

// 예시 str += " World"; // 추가할 문자열 len = strlen(" World") = 6

int newSize = mSize + len;

// 예시: "Hello"에 " World" 추가 mSize = 5 // 기존 "Hello" len = 6 // 추가할 " World" newSize = 5 + 6 = 11

현재 상태: mStr: [H][e][l][l][o][\0][0][0][0][0][0][0] mSize: 5 mCapacity: 12 " World" (6글자) 추가 시: newSize = 11 11 < 12 (용량 충분!) → 재할당 없이 바로 추가

현재 상태: mStr: [H][e][l][l][o][\0][0][0] mSize: 5 mCapacity: 8 " World !!!!" (12글자) 추가 시: newSize = 17 17 >= 8 (용량 부족!) → 재할당 필요!

// 3-1. 새로운 용량 계산 mCapacity = (newSize * 2) + (newSize / 2); // newSize = 17이면 // mCapacity = (17 * 2) + (17 / 2) = 34 + 8 = 42 // 3-2. 새 메모리 할당 char* newStr = new char[mCapacity]; // newStr → [0][0][0]...[0] (42칸) // 3-3. 새 메모리 초기화 memset(newStr, 0, mCapacity); // 3-4. 기존 데이터 복사 memcpy(newStr, mStr, mSize); // mStr: [H][e][l][l][o][\0][0][0] // ↓ ↓ ↓ ↓ ↓ ↓ // newStr: [H][e][l][l][o][0][0]...[0] (42칸) // 3-5. 기존 메모리 해제 delete[] mStr; mStr = nullptr; // 3-6. 새 메모리로 교체 mStr = newStr;

memcpy(mStr + mSize, str, len + 1); mSize = newSize;

mStr + mSize // 기존 문자열의 끝 위치를 가리킴 // 예시: "Hello"의 경우 mStr → [H][e][l][l][o][\0][0]...[0] ↑ ↑ mStr mStr + mSize (5번 위치, \0가 있는 곳)

// " World" 추가 시 memcpy(mStr + mSize, " World", len + 1); // ↑ 복사 시작 위치 (5번 인덱스) // ↑ 6글자 + \0 = 7바이트 복사 전: mStr: [H][e][l][l][o][\0][0][0][0][0][0][0] ↑ 여기부터 복사 복사 후: mStr: [H][e][l][l][o][ ][W][o][r][l][d][\0] mSize: 11

ya::string str("Hello"); // 초기 상태 str += " World"; // 문자열 추가

ya::string str("Hello"); cout << str[0]; // 'H' 출력 (읽기) str[1] = 'a'; // "Hallo"로 변경 (쓰기)

char& operator[] (int index) { return mStr[index]; }

char& operator[] (int index) // ✅ 참조 반환 { return mStr[index]; } // 이렇게 동작: str[0] = 'h'; // ↓ 실제로는 mStr[0] = 'h'; // 직접 수정 가능!

char operator[] (int index) // ❌ 값 반환 { return mStr[index]; } // 이렇게 동작: str[0] = 'h'; // ↓ 실제로는 char temp = mStr[0]; // 복사본 생성 temp = 'h'; // 복사본만 수정됨 // mStr[0]은 그대로! 원본 수정 안 됨!

ya::string str("Hello"); // 읽기: 값을 가져옴 cout << str[0]; // 'H' 출력 char c = str[1]; // c = 'e' // 쓰기: 값을 변경 str[0] = 'h'; // "hello"로 변경 str[4] = 'p'; // "hellp"로 변경

ya::string str("Hello"); str[1] = 'a';

int Size() const { return mSize; }

int Size() const // ← 이 함수는 멤버 변수를 수정하지 않음을 보장

ya::string str("Hello"); int len = str.Size(); // ✅ 안전하게 길이만 읽어옴

const char* c_str() const { return mStr; }

ya::string str("Hello"); // cout은 char* 타입을 출력할 수 있음 cout << str.c_str(); // ✅ "Hello" 출력 // 직접 출력하면? cout << str; // ❌ 에러! (연산자가 없음)

const char* c_str() const // ↑ ↑ // | 함수가 멤버를 수정 안 함 // 반환된 문자열을 수정하면 안 됨

ya::string str("Hello"); const char* ptr = str.c_str(); ptr[0] = 'h'; // ❌ 에러! const char*는 수정 불가

#include <iostream> #include <cstring> // strlen, memcpy, memset namespace ya { class string { private: char* mStr; int mSize; int mCapacity; public: // 생성자 string(const char* str) { mSize = strlen(str); // 넉넉하게 할당 (기본 크기보다 조금 더 크게) mCapacity = (mSize * 2) + (mSize / 2); if (mCapacity == 0) mCapacity = 1; // 빈 문자열 대비 mStr = new char[mCapacity]; memset(mStr, 0, mCapacity); memcpy(mStr, str, mSize + 1); // NULL 문자 포함 복사 } // 소멸자 ~string() { if (mStr != nullptr) { delete[] mStr; mStr = nullptr; } } // += 연산자 void operator+= (const char* str) { int len = strlen(str); int newSize = mSize + len; // 용량이 부족할 경우 재할당 if (newSize >= mCapacity) { // 용량 늘리기 (기존 로직 유지) mCapacity = (newSize * 2) + (newSize / 2); char* newStr = new char[mCapacity]; memset(newStr, 0, mCapacity); // 1. 기존 데이터 복사 (새 공간으로) memcpy(newStr, mStr, mSize); // 2. 기존 메모리 해제 delete[] mStr; // 3. 포인터 교체 (중요!) mStr = newStr; } // 4. 문자열 이어 붙이기 (기존 끝부분부터, NULL 문자 포함) memcpy(mStr + mSize, str, len + 1); // 5. 사이즈 갱신 mSize = newSize; } // [] 연산자: 인덱스로 문자 접근 char& operator[] (int index) { return mStr[index]; } // Size 함수 int Size() const { return mSize; } // c_str 함수 (문자열 주소 반환) const char* c_str() const { return mStr; } }; } int main() { // 테스트 코드 ya::string s("Hello"); std::cout << "처음: " << s.c_str() << std::endl; s += " World!"; std::cout << "변경 후: " << s.c_str() << std::endl; std::cout << "길이: " << s.Size() << std::endl; std::cout << "인덱스 [1]: " << s[1] << std::endl; return 0; }

int main() { // std::string 사용법 비교 std::string stdStr("Hello"); stdStr += " World"; cout << "std::string: " << stdStr << endl; cout << "4번째 문자: " << stdStr[4] << endl; cout << "━━━━━━━━━━━━━━━━━━━━" << endl; // 우리가 만든 ya::string 사용 ya::string myStr("Hello"); cout << "초기 문자열: " << myStr.c_str() << endl; cout << "길이: " << myStr.Size() << endl; // 문자열 추가 myStr += " World"; cout << "\n문자열 추가 후: " << myStr.c_str() << endl; cout << "길이: " << myStr.Size() << endl; // 개별 문자 변경 myStr[0] = 'h'; // 'H' → 'h' cout << "\n첫 글자 변경 후: " << myStr.c_str() << endl; // 인덱스 접근 cout << "4번째 문자: " << myStr[4] << endl; return 0; }

// ❌ 정적 할당: 크기가 고정됨 char str[10]; // 최대 9글자만 저장 가능

mCapacity: [H][e][l][l][o][\0][ ][ ][ ][ ][ ][ ] (12칸 할당) mSize: 5 ↑─────────────────↑ (실제 사용 5칸) mStr: 포인터가 첫 번째 위치를 가리킴 // ✅ 동적 할당: 필요한 만큼 확장 가능 char* str = new char[size]; // 필요한 크기만큼 할당

// 1단계: 할당 mStr = new char[mCapacity]; // 2단계: 사용 memcpy(mStr, "Hello", 6); // 3단계: 해제 (소멸자에서) delete[] mStr;

// ❌ 연산자 오버로딩 없이 str.append(" World"); char c = str.at(0); // ✅ 연산자 오버로딩으로 str += " World"; // 더 직관적! char c = str[0]; // 더 간단!

// ✅ 참조 반환: 원본 수정 가능 char& operator[] (int index) { return mStr[index]; } str[0] = 'h'; // 원본이 바뀜 // ❌ 값 반환: 복사본만 수정됨 char operator[] (int index) { return mStr[index]; } str[0] = 'h'; // 원본은 그대로

int Size() const // 이 함수는 멤버를 수정하지 않음

mCapacity = (mSize * 2) + (mSize / 2); // 2.5배 할당

// 1. 문자열이 비어있는지 확인 bool IsEmpty() const { return mSize == 0; } // 2. 문자열 비우기 void Clear() { memset(mStr, 0, mCapacity); mSize = 0; } // 사용 예시 ya::string str("Hello"); if (!str.IsEmpty()) str.Clear();

// == 연산자 구현 bool operator== (const char* str) { return strcmp(mStr, str) == 0; } // 사용 예시 ya::string str("Hello"); if (str == "Hello") cout << "같습니다!" << endl;

// 다른 string 객체로부터 복사 string(const string& other) { mSize = other.mSize; mCapacity = other.mCapacity; mStr = new char[mCapacity]; memset(mStr, 0, mCapacity); memcpy(mStr, other.mStr, mSize + 1); } // 사용 예시 ya::string str1("Hello"); ya::string str2(str1); // str1을 복사

#include <vector> std::vector<int> vec; vec.resize(100); vec.push_back(1); // 요소 추가 vec.push_back(2); vec.push_back(3); cout << vec[0]; // 1 출력 cout << vec.size(); // 3 출력

template<typename T> class vector { public: vector(); // 생성자 ~vector(); // 소멸자 void push_back(T value); // 요소 추가 void clear(); // 모든 요소 제거 void resize(int newSize); // 크기 변경(사용 가능 공간) void reserve(int size); // 실제 메모리 할당 크기 T& operator[](int index); // 인덱스 접근 int size() const; // 크기 반환 private: T* mData; // 실제 데이터 배열 int mSize; // 현재 요소 개수 int mCapacity; // 할당된 용량 };

// push_back 구현 힌트 void push_back(T value) { // 1. 용량 체크 if (mSize >= mCapacity) { // 재할당 (string과 비슷) } // 2. 요소 추가 mData[mSize] = value; mSize++; }

// 여유 공간 없이 (비효율적) "H" → 재할당 "He" → 재할당 "Hel" → 재할당 // 매번 재할당! // 여유 공간 있음 (효율적) "H" → 재할당 (12칸 확보) "He" → 여유 공간 사용 "Hel" → 여유 공간 사용 // 한 번만 재할당!

char src[] = "Hello"; // memcpy: 정확히 6바이트 복사 memcpy(dest, src, 6); // strcpy: \0까지 자동 복사 strcpy(dest, src);

int* a = new int; // 단일 할당 delete a; // 단일 해제 int* arr = new int[10]; // 배열 할당 delete[] arr; // 배열 해제

const char* c_str() const // ↑ ↑ // | 2번째: 함수가 멤버를 수정 안 함 // 1번째: 반환된 포인터로 문자열 수정 안 함

char& operator[](int index) { return mStr[index]; // ✅ 안전 (객체가 살아있음) } // 위험한 경우: char& GetChar() { char c = 'A'; return c; // ❌ 위험! 지역 변수 반환 }