[Lecture] Cpp - Finals Summary

💻 2023년 Cpp 기말고사 대비 요점 정리

👀 [08] 상속

상속의 개념

• 상속(Inheritance) : 객체 지향 언어의 본질적인 특성
  • 두 클래스 사이에 부모-자식의 상속 관계 선언
  • 자식 클래스의 객체가 생성될 때, 자신의 멤버뿐 아니라 부모 클래스의 멤버를 포함할 것을 지시함
  • 부모 클래스 => 기본 클래스(base class)
  • 자식 클래스 => 파생 클래스(derived class)
  • cpp는 여러 개의 클래스를 동시에 상속받는 다중 상속(multiple inheritance) 허용
• 상속의 목적과 장점
  • 간결한 클래스 작성
  • 클래스 간의 계층적 분류 및 관리의 용이함
  • 클래스 재사용과 확장을 통한 소프트웨어의 생산성 향상
• 상속은 is-a 관계
  • has-a 관계는 상속으로 모델링 X

클래스 상속과 객체

class Student : public Person {

};
class StudentWorker : public Student {

};

• Person을 상속받는 Student와 Student를 상속받는 StudentWorker 선언
• 기본 클래스 이름 앞에 반드시 상속 접근을 지정해야 하는데, 접근 지정자 3개 모두 사용 가능함
• 상속의 횟수는 제한이 없음

class ColorPoint : public Point {
  // Point를 상속받는 ColorPoint의 상속 선언
};
int main() {
  Point p; // Point 타입인 기본 클래스 객체 p 생성
  ColorPoint cp; // ColorPoint 타입인 파생 클래스 객체 cp 생성
}

• 객체 p는 Point 클래스의 멤버만 가짐
• 객체 cp는 Point 멤버와 ColorPoint 멤버 모두 가짐

파생 클래스에서 기본 클래스 멤버 접근

• 파생 클래스는 상속을 통해 기본 클래스의 멤버를 자신의 멤버로 확장
• 파생 클래스의 멤버들은 기본 클래스의 private 멤버 외에 모든 멤버를 접근할 수 있음

기본 클래스의 private 멤버의 상속과 접근

• 기본 클래스의 private 멤버도 파생 클래스에 상속됨
• 파생 클래스의 객체가 생길 때 파생 클래스의 객체 내에 생성됨
• 즉, 기본 클래스에 선언된 private 멤버는 파생 클래스에 상속되고 파생 클래스의 객체에도 포함되지만, 파생 클래스의 어떤 함수에서도 직접 접근이 불가함

클래스 외부에서 파생 클래스의 멤버 호출

• main() 함수와 같이 파생 클래스 외부에서 파생 클래스 객체의 public 멤버와 기본 클래스의 public 멤버를 모두 접근할 수 있음

protected 접근 지정

• protected 접근 지정으로 선언된 멤버는 클래스 내의 멤버 함수와 이 클래스를 상속받은 파생 클래스의 멤버 함수에게만 접근이 허용됨

상속과 생성자, 소멸자

• 파생 클래스의 객체가 생성될 때 파생 클래스의 생성자와 기본 클래스의 생성자가 모두 실행됨
  • 파생 클래스의 생성자보다 기본 클래스의 생성자가 먼저 실행됨
  • 생성자는 객체를 초기화할 목적으로 사용됨
  • 생성자의 호출 관계는 컴파일러에 의해 이루어짐
• 소멸자는 생성자의 실행 순서와 반대로 실행됨
• 파생 클래스에서 기본 클래스의 생성자를 선택하지 않은 경우, 기본 클래스의 기본 생성자가 호출됨

B(int x) : A(x+3) {
    cout << "매개변수생성자 B" << x << endl;
}

• 파생 클래스의 생성자를 작성할 때 기본 클래스의 생성자를 명시적으로 선택하는 방법

상속의 종류

