AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.0 전체 열람

Ver3.0 🎯 C++ 정규표현식과 std::regex를 활용한 텍스트 처리

2025.11.05

재능넷

댓글 0 전체 53 페이지

🎯 C++ 정규표현식과 std::regex를 활용한 텍스트 처리

친구처럼 쉽게 배우는 텍스트 마법사 되기 프로젝트! ✨

🚀 정규표현식, 너 누구니?

야, 혹시 텍스트 파일에서 이메일 주소만 쏙쏙 뽑아내거나, 전화번호 형식이 맞는지 검사하거나, 특정 패턴의 문자열을 한 번에 바꿔야 할 때 막막했던 적 있지? 😅 그럴 때 필요한 게 바로 정규표현식(Regular Expression)이야!

정규표현식은 쉽게 말해서 문자열 패턴을 표현하는 특별한 언어라고 생각하면 돼. 마치 "010으로 시작하고 숫자 8개가 더 있는 거 찾아줘!"라고 컴퓨터에게 명령하는 거지. 이걸 C++에서 사용할 수 있게 해주는 게 바로 std::regex 라이브러리야! 🎉

C++11부터 표준 라이브러리에 포함되어서, 별도의 외부 라이브러리 없이도 강력한 텍스트 처리 기능을 사용할 수 있게 됐어. 이제부터 친구처럼 편하게 하나씩 알아보자!

📚 std::regex 기본 구조 파헤치기

자, 이제 본격적으로 C++의 std::regex를 사용해보자! 먼저 필요한 헤더 파일을 포함시켜야 해:

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string text = "내 이메일은 hello@example.com 이야!";
    std::regex pattern("[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z]+");
    
    if (std::regex_search(text, pattern)) {
        std::cout << "이메일을 찾았어! 🎉" << std::endl;
    }
    
    return 0;
}

위 코드를 보면 세 가지 핵심 요소가 있어:

1️⃣ std::string - 검색할 텍스트를 담는 문자열

2️⃣ std::regex - 찾고 싶은 패턴을 정의하는 정규표현식 객체

3️⃣ std::regex_search - 실제로 패턴을 찾아주는 함수

🔍 주요 함수들 총정리

std::regex 라이브러리는 여러 가지 유용한 함수들을 제공해. 각각의 특징을 알아보자!

함수명	기능	사용 시나리오
regex_match	전체 문자열이 패턴과 일치하는지 확인	입력값 전체 검증 (예: 비밀번호 형식)
regex_search	문자열 내에서 패턴을 찾음	텍스트에서 특정 패턴 찾기
regex_replace	패턴과 일치하는 부분을 치환	문자열 일괄 변경
regex_iterator	모든 매칭 결과를 순회	여러 개의 매칭 결과 처리

🎨 정규표현식 패턴 문법 마스터하기

정규표현식의 진짜 힘은 패턴 문법에 있어! 처음엔 좀 복잡해 보이지만, 하나씩 익히면 정말 강력한 도구가 돼. 😎

🔤 기본 문자 클래스

. (점) - 줄바꿈을 제외한 모든 문자 하나와 매칭

\d - 숫자 하나 [0-9]와 동일

\D - 숫자가 아닌 문자

\w - 단어 문자 [a-zA-Z0-9_]

\W - 단어 문자가 아닌 것

\s - 공백 문자 (스페이스, 탭, 줄바꿈)

\S - 공백이 아닌 문자

// 숫자 3개 찾기
std::regex pattern1("\\d{3}");  // 123, 456 등

// 단어 찾기
std::regex pattern2("\\w+");    // hello, world123 등

// 공백으로 구분된 단어들
std::regex pattern3("\\w+\\s+\\w+");  // "hello world" 등

💡 꿀팁! C++에서는 백슬래시를 이스케이프해야 해서 \\d처럼 두 번 써야 해. 이게 좀 귀찮으면 raw string literal을 사용할 수 있어: R"(\d{3})" 이렇게!

🔢 수량자 (Quantifiers)

수량자는 패턴이 몇 번 반복되는지를 지정해줘. 이게 정말 유용해!

* - 0번 이상 반복 (없어도 되고, 여러 번 있어도 됨)

+ - 1번 이상 반복 (최소 1번은 있어야 함)

? - 0번 또는 1번 (있거나 없거나)

{n} - 정확히 n번

{n,} - n번 이상

{n,m} - n번 이상 m번 이하

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string text = "전화번호: 010-1234-5678, 02-123-4567";
    
    // 휴대폰 번호 패턴 (010-xxxx-xxxx)
    std::regex mobile(R"(010-\d{4}-\d{4})");
    
    // 일반 전화번호 패턴 (0x-xxx-xxxx 또는 0xx-xxxx-xxxx)
    std::regex phone(R"(0\d{1,2}-\d{3,4}-\d{4})");
    
    std::smatch match;
    
    if (std::regex_search(text, match, mobile)) {
        std::cout << "휴대폰: " << match.str() << std::endl;
    }
    
    return 0;
}

🎯 앵커와 경계

문자열의 시작이나 끝, 단어의 경계를 지정할 수 있어:

^ - 문자열의 시작

$ - 문자열의 끝

\b - 단어 경계 (단어의 시작이나 끝)

\B - 단어 경계가 아닌 곳

// 문자열이 숫자로만 이루어져 있는지 확인
std::regex only_digits(R"(^\d+$)");

// "cat"이라는 단어만 찾기 ("catch"의 cat은 제외)
std::regex word_cat(R"(\bcat\b)");

std::string test1 = "12345";
std::string test2 = "abc123";
std::string test3 = "I have a cat";
std::string test4 = "I catch fish";

std::cout << std::regex_match(test1, only_digits) << std::endl;  // 1 (true)
std::cout << std::regex_match(test2, only_digits) << std::endl;  // 0 (false)
std::cout << std::regex_search(test3, word_cat) << std::endl;    // 1 (true)
std::cout << std::regex_search(test4, word_cat) << std::endl;    // 0 (false)

🛠️ 실전 예제로 배우는 std::regex

이론은 이제 충분해! 실제로 자주 사용하는 패턴들을 코드로 구현해보자. 🚀

📧 이메일 주소 검증하기

이메일 주소는 웹 개발에서 가장 많이 검증하는 패턴 중 하나야. 완벽한 이메일 검증은 복잡하지만, 실용적인 수준의 검증 코드를 만들어보자:

#include <iostream>
#include <regex>
#include <string>
#include <vector>

bool validateEmail(const std::string& email) {
    // 이메일 패턴: 영문자/숫자/특수문자 + @ + 도메인 + . + 최상위도메인
    std::regex pattern(
        R"(^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$)"
    );
    
    return std::regex_match(email, pattern);
}

int main() {
    std::vector<std::string> emails = {
        "user@example.com",      // ✅ 유효
        "test.user@domain.co.kr", // ✅ 유효
        "invalid@",              // ❌ 무효
        "@invalid.com",          // ❌ 무효
        "no-at-sign.com"         // ❌ 무효
    };
    
    for (const auto& email : emails) {
        std::cout << email << " : " 
                  << (validateEmail(email) ? "✅ 유효" : "❌ 무효") 
                  << std::endl;
    }
    
    return 0;
}

