Post

문자열 뒤집기 (char*)

문자열 뒤집기 (char*)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

void reverse(char* str) {
    if (str == nullptr) return;

    // 문자열의 끝을 찾음 (널 종료 문자 전까지 이동)
    char* end = str;
    while (*end != '\0') {
        ++end;
    }
    --end; // '\0' 이전 문자로 이동

    // 앞(str)과 뒤(end)를 바꿔가며 역순 처리
    while (str < end) {
        char temp = *str;
        *str = *end;
        *end = temp;

        ++str;
        --end;
    }
}



strlen swap 함수 사용

  • strlen은 C 스타일 문자열에서 '\0'을 만나면 끝이라고 인식하여 길이를 계산하는 함수입니다.
    char* 타입의 문자열은 항상 널 문자로 끝나기 때문에, strlen 함수가 잘 동작할 수 있습니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
#include <cstring> // strlen 사용을 위해 필요

void reverse(char* str) {
    if (str == nullptr) return;  // nullptr 방어

    size_t len = strlen(str);
    size_t left = 0;
    size_t right = len - 1;

    while (left < right) {
        std::swap(str[left], str[right]);
        left++;
        right--;
    }
}


size_t를 쓰는가?

  1. 표준 라이브러리 함수와 타입 일치
    1
    
     size_t len = strlen(str); // strlen 반환 타입이 size_t
    

    -> int len = strlen(str); 처럼 쓰면 경고나 암묵적인 형변환이 생길 수 있다.

  2. 음수 방지
    size_t는 unsigned(부호없음)이기 때문에, 음수 인덱스 같은 논리적 오류를 예방할 수 있다.
  3. 플랫폼 독립적인 크기
    size_t는 플랫폼에 따라 32bit 또는 64bit로 자동 설정되므로,
    더 큰 배열에도 안전하게 쓸 수 있다.


주의할 점

  • size_t는 부호 없는 타입이라 0 - 1은 언더플로우로 매우 큰 수가 된다.
    따라서 반복문에서 size_t i = n - 1; i >= 0; i-- 같은 패턴은 무한 루프가 될 수 있다.



테스트 코드

1
2
3
4
5
6
int main() {
    char text[] = "hello";
    reverse(text);
    std::cout << text << std::endl;  // 출력: "olleh"
    return 0;
}



매개변수가 const char* 타입이라면?

복사 후 뒤집기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <cstring>

char* reverseConstStr(const char* str) {
    if (!str) return nullptr;

    size_t len = strlen(str);
    char* copy = new char[len + 1];  // null 문자 포함
    strcpy(copy, str);  // 문자열 복사

    // 복사된 문자열을 뒤집기
    size_t left = 0, right = len - 1;
    while (left < right) {
        char temp = copy[left];
        copy[left] = copy[right];
        copy[right] = temp;
        left++;
        right--;
    }

    return copy;  // 호출한 쪽에서 delete[] 필요!
}
1
2
3
4
5
6
7
int main() {
    const char* original = "hello";
    char* reversed = reverseConstStr(original);
    std::cout << reversed << std::endl;  // 출력: "olleh"
    delete[] reversed;
    return 0;
}
This post is licensed under CC BY 4.0 by the author.