• public 상속 : 기본 클래스의 protected, public 멤버들은 접근 지정 변경 없이 파생 클래스에 그대로 상속 확정됨
• private 상속 : 기본 클래스의 protected, public 멤버들은 모두 private 접근 지정으로 변경되어 파생 클래스에 상속 확정됨
• protected 상속 : 기본 클래스의 protected, public 멤버들은 모두 protected 접근 지정으로 변경되어 파생 클래스에 상속 확정됨

👀 [10] 템플릿과 표준 템플릿 라이브러리(STL; Standard Template Library)

일반화와 템플릿

• template : 함수나 클래스 코드를 찍어내듯이 생산할 수 있도록 일반화(generic) 시키는 도구
  • 템플릿 함수(template function) or 제네릭 함수(generic function) : template 키워드를 이용해 만든 함수
    • 템플릿 함수는 컴파일되지도 호출되지도 않는 함수의 틀
    • 템플릿 함수로부터 구체화된 버전의 함수가 컴파일되고 호출됨

템플릿 선언과 제네릭 타입

// 중복 함수 1
void myswap(int &a, int &b) {
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

// 중복 함수 2
void myswap(double &a, double &b) {
    double tmp;
    tmp = a;
    a = b;
    b = tmp;
}

// 제네릭 함수
template <class T>
void myswap(T &a, T &b) {
    T tmp;
    tmp = a;
    a = b;
    b = tmp;
}

• template 키워드와 <class T> 나 <typename T> 로 제네릭 타입 T 선언
  • 제네릭 타입(generic type) : cpp의 기본 타입이 아니며, 이들을 일반화시킨 새로운 타입

구체화

• 구체화(specialization) : 중복 함수들을 템플릿화하는 과정의 역과정
  • 컴파일러가 담당함
  • 구체화를 통해 생성된 함수를 구체화된 함수(specialized function) 라고 함

템플릿의 장단점과 제네릭 프로그래밍

• 소프트웨어의 생산성과 유연성 향상
• 포팅에 취약
• 오류 메시지가 빈약하여 디버깅에 많은 어려움
• 제네릭 프로그래밍(generic programming) : 템플릿을 사용하여 제네릭 함수나 제네릭 클래스를 만들고 이를 활용하여 프로그램을 작성하는 패러다임

다양한 제네릭 함수

• 제네릭 함수를 만들 때, 개발자의 필요에 따라 제네릭 타입은 하나 이상 마음대로 선언하면 됨
• 템플릿 함수와 동일한 이름으로 중복된 함수가 있을 경우, 중복 함수가 우선하여 바인딩됨

제네릭 클래스

template <class T>
class Box {
    T data;
public:
    Box() { }
    void set(T v) {
        data = v;
    }
    T get() {
        return data;
    }
};

• 클래스도 template 키워드로 일반화시킬 수 있음
• 클래스의 모든 멤버 함수 역시 템플릿 함수로 작성되어야 함

STL과 활용

• 표준 템플릿 라이브러리(Standard Template Library) : 템플릿으로 작성된 많은 제네릭 클래스와 함수 라이브러리
  • 프로그래밍에 매우 유용한 수많은 컨테이너와 알고리즘 제공
  • 객체 지향 기법과 제네릭 프로그래밍 기법을 사용하여 만들어졌기에 유연성이 좋음
  • 전문가가 만들어서 검증되었음
• 컨테이너(container) - 템플릿 클래스
  • 자료를 저장하는 구조
  • 순차 컨테이너
    • 자료 순차 저장
    • vector : 동적 배열
      • 뒤에서 자료 추가
    • deque : 양 끝에서 입력과 출력 가능
    • list : 벡터와 유사
      • 자료를 중간에 추가하는 연산이 효율적임
  • 연관 컨테이너
    • 사전과 같은 구조를 사용해 자료 정렬 저장
    • set : 중복이 없는 자료들이 정렬되어 저장 - 연관
      • multiset : 중복 허용
    • map : key-value 형식으로 저장 - 연관
      • 키가 제시되면 해당 값을 찾을 수 있음
      • multimap : 중복 허용
  • 컨테이너 어댑터
    • 순차 컨테이너에 제약을 가해서 데이터들이 정해진 방식으로만 입출력
    • queue : 선입선출 자료 구조
    • stack : 후입선출 자료 구조
    • priority queue : 큐의 요소들이 우선 순위를 가지고 있고 우선 순위가 높은 요소가 먼저 출력되는 자료 구조
• 반복자(iterator) - 컨테이너 원소에 대한 일반화된 포인터(generalized pointer)
  • 컨테이너 내에 저장된 요소들을 순차적으로 처리하기 위한 컴포넌트
  • 컨테이너와 알고리즘 사이의 다리 역할
  • 반복자의 연산자
    • ++ : 컨테이너 다음 요소를 가리키기 위한 연산자
    • -- : 컨테이너 이전 요소를 가리키기 위한 연산자
    • ==, != : bool 연산자
    • * : 반복자가 가리키는 요소의 값을 추출하기 위한 연산자
• 알고리즘(algorithm) - 템플릿 함수
  • 정렬이나 탐색과 같은 다양한 알고리즘 구현
  • find : 컨테이너 내에서 특정 자료 찾기
  • sort : 자료들 크기순 정렬
  • reverse : 자료들 순서 역순
  • remove : 조건을 만족하는 자료 삭제
  • transform : 컨테이너의 요소들을 사용자가 제공하는 변환 함수에 따라서 변환

list

#include <iostream>
#include <time.h>
#include <list>
using namespace std;

int main()
{
    list<int> values;
    list<int>::iterator it;
    srand(time(NULL));
    for (int i = 0; i < 10; i++) {
        values.push_back(rand() % 100);
    }
    values.sort();

    for (it = values.begin(); it != values.end(); it++)
        cout << *it << " ";

    cout << endl;
    return 0;
}

• push_back(), pop_back(), insert(n, v)

vector

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<double> score(10);
    double max = 0;

    for (int i=0; i<score.size(); i++) {
        cout << "성적 입력: ";
        cin >> score[i];
        if (score[i] > max) {
            max = score[i];
        }
    }

    cout << "최고 성적: " << max << endl;

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<double> score;
    double max = 0;

    while(1) {
        double v = 0;
        cout << "성적 입력(-1 입력 시 종료): ";
        cin >> v;
        if (v == -1) break;
        score.push_back(v);
        if (v>max) max=v;
    }

    cout << "최고 성적: " << max << endl;

    return 0;
}