📌 참고: 위 패턴은 일반적인 이메일 형식을 검증해. RFC 5322 표준을 완벽하게 따르려면 훨씬 복잡한 패턴이 필요하지만, 실무에서는 위 정도면 충분해!

📱 전화번호 추출 및 포맷팅

텍스트에서 전화번호를 찾아서 통일된 형식으로 바꿔보자:

#include <iostream>
#include <regex>
#include <string>

std::string formatPhoneNumber(const std::string& text) {
    // 다양한 전화번호 형식을 찾는 패턴
    // 010-1234-5678, 01012345678, 010.1234.5678 등
    std::regex pattern(R"(010[-.\s]?(\d{4})[-.\s]?(\d{4}))");
    
    // $1, $2는 캡처 그룹을 의미 (괄호로 묶인 부분)
    std::string formatted = std::regex_replace(
        text, 
        pattern, 
        "010-$1-$2"
    );
    
    return formatted;
}

int main() {
    std::string text = "연락처: 01012345678, 010.9876.5432, 010-1111-2222";
    
    std::cout << "원본: " << text << std::endl;
    std::cout << "변환: " << formatPhoneNumber(text) << std::endl;
    
    // 출력:
    // 원본: 연락처: 01012345678, 010.9876.5432, 010-1111-2222
    // 변환: 연락처: 010-1234-5678, 010-9876-5432, 010-1111-2222
    
    return 0;
}

💡 캡처 그룹 활용법! 괄호 ()로 묶인 부분은 캡처 그룹이 돼. $1, $2로 참조할 수 있어서 패턴의 일부만 추출하거나 재배치할 때 엄청 유용해!

🔐 비밀번호 강도 검증

보안이 중요한 시대! 비밀번호가 충분히 강력한지 검증하는 코드를 만들어보자:

#include <iostream>
#include <regex>
#include <string>

struct PasswordStrength {
    bool hasMinLength;
    bool hasUpperCase;
    bool hasLowerCase;
    bool hasDigit;
    bool hasSpecialChar;
    
    bool isStrong() const {
        return hasMinLength && hasUpperCase && 
               hasLowerCase && hasDigit && hasSpecialChar;
    }
};

PasswordStrength checkPassword(const std::string& password) {
    PasswordStrength strength;
    
    // 최소 8자 이상
    strength.hasMinLength = password.length() >= 8;
    
    // 대문자 포함
    strength.hasUpperCase = std::regex_search(password, std::regex("[A-Z]"));
    
    // 소문자 포함
    strength.hasLowerCase = std::regex_search(password, std::regex("[a-z]"));
    
    // 숫자 포함
    strength.hasDigit = std::regex_search(password, std::regex(R"(\d)"));
    
    // 특수문자 포함
    strength.hasSpecialChar = std::regex_search(
        password, 
        std::regex(R"([!@#$%^&*()_+\-=\[\]{};':"\\|,.<>/?])")
    );
    
    return strength;
}

void printPasswordAnalysis(const std::string& password) {
    auto strength = checkPassword(password);
    
    std::cout << "비밀번호: " << password << std::endl;
    std::cout << "길이 (8자 이상): " << (strength.hasMinLength ? "✅" : "❌") << std::endl;
    std::cout << "대문자 포함: " << (strength.hasUpperCase ? "✅" : "❌") << std::endl;
    std::cout << "소문자 포함: " << (strength.hasLowerCase ? "✅" : "❌") << std::endl;
    std::cout << "숫자 포함: " << (strength.hasDigit ? "✅" : "❌") << std::endl;
    std::cout << "특수문자 포함: " << (strength.hasSpecialChar ? "✅" : "❌") << std::endl;
    std::cout << "강도: " << (strength.isStrong() ? "🔒 강함" : "⚠️ 약함") << std::endl;
    std::cout << "---" << std::endl;
}

int main() {
    printPasswordAnalysis("password");           // 약함
    printPasswordAnalysis("Password123");        // 약함 (특수문자 없음)
    printPasswordAnalysis("Pass123!");           // 약함 (8자 미만)
    printPasswordAnalysis("Password123!");       // 강함!
    
    return 0;
}

🎯 고급 기능: regex_iterator와 smatch

한 문자열에서 여러 개의 매칭 결과를 찾아야 할 때가 있지? 그럴 때는 regex_iterator를 사용하면 돼! 😊

🔄 모든 매칭 결과 순회하기

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string text = "이메일 목록: user1@test.com, admin@example.com, info@company.co.kr";
    std::regex pattern(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})");
    
    // regex_iterator 생성
    auto words_begin = std::sregex_iterator(text.begin(), text.end(), pattern);
    auto words_end = std::sregex_iterator();
    
    int count = 0;
    std::cout << "발견된 이메일 주소들:" << std::endl;
    
    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
        std::smatch match = *i;
        std::cout << ++count << ". " << match.str() << std::endl;
    }
    
    std::cout << "총 " << count << "개의 이메일을 찾았어요! 📧" << std::endl;
    
    return 0;
}

// 출력:
// 발견된 이메일 주소들:
// 1. user1@test.com
// 2. admin@example.com
// 3. info@company.co.kr
// 총 3개의 이메일을 찾았어요! 📧

📦 smatch로 상세 정보 추출하기

smatch는 매칭 결과에 대한 상세한 정보를 담고 있어. 캡처 그룹별로 접근할 수 있어서 정말 유용해!

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string text = "생년월일: 1990-05-15";
    
    // 캡처 그룹으로 년, 월, 일을 분리
    std::regex pattern(R"((\d{4})-(\d{2})-(\d{2}))");
    std::smatch match;
    
    if (std::regex_search(text, match, pattern)) {
        std::cout << "전체 매칭: " << match.str(0) << std::endl;
        std::cout << "년도: " << match.str(1) << std::endl;
        std::cout << "월: " << match.str(2) << std::endl;
        std::cout << "일: " << match.str(3) << std::endl;
        
        // 추가 정보
        std::cout << "\n매칭 위치: " << match.position() << std::endl;
        std::cout << "매칭 길이: " << match.length() << std::endl;
        std::cout << "매칭 전 문자열: " << match.prefix() << std::endl;
        std::cout << "매칭 후 문자열: " << match.suffix() << std::endl;
    }
    
    return 0;
}

// 출력:
// 전체 매칭: 1990-05-15
// 년도: 1990
// 월: 05
// 일: 15
// 
// 매칭 위치: 7
// 매칭 길이: 10
// 매칭 전 문자열: 생년월일: 
// 매칭 후 문자열:

🎓 smatch 주요 메서드:

• str(n) - n번째 캡처 그룹의 문자열 (0은 전체 매칭)

• position(n) - n번째 캡처 그룹의 시작 위치

• length(n) - n번째 캡처 그룹의 길이

• prefix() - 매칭 이전의 문자열

• suffix() - 매칭 이후의 문자열

• size() - 캡처 그룹의 개수 (전체 매칭 포함)

⚡ 성능 최적화 팁

정규표현식은 강력하지만, 잘못 사용하면 성능 문제가 생길 수 있어. 실전에서 유용한 최적화 팁들을 알려줄게! 🚀

