[Lecture] Cpp - Mid Summary

💻 2023년 Cpp 중간고사 대비 요점 정리

👀 [01] Cpp 시작

cpp의 객체 지향 특성

• cpp는 객체 지향 언어
• 캡슐화(Encapsulation) : 데이터를 캡슐로 싸서 외부의 접근으로부터 데이터를 보호하는 객체 지향 특성
• 클래스(Class) : cpp에서 캡슐의 역할을 함
  • 객체를 정의하는 틀
• 객체(Object) : 클래스를 사용해서 만들어진 실체(instance)
• 상속성(Inheritance) : 객체를 정의하는 클래스 사이에 상속 관계를 두어, 자식 클래스의 객체가 생성될 때 자식 클래스에 선언된 멤버뿐 아니라 부모 클래스에 선언된 멤버들도 함께 가지고 생성됨
• 다형성(Polymorphism) : 하나의 기능이 경우에 따라 서로 다르게 보이거나 다르게 작동하는 현상
  • + 연산자는 정수 덧셈이나 문자열 연결, 객체 더하기 등 피연산자에 따라 서로 다른 연산이 이루어짐 => 연산자 중복(operator overloading)
  • 같은 이름의 함수가 매개 변수의 개수나 타입이 다르면 서로 다른 함수로 인식됨 => 함수 중복(function overloading)
  • 다형성은 상속 관계에서도 나타남
    • 부모 클래스에 구현된 함수를 동일한 이름으로 자식 클래스에서 다르게 구현 => 함수 재정의 또는 함수 오버라이딩(function overriding)

👀 [02] Cpp 프로그래밍의 기본

#include

• 전처리기(cpp Preprocessor) 에 대한 지시문
  • 소스 파일 컴파일 전 헤더 파일을 읽어 소스 파일 내로 삽입할 것을 지시함
• 헤더 파일에는 cpp 표준 입출력을 위한 클래스와 객체가 선언되어 있음

화면 출력

• cout 객체
  • 스크린 장치와 연결된 cpp 표준 출력 스트림 객체(standard output stream object)
• << 연산자
  • 스트림 삽입 연산자(stream insertion operator)
  • 오른쪽 피연산자 데이터를 왼쪽 스트림 객체에 삽입
  • 본래 << 연산자는 정수를 왼쪽으로 시프트(shift) 하는 cpp의 기본 연산자임
    • 헤더 파일에서 재정의되어 사용되고 있음

namespace

• 프로젝트를 여러 명이 나누어 개발하는 경우 혹은 다른 사람이 작성한 소스 코드나 목적 파일을 가져와서 사용하는 경우 이름(identifier) 이 충돌하는 경우가 생김
• 변수, 함수, 클래스 등의 이름이 충돌하는 것을 방지하기 위해 고유한 이름 공간 namespace 키워드 도입
• 이름 공간 생성 방법 : namespace 키워드 뒤에 중괄호로 영역 지정
• :: : cpp의 표준 연산자인 범위 지정 연산자

std::

• std : cpp 표준에서 정한 표준 이름 공간
  • 모든 cpp 표준 라이브러리는 std 이름 공간에 정의되어 있음
  • std 내에 정의되어 있는 함수들을 사용하려면 std:: 접두어를 붙여서 공간을 명시해주어야 함

std::의 생략과 using 지시어

• using : 이름 공간 접두어를 생략할 수 있는 지시어
  • using std::cout : std 내에 정의되어 있는 cout 함수에 대해서만 접두어를 생략할 수 있음
  • using namespace std : std 내에 정의되어 있는 모든 함수에 대해서 접두어를 생략할 수 있음

키 입력

• cin 객체
  • 키보드와 cpp 응용 프로그램을 연결하는 cpp 표준 입력 스트림 객체(standard input stream object)
  • 키보드 입력 값들은 모두 cin 객체의 스트림 버퍼로 들어오며, 응용 프로그램은 cin 객체로부터 입력된 키 값을 받음