• push_back() : 벡터 끝에 요소 추가 후 크기 1
• pop_back() : 백터 끝에서 요소 제거 후 크기 -1
• insert(n, v) : 벡터의 n번째 자리에 v 요소 추가

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<double> score;
    double max = 0;

    while(1) {
        double v = 0;
        cout << "성적 입력(-1 입력 시 종료): ";
        cin >> v;
        if (v == -1) break;
        score.push_back(v);
    }

    vector<double>::iterator it;

    // c++14 이전 버전
    for (it=score.begin(); it!=score.end(); it++) {
        if (*it>max) max = *it;
    }

    // c++14
    // for (auto p=score.begin(); p!=score.end(); ++p) ..
    // for (auto &n : score) ..

    cout << "최고 성적: " << max << endl;

    return 0;
}

• 반복자 사용
• auto : 컴파일러에게 변수 선언문으로부터 변수의 타입을 추론하여 결정하도록 지시함

컨테이너 공통 함수

• 

deque

• push_front() : 데큐 앞에 값 추가
• pop_front() : 데큐 앞의값 추출
• push_back() : 데큐 뒤에 값 추가
• pop_back() : 데큐 뒤의 값 추출

map

• make_pair(t, u) : t가 키, u가 값

stack, queue

• push() : 값을 저장
• pop() : 스택은 후입선출 구조로 값 추출, 큐는 선입선출 구조로 값 추출

