코딩시러

오늘 수업때 인접리스트로 DFS구현을 해보라 하셨는데 뭔가 생각한대로 잘되서 기분이가 좋았음

#include <iostream>
#include <vector>

using namespace std;

void 재귀(int start, const vector<vector<int>>& edges, vector<bool>& visited)
{
    if (visited[start]) return;
    visited[start] = true;
    cout << start << ", ";
    for (int i = 0; i < edges[start].size(); i++)
    {
        재귀(edges[start][i], edges, visited);
    }
}

void DFS(int start, const vector<vector<int>>& edges)
{
    vector<bool> visited(edges.size(), false);
    재귀(start, edges, visited);
}

int main()
{
    vector<vector<int>> edges;
    edges.push_back({ 1, 2 });      //0
    edges.push_back({ 3, 6, 7 });   //1
    edges.push_back({ 4, 5 });      //2
    edges.push_back({ 6, 7 });      //3
    edges.push_back({ 8, 9 });      //4 
    edges.push_back({ 10, 11 });    //5
    edges.push_back({ });           //6
    edges.push_back({ });           //7
    edges.push_back({ });           //8
    edges.push_back({ });           //9
    edges.push_back({ });           //10
    edges.push_back({ });           //11

    cout << "DFS: ";
    DFS(0, edges);
    cout << endl;

    return 0;
}

근데 실수로 무향그래프인데 단방향그래프라 생각하고 짜버림 그리고 너무 쉽게 생겨먹음

그래서 좀 이상한 무방향그래프를 가져와봄

된다 ㅋㅋ 기모띠 기분 굿 나이스입니다 좋은 하루 되세요~

하이염

한국인을 위한 코드 미리보기부터 가겠습니다.

#include <iostream>

class Complex
{
private:
	int real;
	int image;
public:
	Complex(int r = 0, int i = 0) : real(r), image(i) {}
	~Complex() = default;

	Complex operator+(const Complex& _val)
	{
		return Complex(real + _val.real, image + _val.image);
	}
	Complex operator-(const Complex& _val)
	{
		return Complex(real - _val.real, image - _val.image);
	}
	Complex operator++()
	{
		return Complex(++real, ++image);
	}
	Complex operator++(int)
	{
		return Complex (real++, image++);
	}
	friend std::ostream& operator<< (std::ostream& _os, const Complex& _class);
};

std::ostream& operator<< (std::ostream& _os, const Complex& _class)
{
	_os << _class.real << " + " << _class.image << "i" << '\n';
	return _os; // 뒤로 연계할 수 있도록 cout을 계속 연결해준다.
}


int main()
{
	Complex x(10, 20), y(20,40);
	Complex z;

	std::cout << x;
	std::cout << y;

	std::cout << x++;
	std::cout << ++x;

	z = x + y;
	std::cout << z;

	z = y - x;
	std::cout << z;
}

ㅁㅊ 클래스끼리 더하기 뺴기를 할 수 있다니 ㅋㅋ ㄷㄷ

operator 연산자라는건 쉽게말하면 연산자의 역할을 직접 정해줄 수 있게 해주는 고마운 애다.

중첩클래스는 말그대로 class의 class의 class의 class의 class다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ (ㅈㅅ.. 근데 진짜임 ㅁㅊㅋㅋ)

이해를 돕기위한 사진을 보고 가시겠습니다...

ㅈㅅ 이해를 돕기위한건 핑계고 그냥 이름 듣자마자 이거 생각나서 넣어봄.

사실 이번 주제는 하나도 어려운게 아니라 그냥 이런게 있다 하는 개념이라 뭐 별거없다.

그래서 이번 코드는 게임엔진 구조도 익힐 겸 실제로 사용하는 요소들을 넣어서 짜봤다.(Scene, Object, ObjectManager) ㅈㄴ 힘들었으니 개추부탁드립니다....

코드부터 바로 보고 시작하자.

#include <iostream>

class ObjectManager;

class Object
{
private:
	char* m_name;
public:

	Object(const char* _name)
	{
		m_name = new char[strlen(_name) + 1];
		strcpy_s(m_name, strlen(_name) + 1, _name);
	}

	~Object()
	{
		delete[] m_name;
	}

	char* GetName() 
	{
		return m_name;
	}
};



class Scene
{
private:
	// Scene에서만 쓸거면 Scene내부에 class를 만들어 준다. (근데 원래는 이러면 안댐 사실)
	class ObjectManager
	{
	private:

		Object* m_objectList[10]; // 걍 정적으로 선언헀지만 실제론 가변길이 컨테이너를 사용해야 한다능
		int size = 0;

	public:

		ObjectManager() = default;
		~ObjectManager() = default;