1️⃣ 정규표현식 객체 재사용하기

⚠️ 비효율적인 코드:

// 나쁜 예: 매번 regex 객체를 생성
for (const auto& text : texts) {
    std::regex pattern(R"(\d+)");  // 반복문마다 컴파일! 😱
    if (std::regex_search(text, pattern)) {
        // ...
    }
}

✅ 효율적인 코드:

// 좋은 예: regex 객체를 한 번만 생성
std::regex pattern(R"(\d+)");  // 한 번만 컴파일! 😊

for (const auto& text : texts) {
    if (std::regex_search(text, pattern)) {
        // ...
    }
}

정규표현식 패턴을 컴파일하는 건 비용이 큰 작업이야. 같은 패턴을 여러 번 사용한다면 반드시 객체를 재사용해야 해!

2️⃣ 적절한 함수 선택하기

regex_match - 전체 문자열이 패턴과 일치하는지만 확인할 때 (가장 빠름)

regex_search - 문자열 내에서 패턴을 찾을 때

regex_iterator - 모든 매칭을 찾아야 할 때

std::string input = "12345";

// 전체가 숫자인지만 확인하면 되는 경우
if (std::regex_match(input, std::regex(R"(^\d+$)"))) {
    // regex_match가 regex_search보다 빠름!
}

// 숫자가 포함되어 있는지 확인하는 경우
if (std::regex_search(input, std::regex(R"(\d+)"))) {
    // 이 경우는 regex_search 사용
}

3️⃣ 탐욕적 vs 게으른 수량자

수량자의 탐욕성(greedy)을 이해하면 성능과 정확성을 모두 잡을 수 있어!

탐욕적 수량자 (Greedy): 가능한 한 많이 매칭

• *, +, {n,}

게으른 수량자 (Lazy): 가능한 한 적게 매칭

• *?, +?, {n,}?

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string html = "<div>첫번째</div><div>두번째</div>";
    
    // 탐욕적: 가능한 한 많이 매칭
    std::regex greedy(R"(<div>.*</div>)");
    std::smatch match1;
    if (std::regex_search(html, match1, greedy)) {
        std::cout << "탐욕적: " << match1.str() << std::endl;
        // 출력: <div>첫번째</div><div>두번째</div> (전체를 매칭!)
    }
    
    // 게으른: 가능한 한 적게 매칭
    std::regex lazy(R"(<div>.*?</div>)");
    std::smatch match2;
    if (std::regex_search(html, match2, lazy)) {
        std::cout << "게으른: " << match2.str() << std::endl;
        // 출력: <div>첫번째</div> (첫 번째만 매칭!)
    }
    
    return 0;
}

💡 HTML/XML 파싱할 때는 게으른 수량자를 사용하는 게 일반적이야. 하지만 복잡한 HTML은 정규표현식보다 전용 파서를 사용하는 게 좋아!

4️⃣ 컴파일 옵션 활용하기

std::regex는 다양한 컴파일 옵션을 제공해. 상황에 맞게 사용하면 성능과 기능을 최적화할 수 있어!

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string text = "Hello WORLD";
    
    // 기본: 대소문자 구분
    std::regex pattern1("hello");
    std::cout << std::regex_search(text, pattern1) << std::endl;  // 0 (false)
    
    // icase: 대소문자 무시
    std::regex pattern2("hello", std::regex::icase);
    std::cout << std::regex_search(text, pattern2) << std::endl;  // 1 (true)
    
    // optimize: 성능 최적화 (컴파일 시간은 늘어나지만 실행 속도 향상)
    std::regex pattern3(R"(\d+)", std::regex::optimize);
    
    // ECMAScript (기본), extended, awk, grep, egrep 등 문법 선택 가능
    std::regex pattern4(R"(\d+)", std::regex::extended);
    
    return 0;
}

옵션	설명	사용 시나리오
icase	대소문자 무시	사용자 입력 검증
optimize	실행 속도 최적화	같은 패턴을 많이 사용할 때
nosubs	캡처 그룹 무시	매칭 여부만 확인할 때
multiline	^와 $가 각 줄에 적용	여러 줄 텍스트 처리

🎨 실전 프로젝트: 로그 파일 분석기

이제 배운 내용을 종합해서 실용적인 프로젝트를 만들어보자! 서버 로그 파일을 분석하는 프로그램이야. 🔍

#include <iostream>
#include <regex>
#include <string>
#include <vector>
#include <map>
#include <fstream>

struct LogEntry {
    std::string timestamp;
    std::string level;
    std::string ip;
    std::string message;
};

class LogAnalyzer {
private:
    // 로그 패턴: [2024-01-15 10:30:45] ERROR 192.168.1.1 - Connection failed
    std::regex logPattern{
        R"(\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+) ([\d.]+) - (.+))"
    };
    
    std::vector<LogEntry> logs;
    std::map<std::string, int> levelCount;
    std::map<std::string, int> ipCount;

public:
    void parseLine(const std::string& line) {
        std::smatch match;
        if (std::regex_search(line, match, logPattern)) {
            LogEntry entry;
            entry.timestamp = match.str(1);
            entry.level = match.str(2);
            entry.ip = match.str(3);
            entry.message = match.str(4);
            
            logs.push_back(entry);
            levelCount[entry.level]++;
            ipCount[entry.ip]++;
        }
    }
    
    void parseFile(const std::string& filename) {
        std::ifstream file(filename);
        std::string line;
        
        while (std::getline(file, line)) {
            parseLine(line);
        }
    }
    
    void printStatistics() {
        std::cout << "📊 로그 분석 결과\n" << std::endl;
        std::cout << "총 로그 수: " << logs.size() << std::endl;
        
        std::cout << "\n로그 레벨별 통계:" << std::endl;
        for (const auto& [level, count] : levelCount) {
            std::cout << "  " << level << ": " << count << "건" << std::endl;
        }
        
        std::cout << "\nIP별 접속 통계 (상위 5개):" << std::endl;
        std::vector<std::pair<std::string, int>> sortedIPs(ipCount.begin(), ipCount.end());
        std::sort(sortedIPs.begin(), sortedIPs.end(),
                  [](const auto& a, const auto& b) { return a.second > b.second; });
        
        int count = 0;
        for (const auto& [ip, cnt] : sortedIPs) {
            if (++count > 5) break;
            std::cout << "  " << ip << ": " << cnt << "회" << std::endl;
        }
    }
    
    std::vector<LogEntry> findErrorsFromIP(const std::string& ip) {
        std::vector<LogEntry> errors;
        for (const auto& log : logs) {
            if (log.ip == ip && log.level == "ERROR") {
                errors.push_back(log);
            }
        }
        return errors;
    }
    
    std::vector<LogEntry> findByTimeRange(
        const std::string& startTime, 
        const std::string& endTime
    ) {
        std::vector<LogEntry> results;
        for (const auto& log : logs) {
            if (log.timestamp >= startTime && log.timestamp <= endTime) {
                results.push_back(log);
            }
        }
        return results;
    }
};