find, find_if

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    vector<string> vec = { "사과", "토마토", "배", "수박", "키위" };

    auto it = find(vec.begin(), vec.end(), "수박");
    if (it != vec.end()) {
        cout << "수박이 " << distance(vec.begin(), it) << "에 있습니다." << endl;
    }
    return 0;
}

count

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

template <class T>
bool is_even(const T &num) {
    return (num % 2) == 0;
}

int main() {
    vector<int> vec;
    for (int i = 0; i<10; i++)
        vec.push_back(i);

    size_t n = count_if(vec.begin(), vec.end(), is_even<int>);
    cout << "값이 짝수인 요소의 개수: " << n << endl;
    return 0;
}

binary_search() 및 lambda

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    vector<string> v = { "one", "two", "three" };
    bool result;
    auto comp = [](string s1, string s2) { return (s1==s2); };

    result = binary_search(v.begin(), v.end(), "two", comp);
    if (result == true)
        cout << "문자열 \"two\" 은 벡터 안에 있음." << endl;
    return 0;
}

for_each() 및 lambda

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    for_each(v.begin(), v.end(), [](int n){ if (n%2==0) cout<<n<<" ";} );
    cout << endl;
    return 0;
}

5보다 큰 정수

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> n = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto cnt = count_if(n.begin(), n.end(), [](int n) { return (n > 5); });
    cout << "5보다 큰 정수의 개수: " << cnt << endl;

    return 0;
}

👀 [11] Cpp 입출력 시스템

스트림(stream)

• 순서가 있는 데이터의 연속적인 흐름
• Cpp 표준 입출력 시스템은 버퍼를 사용하는 스트림 입출력만 지원
• cin : Cpp의 표준 입력 스트림 객체
  • istream 타입
• cout : Cpp의 표준 출력 스트림 객체
  • ostream 타입
• cerr, clog : Cpp의 표준 오류 출력 스트림 객체
  • clog 는 버퍼를 거침
  • cerr 은 버퍼를 거치지 않음

삽입 연산자와 추출 연산자

• << : 삽입 연산자
  • ostream 클래스에 작성된 연산자
• >> : 추출 연산자
  • istream 클래스에 작성된 연산자

👀 [12] Cpp 파일 입출력

파일 스트림

• ofstream : 출력 파일 스트림 클래스
  • 출력 파일 생성 및 파일에 데이터 작성 시 사용
• ifstream : 입력 파일 스트림 클래스
  • 파일의 데이터를 읽을 시 사용
• fstream : 일반적인 파일 스트림

파일 쓰기

#include <fstream>

using namespace std;

int main() {
    ofstream os("number.txt");

    if (!os.is_open()) {
        cerr << "error!" << endl;
        exit(1);
    }
    for (int i=0; i<100; i++)
        os << i << " ";
    return 0;
}

• 파일 객체는 범위를 벗어나면 파일 객체 소멸자가 파일을 닫음

파일 읽기

#include <fstream>

using namespace std;
int main() {
    ifstream is("numbers.txt");
    if (!is.is_open()) {
        cerr << "파일 오픈에 실패하였습니다" << endl;
        exit(1);
    }
    int number;
    while (is) {
        is >> number;
        cout << number << " ";
    }
    cout << endl;
    return 0;
}

파일 모드

• ios::in : 입력 모드
• ios::out : 출력 모드
• ios::binary : 이진 파일 입출력 모드
• ios::ate : 파일의 끝을 초기 위치로 하는 모드
• ios::app : 파일의 끝에 추가하는 모드
• ios::trunc : 새로운 내용으로 교체 모드

👀 [추가] 예외처리

예외(exception)

• 잘못된 코드, 부정확한 데이터, 예외적인 상황에 의하여 발생하는 오류
• interrupt : 컴퓨터 작동 중 문제가 발생한 경우라도 업무 처리가 계속될 수 있도록 하는 기능

오류 처리 방식

• 다중 if 문으로 처리하는 방식은 비효율적임