		Object* CreateObject(const char* _name)
		{
			Object* obj = new Object(_name);
			m_objectList[size++] = obj;
			return obj;
		}

		Object* GetObject(int _val)
		{
			return m_objectList[_val];
		}

		int GetObjectCount()
		{
			return size;
		}

	};

	ObjectManager* m_objectManager;

public:

	Scene()
	{
		m_objectManager = new ObjectManager();
	}
	~Scene()
	{
		delete m_objectManager;
	}

	ObjectManager* GetObjectManager() { return m_objectManager; }
	void Show()
	{
		std::cout << "Total ObjectCount : " << m_objectManager->GetObjectCount() << '\n';
		for (int i = 0; i < m_objectManager->GetObjectCount(); i++)
		{
			std::cout << i << "st Object : " << m_objectManager->GetObject(i)->GetName() << '\n';
		}
	}
};


int main()
{
	Scene myScene;
	myScene.GetObjectManager()->CreateObject("코딩이 즐겁다1");
	myScene.GetObjectManager()->CreateObject("코딩이 즐겁다2");
	myScene.GetObjectManager()->CreateObject("코딩이 즐겁다3");

	myScene.Show();

}

사실 그냥 클래스 안에 클래스나 struct를 짤 수 있다는 것만 알면 된다. 걍 심심해서 짜봄...

너무 대충 쓴 것 같아서 추가

list나 vector, stack 등과 같은 컨테이너의 iterator도 중첩클래스의 일부라고 보면 좋다.

STL - iterator — 개발자의 글쓰기 (tistory.com)

이분거도 보면 class안에 struct, 혹은 class가 들어간다.

위 사진에서 예를 들면 NODE와 MyListIterator객체는 MyList의 내부에서 밖에 쓸 일이 없으므로 MyList안에 class를 구현한 것이다.

한국인을 위한 코드 미리보기

#include <iostream>

class MyClass
{

	int num = 0;

public:

	int Get() { return num; }
	void Set(int a) { num = a; }

	MyClass Sum1(MyClass obj)
	{
		MyClass temp;
		temp.Set(obj.Get() + this->Get());
		return temp;
	}
	friend MyClass Sum2(MyClass obj1, MyClass obj2);
};

MyClass Sum2(MyClass obj1, MyClass obj2)
{
	MyClass temp;
    // MyClass에서 friend 키워드를 주었기 때문에 private멤버에 접근이 가능한ww
	temp.num = obj1.num + obj2.num;
	return temp;
}

int main()
{

	MyClass x; x.Set(1);
	MyClass y; y.Set(2);

	MyClass z1 = x.Sum1(y);
	MyClass z2 = Sum2(x, y);

	std::cout << z1.Get() << " " << z2.Get();

	return 0;

}

미친 나도 친구가 없는데 class가 친구가 있네

friend 키워드를 통해 해당 함수에 자기의 private 멤버에 접근할 수 있다.

뭐야 ㅅㅂ 미친거아님?wwww 이라고 생각할 수도 있겠지만.... class의 캡슐화에 위배된다...라네요.

사실 저는 캡슐화 알빠노(물론 중요함. 하기 귀찮아서 그렇지) 라는 입장이기 때문에 별 생각 안들지만, 딱 보자마자 든 생각이.. 의존성이 너무 강해진다? 였다는 것.

(의존성이라는 것은 서로가 서로를 너무 의존해서 하나가 바뀌거나 없어지면 의존하던 코드도 같이 무너지는? 그런 느낌이라고 생각합니다. 사실 제 생각임 팩트인진 모름.)

어쨋든 friend 써보니까 매우 신세계긴 하네요. 하지만 안쓸듯. 일단 앞서 말했듯이 캡슐화를 위배하는 것도 있지만, 저는 그런거 알빠노고, 사실 의존성이 강해지는게 너무 맘에 걸리긴 한다는ww 추가적으로 friend를 남발하다 보면 여기저기서 멤버를 가져오기 때문에 그 유명한 스파게티코드가 될거 같다는? 느낌적인 느낌

그래도 연관성이 높은 객체끼리 쓰면 편의성이 아주 높아진다고 하니 감당가능하신 분들은 알아서 쓰시길.... 전 지능딸려서 남발하다가 나중에 유지보수를 못할 것 같아서 안쓸 것 같습니다 ㅅ_ㄱ...

20240907추가

friend..... 쓰는 날이 오긴 하더라.......

캡슐화를 위반하는 대신 은닉성을 좀 더 강화할 수 있어서 가끔 쓸거같습니다....

다만 남발하면 여전히 복잡해지고, 어쨋든 캡슐화를 위반하는거니 조심해서 써야 된다는 강박을 가지고 있는 중..

friend가 좋긴한데 너무 치트키 느낌이라 공부하는 입장에선 자제해서 써야겠습니다.