C++와 Excel(CSV) 연동으로 대규모 데이터 처리 자동화하기

이름,나이,직업  
홍길동,30,개발자  
김영희,28,디자이너  
이철수,35,데이터 분석가  

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("data.csv"); // CSV 파일 생성

    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return 1;
    }

    // CSV 헤더 작성
    file << "이름,나이,직업\n";

    // 데이터 입력
    file << "홍길동,30,개발자\n";
    file << "김영희,28,디자이너\n";
    file << "이철수,35,데이터 분석가\n";

    file.close();
    std::cout << "CSV 파일이 생성되었습니다." << std::endl;

    return 0;
}

이름,나이,직업
홍길동,30,개발자
김영희,28,디자이너
이철수,35,데이터 분석가

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

int main() {
    std::ifstream file("data.csv"); // 파일 열기

    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return 1;
    }

    std::string line;

    // 첫 번째 줄(헤더) 건너뛰기
    std::getline(file, line);

    while (std::getline(file, line)) { // 한 줄씩 읽기
        std::stringstream ss(line);
        std::vector<std::string> row;
        std::string cell;

        while (std::getline(ss, cell, ',')) { // 쉼표를 기준으로 데이터 분할
            row.push_back(cell);
        }

        // 출력
        std::cout << "이름: " << row[0] << ", 나이: " << row[1] << ", 직업: " << row[2] << std::endl;
    }

    file.close();
    return 0;
}

이름: 홍길동, 나이: 30, 직업: 개발자
이름: 김영희, 나이: 28, 직업: 디자이너
이름: 이철수, 나이: 35, 직업: 데이터 분석가

#include <iostream>
#include <fstream>
#include <vector>

int main() {
    std::ofstream file("large_data.csv", std::ios::out | std::ios::binary);

    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return 1;
    }

    std::vector<std::string> buffer;
    buffer.reserve(10000);  // 버퍼 크기 설정 (예: 10,000개 라인 저장)

    for (int i = 0; i < 1000000; ++i) {  // 100만 개의 데이터 생성
        buffer.push_back("사용자" + std::to_string(i) + ", " + std::to_string(20 + (i % 50)) + ", 직업" + std::to_string(i % 5) + "\n");

        if (buffer.size() >= 10000) {  // 버퍼가 일정 크기에 도달하면 한 번에 쓰기
            for (const auto &line : buffer) {
                file << line;
            }
            buffer.clear();
        }
    }

    // 남아 있는 데이터 처리
    for (const auto &line : buffer) {
        file << line;
    }

    file.close();
    std::cout << "CSV 파일 생성 완료!" << std::endl;
    return 0;
}

#include <iostream>
#include <fstream>
#include <vector>
#include <thread>

void processChunk(const std::vector<std::string>& data, const std::string& filename) {
    std::ofstream file(filename, std::ios::app);  // 파일 추가 모드
    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다: " << filename << std::endl;
        return;
    }

    for (const auto& line : data) {
        file << line;
    }

    file.close();
}