• >> 연산자
  • 스트림 추출 연산자(stream extracion operator)
  • 왼쪽 피연산자인 스트림 객체로부터 데이터를 읽어 오른쪽 피연산자에 지정된 변수에 삽입
  • << 연산자와 마찬가지로 정수를 시프트하는 cpp의 기본 연산자이지만 재정의되어 사용됨

👀 [03] 클래스와 객체

객체

• 스타크래프트에 등장하는 각 인물들, 테트리스 게임에 나오는 각 블록들, 한글 프로그램의 메뉴나 버튼 => 객체(object)
• 객체는 멤버 변수와 멤버 함수로 구성됨
  • 멤버 변수 : 객체의 상태(state) 를 나타내는 속성들
  • 멤버 함수 : 행동(behavior) 을 구현한 코드들
• 외부에서 객체에게 어떤 작업을 요청하거나 상태를 알고자 할 때, 객체 내에 공개된 멤버 함수를 호출함

클래스와 객체

• 클래스(class) : 객체(object) 를 정의하는 틀 혹은 설계도
  • 클래스에 멤버 변수와 멤버 함수를 선언함
• 객체는 클래스라는 틀에서 찍어내어, 멤버 변수 메모리와 멤버 함수 코드를 실제 가지고 프로그램이 실행되는 동안 실존하는 실체 또는 인스턴스(instance) 임

클래스 선언

class A {
private:
    int a;
    int b;
public:
    int get_sum() {
        return a+b;
    }
};

• 클래스 선언부(class declaration) 와 클래스 구현부(class implementation) 으로 분류
• class 키워드로 선언
• c 언어의 구조체(struct) 와 같이 개발자가 정의하는 새로운 데이터 타입임
• 선언부에서는 멤버 변수와 멤버 함수의 원형을 선언함
  • 멤버 변수 초기화 가능
• 접근 지정자(access specifier)
  • public : 클래스 외부로부터 접근 허용
  • private : 클래스 외부로부터 접근을 허용하지 않음(Default)
  • protected : 파생 클래스에게 접근을 허용하고 다른 클래스나 외부 함수에서는 접근할 수 없음
• 위와 같이 클래스 선언부에서 클래스 함수를 구현할 수는 있지만 클래스의 재사용을 위해 보통 분리하여 작성함

class A {
private:
    int a;
    int b;
public:
    int get_sum();
};

int A::get_sum() {
    return a+b;
}

• 선언부와 구현부를 분리해서 정의한 코드
• 클래스 함수 : 함수의 리턴 타입, 클래스 이름, 범위 지정 연산자, 멤버 함수명과 매개 변수

생성자

• 객체를 생성할 때 객체를 초기화할 수 있음

• 생성자(constructor) : 클래스에서 객체가 생성될 때 자동으로 실행되는 특별한 멤버 함수

  • 객체 초기화 함수

• 생성자의 특징

  • 생성자의 목적은 객체가 생성될 때 필요한 초기 작업을 위함
  • 생성자 함수는 오직 한 번만 실행됨
  • 생성자 함수의 이름은 클래스 이름과 동일하게 작성되어야 함
  • 생성자 함수의 원형에 리턴 타입을 선언하지 않아야 함
  • 생성자는 중복 가능함

• 위임 생성자(delegating constructor)

  • 기본 생성자와 매개 변수를 가지는 생성자를 따로 정의하게 되면 객체를 초기화하는 비슷한 코드가 중복됨

  Circle::Circle() : Circle(1) { }
  
  Circle::Circle(int r) {
    radius = r;
    cout << "반지름 " << radius << " 원 생성" << endl;
  }

  • 중복된 초기화 코드를 하나의 생성자로 몰고, 다른 생성자에서 이 생성자를 호출할 수 있게 함
  • 객체의 초기화 작업이 코딩된 Circle(int r) : 타겟 생성자
  • 객체의 초기화를 다른 생성자에 위임하는 Circle() : 위임 생성자

