클래스 템플릿

#include <string>
// 정수형 스택
class IntStack {
private:
    int* arr;
    int top;
    int capacity;
public:
    // ... 생성자, push, pop 등 구현 ...
};

// 문자열 스택
class StringStack {
private:
    std::string* arr;
    int top;
    int capacity;
public:
    // ... 생성자, push, pop 등 구현 ...
};

// Double형 스택도 만들려면 또 복사/붙여넣기 해야 할까?

template <typename T> // 또는 template <class T>
class 클래스이름 {
public:
    // T 타입을 사용하는 멤버 변수 및 멤버 함수
    T data;
    T getValue();
    void setValue(T value);
};

// 여러 개의 타입 매개변수 사용 가능
template <typename KeyType, typename ValueType>
class MyMap {
    // KeyType과 ValueType을 사용하는 멤버
};

#include <iostream>
#include <string>

// 클래스 템플릿 정의
template <typename T1, typename T2>
class Pair {
private:
    T1 first;
    T2 second;

public:
    // 생성자
    Pair(T1 f, T2 s) : first(f), second(s) {
        std::cout << "Pair 객체 생성.\n";
    }

    // Getter 함수 (const 멤버 함수)
    T1 getFirst() const { return first; }
    T2 getSecond() const { return second; }

    // Setter 함수
    void setFirst(T1 f) { first = f; }
    void setSecond(T2 s) { second = s; }

    void display() const {
        std::cout << "First: " << first << ", Second: " << second << std::endl;
    }
};

int main() {
    // 1. int와 double 타입을 사용하는 Pair 객체 생성
    // 컴파일러가 Pair<int, double> 클래스를 인스턴스화
    Pair<int, double> p1(10, 20.5);
    p1.display(); // 출력: First: 10, Second: 20.5

    // 2. std::string과 char 타입을 사용하는 Pair 객체 생성
    Pair<std::string, char> p2("Hello", 'W');
    p2.display(); // 출력: First: Hello, Second: W

    // 3. Pair 템플릿을 중첩하여 사용
    Pair<int, Pair<std::string, double>> p3(1, Pair<std::string, double>("Nested", 3.14));
    // Pair 자체에는 스트림 삽입 연산자가 없으므로 중첩 값은 직접 나누어 출력합니다.
    std::cout << "First: " << p3.getFirst() << ", Second: ";
    p3.getSecond().display(); // 출력: First: 1, Second: First: Nested, Second: 3.14

    std::cout << "p3.getFirst(): " << p3.getFirst() << std::endl;
    std::cout << "p3.getSecond().getFirst(): " << p3.getSecond().getFirst() << std::endl;

    return 0;
}

#pragma once
#include <iostream>
#include <string>
#include <typeinfo>
#include <stdexcept>
#include <vector> // std::vector 사용 예시

// 클래스 템플릿 선언 및 정의
template <typename T>
class MyContainer {
private:
    std::vector<T> elements; // T 타입의 요소를 저장하는 vector
    int capacity;

public:
    MyContainer(int cap) : capacity(cap) {
        if (cap < 0) throw std::invalid_argument("capacity must be nonnegative");
        elements.reserve(capacity); // 미리 메모리 할당
        std::cout << "MyContainer<" << typeid(T).name() << "> 생성, 용량: " << capacity << std::endl;
    }

    void add(const T& item) {
        if (elements.size() < capacity) {
            elements.push_back(item);
            std::cout << "항목 추가: " << item << std::endl;
        } else {
            std::cerr << "컨테이너가 가득 찼습니다!\n";
        }
    }

    T get(int index) const {
        if (index >= 0 && index < elements.size()) {
            return elements[index];
        } else {
            std::cerr << "오류: 인덱스 범위를 벗어났습니다.\n";
            // 실제 코드에서는 예외 처리 또는 다른 오류 반환 방식 사용
            return T(); // T의 기본 생성자로 생성된 값 반환
        }
    }

    void displayAll() const {
        std::cout << "컨테이너 내용: [";
        for (std::size_t i = 0; i < elements.size(); ++i) {
            std::cout << elements[i] << (i == elements.size() - 1 ? "" : ", ");
        }
        std::cout << "]\n";
    }