int main() {
    try {
        ...
        if ()
            throw exception;
    } catch (예외타입   매개변수) {
        ...
    }
}

• try : 예외가 발생할 수 있는 블록
• throw : 예외를 전송
• catch : try 블록에서 예외가 발생하면 처리하는 블록

👀 [추가] 멀티 스레드 프로그래밍

스레드(thread)

• <thread> 라이브러리에 정의되어 있음
• 동시에 처리해야 할 일이 있을 때
• CPU 성능 최대 활용
• 보다 빠르고 적은 비용
• 대기시간 및 응답시간 최소화
• 시스템 단순화

Cpp에서의 스레드

#include<iostream>
#include<thread>
using namespace std;

void func1() {
    cout<<"my func1"<<endl;
}

int main() {
    thread t(&func1);  //방법 1
    t.join();         //join()을 실행시키면 t가 종료되기 전까지 대기

    return 0;
}

• 기본 활용

// thread_ex.h
#ifndef STUDY_H
#define STUDY_H
#include <fstream>

class Operator {
protected:
    std::fstream f1;
    std::fstream f2;
public:
    Operator();
    ~Operator();
    void sum();
    void sub();
};

#endif

// thread_ex.cpp
#include <iostream>
#include <fstream>
#include <thread>
using namespace std;

#include "thread_ex.h"

Operator::Operator() { cout << "operator constructor" << endl; }
Operator::~Operator() { cout << "operator distructor" << endl; }
void Operator::sum() {
    cout << "sum() running..." << endl;
    f1.open("source.txt");
    fstream wf1("plus.txt", ios::out);

    if (f1.is_open() && wf1.is_open()) {
        while (f1) {
            int a, b;
            f1 >> a >> b;
            wf1 << a << " + " << b << " = " << a+b << endl;
        }
        wf1.close();
    } else {
        cerr << "error!" << endl;
        exit(1);
    }
    cout << "sum() shutdown..." << endl;
}
void Operator::sub() {
    f2.open("source.txt");
    cout << "sub() running..." << endl;
    fstream wf2("minus.txt", ios::out);

    if (f2.is_open() && wf2.is_open()) {
        while (f2) {
            int a, b;
            f2 >> a >> b;
            wf2 << a << " - " << b << " = " << a-b << endl;
        }
        wf2.close();
    } else {
        cerr << "error!" << endl;
        exit(1);
    }
    cout << "sub() shutdown..." << endl;
}

int main() {
    Operator o;

    thread t1(&Operator::sum, &o);
    thread t2(&Operator::sub, &o);

    t1.join();
    t2.join();

    return 0;
}

👀 [추가] 여러 가지 추가 내용들

멤버 변수 간단 초기화

class Car {
    int speed;
    int gear;
    string color;
public:
    Car(int _s, int _g, string _c) : speed(_s), gear(_g), color(_c) { }
};

상수 멤버의 초기화

class Car {
    const int MAX_SPEED;
    int speed;
public:
    Car() : MAX_SPEED(300) { }
};

객체와 연산자

int main() {
    Car c1(0, 1, "white");
    Car c2(0, 1, "red");
    c1 = c2;
    if (c1==c2) {
        cout << "true" << endl;
    } else {
        cout << "false" << endl;
    }
    return 0;
}

• 객체에 할당 연산자 = 을 사용하면 c2 객체가 가지고 있는 변수의 값이 c1으로 복사됨
• 객체 비교 시에는 == 사용

정적 멤버 함수

class Car {
    ...
public:
    static int count;    // 정적 변수의 선언

    ...
    // 정적 멤버 함수
    static int getCount() {
        return count; 
    }
};
int Car::count=0;    // 정적 변수의 정의

int main()
{
    Car c1(100, 0, "blue");     
    Car c2(0, 0, "white");     
    int n = Car::getCount();    
    cout <<"지금까지 생성된 자동차 수 = " << n << endl;
    return 0;
}