JEVLOG

다중 상속과 가상 상속

gyunnnnnn — Fri, 27 Jan 2023 20:06:44 +0900

멤버 함수와 가상 함수의 동작 원리

객체가 생성되면 멤버 변수는 객체 내에 존재한다.
멤버 함수는 메모리의 한 공간에 별도로 위치하고 이 함수가 정의된 클래스의 모든 객체가 이를 공유하는 형태를 취한다.
한 개 이상의 가상 함수를 포함하는 클래스에 대해서는 컴파일러가 가상 함수 테이블을 만든다.
가상 함수 테이블은 객체의 생성과 상관없이 main 함수가 호출되기전 메모리 공간에 할당된다.
가상 함수 테이블은 호출되어야 할 함수의 위치정보를 담고 있는 테이블이다.

class A
{
public:
    virtual void Func() { cout << "A" << endl; }
};

class B : public A
{
public:
    void Func() { cout << "B" << endl; }
};

int main()
{
    A* a = new A();
    a->Func(); // 결과는 A
    A* b = new B();
    b->Func(); // 결과는 B
    return 0;
}

A <- B 구조에서 B 클래스의 가상 함수 테이블을 살펴보면, 오버 라이딩된 A클래스의 Func 함수에 대한 정보가 없다.
- 가상 함수의 호출 원리로 b의 Func 함수를 호출하면 B클래스의 Func 함수가 호출된다.

다중 상속

class A
{
public:
    void Func() { }
};

class B
{
public:
    void Func() { }
};

class C : public A, public B
{
public:
    void Call Func() 
    {
        Func(); // 모호성 존재
        A::Func();
        B::Func();
    }
};

어느 클래스에 선언된 멤버에 접근을 하는지에 대해 모호성이 존재한다.
A, B 클래스가 같은 이름의 함수를 가지고 있다면 A::Func();, B::Func();로 클래스를 명시해야 한다.

가상 상속

class Base
{
public:
    Base() { cout << "Base Constructor" << endl; }
    void BaseFunc() { cout << "Base" << endl; }
};

class Middle1 : virtual public Base
{
public:
    Middle1() : Base() { cout << "Middle1 Constructor" << endl; }
    void Middle1Func()
    {
        BaseFunc();
        cout << "Middle1" << endl;
    }
};

class Middle2 : virtual public Base
{
public:
    Middle2() : Base() { cout << "Middle2 Constructor" << endl;  }
    void Middle2Func()
    {
        BaseFunc();
        cout << "Middle2" << endl;
    }
};

class Last : public Middle1, public Middle2
{
public:
    Last() : Middle1(), Middle2() { cout << "Last Constructor" << endl; }
    void LastFunc()
    {
        Middle1Func();
        Middle2Func();
        BaseFunc();
    }
};

int main()
{
    Last last;
    last.LastFunc();
    return 0;
}

다중 상속을 하면 last 생성 시 base 생성자가 두 번 호출된다.
Middle1, Middle2에서 가상 상속을 통해 가상 상속을 하면 base 생성자가 한 번만 호출되도록 할 수 있다.

가상 함수

gyunnnnnn — Mon, 16 Jan 2023 20:03:42 +0900

객체 포인터의 참조 관계

객체 포인터 변수

객체의 주소 값을 저장하는 포인터 변수

Person * ptr = new Person();

A형 포인터 변수는 A객체 또는 A를 직접 혹은 간접적으로 상속하는 모든 객체를 가리킬 수 있다.

class Person{};
class Student : public Person{};
class PartTimeStudent : public Student{};
Person * ptr1 = new Student(); // Person형 포인터 변수 ptr
Person * ptr2 = new PartTimeStudent(); // Person형 포인터 변수 ptr
Student * ptr3 = new PartTimeStudent(); // Student형 포인터 변수 ptr

위와 같이 Person형 포인터는 Person 객체뿐만 아니라, Person을 상속하는 파생 클래스의 객체도 가리킬 수 있다.

각 객체 포인터에 대한 참조 가능 여부

함수 오버 라이딩

파생 클래스와 기본 클래스에서 동일한 이름과 형태로 두 함수를 정의하는 것
오버 라이딩된 기본 클래스의 함수는 오버 라이딩을 한 파생 클래스의 함수에 가려진다.