    // 소멸자도 템플릿 클래스 내에 정의
    ~MyContainer() {
        std::cout << "MyContainer<" << typeid(T).name() << "> 소멸.\n";
    }
};

#include "MyContainer.h" // 모든 클래스 템플릿 정의가 포함됨

int main() {
    MyContainer<int> intContainer(5); // int 타입 컨테이너
    intContainer.add(10);
    intContainer.add(20);
    intContainer.add(30);
    intContainer.displayAll(); // 출력: 컨테이너 내용: [10, 20, 30]
    std::cout << "인덱스 1의 값: " << intContainer.get(1) << std::endl; // 출력: 인덱스 1의 값: 20

    std::cout << "--------------------------------\n";

    MyContainer<std::string> stringContainer(3); // std::string 타입 컨테이너
    stringContainer.add("Apple");
    stringContainer.add("Banana");
    stringContainer.add("Cherry");
    stringContainer.add("Durian"); // 컨테이너가 가득 찼습니다!
    stringContainer.displayAll(); // 출력: 컨테이너 내용: [Apple, Banana, Cherry]

    std::cout << "--------------------------------\n";

    // 동적 할당
    MyContainer<double>* doubleContainer = new MyContainer<double>(2);
    doubleContainer->add(1.1);
    doubleContainer->add(2.2);
    doubleContainer->displayAll();
    delete doubleContainer; // 소멸자 호출

    return 0;
}

g++ -std=c++17 main.cpp -o container_demo
./container_demo

template <typename T, int N> // N은 정수형 비타입 매개변수
class MyStaticArray {
private:
    T arr[N]; // 크기가 N인 T 타입 배열
public:
    // ...
};

#include <typeinfo>
#include <iostream>
#include <string>

template <typename T, int MAX_SIZE> // T: 타입, MAX_SIZE: 정수형 비타입 매개변수
class FixedSizeStack {
    static_assert(MAX_SIZE > 0, "MAX_SIZE must be positive");
private:
    T elements[MAX_SIZE]; // 컴파일 시점에 크기가 결정되는 배열
    int top;

public:
    FixedSizeStack() : top(-1) {
        std::cout << "FixedSizeStack<" << typeid(T).name() << ", " << MAX_SIZE << "> 생성.\n";
    }

    void push(const T& item) {
        if (top < MAX_SIZE - 1) {
            elements[++top] = item;
            std::cout << "Push: " << item << std::endl;
        } else {
            std::cerr << "스택이 가득 찼습니다!\n";
        }
    }

    T pop() {
        if (top >= 0) {
            T item = elements[top--];
            std::cout << "Pop: " << item << std::endl;
            return item;
        } else {
            std::cerr << "스택이 비어 있습니다!\n";
            return T(); // T의 기본 생성자로 생성된 값 반환
        }
    }

    bool isEmpty() const { return top == -1; }
    bool isFull() const { return top == MAX_SIZE - 1; }
};

int main() {
    FixedSizeStack<int, 5> intStack; // int형, 최대 5개 저장 가능한 스택
    intStack.push(10);
    intStack.push(20);
    intStack.pop(); // 출력: Pop: 20
    intStack.push(30);
    intStack.push(40);
    intStack.push(50);
    intStack.push(60); // 출력: Push: 60 (현재 5개로 가득 참)
    intStack.push(70); // 출력: 스택이 가득 찼습니다!

    std::cout << "--------------------------------\n";

    FixedSizeStack<std::string, 3> stringStack; // string형, 최대 3개 저장 가능한 스택
    stringStack.push("A");
    stringStack.push("B");
    stringStack.push("C");
    stringStack.pop(); // 출력: Pop: C
    stringStack.pop(); // 출력: Pop: B
    stringStack.pop(); // 출력: Pop: A
    stringStack.pop(); // 출력: 스택이 비어 있습니다!

    return 0;
}

// 일반 템플릿 클래스
template <typename T>
class MyClass { /* ... */ };

// 특정 타입 (예: int)에 대한 완전 특수화
template <> // 완전 특수화
class MyClass<int> { /* int 타입에 대한 특별한 구현 */ };