• 기본 생성자(default constructor)

  • 클래스에 선언된 어떤 생성자도 없을 때 컴파일러가 자동으로 생성해주는 생성자
  • 매개 변수가 없는 생성자
  • 자동으로 생성되는 경우
    • 생성자가 하나도 없는 클래스의 경우, 컴파일러가 보이지 않게 기본 생성자를 삽입함
  • 자동으로 생성되지 않는 경우
    • 생성자가 하나라도 선언된 클래스의 경우, 컴파일러는 기본 생성자를 자동 삽입하지 않음

소멸자

• 객체가 소멸되면 객체 메모리는 시스템으로 반환됨
• 소멸자(destructor) : 객체가 소멸되는 시점에서 자동으로 호출되는 클래스의 멤버 함수
• 소멸자의 특징
  • 소멸자의 목적은 객체가 사라질 때 필요한 마무리 작업을 위함
  • 소멸자의 이름은 클래스 이름 앞에 ~를 붙임
  • 소멸자는 리턴 타입이 없으며 어떤 값도 리턴해서도 안 됨
  • 소멸자는 오직 한 개만 존재하며 매개 변수를 가지지 않음
  • 소멸자가 선언되어 있지 않으면 기본 소멸자가 자동으로 생성됨

접근 지정

• 멤버 접근 지정자(access specifier)
  • private(비공개)
    • 접근 지정의 default
    • private 접근 지정으로 선언된 멤버는 클래스 내의 멤버 함수들에게만 접근이 허용됨
    • 멤버 변수는 private 로 지정하는 것이 바람직함
  • public(공개)
    • public 접근 지정으로 선언된 멤버는 클래스 내외를 막론하고 프로그램의 모든 함수들에게 접근이 허용됨
    • 생성자는 public 으로 지정해야 함
  • protected(보호)
    • protected 접근 지정으로 선언된 멤버는 클래스 내의 멤버 함수와 이 클래스를 상속받은 파생 클래스의 멤버 함수에게만 접근이 허용됨

👀 [04] 객체 포인터와 객체 배열, 객체의 동적 생성

객체 포인터

• Circle *p : 객체에 대한 포인터 변수 선언
  • 아무 객체도 가리키고 있지 않음
• Circle* p = &donut; : 포인터 변수에 객체 주소 지정
  • 객체의 주소는 객체 이름 앞에 & 연산자를 사용하여 표현
• d = donut.getArea(); : 객체 이름으로 멤버 접근
  • . 연산자 사용
• d = p->getArea(); : 객체 포인터로 멤버 접근
  • -> 연산자 사용
  • d = (*p).getArea(); 와 같음

동적 메모리 할당 및 반환

• c 언어에서 동적 메모리 할당 및 반환은 malloc() 과 free() 등의 표준 c 함수를 사용
• cpp에서는 new 와 delete 연산자를 이용
  • new
    • 힙(heap) 공간에서 메모리를 할당받음 => 예약어
  • delete
    • 할당받은 메모리를 힙으로 반환

[data_type] *[pointer_variable] = new [data_type];
delete [pointer_variable];

• new 와 delete 기본 형식
• new : 데이터 타입의 크기만큼 힙으로부터 메모리를 할당받고 주소를 리턴함
• delete : 포인터 변수가 가리키는 메모리를 힙으로 반환
• 힙 메모리가 부족하면 new는 NULL 을 리턴
• 동적으로 할당받지 않는 메모리를 delete 로 반환 시 오류

[data_type] *[pointer_variable] = new [data_type] [array_size];
delete [] [pointer_variable];

• 배열을 동적으로 할당받고 반환하는 new 와 delete 기본 형식
• new : 배열의 크기만한 배열을 할당받아 주소를 리턴
• delete : 포인터 변수가 가리키는 배열 메모리 반환

객체와 객체 배열의 동적 생성 및 반환