오버 로딩 vs 오버 라이딩

오버 로딩

같은 클래스 내에서 같은 이름의 메서드를 사용하는 것

오버 라이딩

기본 클래스에서 정의한 메서드를 파생 클래스에서 변경하는 것

가상 함수

C++ 컴파일러는 포인터 연산의 가능성 여부를 판단할 때 선언한 포인터의 자료형을 기준으로 판단하지, 실제 가리키는 객체의 자료형을 기준으로 판단하지 않는다.

// 컴파일 성공
// 포인터는 Base
Base * bptr = new Derived(); 

// 컴파일 에러
Derived * dptr = bptr; 

// 컴파일 에러
// bptr 포인터는 Base이기 때문에 Derived에 있는 함수는 호출할 수 없다.
bptr -> DerivedFunc() 

// 컴파일 성공
Derived * dptr = new Derived();

// 컴파일 성공
Base * bptr = dptr;

virtual

virtual 키워드는 함수에 붙일 수 있다. 부모가 자식을 가리켜 자식에서 새롭게 정의된 기능을 쓸 수 있다.
virtual 키워드는 오버 라이딩을 성립할 수 있게 해 주어 다형성을 구현하는 핵심 역할을 한다.
가상 함수 포인터로 인해 클래스 크기에 4Byte가 더 들어간다.(32비트 컴퓨터 기준)
memset으로 객체를 초기화하면 가상 함수 테이블 정보까지 같이 초기화 된다.
virtual 키워드를 사용해 가상 함수로 선언되면, 해당 함수 호출 시 포인터의 자료형을 기반으로 호출 대상을 결정하지 않고, 포인터 변수가 실제로 가리키는 객체를 참조하여 호출의 대상을 결정한다.

class A
{
public:
    int a;
    virtual void func()
    {
        cout << "A" << endl;
    }
};

class B : public A
{
public:
    int a;
    virtual void func()
    {
        cout << "B" << endl;
    }
};

class C : public B
{
public:
    int a;
    virtual void func()
    {
        cout << "C" << endl;
    }
};

int main()
{
    A* a = new A;
    A* b = new B;
    A* c = new C;

    a->func();
    b->func();
    c->func();

    cout << sizeof(a) << " " << sizeof(b) << " " << sizeof(c) << endl; // 4,4,4
    cout << sizeof(A) << " " << sizeof(B) << " " << sizeof(C) << endl; // 8,12,16
}

실행 결과 : A B C
virtual 선언이 안 되어 있다면 A A A로 출력된다.

다형성

모습은 같은데 형태는 다르다 = 문장은 같은데 결과는 다르다.
- 참조하는 객체의 자료형이 다르기 때문이다.
이름이 같은 함수여도 참조하는 객체에 따라서 결과가 다르다.

순수 가상 함수

함수의 몸체가 정의되지 않은 함수
0의 대입을 통해 표현한다.
잘못된 객체 생성을 막는 용도로 사용한다.
```
virtual int AbstractFunc() = 0; // 순수 가상함수
```

추상 클래스

하나 이상의 멤버 함수를 순수 가상 함수로 선언한 클래스를 추상 클래스라 한다.
추상 클래스는 객체 생성이 불가능한 클래스라는 의미를 지닌다.

가상 소멸자

맨 위에 존재하는 기본 클래스의 소멸자만 virtual로 선언하면 이를 상속하는 파생 클래스의 소멸자들도 모두 가상 소멸자로 선언이 된다.
가상 소멸자가 호출되면, 상속의 계층구조상 맨 아래에 존재하는 파생 클래스의 소멸자가 대신 호출된다.
파생 클래스 -> 기본 클래스의 순으로 소멸자가 호출된다.

class First
{
public:
    string strOne;
    First(string str) : strOne(str){}
    virtual ~First()
    {
        cout << "~First()" << endl;
    }
};

class Second : public First
{
public:
    string strTwo;
    Second(string str1, string str2) : First(str1), strTwo(str2) {}
    ~Second()
    {
        cout << "~Second()" << endl;
    }
};

First * ptr1 = new Second("simple", "complex");
delete ptr1;