int main() {
    const int NUM_THREADS = 4;
    std::vector<std::vector<std::string>> chunks(NUM_THREADS);

    // 가상의 데이터 생성 (100만 개)
    for (int i = 0; i < 1000000; ++i) {
        chunks[i % NUM_THREADS].push_back("사용자" + std::to_string(i) + ", " + std::to_string(20 + (i % 50)) + ", 직업" + std::to_string(i % 5) + "\n");
    }

    std::vector<std::thread> threads;
    for (int i = 0; i < NUM_THREADS; ++i) {
        threads.emplace_back(processChunk, std::ref(chunks[i]), "parallel_data.csv");
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "병렬 데이터 처리 완료!" << std::endl;
    return 0;
}

#include <iostream>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

void readLargeCSV(const std::string &filename) {
    int fd = open(filename.c_str(), O_RDONLY);
    if (fd == -1) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    struct stat fileStat;
    if (fstat(fd, &fileStat) == -1) {
        close(fd);
        std::cerr << "파일 정보를 가져올 수 없습니다." << std::endl;
        return;
    }

    size_t fileSize = fileStat.st_size;
    char *data = static_cast<char*>(mmap(nullptr, fileSize, PROT_READ, MAP_PRIVATE, fd, 0));
    if (data == MAP_FAILED) {
        close(fd);
        std::cerr << "메모리 매핑 실패!" << std::endl;
        return;
    }

    // 파일 내용을 빠르게 출력 (샘플)
    for (size_t i = 0; i < fileSize; ++i) {
        if (data[i] == '\n') std::cout << std::endl;
        else std::cout << data[i];
    }

    munmap(data, fileSize);
    close(fd);
}

int main() {
    readLargeCSV("large_data.csv");
    return 0;
}

#include <iostream>
#include <zlib.h>

void compressCSV(const std::string& inputFile, const std::string& outputFile) {
    std::ifstream inFile(inputFile, std::ios::binary);
    std::ofstream outFile(outputFile, std::ios::binary);

    z_stream zs = {};
    deflateInit(&zs, Z_BEST_COMPRESSION);

    char inBuffer[4096];
    char outBuffer[4096];

    while (inFile.read(inBuffer, sizeof(inBuffer))) {
        zs.next_in = reinterpret_cast<unsigned char*>(inBuffer);
        zs.avail_in = inFile.gcount();

        do {
            zs.next_out = reinterpret_cast<unsigned char*>(outBuffer);
            zs.avail_out = sizeof(outBuffer);
            deflate(&zs, Z_NO_FLUSH);
            outFile.write(outBuffer, sizeof(outBuffer) - zs.avail_out);
        } while (zs.avail_out == 0);
    }

    deflateEnd(&zs);
    inFile.close();
    outFile.close();
    std::cout << "CSV 파일 압축 완료!" << std::endl;
}

#include <iostream>
#include <fstream>
#include <sstream>

void filterCSV(const std::string &inputFile, const std::string &outputFile) {
    std::ifstream inFile(inputFile);
    std::ofstream outFile(outputFile);

    if (!inFile.is_open() || !outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::string line;
    std::getline(inFile, line);  // 헤더 읽기
    outFile << line << "\n";     // 헤더 복사

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        std::string name, ageStr, job;
        std::getline(ss, name, ',');
        std::getline(ss, ageStr, ',');
        std::getline(ss, job, ',');

        int age = std::stoi(ageStr);
        if (age >= 30) {  // 나이가 30 이상인 데이터만 저장
            outFile << line << "\n";
        }
    }

    inFile.close();
    outFile.close();
    std::cout << "필터링된 데이터 저장 완료: " << outputFile << std::endl;
}

int main() {
    filterCSV("data.csv", "filtered_data.csv");
    return 0;
}

이름,나이,직업
홍길동,30,개발자
이철수,35,데이터 분석가

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>

struct Person {
    std::string name;
    int age;
    std::string job;
};

bool compareByAge(const Person &a, const Person &b) {
    return a.age < b.age;
}

void sortCSV(const std::string &inputFile, const std::string &outputFile) {
    std::ifstream inFile(inputFile);
    std::ofstream outFile(outputFile);

    if (!inFile.is_open() || !outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::string line;
    std::getline(inFile, line);  // 헤더 저장
    outFile << line << "\n";

    std::vector<Person> people;

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        Person p;
        std::string ageStr;
        std::getline(ss, p.name, ',');
        std::getline(ss, ageStr, ',');
        std::getline(ss, p.job, ',');
        p.age = std::stoi(ageStr);
        people.push_back(p);
    }

    // 나이를 기준으로 정렬
    std::sort(people.begin(), people.end(), compareByAge);

    for (const auto &p : people) {
        outFile << p.name << "," << p.age << "," << p.job << "\n";
    }

    inFile.close();
    outFile.close();
    std::cout << "CSV 데이터 정렬 완료: " << outputFile << std::endl;
}

int main() {
    sortCSV("data.csv", "sorted_data.csv");
    return 0;
}

이름,나이,직업
김영희,28,디자이너
홍길동,30,개발자
이철수,35,데이터 분석가

#include <iostream>
#include <fstream>
#include <sstream>
#include <unordered_map>

void groupByJob(const std::string &inputFile) {
    std::ifstream inFile(inputFile);

    if (!inFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::unordered_map<std::string, std::pair<int, int>> jobData;  // 직업별 (나이 합, 개수)
    std::string line;
    std::getline(inFile, line);  // 헤더 스킵

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        std::string name, ageStr, job;
        std::getline(ss, name, ',');
        std::getline(ss, ageStr, ',');
        std::getline(ss, job, ',');

        int age = std::stoi(ageStr);
        jobData[job].first += age;
        jobData[job].second += 1;
    }

    inFile.close();

    std::cout << "직업별 평균 나이:\n";
    for (const auto &[job, data] : jobData) {
        std::cout << job << ": " << (data.first / static_cast<double>(data.second)) << "세\n";
    }
}

int main() {
    groupByJob("data.csv");
    return 0;
}

직업별 평균 나이:
개발자: 30세
디자이너: 28세
데이터 분석가: 35세

git clone https://github.com/troldal/OpenXLSX.git
cd OpenXLSX
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

#include <iostream>
#include <fstream>
#include <sstream>
#include <OpenXLSX.hpp>  // OpenXLSX 라이브러리 사용

void convertCSVToExcel(const std::string &csvFile, const std::string &excelFile) {
    std::ifstream inFile(csvFile);
    if (!inFile.is_open()) {
        std::cerr << "CSV 파일을 열 수 없습니다." << std::endl;
        return;
    }

    OpenXLSX::XLDocument doc;
    doc.create(excelFile);
    OpenXLSX::XLWorksheet sheet = doc.workbook().worksheet("Sheet1");

    std::string line;
    int row = 1;

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        std::string cell;
        int col = 1;

        while (std::getline(ss, cell, ',')) {
            sheet.cell(row, col).value() = cell;
            col++;
        }
        row++;
    }

    doc.save();
    doc.close();
    inFile.close();
    std::cout << "CSV 파일이 Excel 파일로 변환되었습니다: " << excelFile << std::endl;
}