int main() {
    LogAnalyzer analyzer;
    
    // 샘플 로그 데이터
    std::vector<std::string> sampleLogs = {
        "[2024-01-15 10:30:45] INFO 192.168.1.100 - User login successful",
        "[2024-01-15 10:31:20] ERROR 192.168.1.100 - Database connection failed",
        "[2024-01-15 10:32:15] INFO 192.168.1.101 - Page loaded",
        "[2024-01-15 10:33:00] WARNING 192.168.1.102 - High memory usage",
        "[2024-01-15 10:34:30] ERROR 192.168.1.100 - Timeout occurred",
        "[2024-01-15 10:35:45] INFO 192.168.1.103 - File uploaded",
        "[2024-01-15 10:36:20] ERROR 192.168.1.101 - Invalid request"
    };
    
    // 로그 파싱
    for (const auto& log : sampleLogs) {
        analyzer.parseLine(log);
    }
    
    // 통계 출력
    analyzer.printStatistics();
    
    // 특정 IP의 에러 찾기
    std::cout << "\n🔍 192.168.1.100의 에러 로그:" << std::endl;
    auto errors = analyzer.findErrorsFromIP("192.168.1.100");
    for (const auto& error : errors) {
        std::cout << "  [" << error.timestamp << "] " 
                  << error.message << std::endl;
    }
    
    return 0;
}

이 로그 분석기는 실제 서버 관리에서 유용하게 사용할 수 있어! 정규표현식으로 로그 형식을 파싱하고, 통계를 내고, 특정 조건의 로그를 찾을 수 있지. 😊

🌐 실전 활용: URL 파싱과 검증

웹 개발에서 빠질 수 없는 게 URL 처리지! URL을 파싱하고 검증하는 실용적인 예제를 만들어보자. 🌍

#include <iostream>
#include <regex>
#include <string>
#include <optional>

struct URL {
    std::string protocol;
    std::string domain;
    std::string port;
    std::string path;
    std::string query;
    std::string fragment;
    
    void print() const {
        std::cout << "🔗 URL 분석 결과:" << std::endl;
        std::cout << "  프로토콜: " << protocol << std::endl;
        std::cout << "  도메인: " << domain << std::endl;
        if (!port.empty()) 
            std::cout << "  포트: " << port << std::endl;
        if (!path.empty()) 
            std::cout << "  경로: " << path << std::endl;
        if (!query.empty()) 
            std::cout << "  쿼리: " << query << std::endl;
        if (!fragment.empty()) 
            std::cout << "  프래그먼트: " << fragment << std::endl;
    }
};

class URLParser {
private:
    // URL 파싱 정규표현식
    std::regex urlPattern{
        R"(^(https?):\/\/"                    // 프로토콜
        R"(([a-zA-Z0-9.-]+)"                  // 도메인
        R"((?::(\d+))?"                       // 포트 (선택)
        R"(([\/\w.-]*)"                       // 경로 (선택)
        R"((?:\?([^#]*))?"                    // 쿼리 (선택)
        R"((?:#(.*))?$)"                      // 프래그먼트 (선택)
    };

public:
    std::optional<URL> parse(const std::string& urlString) {
        std::smatch match;
        
        if (!std::regex_match(urlString, match, urlPattern)) {
            return std::nullopt;
        }
        
        URL url;
        url.protocol = match.str(1);
        url.domain = match.str(2);
        url.port = match.str(3);
        url.path = match.str(4);
        url.query = match.str(5);
        url.fragment = match.str(6);
        
        return url;
    }
    
    bool isValidURL(const std::string& urlString) {
        return std::regex_match(urlString, urlPattern);
    }
    
    std::string extractDomain(const std::string& urlString) {
        std::regex domainPattern(R"(https?:\/\/([a-zA-Z0-9.-]+))");
        std::smatch match;
        
        if (std::regex_search(urlString, match, domainPattern)) {
            return match.str(1);
        }
        return "";
    }
    
    std::map<std::string, std::string> parseQueryString(const std::string& query) {
        std::map<std::string, std::string> params;
        std::regex paramPattern(R"(([^&=]+)=([^&]*))");
        
        auto begin = std::sregex_iterator(query.begin(), query.end(), paramPattern);
        auto end = std::sregex_iterator();
        
        for (auto it = begin; it != end; ++it) {
            std::smatch match = *it;
            params[match.str(1)] = match.str(2);
        }
        
        return params;
    }
};

int main() {
    URLParser parser;
    
    std::vector<std::string> testURLs = {
        "https://www.jaenung.net/knowledge/article?id=123&category=cpp#section2",
        "http://example.com:8080/api/users",
        "https://github.com/user/repo",
        "invalid-url",
        "ftp://files.example.com/download"
    };
    
    for (const auto& urlString : testURLs) {
        std::cout << "\n분석 대상: " << urlString << std::endl;
        
        if (auto url = parser.parse(urlString)) {
            url->print();
            
            // 쿼리 파라미터 파싱
            if (!url->query.empty()) {
                std::cout << "\n  📋 쿼리 파라미터:" << std::endl;
                auto params = parser.parseQueryString(url->query);
                for (const auto& [key, value] : params) {
                    std::cout << "    " << key << " = " << value << std::endl;
                }
            }
        } else {
            std::cout << "  ❌ 유효하지 않은 URL입니다." << std::endl;
        }
        std::cout << std::string(50, '-') << std::endl;
    }
    
    return 0;
}

이 URL 파서는 웹 크롤러나 API 클라이언트를 만들 때 정말 유용해! 재능넷 같은 플랫폼에서도 URL 검증과 파싱은 필수적인 기능이지. 🎯

🎭 정규표현식 디버깅과 테스트

정규표현식은 강력하지만 복잡해질수록 디버깅이 어려워져. 효과적으로 테스트하고 디버깅하는 방법을 알아보자! 🔧

🧪 테스트 프레임워크 만들기

#include <iostream>
#include <regex>
#include <string>
#include <vector>

class RegexTester {
private:
    struct TestCase {
        std::string input;
        bool shouldMatch;
        std::string description;
    };
    
    std::string pattern;
    std::regex regex;
    std::vector<TestCase> testCases;
    
public:
    RegexTester(const std::string& pattern) 
        : pattern(pattern), regex(pattern) {}
    
    void addTest(const std::string& input, bool shouldMatch, 
                 const std::string& description = "") {
        testCases.push_back({input, shouldMatch, description});
    }
    
    void runTests() {
        std::cout << "🧪 정규표현식 테스트 시작" << std::endl;
        std::cout << "패턴: " << pattern << "\n" << std::endl;
        
        int passed = 0;
        int failed = 0;
        
        for (size_t i = 0; i < testCases.size(); ++i) {
            const auto& test = testCases[i];
            bool result = std::regex_match(test.input, regex);
            bool success = (result == test.shouldMatch);
            
            if (success) {
                std::cout << "✅ 테스트 " << (i + 1) << " 통과";
                passed++;
            } else {
                std::cout << "❌ 테스트 " << (i + 1) << " 실패";
                failed++;
            }
            
            std::cout << " - " << test.input;
            if (!test.description.empty()) {
                std::cout << " (" << test.description << ")";
            }
            std::cout << std::endl;
            
            if (!success) {
                std::cout << "  예상: " << (test.shouldMatch ? "매칭" : "불일치")
                          << ", 실제: " << (result ? "매칭" : "불일치") << std::endl;
            }
        }
        
        std::cout << "\n📊 결과: " << passed << "개 통과, " 
                  << failed << "개 실패" << std::endl;
    }
    