Second * ptr2 = new Second("simple", "complex");
delete ptr2;

모두 ~Second() -> ~First() 순으로 소멸자가 호출된다.
소멸자에 virtual 선언이 없다면 1에서는 ~First()만 호출이 된다.

C++에서 상속에 대해 정리

gyunnnnnn — Fri, 13 Jan 2023 20:11:15 +0900

상속이란?

기존에 정의해 놓은 클래스의 재활용을 목적으로 만들어진 문법적 요소이다.
```
class Base{};
class Derived : public Base{};
```

상속받은 클래스(파생 클래스)의 생성자 정의

파생 클래스의 객체 생성 과정에서 기초 클래스의 생성자는 무조건 호출된다.
파생 클래스의 생성자는 기초 클래스의 멤버까지 초기화 할 의무가 있다.
파생 클래스의 생성자는 기초 클래스의 생성자를 호출해서 부모 클래스의 멤버를 초기화 하는 것이 좋다.
파생 클래스의 생성자에서 기초 클래스의 생성자 호출을 명시하지 않으면, 기초 클래스의 void 생성자가 호출된다.
접근 제한의 기준은 클래스이므로 상속받은 private 변수는 그 클래스의 public 함수를 통해서 간접적으로 접근을 해야한다.

파생 클래스의 객체 생성과정

메모리 공간 할당
파생 클래스의 생성자 호출
기초 클래스의 생성자 호출
기초 클래스의 생성자 실행
파생 클래스의 생성자 실행
객체 생성 완료

파생 클래스 객체의 소멸과정

파생 클래스의 객체가 소멸될 때는, 파생 클래스의 소멸자가 실행되고 기초 클래스의 소멸자가 실행된다.
소멸자에선 자신의 생성자에서 할당한 메모리 공간에 대한 해제만을 책임진다.
스택에 생성된 객체의 소멸순서는 생성순서와 반대이다.

세 가지 형태의 상속

public 상속

public으로 선언된 멤버변수는 모든 클래스에서 접근이 가능하다.

protected 상속

protected로 선언된 멤버변수는 이를 상속하는 파생 클래스에서 접근이 가능하다.

private 상속

private로 선언된 멤버변수는 접근이 불가능하다.
A <- B <- C 관계에서 B를 private상속하면 C가 B를 public으로 상속받아도 B의 멤버변수에 접근이 불가능하다.

상속을 위한 조건

상속을 위한 기본 조건으로는 IS-A 관계의 성립이 있다.
HAS-A 관계도 상속의 조건은 되지만 객체 합성으로 이를 대신하는 것이 일반적이다.
상속을 통해 연관된 일련의 클래스에 대해 공통적인 규약을 정의할 수 있다.

백준 17143. 낚시왕

gyunnnnnn — Tue, 6 Dec 2022 11:35:59 +0900

17143. 낚시왕

문제에서 주어진대로 진행하는 시뮬레이션 문제이다.
정렬을 편하게 하기 위해 상어 구조체를 만들고 크기순, 번호순으로 정렬하기 위한 compare함수를 선언하였다.

풀이 과정

낚시왕이 오른쪽으로 한 칸 이동한다.
낚시왕이 있는 열에 있는 상어 중에서 가장 땅과 가까운 상어를 잡는다. 이때, 상어를 잡으면 잡힌 상어는 격자판에서 사라진다.
상어를 이동시킨다.
1~3과정을 낚시왕이 맨 끝 자리로 이동할때까지 반복한다.