int main() {
    convertCSVToExcel("data.csv", "output.xlsx");
    return 0;
}

#include <iostream>
#include <fstream>
#include <OpenXLSX.hpp>

void convertExcelToCSV(const std::string &excelFile, const std::string &csvFile) {
    OpenXLSX::XLDocument doc;
    doc.open(excelFile);
    OpenXLSX::XLWorksheet sheet = doc.workbook().worksheet("Sheet1");

    std::ofstream outFile(csvFile);
    if (!outFile.is_open()) {
        std::cerr << "CSV 파일을 생성할 수 없습니다." << std::endl;
        return;
    }

    for (uint32_t row = 1; row <= sheet.rowCount(); ++row) {
        for (uint32_t col = 1; col <= sheet.columnCount(); ++col) {
            outFile << sheet.cell(row, col).value().get<std::string>();
            if (col < sheet.columnCount()) outFile << ",";  // 쉼표 구분
        }
        outFile << "\n";  // 행 구분
    }

    doc.close();
    outFile.close();
    std::cout << "Excel 파일이 CSV로 변환되었습니다: " << csvFile << std::endl;
}

int main() {
    convertExcelToCSV("output.xlsx", "converted_data.csv");
    return 0;
}

std::ofstream outFile("output.csv", std::ios::binary);
unsigned char bom[] = {0xEF, 0xBB, 0xBF};  // UTF-8 BOM
outFile.write(reinterpret_cast<char*>(bom), sizeof(bom));  

outFile << "\"" << data << "\"";

#include <iomanip>
outFile << std::fixed << std::setprecision(6) << data;

#include <iostream>
#include "csv.h"  // OpenCSV 라이브러리 포함

int main() {
    io::CSVReader<3> in("data.csv");  // 3개의 컬럼을 가진 CSV 파일
    in.read_header(io::ignore_extra_column, "이름", "나이", "직업");

    std::string name, job;
    int age;

    while (in.read_row(name, age, job)) {
        std::cout << "이름: " << name << ", 나이: " << age << ", 직업: " << job << std::endl;
    }

    return 0;
}