    void explainPattern() {
        std::cout << "\n📖 패턴 설명:" << std::endl;
        std::cout << pattern << std::endl;
        // 여기에 패턴 분석 로직을 추가할 수 있어
    }
};

int main() {
    // 이메일 검증 테스트
    RegexTester emailTester(R"(^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$)");
    
    emailTester.addTest("user@example.com", true, "기본 이메일");
    emailTester.addTest("test.user@domain.co.kr", true, "점과 서브도메인");
    emailTester.addTest("user+tag@example.com", true, "플러스 기호");
    emailTester.addTest("invalid@", false, "도메인 없음");
    emailTester.addTest("@invalid.com", false, "사용자명 없음");
    emailTester.addTest("no-at-sign.com", false, "@기호 없음");
    emailTester.addTest("user@domain", false, "최상위 도메인 없음");
    
    emailTester.runTests();
    
    std::cout << "\n" << std::string(60, '=') << "\n" << std::endl;
    
    // 전화번호 검증 테스트
    RegexTester phoneTester(R"(^01[0-9]-\d{4}-\d{4}$)");
    
    phoneTester.addTest("010-1234-5678", true, "일반 휴대폰");
    phoneTester.addTest("011-9876-5432", true, "011 번호");
    phoneTester.addTest("010-123-5678", false, "중간 자리 부족");
    phoneTester.addTest("02-1234-5678", false, "지역번호");
    phoneTester.addTest("01012345678", false, "하이픈 없음");
    
    phoneTester.runTests();
    
    return 0;
}

💡 실전 팁: 정규표현식을 작성할 때는 항상 테스트 케이스를 함께 만들어. 특히 경계 조건(boundary conditions)을 꼭 테스트해야 해!

🔍 일반적인 실수와 해결법

실수 1: 백슬래시 이스케이프 잊기

// ❌ 잘못된 코드
std::regex pattern("\d+");  // 컴파일 에러 또는 예상과 다른 동작

// ✅ 올바른 코드
std::regex pattern("\\d+");  // 백슬래시 두 번
// 또는
std::regex pattern(R"(\d+)");  // raw string literal 사용

실수 2: 특수 문자 이스케이프 안 하기

// ❌ 잘못된 코드 - 점(.)은 모든 문자를 의미
std::regex pattern("192.168.1.1");  // "192A168B1C1"도 매칭됨!

// ✅ 올바른 코드
std::regex pattern(R"(192\.168\.1\.1)");  // 점을 리터럴로 처리

실수 3: regex_match와 regex_search 혼동

std::string text = "내 번호는 010-1234-5678이야";
std::regex pattern(R"(010-\d{4}-\d{4})");

// regex_match: 전체 문자열이 패턴과 일치해야 함
std::cout << std::regex_match(text, pattern) << std::endl;  // 0 (false)

// regex_search: 문자열 내에서 패턴을 찾음
std::cout << std::regex_search(text, pattern) << std::endl;  // 1 (true)

🛡️ 보안과 성능: ReDoS 공격 방어하기

정규표현식은 강력하지만, 잘못 작성하면 ReDoS(Regular Expression Denial of Service) 공격에 취약해질 수 있어. 이건 정말 중요한 보안 이슈야! 🚨

⚠️ 위험한 패턴의 예

위험한 패턴: 중첩된 수량자

// ❌ 위험한 패턴 - 백트래킹이 기하급수적으로 증가
std::regex dangerous(R"((a+)+b)");

// 이 입력은 엄청난 시간이 걸림 (ReDoS 공격!)
std::string malicious = "aaaaaaaaaaaaaaaaaaaaaaaaaaaa!";
// 'b'가 없어서 모든 조합을 시도하게 됨

✅ 안전한 패턴으로 개선

// ✅ 안전한 패턴 - 중첩 제거
std::regex safe(R"(a+b)");

// 또는 소유 수량자 사용 (C++에서는 제한적)
std::regex safer(R"(a++b)");  // 백트래킹 없음

🔒 안전한 정규표현식 작성 가이드

1. 중첩된 수량자 피하기

• (a+)+, (a*)* 같은 패턴은 위험

• 가능하면 단일 수량자로 표현: a+

2. 교대(alternation) 최적화

• (a|a)* 같은 중복 피하기

• 공통 부분을 앞으로: (abc|abd) → ab(c|d)

3. 입력 길이 제한

• 사용자 입력은 항상 길이 검증

• 합리적인 최대 길이 설정

4. 타임아웃 설정 고려

• 장시간 실행되는 정규표현식 감지

• 별도 스레드에서 실행하고 타임아웃 적용

#include <iostream>
#include <regex>
#include <string>
#include <chrono>
#include <future>

class SafeRegex {
private:
    std::regex pattern;
    std::chrono::milliseconds timeout;
    size_t maxInputLength;

public:
    SafeRegex(const std::string& pattern, 
              std::chrono::milliseconds timeout = std::chrono::milliseconds(1000),
              size_t maxInputLength = 10000)
        : pattern(pattern), timeout(timeout), maxInputLength(maxInputLength) {}
    
    bool safeMatch(const std::string& input) {
        // 입력 길이 검증
        if (input.length() > maxInputLength) {
            std::cerr << "⚠️ 입력이 너무 깁니다!" << std::endl;
            return false;
        }
        
        // 타임아웃을 적용한 매칭
        auto future = std::async(std::launch::async, [this, &input]() {
            return std::regex_match(input, this->pattern);
        });
        
        if (future.wait_for(timeout) == std::future_status::timeout) {
            std::cerr << "⏱️ 정규표현식 실행 시간 초과!" << std::endl;
            return false;
        }
        
        return future.get();
    }
    
    // 패턴의 위험도 간단히 체크
    static bool isDangerousPattern(const std::string& pattern) {
        // 중첩된 수량자 패턴 감지
        std::regex nested(R"(\([^)]*[+*]\)[+*])");
        if (std::regex_search(pattern, nested)) {
            std::cout << "⚠️ 경고: 중첩된 수량자가 감지되었습니다!" << std::endl;
            return true;
        }
        return false;
    }
};

int main() {
    // 위험한 패턴 체크
    std::string dangerousPattern = R"((a+)+b)";
    SafeRegex::isDangerousPattern(dangerousPattern);
    
    // 안전한 정규표현식 사용
    SafeRegex safeRegex(R"(^[a-zA-Z0-9]+$)", std::chrono::milliseconds(100));
    
    std::cout << "테스트 1: " << safeRegex.safeMatch("abc123") << std::endl;
    std::cout << "테스트 2: " << safeRegex.safeMatch("abc-123") << std::endl;
    
    // 너무 긴 입력 테스트
    std::string longInput(20000, 'a');
    std::cout << "테스트 3: " << safeRegex.safeMatch(longInput) << std::endl;
    
    return 0;
}