소스코드

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int dx[] = { 0,-1,1,0,0 };
int dy[] = { 0,0,0,1,-1 };
int ans;
int map[101][101];
int curDir;
int moveCount;
int alives[10001];
struct shark
{
    int r; // 1~R
    int c; // 1~C
    int s; // 속력 0~1000
    int d; // 방향 1~4
    int z; // 크기 1~10000
    int idx; // 상어 번호
};
// 크기순 정렬
bool compare(shark& a, shark& b)
{
    return a.z < b.z;
}
// 번호순 정렬
bool compare2(shark& a, shark& b)
{
    return a.idx < b.idx;
}
int main()
{
    vector<shark> sharks;
    int r, c, m;
    cin >> r >> c >> m;
    for (int i = 1; i <= m; i++)
    {
        int r, c, s, d, z;
        cin >> r >> c >> s >> d >> z;
        sharks.push_back({ r,c,s,d,z,i });
        map[r][c] = i;
        alives[i] = 1;
    }
    // 낚시왕의 위치
    int cnt = 0;
    while (cnt < c)
    {
        // 번호순 정렬
        sort(sharks.begin(), sharks.end(), compare2);
        // 1.낚시왕이 오른쪽으로 한 칸 이동한다.
        cnt++;
        // 2. 낚시왕이 있는 열에 있는 상어 중에서 가장 땅과 가까운 상어를 잡는다.
        // 상어를 잡으면 격자판에서 잡은 상어가 사라진다.
        for (int i = 1; i <= r; i++)
        {
            if (map[i][cnt] != 0)
            {
                // 잡은 상어는 alive[i]를 0으로 하고 상어 크기를 답에 더함
                alives[map[i][cnt]] = 0;
                ans += sharks[map[i][cnt] - 1].z;
                map[i][cnt] = 0;
                break;
            }
        }
        // 상어 크기순 정렬
        sort(sharks.begin(), sharks.end(), compare);
        // 3. 상어가 이동한다.
        for (int i = 0; i < sharks.size(); i++)
        {
            if (alives[sharks[i].idx] == 1)
            {
                // 현재 상어의 위치에 저장된 값이 자기자신이면 0으로 바꿔줌
                // 아니면 자기보다 크기가 작은 상어가 자신 위치에 온것이므로 내둔다.
                if (map[sharks[i].r][sharks[i].c] == sharks[i].idx)
                {
                    map[sharks[i].r][sharks[i].c] = 0;
                }
                int movement = sharks[i].s;
                // 방향에 맞게 상어 이동시키기
                switch (sharks[i].d)
                {
                    // 위,아래방향일땐 r-1 *2 시간마다 같은 위치
                case 1:
                    movement %= ((r - 1) * 2);
                    curDir = 1;
                    moveCount = 0;
                    while (moveCount < movement)
                    {
                        if (sharks[i].r == 1)
                        {
                            curDir = 2;
                        }
                        else if (sharks[i].r == r)
                        {
                            curDir = 1;
                        }
                        sharks[i].r += dx[curDir];
                        moveCount++;
                    }
                    sharks[i].d = curDir;
                    map[sharks[i].r][sharks[i].c] = sharks[i].idx;
                    break;
                case 2:
                    movement %= ((r - 1) * 2);
                    curDir = 2;
                    moveCount = 0;
                    while (moveCount < movement)
                    {
                        if (sharks[i].r == 1)
                        {
                            curDir = 2;
                        }
                        else if (sharks[i].r == r)
                        {
                            curDir = 1;
                        }
                        sharks[i].r += dx[curDir];
                        moveCount++;
                    }
                    sharks[i].d = curDir;
                    map[sharks[i].r][sharks[i].c] = sharks[i].idx;
                    break;
                    // 좌, 우 방향일땐 c-1*2 시간마다 같은 위치
                case 3:
                    movement %= ((c - 1) * 2);
                    curDir = 3;
                    moveCount = 0;
                    while (moveCount < movement)
                    {
                        if (sharks[i].c == 1)
                        {
                            curDir = 3;
                        }
                        else if (sharks[i].c == c)
                        {
                            curDir = 4;
                        }
                        sharks[i].c += dy[curDir];
                        moveCount++;
                    }
                    sharks[i].d = curDir;
                    map[sharks[i].r][sharks[i].c] = sharks[i].idx;
                    break;
                case 4:
                    movement %= ((c - 1) * 2);
                    curDir = 4;
                    moveCount = 0;
                    while (moveCount < movement)
                    {
                        if (sharks[i].c == 1)
                        {
                            curDir = 3;
                        }
                        else if (sharks[i].c == c)
                        {
                            curDir = 4;
                        }
                        sharks[i].c += dy[curDir];
                        moveCount++;
                    }
                    sharks[i].d = curDir;
                    map[sharks[i].r][sharks[i].c] = sharks[i].idx;
                    break;
                }
            }
        }
        // 맵에 0이 아닌 상어 번호가 있다면 alives의 값 증가
        for (int i = 1; i <= r; i++)
        {
            for (int j = 1; j <= c; j++)
            {
                if (map[i][j] != 0)
                {
                    alives[map[i][j]]++;
                }
            }
        }
        // alives의 모든 값을 1을 빼서 0또는 1로 만든다.
        for (int i = 0; i <= m; i++)
        {
            alives[i]--;
        }
    }
    cout << ans << endl;
    return 0;
}