[class_name] *[pointer_variable] = new [class_name];
[class_name] *[pointer_variable] = new [class_name](constructor_parameter_list);

• new 연산자를 이용하여 객체를 동적 생성하는 구문
• new : 클래스 크기의 메모리를 할당받아 객체를 생성
  • 생성자를 호출

delete [pointer_variable];

• delete 연산자를 이용하여 포인터 변수가 가리키는 객체를 반환

[class_name] *[pointer_variable] = new [class_name] [array_size];

• new 연산자를 이용하여 객체 배열을 동적으로 생성하는 구문
  • 각 객체에 대해 기본 생성자가 호출됨

delete [] [pointer_variable];

• delete 연산자를 이용하여 동적으로 할당받은 배열을 반환

동적 할당 메모리의 반환

• 힙(heap) 은 프로그램이 실행 중에 new 를 이용하여 동적으로 할당받아 사용할 수 있는 메모리
• 대부분 운영체제에서 프로그램마다 힙이 따로 주어지기에 한 프로그램이 동적으로 많은 메모리를 할당받는 것이 다른 프로그램의 힙에 전혀 영향을 주지 않음
• 할당받은 후 필요 없게 된 메모리를 힙에 반환하지 않거나 논리적 오류로 인한 메모리 누수(memory leak) 가 발생하면 힙에 메모리가 부족하여 할당받지 못하게 됨
  • 메모리 누수(memory leak) : 동적으로 할당받은 메모리의 주소를 잃어버려 힙에 반환할 수 없을 때 발생
    • 지속적으로 발생할 경우 힙의 크기가 줄어들어 실행 중 메모리를 할당받을 수 없는 심각한 논리적 오류가 발생함

this 포인터

• this
  • 객체 자신에 대한 포인터
  • 클래스의 멤버 함수 내에서만 사용됨
  • 파이썬의 self 랑 비슷한 개념
• this 가 필요한 경우
  • 매개 변수의 이름을 멤버 변수와 동일하게 사용하는 경우
  • 객체의 멤버 함수에서 객체 자신의 주소를 리턴하는 경우
    • 연산자 중복을 구현할 때의 경우임
• this 의 제약 조건
  • 클래스의 멤버 함수에서만 사용할 수 있음
  • 멤버 함수라도 정적 멤버 함수(static member function) 는 사용할 수 없음

👀 [08] 상속

상속의 개념

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

클래스 상속과 객체

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 멤버를 모두 접근할 수 있음

👀 [추가] 다형성과 가상 함수

다형성

• 다형성(polymorphism) : 객체들의 타입이 다르면 똑같은 메시지가 전달되더라도 서로 다른 동작을 하는 것

객체 포인터의 형변환

class Shape {
protected:
    int x, y;
public:
    Shape() { cout << "Shape Constructor" << endl; }
    ~Shape() { cout << "Shape Destructor" << endl; }
    void set(int x, int y) {
        this->x = x;
        this->y = y;
    }
    void draw() {
        cout << "Shape Draw" << endl;
    }
};

class Rectangle : public Shape {
private:
    int w, h;
public:
    Rectangle() { cout << "Rectangle Constructor" << endl; }
    ~Rectangle() { cout << "Rectangle Destructor" << endl; }
    void setWidth(int w) {
        this->w = w;
    }
    void setHeight(int h) {
        this->h = h;
    }
    void draw() {
        cout << "Rectangle Draw" << endl;
    }
};

class Circle : public Shape {
private:
    int r;
public:
    void setRadius(int r) {
        this->r = r;
    }
    void draw() {
        cout << "Circle Draw" << endl;
    }
};

• 부모 클래스인 Shape와 Shape를 상속받는 자식 클래스 Rectangle과 Circle

int main() {
    Shape *ps = new Rectangle();
    ps->set(10, 10);
    ps->draw();
    delete ps;

    return 0;
}