🎨 실전 프로젝트: 마크다운 파서 만들기

이제 정말 실용적인 프로젝트를 만들어보자! 간단한 마크다운 파서를 정규표현식으로 구현해볼게. 📝

#include <iostream>
#include <regex>
#include <string>
#include <sstream>

class MarkdownParser {
private:
    // 다양한 마크다운 패턴들
    std::regex headerPattern{R"(^(#{1,6})\s+(.+)$)"};
    std::regex boldPattern{R"(\*\*(.+?)\*\*)"};
    std::regex italicPattern{R"(\*(.+?)\*)"};
    std::regex codePattern{R"(`(.+?)`)"};
    std::regex linkPattern{R"(\[([^\]]+)\]\(([^)]+)\))"};
    std::regex imagePattern{R"(!\[([^\]]*)\]\(([^)]+)\))"};
    std::regex listPattern{R"(^[\*\-]\s+(.+)$)"};
    std::regex blockquotePattern{R"(^>\s+(.+)$)"};

public:
    std::string parseHeader(const std::string& line) {
        std::smatch match;
        if (std::regex_match(line, match, headerPattern)) {
            int level = match.str(1).length();
            std::string content = match.str(2);
            return "<h" + std::to_string(level) + ">" + 
                   content + "</h" + std::to_string(level) + ">";
        }
        return line;
    }
    
    std::string parseInline(const std::string& text) {
        std::string result = text;
        
        // 볼드 처리
        result = std::regex_replace(result, boldPattern, "<strong>$1</strong>");
        
        // 이탤릭 처리
        result = std::regex_replace(result, italicPattern, "<em>$1</em>");
        
        // 코드 처리
        result = std::regex_replace(result, codePattern, "<code>$1</code>");
        
        // 링크 처리
        result = std::regex_replace(result, linkPattern, 
                                   "<a href=\"$2\">$1</a>");
        
        // 이미지 처리
        result = std::regex_replace(result, imagePattern, 
                                   "<img src=\"$2\" alt=\"$1\" />");
        
        return result;
    }
    
    std::string parseList(const std::string& line) {
        std::smatch match;
        if (std::regex_match(line, match, listPattern)) {
            return "<li>" + parseInline(match.str(1)) + "</li>";
        }
        return line;
    }
    
    std::string parseBlockquote(const std::string& line) {
        std::smatch match;
        if (std::regex_match(line, match, blockquotePattern)) {
            return "<blockquote>" + parseInline(match.str(1)) + "</blockquote>";
        }
        return line;
    }
    
    std::string parse(const std::string& markdown) {
        std::istringstream stream(markdown);
        std::string line;
        std::string html;
        bool inList = false;
        
        while (std::getline(stream, line)) {
            if (line.empty()) {
                if (inList) {
                    html += "</ul>\n";
                    inList = false;
                }
                html += "<br>\n";
                continue;
            }
            
            // 헤더 체크
            std::string parsed = parseHeader(line);
            if (parsed != line) {
                if (inList) {
                    html += "</ul>\n";
                    inList = false;
                }
                html += parsed + "\n";
                continue;
            }
            
            // 리스트 체크
            parsed = parseList(line);
            if (parsed != line) {
                if (!inList) {
                    html += "<ul>\n";
                    inList = true;
                }
                html += parsed + "\n";
                continue;
            }
            
            // 인용구 체크
            parsed = parseBlockquote(line);
            if (parsed != line) {
                if (inList) {
                    html += "</ul>\n";
                    inList = false;
                }
                html += parsed + "\n";
                continue;
            }
            
            // 일반 텍스트
            if (inList) {
                html += "</ul>\n";
                inList = false;
            }
            html += "<p>" + parseInline(line) + "</p>\n";
        }
        
        if (inList) {
            html += "</ul>\n";
        }
        
        return html;
    }
};

int main() {
    MarkdownParser parser;
    
    std::string markdown = R"(# 재능넷에서 배우는 C++ 정규표현식

## 소개

**정규표현식**은 *텍스트 처리*의 강력한 도구입니다.

### 주요 기능

- 패턴 매칭
- 텍스트 추출
- 문자열 치환

> 정규표현식을 마스터하면 텍스트 처리가 정말 쉬워져요!

자세한 내용은 [재능넷](https://www.jaenung.net)에서 확인하세요.

코드 예제: `std::regex pattern(R"(\d+)")`
)";

    std::cout << "=== 마크다운 원본 ===" << std::endl;
    std::cout << markdown << std::endl;
    std::cout << "\n=== HTML 변환 결과 ===" << std::endl;
    std::cout << parser.parse(markdown) << std::endl;
    
    return 0;
}

이 마크다운 파서는 실제로 사용할 수 있는 수준이야! 물론 완전한 마크다운 파서를 만들려면 더 많은 기능이 필요하지만, 정규표현식의 활용법을 배우기엔 완벽한 예제지. 😊

🌟 실전 활용: 민감정보 마스킹

개인정보 보호가 중요한 시대! 로그나 출력에서 민감한 정보를 자동으로 마스킹하는 유틸리티를 만들어보자. 🔐

#include <iostream>
#include <regex>
#include <string>
#include <map>

class SensitiveDataMasker {
private:
    struct MaskRule {
        std::regex pattern;
        std::function<std::string(const std::smatch&)> replacer;
    };
    
    std::vector<MaskRule> rules;

public:
    SensitiveDataMasker() {
        // 이메일 마스킹: user@example.com → u***@example.com
        rules.push_back({
            std::regex(R"(([a-zA-Z0-9])[a-zA-Z0-9._%+-]*@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}))"),
            [](const std::smatch& m) {
                return m.str(1) + "***@" + m.str(2);
            }
        });
        
        // 전화번호 마스킹: 010-1234-5678 → 010-****-5678
        rules.push_back({
            std::regex(R"((01[0-9])-(\d{4})-(\d{4}))"),
            [](const std::smatch& m) {
                return m.str(1) + "-****-" + m.str(3);
            }
        });
        
        // 주민등록번호 마스킹: 123456-1234567 → 123456-*******
        rules.push_back({
            std::regex(R"((\d{6})-(\d{7}))"),
            [](const std::smatch& m) {
                return m.str(1) + "-*******";
            }
        });
        
        // 신용카드 번호 마스킹: 1234-5678-9012-3456 → ****-****-****-3456
        rules.push_back({
            std::regex(R"((\d{4})-(\d{4})-(\d{4})-(\d{4}))"),
            [](const std::smatch& m) {
                return "****-****-****-" + m.str(4);
            }
        });
        
        // IP 주소 마스킹: 192.168.1.100 → 192.168.*.*
        rules.push_back({
            std::regex(R"((\d{1,3}\.\d{1,3})\.\d{1,3}\.\d{1,3})"),
            [](const std::smatch& m) {
                return m.str(1) + ".*.*";
            }
        });
    }
    