전체 소스 코드

자료구조 List에 대한 설명과 구현

gyunnnnnn — Mon, 5 Dec 2022 10:34:13 +0900

리스트란?

각각의 데이터가 자신의 다음 데이터(또는 이전, 다음 데이터 모두)의 위치를 가지고 있는 자료구조
데이터가 메모리에서 연속적으로 위치하고 있지는 않다.

리스트 종류

Singly Linked List - 데이터가 자신의 다음 데이터의 위치만 가지고 있다.
Double Linked List - 데이터가 자신의 이전과 다음 데이터의 위치를 가지고 있다.
Circular Linked List - 마지막 데이터가 처음 데이터의 위치를 가지고 있다.

리스트 연산의 시간 복잡도

데이터를 추가(임의의 위치) - O(1)
데이터를 제거(임의의 위치) - O(1)
데이터 확인/변경 - O(N)

리스트 구현(Singly Linked List)

#include<iostream>

using namespace std;

template<class T>
class Node
{
private:
    T data; // 데이터
public:
    Node<T> * nextNode; // 다음 노드를 가리키는 포인터
    T GetData()
    {
        return data;
    }
    Node(int k) : data(k), nextNode(NULL) {}
};

// 노드 추가
template<class T>
void AppendNode(Node<T>** Head, Node<T>* NewNode)
{
    if ((*Head) == NULL)
    {
        *Head = NewNode;
    }
    else
    {
        Node<T>* Tail = (*Head);
        while (Tail->nextNode != NULL)
        {
            Tail = Tail->nextNode;
        }
        Tail->nextNode = NewNode;
    }
}

// 노드 위치 반환
template<class T>
Node<T>* GetNodeAt(Node<T>* Head, int location)
{
    Node<T>* current = Head;
    while (current != NULL && (--location) >= 0)
    {
        current = current->nextNode;
    }
    return current;
}

// 노드 삭제
template<class T>
void RemoveNode(Node<T>** Head, Node<T>* Remove)
{
    if (*Head == Remove)
    {
        *Head = Remove->nextNode;
    }
    else
    {
        Node* Current = *Head;
        //처음부터 지우려는 노드의 이전 노드까지 순회
        while (Current != NULL && Current->nextNode != Remove) 
        {
            Current = Current->nextNode;
        }
        if (Current != NULL)
        {
            Current->nextNode = Remove->nextNode;
        }
    }
}

// 노드 삽입
template<class T>
void InsertNode(Node<T>* Current, Node<T>* NewNode)
{
    NewNode->nextNode = Current->nextNode;
    Current->nextNode = NewNode;
}

// 노드 갯수 반환
template<class T>
int GetNodeCount(Node<T>* Head)
{
    int count = 0;
    Node<T>* Current = Head;
    while (Current != NULL)
    {
        Current = Current->nextNode;
        count++;
    }
    return count;
}

백준 17135. 캐슬 디펜스

gyunnnnnn — Mon, 28 Nov 2022 18:41:46 +0900

17135. 캐슬 디펜스

브루트포스 + 시뮬레이션 문제였다.
문제에 써있는 내용대로 궁수 3명의 위치를 선택 후 시뮬레이션을 진행하여 풀면 된다.

풀이 과정

궁수 3명의 위치를 선택한다. (go 함수)
적을 공격하고 적이 이동하도록 시뮬레이션해준다. (Simulate 함수)
1. 궁수는 자신으로부터 거리가 D이하인 적 중에서 가장 가까운 적을 공격한다.
2. 거리가 가까운 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다.
모든 적이 맨 아래로 이동하여 제외될때까지 반복한다.
1~3 과정을 반복한다.

소스코드

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

