코딩시러

오늘은 정렬에 대해 알아볼 것인ww

사실 정렬에는 무수히 많은 알고리즘이 있따.

아래가 정렬의 종류라네요.... 난 몰랑...

• 선택정렬
• 삽입정렬
• 버블정렬
• 병합정렬
• 힙정렬
• 퀵정렬
• 트리정렬

사실 다 알필욘 없고 오늘은 버블정렬에 대해 글을 써보겠스빈당

버블정렬이란?

버블정렬은 움짤만 봐도 알 수 있듯이, 인접한 두 원소를 비교해가며 조건에 따라 swap(교환이라는 뜻ㅎ)하는 정렬알고리즘입니당....

이 움짤에서 사실 디테일이 들어가있는데, 눈치채신 분들도 있겠지만 더 이상 정렬할 필요가 없을 때 정렬을 멈추는 것입니다 ㄷㄷ... 이게 진짜 중요합니다 굿

오늘의 수업에서 짠 저의 버블정렬 알고리즘을 공개하겠습니다....... 두둥

// 버블정렬
struct MySort
{
    static void BubbleSort(std::vector<int>& numbers)
    {
        bool isSwap;
        for (int i = 0; i < numbers.size(); i++) {
            std::cout << "cycle start\n";
            isSwap = false;
            for (int j = 0; j < numbers.size() - 1 - i; j++)
            {
                if (numbers[j] > numbers[j + 1])
                {
                    std::swap(numbers[j], numbers[j + 1]);
                    isSwap = true;
                    std::cout << "sort!\n";
                }
            }
            if (!isSwap) return;
        }
    }
};

돌을 던지지 마시오

기본적인 오름차순 버블정렬 알고리즘을 짜봤읍니다...

numbers[j] > numbers[j + 1]를 비교해서 참이면 swap을 해줬고, isSwap을 참으로 바꿔줬읍니다.

isSwap은 매 사이클마다 false로 바꿔주는데, swap한적이 없으면 정렬이 다 되어있는 상태이므로, 정렬을 종료하도록 코드를 짜줬읍니다.

하이염

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

#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가 좋긴한데 너무 치트키 느낌이라 공부하는 입장에선 자제해서 써야겠습니다.