    std::string mask(const std::string& text) {
        std::string result = text;
        
        for (const auto& rule : rules) {
            std::string temp;
            auto begin = std::sregex_iterator(result.begin(), result.end(), rule.pattern);
            auto end = std::sregex_iterator();
            
            size_t lastPos = 0;
            for (auto it = begin; it != end; ++it) {
                const std::smatch& match = *it;
                temp += result.substr(lastPos, match.position() - lastPos);
                temp += rule.replacer(match);
                lastPos = match.position() + match.length();
            }
            temp += result.substr(lastPos);
            result = temp;
        }
        
        return result;
    }
    
    void addCustomRule(const std::string& pattern, 
                       std::function<std::string(const std::smatch&)> replacer) {
        rules.push_back({std::regex(pattern), replacer});
    }
};

int main() {
    SensitiveDataMasker masker;
    
    std::vector<std::string> testData = {
        "사용자 이메일: john.doe@example.com",
        "연락처: 010-1234-5678",
        "주민번호: 901234-1234567",
        "카드번호: 1234-5678-9012-3456",
        "접속 IP: 192.168.1.100",
        "복합 정보: user@test.com, 010-9876-5432, 192.168.0.50"
    };
    
    std::cout << "🔒 민감정보 마스킹 결과\n" << std::endl;
    
    for (const auto& data : testData) {
        std::cout << "원본: " << data << std::endl;
        std::cout << "마스킹: " << masker.mask(data) << std::endl;
        std::cout << std::string(60, '-') << std::endl;
    }
    
    // 커스텀 규칙 추가 예제
    masker.addCustomRule(
        R"(비밀번호:\s*(\S+))",
        [](const std::smatch& m) {
            return "비밀번호: ********";
        }
    );
    
    std::string passwordLog = "로그인 시도 - 비밀번호: MySecret123!";
    std::cout << "\n커스텀 규칙 테스트:" << std::endl;
    std::cout << "원본: " << passwordLog << std::endl;
    std::cout << "마스킹: " << masker.mask(passwordLog) << std::endl;
    
    return 0;
}

💡 실전 활용: 이런 마스킹 유틸리티는 로깅 시스템, 디버그 출력, 에러 리포트 등에서 필수적이야. GDPR 같은 개인정보 보호 규정을 준수하는 데도 중요하지!

📚 정규표현식 치트시트

자주 사용하는 패턴들을 정리해봤어. 북마크해두고 필요할 때마다 참고해! 📖

🔤 기본 문자 클래스

패턴	의미	예제
`.`	줄바꿈 제외 모든 문자	`a.c` → "abc", "a1c"
`\d`	숫자 [0-9]	`\d{3}` → "123"
`\D`	숫자가 아닌 문자	`\D+` → "abc"
`\w`	단어 문자 [a-zA-Z0-9_]	`\w+` → "hello_123"
`\W`	단어 문자가 아닌 것	`\W` → "@", "!"
`\s`	공백 문자	`\s+` → " ", "\t"
`\S`	공백이 아닌 문자	`\S+` → "hello"

🔢 수량자

패턴	의미	예제
`*`	0번 이상	`ab*c` → "ac", "abc", "abbc"
`+`	1번 이상	`ab+c` → "abc", "abbc"
`?`	0번 또는 1번	`ab?c` → "ac", "abc"
`{n}`	정확히 n번	`\d{3}` → "123"
`{n,}`	n번 이상	`\d{2,}` → "12", "123"
`{n,m}`	n번 이상 m번 이하	`\d{2,4}` → "12", "123", "1234"

🎯 앵커와 경계

패턴	의미	예제
`^`	문자열 시작	`^hello` → "hello world"
`$`	문자열 끝	`world$` → "hello world"
`\b`	단어 경계	`\bcat\b` → "the cat"
`\B`	단어 경계 아님	`\Bcat\B` → "concatenate"

📦 자주 사용하는 패턴 모음

이메일: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

URL: ^https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(\/.*)?$

전화번호 (한국): ^01[0-9]-\d{3,4}-\d{4}$

날짜 (YYYY-MM-DD): ^\d{4}-\d{2}-\d{2}$

시간 (HH:MM:SS): ^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$

IPv4 주소: ^(\d{1,3}\.){3}\d{1,3}$

16진수 색상 코드: ^#[0-9A-Fa-f]{6}$

비밀번호 (8자 이상, 대소문자+숫자): ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$

🎓 학습 리소스와 다음 단계

여기까지 정말 많은 내용을 배웠어! 이제 정규표현식과 std::regex를 자유자재로 다룰 수 있을 거야. 하지만 학습은 여기서 끝이 아니지! 😊

📖 추천 학습 자료

1. 온라인 정규표현식 테스터

• regex101.com - 실시간 테스트와 설명 제공

• regexr.com - 시각적인 인터페이스

• debuggex.com - 정규표현식 시각화

2. C++ 공식 문서

• cppreference.com/w/cpp/regex - 완벽한 레퍼런스

• C++ 표준 라이브러리 문서

3. 실전 연습

• LeetCode, HackerRank의 정규표현식 문제

• 실제 프로젝트에 적용해보기

• 재능넷에서 다른 개발자들과 지식 공유하기

🚀 다음 단계로

초급 → 중급으로

✅ 기본 패턴 작성 완료

✅ std::regex 함수들 이해

🎯 다음 목표: 복잡한 패턴 최적화, 성능 튜닝

중급 → 고급으로

✅ 복잡한 패턴 작성 가능

✅ 성능 최적화 이해

🎯 다음 목표: 커스텀 파서 구현, 보안 고려사항 마스터

💼 실무 적용 아이디어

1. 로그 분석 시스템

서버 로그를 실시간으로 분석하고 이상 패턴을 감지하는 시스템

2. 데이터 검증 라이브러리

다양한 형식의 데이터를 검증하는 재사용 가능한 라이브러리

3. 텍스트 처리 도구

마크다운 파서, 코드 하이라이터, 템플릿 엔진 등

4. 보안 도구

민감정보 탐지 및 마스킹, SQL 인젝션 방어 등

5. 웹 스크래핑

웹 페이지에서 필요한 정보를 추출하는 크롤러

🎉 마무리하며

와! 여기까지 정말 긴 여정이었어. C++의 정규표현식과 std::regex에 대해 기초부터 고급 활용까지 모두 다뤄봤지. 🎊

정규표현식은 처음엔 어렵게 느껴질 수 있지만, 한 번 익숙해지면 정말 강력한 도구가 돼. 텍스트 처리가 필요한 거의 모든 곳에서 활용할 수 있거든! 💪

🌟 핵심 요약

1️⃣ std::regex는 C++11부터 표준 라이브러리에 포함된 강력한 정규표현식 엔진

2️⃣ regex_match, regex_search, regex_replace 등 다양한 함수 제공

3️⃣ 패턴 문법을 이해하면 복잡한 텍스트 처리도 간단하게 해결

4️⃣ 성능과 보안을 항상 고려해야 함 (ReDoS 공격 주의!)

5️⃣ 실전 프로젝트에 적용하면서 실력을 키우는 게 최고의 학습법

이제 여러분도 텍스트 처리의 마법사가 될 준비가 됐어! 🧙‍♂️ 재능넷에서 배운 내용을 실제 프로젝트에 적용해보고, 다른 개발자들과도 지식을 나눠보자. 함께 성장하는 게 가장 빠른 길이니까! 😊