int map[16][16];
int n, m, d;
int ch[3];
int ans;
int endLine=-1; // 최초 상태에 적이 있는 가장 높은 곳
vector<pair<int, int>> shotPos; // 궁수가 쏜 좌표를 모아논곳

// 두점의 거리를 구하는 함수
int GetDistance(int x1, int y1, int x2, int y2)
{
    int x = x1 - x2 > 0 ? x1 - x2 : x2 - x1;
    int y = y1 - y2 > 0 ? y1 - y2 : y2 - y1;
    return x + y;
}

void Simulate()
{
    int cnt = 0;
    int sum = 0;
    // 맵 복사
    int tmpMap[16][16];
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            tmpMap[i][j] = map[i][j];
        }
    }

    // 맨 위의 적이 다 내려올때까지 반복
    while (cnt< endLine)
    {
        shotPos.clear();
        // 궁수가 먼저 공격
        for (int i = 0; i < 3; i++)
        {
            int shotX = 20;
            int shotY = 20;
            int tmpDist = d;
            for (int j = n - 1; j >= 0; j--)
            {
                for (int k = 0; k < m; k++)
                {
                    // 거리가 작으면 무조건 선택
                    if (tmpMap[j][k] == 1 && 
                        GetDistance(j, k, n, ch[i]) < tmpDist)
                    {
                        tmpDist = GetDistance(j, k, n, ch[i]);
                        shotX = j;
                        shotY = k;
                    }
                    // 거리가 같을땐 가장 왼쪽
                    else if (tmpMap[j][k] == 1 && 
                            GetDistance(j, k, n, ch[i]) == tmpDist)
                    {
                        if (k < shotY)
                        {
                            shotX = j;
                            shotY = k;
                        }
                    }
                }
            }
            // 궁수가 쏜 위치가 갱신되어있는 상태라면 추가
            if (shotX != 20 && shotY != 20)
            {
                shotPos.push_back({ shotX,shotY });
            }
        }

        // 궁수가 쏜 포지션들에 대해 반복
        for (int i = 0; i < shotPos.size(); i++)
        {
            // 중복된 지점을 쐈을땐 1만 증가해야하므로 아래 조건 추가
            if (tmpMap[shotPos[i].first][shotPos[i].second] == 1)
            {
                tmpMap[shotPos[i].first][shotPos[i].second] = 0;
                sum++;
            }

        }

        // 적 이동
        for (int i = n-1; i >=1; i--)
        {
            for (int j = 0; j < m; j++)
            {
                tmpMap[i][j] = tmpMap[i - 1][j];
            }
        }
        for (int i = 0; i < m; i++)
        {
            tmpMap[0][i] = 0;
        }
        cnt++;
    }

    // 최댓값이라면 갱신
    ans = max(ans, sum);
}

// 궁수 3명을 놓을 위치 선택
void go(int cnt,int idx)
{
    if (cnt == 3)
    {
        Simulate();
        return;
    }

    for (int i = idx; i < m; i++)
    {
        ch[cnt] = i;
        go(cnt + 1, i + 1);
    }
}

int main()
{
    cin >> n >> m >> d;

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> map[i][j];
            if (map[i][j] == 1 && endLine==-1)
            {
                endLine = n-i;
            }
        }
    }

    go(0,0);
    cout << ans << endl;
    return 0;
}

전체 소스 코드

const, friend, static, mutable, explicit

gyunnnnnn — Sun, 27 Nov 2022 00:13:57 +0900

const

const는 값을 상수로 선언할 수 있도록 도와주는 키워드다.
const를 앞에 붙이면 값은 변경할 수 없게 된다.
const의 선언 유무도 함수 오버로딩 조건에 해당이 된다.

class Test
{
public:
    void Func() { }
    void Func() const { }
};

객체도 상수화 할 수 있다.
이 객체를 대상으로는 const 멤버 함수의 호출만 허용한다.

class SoSimple
{
private:
    int num;
public;
    SoSimple(int n) : num(n){ } // 생성자
    SoSimple& NotConstFunc(int n)
    {
        num+=n;
    }
    void ConstFunc() const // const 함수
    {
        cout << " Func() " << endl;
    }
};

const SoSimple sim(20);
sim.NotConstFunc(); // 불가능
sim.ConstFunc(); // 가능

friend