이름: 홍길동, 나이: 30, 직업: 개발자
이름: 김영희, 나이: 28, 직업: 디자이너
이름: 이철수, 나이: 35, 데이터 분석가

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("output.csv");

    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return 1;
    }

    file << "이름,나이,직업\n";
    file << "김철수,40,매니저\n";
    file << "박영희,35,마케터\n";
    file.close();

    std::cout << "CSV 파일이 저장되었습니다." << std::endl;
    return 0;
}

이름,나이,직업
김철수,40,매니저
박영희,35,마케터

#include <iostream>
#include "rapidcsv.h"  // RapidCSV 라이브러리

int main() {
    rapidcsv::Document doc("data.csv");

    std::vector<std::string> names = doc.GetColumn<std::string>("이름");
    std::vector<int> ages = doc.GetColumn<int>("나이");

    for (size_t i = 0; i < names.size(); ++i) {
        std::cout << "이름: " << names[i] << ", 나이: " << ages[i] << std::endl;
    }

    return 0;
}

이름: 홍길동, 나이: 30
이름: 김영희, 나이: 28
이름: 이철수, 나이: 35

#include <iostream>
#include "rapidcsv.h"

int main() {
    rapidcsv::Document doc("data.csv");

    // 특정 행의 데이터를 수정
    doc.SetCell<std::string>("직업", 1, "소프트웨어 엔지니어");

    // 새로운 행 추가
    doc.InsertRow(3, std::vector<std::string>{"박철민", "32", "데이터 과학자"});

    // 수정된 데이터를 저장
    doc.Save("modified_data.csv");

    std::cout << "CSV 파일이 수정되었습니다." << std::endl;
    return 0;
}

이름,나이,직업
홍길동,30,소프트웨어 엔지니어
김영희,28,디자이너
이철수,35,데이터 분석가
박철민,32,데이터 과학자

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <thread>

const int NUM_THREADS = 4;  // 스레드 개수

void readCSVChunk(const std::string &filename, int startLine, int numLines, int threadID) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다: " << filename << std::endl;
        return;
    }

    std::string line;
    int currentLine = 0;

    while (std::getline(file, line)) {
        if (currentLine >= startLine && currentLine < startLine + numLines) {
            std::stringstream ss(line);
            std::vector<std::string> row;
            std::string cell;

            while (std::getline(ss, cell, ',')) {
                row.push_back(cell);
            }

            std::cout << "[Thread " << threadID << "] ";
            for (const auto &data : row) {
                std::cout << data << " ";
            }
            std::cout << std::endl;
        }
        currentLine++;
    }

    file.close();
}

int main() {
    int totalLines = 1000;  // CSV 총 줄 수 (실제 파일 크기에 따라 조정 필요)
    int linesPerThread = totalLines / NUM_THREADS;

    std::vector<std::thread> threads;

    for (int i = 0; i < NUM_THREADS; i++) {
        int startLine = i * linesPerThread;
        threads.emplace_back(readCSVChunk, "large_data.csv", startLine, linesPerThread, i);
    }

    for (auto &t : threads) {
        t.join();
    }

    std::cout << "CSV 파일 병렬 읽기 완료!" << std::endl;
    return 0;
}

#include <iostream>
#include <fstream>
#include <vector>
#include <thread>
#include <mutex>

const int NUM_THREADS = 4;  // 스레드 개수
std::mutex fileMutex;  // 파일 동기화를 위한 뮤텍스

void writeCSVChunk(const std::string &filename, int startID, int numEntries, int threadID) {
    std::ofstream file(filename, std::ios::app);  // 추가 모드
    if (!file.is_open()) {
        std::cerr << "파일을 열 수 없습니다: " << filename << std::endl;
        return;
    }

    for (int i = 0; i < numEntries; i++) {
        std::string line = "User" + std::to_string(startID + i) + "," + std::to_string(20 + (i % 50)) + ",Job" + std::to_string(i % 5) + "\n";

        std::lock_guard<std::mutex> lock(fileMutex);  // 파일 동기화
        file << line;
    }

    file.close();
    std::cout << "[Thread " << threadID << "] CSV 파일에 데이터 추가 완료\n";
}

