코딩시러

생성자 상속이라는 문법이 있다.

https://learn.microsoft.com/ko-kr/cpp/cpp/constructors-cpp?view=msvc-170#inheriting_constructors

class Base {
public:
	Base()
	{
		std::cout << "Call : Base()" << '\n';
	}
	Base(int a)
	{
		std::cout << "Call : Base(int)" << '\n';
	}
	Base(const std::string& a)
	{
		std::cout << "Call : Base(const std::string&)" << '\n';
	}
};

class Derived : public Base {
public:
	using Base::Base;
};

int main()
{
	Derived d1;
	Derived d2(0);
	Derived d3("0");
	return 0;
}

원래 C++은 클래스를 상속할 경우 부모생성자의 호출을 위해 자식클래스의 생성자를 명시적으로 적을 필요가 있었다.

하지만 생성자 상속이란 문법을 사용해서 생략할 수 있다 (ㄷㄷ)

위 코드에서 Derived클래스는 원래 같았으면 부모생성자의 생성자를 명시적으로 적어줘야 했지만 using Base::Base;를 써줌으로써 기본 생성자, int형을 받는 생성자, const std::string&를 받는 생성자가 자동으로 정의된다.

-실행결과

잘쓰면 코드가독성에 매우 도움이 될 것 같다? 

#include <iostream>
#include <assert.h>

using namespace std;

class String
{
private:
	char* str;
	int lenght;
	int capacity;
public:
	String() : lenght(0), capacity(0) {}
	String(const char* _str)
		: lenght(strlen(_str)),
		capacity(lenght * 2 + 1)
	{
		str = new char[capacity];
		strcpy_s(str, lenght + 1, _str);
	}
	String(const String& _str)
		: lenght(strlen(_str.str)),
		capacity(lenght * 2  + 1)
	{
		str = new char[capacity];
		strcpy_s(str, lenght + 1, _str.str);
	}

	~String()
	{
		delete[] str;
	}
	
	int Size() { return lenght;  }
	int Capacity() { return capacity; }

	bool operator==(const char* _dest)
	{
		return (strcmp(this->str, _dest) == 0);
	}
	bool operator==(const String& _dest)
	{
		return (strcmp(this->str, _dest.str) == 0);
	}

	void operator=(const char* _str)
	{
		int len = strlen(_str);
		if (len + 1 >= capacity)
		{
			delete[] str;
			capacity = len * 2;
			str = new char[capacity];
		}
		strcpy_s(str, len + 1, _str);
		lenght = len;
	}
	void operator=(const String& _str)
	{
		int len = _str.lenght;
		if (len + 1 >= capacity)
		{
			delete[] str;
			capacity = len * 2;
			str = new char[capacity];
		}
		strcpy_s(str, len + 1, _str.str);
		lenght = len;
	}

	String& operator+=(const char* _str)
	{
		int len = strlen(_str);
		if (lenght + len + 1 > capacity)
		{
			capacity = (lenght + len) * 2 + 1;
			char* tempStr = new char[capacity];
			strcpy_s(tempStr, capacity, str);
			delete[] str;  // 기존 메모리 해제
			str = tempStr; // 새로운 메모리로 교체
		}
		strcat_s(str, capacity, _str); // str에 _str 추가
		lenght += len;
		return *this;
	}

	String& operator+=(const String& _str)
	{
		int len = _str.lenght;
		if (lenght + len + 1 > capacity)
		{
			capacity = (lenght + len) * 2 + 1;
			char* tempStr = new char[capacity];
			strcpy_s(tempStr, capacity, str);
			delete[] str;  // 기존 메모리 해제
			str = tempStr; // 새로운 메모리로 교체
		}
		strcat_s(str, capacity, _str.str); // str에 _str 추가
		lenght += len;
		return *this;
	}

	String operator+(const char* _str)
	{
		char* string = new char[lenght + strlen(_str) + 1];
		strcpy_s(string, lenght + 1, str);
		strcat_s(string, lenght + strlen(_str) + 1, _str);
		String temp = string;
		delete[] string;
		return temp;
	}
	String operator+(String& _str)
	{
		char* string = new char[lenght + _str.lenght + 1];
		strcpy_s(string, lenght + 1, str);
		strcat_s(string, lenght + strlen(_str.str) + 1, _str.str);
		String temp = string;
		delete[] string;
		return temp;
	}

	char& operator[](int _index)
	{
		if (_index > lenght) assert(false && "IndexError");
		return str[_index];
	}

	friend ostream& operator <<(ostream& _outStream, const String& _str);
};

ostream& operator <<(ostream& _outStream, const String& _str) {
	cout << _str.str;
	return _outStream;
}

int main()
{
	String s1 = "abc";
	cout << "s1 : " << s1 << '\n';

	String s2 = "def";
	cout << "s2 : " << s2 << '\n';

	String s3 = s1 + s2;
	cout << "s3 : " << s3 << '\n';

	String s4 = "";
	s4 += s3;
	cout << "s4 : " << s4 << '\n';

	String s5;
	s5 = s4 + "qwe";
	cout << "s5 : " << s5 << '\n' << '\n';

	cout << "s1 == s2 : " << (s1 == s2) << '\n';
	cout << "s3 == s4 : " << (s3 == s4) << '\n';
	cout << "s1 == abc : " << (s1 == "abc") << '\n';

	cout << "s1[0] ~ s1[3] : ";
	for (int i = 0; i < s1.Size(); i++)
	{
		cout << s1[i];
		if (i != s1.Size() - 1) cout << ", ";
	}

	return 0;
}

과제하는겸 string클래스를 구현해보았다.

메모리 할당 delete하는데 에러가 떠서 좀 고생함

오늘 수업때 인접리스트로 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;
}

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

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

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

오늘은 정렬에 대해 알아볼 것인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한적이 없으면 정렬이 다 되어있는 상태이므로, 정렬을 종료하도록 코드를 짜줬읍니다.