A 클래스가 B 클래스를 대상으로 friend 선언을 하면,
B 클래스는 A 클래스의 private 멤버에 직접 접근이 가능하다.

class A
{
private:
    int num;
    friend class B;
};

class B
{
public:
    void Func(A &a)
    {
        cout<<" a's num : " << a.num << endl; // private 멤버에 접근 가능
    }
};

B에서 A의 private변수에 접근이 가능하다.
friend 선언은 정보은닉을 무너뜨리는 문법이다.
- 필요한 상황에서만 사용해야 한다.
전역 함수, 클래스의 멤버 함수를 대상으로도 friend 선언이 가능하다.
함수에 대해 friend 선언을 해도 기본 함수 원형의 선언이 포함된다.

static

C에서의 static

전역 변수에 선언
- 선언된 파일 내에서만 참조를 허용하겠다는 의미
함수 내에 선언
- 한 번만 초기화된다.
- 지역변수와 달리 함수를 빠져나가도 소멸되지 않는다.

const static 멤버

선언과 동시에 초기화가 가능하다.

class First
{
public:
    const static int CNT = 0;
};
cout << First::CNT << endl; // 이름을 통해 접근한다.

static 멤버 변수(클래스 변수)

static 변수를 생성자에서 초기화하면 안 된다.
- 객체가 생성될 때마다 변수가 초기화되기 때문이다.
전역 변수로 변수를 선언 시 어디서든 접근할 수 있는데 이걸 제한할 수 있다.
static 멤버에 접근할 때에는 (클래스::변수)로 접근하는 것이 좋다.
- 멤버 변수에 접근하는 것 같은 오해를 없애기 위해서이다.

선언된 클래스의 모든 객체가 공유한다.
public으로 선언이 되면, 클래스의 이름을 이용해서 호출이 가능하다.
객체의 멤버로 존재하는 것이 아니다.

class First
{
private:
    static int num;
};

int First::num = 0;

static 멤버 함수

static 멤버 함수 내에서는 static 멤버 변수와 static 멤버 함수만 호출이 가능하다.
객체 생성과 아무런 관계가 없다.
선언된 클래스의 모든 객체가 공유한다.
객체의 멤버로 존재하는 것이 아니다.

mutable

const 함수 내에서의 값의 변경을 예외적으로 허용한다.
mutable의 과도한 사용은 const의 선언을 의미 없게 만들어버린다.

mutable int num2;
void CopyToNum2() const
{
    num2 = num1;
}

explicit

암시적 변환을 막아준다.
대입 연산자를 이용한 객체의 생성 및 초기화는 불가능하다.

explicit SoSimple(const SoSimple &copy) : num1(copy.num1), num2(copy.num2){}
SoSimple sim2 = sim1; // 에러! 암시적 변환 불가능
SoSimple sim2(sim1); // 가능

Stack

gyunnnnnn — Sat, 26 Nov 2022 21:11:53 +0900

Stack

나중에 들어간 데이터가 제일 먼저 나오는 LIFO(Last In First Out) 구조
특정 위치(한쪽 끝)에서만 데이터를 넣거나 뺼 수 있다.

Stack 연산의 시간복잡도

데이터를 추가(push) -> O(1)
데이터를 제거(pop) -> O(1)
제일 꼭대기의 데이터를 확인(top) -> O(1)

Stack 응용 사례

수식의 괄호 쌍
후위 표기법
DFS

Stack 구현

template<class T>
class Stack
{
private:
    int* stack;
    int size, top;
public:
    Stack<T>(int size) : size(size), top(-1)
    {
        stack = new T[size];
    }
    ~Stack<T>()
    {
        delete stack;
    }
    // 데이터 삽입
    bool Push(T data)
    {
        if (top < size - 1)
        {
            top++;
            stack[top] = data;
            return true;
        }
        else
        {
            return false;
        }
    }
    // 데이터 제거
    T Pop()
    {
        if (top >= 0)
        {
            return stack[top--];
        }
        else
        {
            return -1;
        }
    }
    // 맨 위 데이터 반환
    T Top()
    {
        return stack[top];
    }
    // 스택이 비었는지 확인
    bool IsEmpty()
    {
        return top == -1;
    }
};