int main() {
    int totalEntries = 1000000;  // 생성할 총 데이터 개수
    int entriesPerThread = totalEntries / NUM_THREADS;

    std::vector<std::thread> threads;

    for (int i = 0; i < NUM_THREADS; i++) {
        int startID = i * entriesPerThread;
        threads.emplace_back(writeCSVChunk, "multi_thread_data.csv", startID, entriesPerThread, i);
    }

    for (auto &t : threads) {
        t.join();
    }

    std::cout << "CSV 파일 병렬 쓰기 완료!" << std::endl;
    return 0;
}

#include <iostream>
#include <fstream>
#include <sstream>

void handleMissingValues(const std::string &inputFile, const std::string &outputFile) {
    std::ifstream inFile(inputFile);
    std::ofstream outFile(outputFile);

    if (!inFile.is_open() || !outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::string line;
    std::getline(inFile, line);  // 헤더 처리
    outFile << line << "\n";

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        std::string name, age, job;

        std::getline(ss, name, ',');
        std::getline(ss, age, ',');
        std::getline(ss, job, ',');

        // 누락된 값 처리
        if (name.empty()) name = "Unknown";
        if (age.empty()) age = "0";  // 기본값 설정
        if (job.empty()) job = "미정";

        outFile << name << "," << age << "," << job << "\n";
    }

    inFile.close();
    outFile.close();
    std::cout << "누락된 데이터 처리 완료: " << outputFile << std::endl;
}

int main() {
    handleMissingValues("data.csv", "cleaned_data.csv");
    return 0;
}

이름,나이,직업
홍길동,30,개발자
Unknown,25,디자이너
김영희,0,미정

#include <iostream>
#include <fstream>
#include <sstream>

bool isNumber(const std::string &s) {
    return !s.empty() && std::all_of(s.begin(), s.end(), ::isdigit);
}

void validateCSV(const std::string &inputFile, const std::string &outputFile) {
    std::ifstream inFile(inputFile);
    std::ofstream outFile(outputFile);

    if (!inFile.is_open() || !outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::string line;
    std::getline(inFile, line);  
    outFile << line << "\n";  

    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        std::string name, age, job;
        std::getline(ss, name, ',');
        std::getline(ss, age, ',');
        std::getline(ss, job, ',');

        if (!isNumber(age)) {
            std::cerr << "오류 발견 (잘못된 나이 값): " << line << std::endl;
            continue;  // 잘못된 데이터는 저장하지 않음
        }

        outFile << name << "," << age << "," << job << "\n";
    }

    inFile.close();
    outFile.close();
    std::cout << "데이터 검증 완료!" << std::endl;
}

int main() {
    validateCSV("data.csv", "validated_data.csv");
    return 0;
}

이름,나이,직업
홍길동,30,개발자
김영희,28,디자이너

#include <iostream>
#include <fstream>
#include <sstream>
#include <set>

void removeDuplicates(const std::string &inputFile, const std::string &outputFile) {
    std::ifstream inFile(inputFile);
    std::ofstream outFile(outputFile);

    if (!inFile.is_open() || !outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다." << std::endl;
        return;
    }

    std::set<std::string> seen;
    std::string line;

    std::getline(inFile, line);
    outFile << line << "\n";

    while (std::getline(inFile, line)) {
        if (seen.find(line) == seen.end()) {
            seen.insert(line);
            outFile << line << "\n";
        }
    }

    inFile.close();
    outFile.close();
    std::cout << "중복 데이터 제거 완료!" << std::endl;
}

int main() {
    removeDuplicates("data.csv", "unique_data.csv");
    return 0;
}

이름,나이,직업
홍길동,30,개발자
김영희,28,디자이너

std::ofstream outFile("output.csv", std::ios::binary);
unsigned char bom[] = {0xEF, 0xBB, 0xBF};  // UTF-8 BOM 추가
outFile.write(reinterpret_cast<char*>(bom), sizeof(bom));