궁금한 점이 있거나 더 배우고 싶은 내용이 있다면, 재능넷의 지식인의 숲에서 다른 글들도 찾아보고, 직접 질문도 해봐. 프로그래밍은 혼자가 아니라 함께 배워가는 거니까! 🌳

그럼 여러분의 코딩 여정에 행운을 빌어! Happy Coding! 🚀✨

🎯

정규표현식 마스터 완료!

이제 여러분은 텍스트 처리의 전문가입니다

재능넷에서 더 많은 지식을 탐험해보세요! 🌟

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.

4.3K

홈페이지 연동 모바일 앱, 유튜브 연동 앱, 퀴즈 앱 등 앱개발을 도와 드려요.

안녕하세요. 안드로이드 기반 개인 앱, 프로젝트용 앱부터 그 이상 기능이 추가된 앱까지 제작해 드립니다. - 앱 개발 툴: 안드로이드 스튜디오 - 안드로이드 언어: JAVA, XML - 데이터베이스 언어: 로컬DB-SQLite, 웹DB-MYSQL - 안드로이드 와 서버 통신 언어 - PHP 기능 추가 시 구현정도에 따라 협의가 필요하며 밑에 사항과 같이 연

30,000원~

1.8K

안드로이드, 메트렙, 자료구조, 신호처리, 통신이론 요청 받습니다.

------------------------------------ 만들고 싶어하는 앱을 제작해드립니다. ------------------------------------ 1. 안드로이드 ( 자바 ) * 블루투스, 카메라, 미디어 플레이어, 음성인식, 가계부, 소개팅 앱, 알람 앱, 사진 앱 등등 원하시는 어플리케이션을 만들어 드립니다. 2. 자료구조 ( C

5,000원~

9.7K

사이트를 모바일앱으로 제작해 드립니다. 안드로이드 아이폰 앱제작 어플제작 전문

운영하는 사이트 주소가 있다면 사이트를 안드로이드 앱으로 만들어 드립니다. 기본 5000원은 아무런 기능이 없고 단순히 html 페이지를 로딩하는 앱을 제작하는 경우입니다. 구매할때 쇼핑몰 및 커뮤니티 사이트 등 일반사이트들은 구매옵션의 자바스크립트 지원을 필수 선택해야 제작해드립니다. 아이폰 ios 용 앱제작 의뢰의 경우 협의 가격으로 진행됩니다.먼저 문

5,000원~

8.3K

신뢰있는 앱 개발, 아무에게나 맡기지 마세요!

본 페이지는 실제 서비스와 시스템을 개발·운영하며 축적한 개발 경험과 프로젝트 사례를 소개합니다.사용자 화면, 관리 기능, 내부 처리 구조 등 서비스 전반을 고려한 개발 경험을 바탕으로 구성되어 있습니다. 150만명 회원 규모의 서비스를 직접 개발·운영해 온 경험을 바탕으로, 현실적인 운영 환경에 적합한 실효성 있는 솔루션을 제안합니다. 각 프로젝트는 단순

10,000원~

1.5K

[Android / JAVA/ C] 신호처리 알고리즘/ 안드로이드 앱 개발

안녕하세요. 신호처리를 전공한 개발자 입니다. 1. 영상신호처리, 생체신호처리 알고리즘 개발 2. 안드로이드 앱 개발 3. 윈도우 프로그램 개발 위와 같은 개발에 도움을 드릴 수 있습니다.

1,000,000원~

839

안드로이드, 아이폰iOS 앱 등록 대행 앱스토어 등록

[상품 서비스 안내] 구글 안드로이드앱 등록을 하려는데 어려우십니까? 아이폰 iOS 앱 등록을 하려는데 어려우십니까? xcode에서 빌드하여 connect에 올리는 방법이 어려우십니까? 전문가가 직접 도와 드릴터이니 걱정하지 마십시오. 앱 등록 시 사용하는 화면은 기본적으로 스크린샷 파일을 제공해 주셔야 합니다. 맞춤 디자인으로 꾸미셔서 제공해 주시면 더욱

150,000원~ 후기 0개

258

안드로이드 채팅앱 판매

채팅어플입니다 서버,안드로이드 어플 전체 소스 포함하여 판매하며 아이콘 어플컬러 메뉴변경 등 약간의 커스터마이징이 포함된 가격이며 이 가격의 어플 구매만으로도 마켓에 올리고 홍보를 하시면 수익을 낼 수 있습니다 맞춤식 커스터마이징은 협의하에 추가비용 발생됩니다

1,500,000원~ 후기 0개

140

기존 사이트를 앱처럼 - PWA 전환 및 개발

웹 개발 · PWA 전문 기존 웹사이트를 앱처럼 PWA 전환 · 신규 개발 앱스토어 없이, 설치·푸시알림·오프라인 기능을 웹사이트에 더해드립니다. 왜 PWA인가요? 📲 앱스토어 불필요 심사 없이 즉시 배포. 업데이트도 웹처럼 바로 반영. 💰 비용 절감 iOS/Android 앱 대비 수십~수백만 원 절약 가능. 🔔 재방문율 향상 홈화면 아이콘 + 푸시 알림으

300,000원~ 후기 0개

프로그램개발 · 분야 선택22개 분야

🎯 C++ 정규표현식과 std::regex를 활용한 텍스트 처리

🚀 정규표현식, 너 누구니?

📚 std::regex 기본 구조 파헤치기

🔍 주요 함수들 총정리

🎨 정규표현식 패턴 문법 마스터하기

🔤 기본 문자 클래스

🔢 수량자 (Quantifiers)

🎯 앵커와 경계

🛠️ 실전 예제로 배우는 std::regex

📧 이메일 주소 검증하기

📱 전화번호 추출 및 포맷팅

🔐 비밀번호 강도 검증

🎯 고급 기능: regex_iterator와 smatch

🔄 모든 매칭 결과 순회하기

📦 smatch로 상세 정보 추출하기

⚡ 성능 최적화 팁

1️⃣ 정규표현식 객체 재사용하기

2️⃣ 적절한 함수 선택하기

3️⃣ 탐욕적 vs 게으른 수량자

4️⃣ 컴파일 옵션 활용하기

🎨 실전 프로젝트: 로그 파일 분석기

🌐 실전 활용: URL 파싱과 검증

🎭 정규표현식 디버깅과 테스트

🧪 테스트 프레임워크 만들기

🔍 일반적인 실수와 해결법

🛡️ 보안과 성능: ReDoS 공격 방어하기

⚠️ 위험한 패턴의 예

🔒 안전한 정규표현식 작성 가이드

🎨 실전 프로젝트: 마크다운 파서 만들기

🌟 실전 활용: 민감정보 마스킹

📚 정규표현식 치트시트

🔤 기본 문자 클래스

🔢 수량자

🎯 앵커와 경계

📦 자주 사용하는 패턴 모음

🎓 학습 리소스와 다음 단계

📖 추천 학습 자료

🚀 다음 단계로

💼 실무 적용 아이디어

🎉 마무리하며

관련 키워드

댓글 작성

로그인이 필요합니다

댓글 0

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

해당 지식과 관련있는 인기재능