위상 정렬

gyunnnnnn — Fri, 25 Nov 2022 13:05:22 +0900

TopologySort(위상정렬)

TopologySort란?

순서가 정해져있는 작업을 수행해야 할 때 그 순서를 정하기 위해 사용하는 정렬 알고리즘이다.
DAG(Directed Acyclic Graph : 사이클이 없는 방향 그래프)에만 적용이 가능하다.
정렬의 결과는 여러가지가 나올 수 있다.

TopologySort의 시간 복잡도

시간 복잡도 : O(V+E) (정점의 개수 + 간선의 개수)

TopologySort의 구현

진입차수가 0인 정점을 큐에 삽입한다.
큐에서 원소를 꺼내 연결된 모든 간선을 제거한다.
간선 제거 후에 진입차수(특정한 노드가 있을때 그 노드로 들어오는 다른 노드의 개수)가 0이 된 정점을 큐에 삽입한다.
큐가 빌 때까지 2~3의 과정을 반복한다.

모든 원소를 방문하기 전에 큐가 비었다면 사이클이 존재하는 것이다.
모든 원소를 방문하고 큐가 비었다면 큐에서 꺼낸 순서가 정렬의 결과가 된다.

소스코드

#include<vector>
#include<queue>

using namespace std;

vector<int> result;
// 인자 : 간선 모음, 진입차수 배열, 크기
void topologySort(vector<vector<int>>& a, vector<int>& inDegree, int size)
{
    queue<int> q;
    // 진입 차수가 0인 노드를 큐에 삽입
    for (int i = 0; i < size; i++)
    {
        if (inDegree[i] == 0)
        {
            q.push(i);
        }
    }
    // 모든 노드 반복
    for (int i = 0; i < size; i++)
    {
        // n개를 방문하기 전에 큐가 빈다면 사이클 발생
        if (q.empty())
        {
            return;
        }
        int front = q.front();
        q.pop();
        result.push_back(front);
        for (int i = 0; i < a[front].size(); i++)
        {
            int x = a[front][i];
            // 새롭게 진입차수가 0이 된 정점을 큐에 삽입
            if (--inDegree[x] == 0)
            {
                q.push(x);
            }
        }
    }
}

스택으로 큐 구현하기 / 큐로 스택 구현하기

gyunnnnnn — Fri, 25 Nov 2022 10:02:48 +0900

스택과 큐의 상호 구현

면접 보면서 정말 많이 받은 질문 중 하나이다.
처음 질문받았을 때 어버버 하면서 아무것도 대답 못했던 기억이 있고 두 번째 받았을 땐 자신 있게 작성하다 틀린 기억이 있는 부끄러운 기억이 있다.

스택으로 큐 구현하기

이론은 간단하다. 2개의 스택을 이용해서 구현하면 된다.

Enqueue(삽입)

그냥 첫 번째 스택인 a에 추가만 하면 된다.

Dequeue(제거)

두 번째 스택인 b가 비어있지 않다면 b에 있는 값을 제거(반환) 하면 된다.
두 번째 스택인 b가 비었다면 첫 번째 스택인 a가 빌 때까지 a를 pop(제거)하면서 두 번째 스택인 b에 push(추가) 한다.

class StackQueue
{
public:
    stack<int> a;
    stack<int> b;
    void Enqueue(int data)
    {
        a.push(data);
    }
    int Dequeue()
    {
        if (b.empty())
        {
            while (!a.empty())
            {
                b.push(a.top());
                a.pop();
            }
        }
        int data = b.top();
        b.pop();
        return data;
    }
};

큐로 스택 구현하기

큐로 스택을 구현하는 경우에도 큐 2개를 이용하면 스택을 구현할 수 있다.

#include<queue>
using namespace std;
class QueueStack
{
public:
    queue<int> a;
    queue<int> b;
    void Push(int data)
    {
        if (a.empty())
        {
            a.push(data);
        }
        else
        {
            while (!a.empty())
            {
                b.push(a.front());
                a.pop();
            }
            a.push(data);
            while (!b.empty())
            {
                a.push(b.front());
                b.pop();
            }
        }
    }
    int Pop()
    {
        int data = a.front();
        a.pop();
        return data;
    }
};