• 상향 형변환(upcasting) : 자식 클래스 타입을 부모 클래스 타입으로 변환
  • Rectangle 객체를 Shape 포인터로 가리키고 있는데 포인터 ps는 Rectangle의 멤버 함수에 접근하지 못하며 Shape에 정의된 멤버 함수만 접근할 수 있음

// 1
int main() {
    Shape *ps = new Rectangle();
    Rectangle *pr = (Rectangle *) ps;
    pr->setHeight(10);
    pr->draw();
    delete pr;

    return 0;
}
// 2
int main() {
    Shape *ps = new Rectangle();
    ((Rectangle *)ps)->setHeight(10);
    ((Rectangle *)ps)->draw();
    delete ps;

    return 0;
}

• 하향 형변환(downcasting) : 부모 클래스 타입을 자식 클래스 타입으로 변환
  • Rectangle 객체를 Shape 포인터로 가리키고 있는 포인터 ps로 Rectangle의 멤버 함수에 접근할 수 있는 방법

가상함수

class Shape {
protected:
    int x, y;
public:
    Shape() { cout << "Shape Constructor" << endl; }
    virtual ~Shape() { cout << "Shape Destructor" << endl; }
    void set(int x, int y) {
        this->x = x;
        this->y = y;
    }
    // 가상 함수 정의
    virtual void draw() {
        cout << "Shape Draw" << endl;
    }
};

class Rectangle : public Shape {
private:
    int w, h;
public:
    Rectangle() { cout << "Rectangle Constructor" << endl; }
    ~Rectangle() { cout << "Rectangle Destructor" << endl; }
    void setWidth(int w) {
        this->w = w;
    }
    void setHeight(int h) {
        this->h = h;
    }
    // 재정의(오버라이딩)
    void draw() {
        cout << "Rectangle Draw" << endl;
    }
};

• 부모 클래스인 Shape와 Shape를 상속받는 자식 클래스 Rectangle
• Shape의 draw 함수는 가상 함수로 정의되었으며 Rectangle에서 재정의

int main() {
    Shape *ps = new Rectangle();
    ps->draw();
    delete ps;

    return 0;
}

• Shape의 draw 함수가 아닌 재정의된 Rectangle의 draw 함수가 실행됨

바인딩

• 정적 바인딩(static binding) : 컴파일 단계에서 모든 바인딩이 완료되는 것
  • 컴파일 시간에 호출 함수가 결정됨
  • 속도가 빠름
  • 일반 함수 대상
• 동적 바인딩(dynamic binding) 혹은 지연 바인딩(late binding) : 바인딩이 실행 시까지 연기되고 실행 시간에 실제 호출되는 함수를 결정하는 것
  • 실행 시간에 호출 함수가 결정됨
  • 속도가 느림
  • 가상 함수 대상

참조자와 가상 함수

• 참조자도 포인터와 마찬가지로 모든 것이 동일하게 적용됨
• 부모 클래스의 참조자로 자식 클래스를 가리킬 수 있으며 가상 함수의 동작도 동일함

가상 소멸자

• 다형성을 사용하는 과정에서 소멸자를 가상 함수화 해주지 않으면 메모리 누수 발생
• 소멸자를 가상 함수로 선언하면 부모 클래스의 소멸자 실행 중 동적 바인딩에 의해 자식 클래스의 소멸자에 대한 호출로 변하게 됨
  • 자식 클래스의 소멸자는 자신이 실행된 후 부모 클래스의 소멸자를 호출하도록 컴파일되기 때문에 부모 클래스와 자식 클래스의 소멸자가 모두 순서대로 실행됨

순수 가상 함수

• 순수 가상 함수(pure virtual function) : 함수 헤더만 존재하고 함수의 몸체는 없는 함수
  • virtual [return_type] [function_name]([parameters]) = 0;

추상 클래스

• 추상 클래스(abstract class) : 순수 가상 함수를 가지고 있는 클래스
  • 추상적인 개념을 표현하는데 적당함