https://youtu.be/wN0x9eZLix4?si=oupP5iS4HC27Gfd-

https://youtu.be/Z3moDffp6sk

/*
#include <iostream>

using namespace std;

int n;
void set();

namespace doodle {
	int n;
	void set();
	namespace google {
		int n;
		void set();
	}
}

int main() {
	::set();
	doodle::set();
	doodle::google::set();

	cout << ::n << endl;
	cout << doodle::n << endl;
	cout << doodle::google::n << endl;
}

void ::set() {
	n = 10;
}

void doodle::set() {
	n = 20;
}

void doodle::google::set() {
	n = 30;
}
*/

#include <iostream>

int n;
void set() {
	n = 10;
}

namespace doodle {
	int n;
	void set() {
		n = 20;
	}
	namespace google {
		int n;
		void set() {
			n = 30;
		}
	}
}

int main() {
	using namespace std;
	using namespace doodle;

	::set();
	doodle::set();
	google::set();

	cout << ::n << endl;
	cout << doodle::n << endl;
	cout << google::n << endl;
}

https://blog.naver.com/PostView.naver?blogId=yuyyulee&logNo=221079465686 

https://youtu.be/nprq56hdAqU

#include <stdio.h>

struct ProductInfo
{
	int num; //4B
	char name[100]; //100B
	int cost; //4B
};

int main1_1()
{
	ProductInfo myProduct = { 12323223,"제주 한라봉", 20000 };
	
	ProductInfo* ptr_product = &myProduct;

	printf("상품 번호 : %d\n", (*ptr_product).cost);
	printf("상품 이름 : %s\n", (*ptr_product).name);
	printf("가     격 : %d\n", (*ptr_product).num);
	return 0;
}

int main1_2()
{
	ProductInfo myProduct = { 12323223,"제주 한라봉", 20000 };

	ProductInfo* ptr_product = &myProduct;

	//(*a).b == a->b

	printf("상품 번호 : %d\n", ptr_product->cost);// (*ptr_product).cost);
	printf("상품 이름 : %s\n", ptr_product->name);
	printf("가     격 : %d\n", ptr_product->num);
	return 0;
}

void productSale(ProductInfo &p, int percent)
{
	p.cost -= p.cost * percent / 100;
}

int main1_3()
{
	ProductInfo myProduct = { 12323223,"제주 한라봉", 20000 };


	productSale(myProduct, 10);

	ProductInfo* ptr_product = &myProduct;

	//(*a).b == a->b

	printf("상품 번호 : %d\n", ptr_product->num);
	printf("상품 이름 : %s\n", ptr_product->name);
	printf("가     격 : %d\n", ptr_product->cost);// (*ptr_product).cost);
	return 0;
}


void productSwap(ProductInfo *a, ProductInfo *b)
{
	ProductInfo tmp = *a;
	*a = *b;
	*b = tmp;
}

int main1_4()
{
	ProductInfo myProduct{ 12323223,"제주 한라봉", 20000 };
	ProductInfo otherPro{ 12323223,"성주 꿀참외", 10000 };

	productSwap(&myProduct, &otherPro);
	//(*a).b == a->b

	printf("상품 번호 : %d\n", myProduct.num);
	printf("상품 이름 : %s\n", myProduct.name);
	printf("가     격 : %d\n", myProduct.cost);// (*ptr_product).cost);
	return 0;
}

int main()
{
	main1_1();
	printf("\n");
	main1_2();
	printf("\n");
	main1_3();
	printf("\n");
	main1_4();

	return 0;
}

https://youtu.be/hjRShGENaow

main.cpp

#include <stdio.h>

int main1_1()
{
	typedef struct { int x, y; } Point;
	Point p;
	p.x = 10;
	p.y = 20;
	printf("(%d, %d)\n", p.x, p.y);

	return 0;
}

int main1_2()
{
	struct { int x, y; } p;
	p.x = 10;
	p.y = 20;
	printf("(%d, %d)\n", p.x, p.y);

	return 0;
}


struct p {
private: //비공개
	int x, y;

public: //공개
	int getX() { return x; }
	int getY() { return y; }
	void setX(int _x) { x = _x; }
	void setY(int _y) { y = _y; }

	p() :x(0), y(0) { printf("시작\n"); }; //초기
	~p() { printf("끝"); }//끝
};

int main1_3()
{
	p p1;
	p1.setX(500);
	p1.setY(20);
	printf("(%d, %d)\n", p1.getX(), p1.getY());

	return 0;
}

int main()
{
	main1_1();
	main1_2();
	main1_3();
	
	return 0;
}

typedef 선언은 typedef를 스토리지 클래스로 사용하는 선언입니다. 선언자는 새 형식이 됩니다. typedef 선언을 사용하여 C에서 이미 정의된 형식이나 사용자가 선언한 형식에 대한 보다 짧거나 의미 있는 이름을 생성할 수 있습니다. typedef 이름을 사용하면 변경될 수 있는 구현 정보를 캡슐화할 수 있습니다.

typedef 선언은 변수 또는 함수 선언과 같은 방식으로 해석되지만, 선언에 형식이 지정되었다고 가정하는 대신 식별자가 형식의 동의어가 됩니다.

https://youtu.be/s8Ah3XAsrgY

#include <stdio.h>

int main1_1()
{
	int point[2] = { 3,4 };
	printf("(%d, %d)\n", point[0], point[1]);
	return 0;
}


int main1_2()
{
	typedef int Pair[];
	Pair point = { 3,4 }; // int point[2] ={3,4};
	printf("(%d, %d)\n", point[0], point[1]);
	return 0;
}

int main2_1()
{
	const char *name = "gizmo";
	printf("이름: %s\n", name);
	return 0;
}

int main2_2()
{
	typedef const char* String; 
	String name = "gizmo"; //const char* name "gizmo"
	printf("이름: %s\n", name);
	return 0;
}

int main()
{
	main1_1();
	main1_2();
	main2_1();
	main2_2();
	
	return 0;
}

#include <iostream>

using std::cout;
using std::cin;
using std::endl;


class Time {
public:
	Time() :h(0), m(0), s(0) {}

	Time(int s_) :Time() {
		s = s_;
	}

	Time(int m_, int s_) :Time(s_) {
		m = m_;
	}

	Time(int h_, int m_, int s_) : Time(m_, s_) {
		h = h_;
	}

//private:
	int h;
	int m;
	int s;
};


int main()
{
	Time t1;
	Time t2(5);
	Time t3(3, 16);
	Time t4(10, 20, 15);

	cout << "t1 : " << t1.h << " : " << t1.m << " : " << t1.s << endl;
	cout << "t2 : " << t2.h << " : " << t2.m << " : " << t2.s << endl;
	cout << "t3 : " << t3.h << " : " << t3.m << " : " << t3.s << endl;
	cout << "t4 : " << t4.h << " : " << t4.m << " : " << t4.s << endl;
}

https://youtu.be/2rXLncQD27c

class Complex
{
public:
	Complex()
	{
		real = 0;
		imag = 0;
	}

private:
	double real;
	double imag;
	
};

class Complex
{
public:
	Complex(): real(0),imag(0){}
private:
	double real;
	double imag;
	
};

class Complex
{
public:
	Complex(double real_= 0, double imag_= 0)
	{
		real = real_;
		imag = imag_;
	}
private:
	double real;
	double imag;
	
};

class Complex
{
public:
	Complex(double real_ = 0, double imag_ = 0) : real(real_),imag(imag_){}
private:
	double real;
	double imag;
	
};

class Complex
{
public:
	Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
private:
	double real;
	double imag;
	
};

https://youtu.be/iIQXlLv_yHI

main.cpp

#include <iostream>

using namespace std;


// private: protected: public:

struct TV
{
//private:
	bool powerOn;
	int channel;
	int volume;

public:
	void on()
	{
		powerOn = true;
		cout << "TV를 켰습니다." << endl;
	}

	void off()
	{
		powerOn = false;
		cout << "TV를 껐습니다." << endl;
	}
	void setChannel(int _cnl)
	{
		if(_cnl >= 1 && _cnl <= 999)
		{
			channel = _cnl;
			cout << "채널을" << _cnl << "으(로) 바귔습니다." << endl;
		}
	}

	void setVolume(int _vol)
	{
		if (_vol >= 0 && _vol <= 100)
		{
			volume = _vol;
			cout << "볼륨을" << _vol << "으(로) 바귔습니다." << endl;
		}
	}
	TV()
		: powerOn()
		, channel(0)
		, volume(7)
	{

	}
};

int main()
{
	TV lg;
	lg.on();
	lg.setChannel(10);
	lg.setVolume(50);
}

public = 어디서든 접근이 가능.
protected = 상속관계일 때 접근이 가능
private = 해당 클래스에서만 접근이 가능

https://youtu.be/kAsnMlsB_Ks

#include <iostream>
using namespace std;

using std::cout;
using std::cin;
using std::endl;

#include <iostream>
namespace MYSPACE
{
	int g_int;
}

int main()
{
	MYSPACE::g_int = 100;
	return 0;
}

https://youtu.be/zwbH4ScKctA

main.cpp

#include <iostream>
#include "CList.h"


int main()
{
	CList<int> list;

	for(int i = 0; i < 100 ; ++i)
		{
			list.push_back(i);
		}

	return 0;
}

CList.h

#pragma once
template<typename T>
struct tListNode
{
	T				data;
	tListNode<T>*	pPrev;
	tListNode<T>*	pNext;

	tListNode()
		: data()
		, pPrev(nullptr)
		, pNext(nullptr)
	{
	}
	
	//기본 초기 값
	tListNode(const T& _data, tListNode<T>* _pPrev, tListNode<T>* _pNext)
		: data(_data)
		, pPrev(_pPrev)
		, pNext(_pNext)
	{

	}
};

template<typename T>
class CList
{
private:
	tListNode<T>*	m_pHead; //헤드
	tListNode<T>*	m_pTail; //총
	int				m_iCount; // 카운터
public:
	void push_back(const T& _data);
	void push_front(const T& _data);
public:
	CList();
	~CList();
};

template<typename T>
void CList<T>::push_back(const T& _data)
{
	//입력된 데이터를 저장할 노드를 동적할당 함
	tListNode<T>* pNewNode = new tListNode<T>(_data, nullptr, nullptr);

	//처음 입력된 테이터라면
	if (nullptr == m_pHead)
	{
		//처음 입력되 테이터라면
		m_pHead = pNewNode;
		m_pTail = pNewNode;
	}
	else
	{
		//데이타가 1개 이상에서 입력된 경우
		//현재 가장 마자막 테이터(tail)를 저장하고 있는 노드와
		//새로 생성된 노드가 서로 가리키게 한다.
		m_pTail->pNext = pNewNode;
		pNewNode->pPrev = m_pTail;


		//List 가 마지막 노드의 주소값을 새로 입력된 노드로 생신한다.
		m_pTail = pNewNode;
	}
	// 데이터 개수 증가
	++m_iCount;
}

template<typename T>
void CList<T>::push_front(const T& _data)
{
	//새로 생성된 노드의 다음을 현재 헤드노드의 주소값으로 채움
	tListNode<T>* pNewNode = new tListNode<T>(_data, nullptr, m_pHead);

	//현재 헤드노드의 이전노드 주소값을 새로 생성된 노드의 주소로 채움
	m_pHead->pPrev = pNewNode;

	//리스트가 새로 생성된 노드의 주소를 새로운 헤드주소로 갱신한다.
	m_pHead = pNewNode;

	//데이터 개수 증가
	++m_iCount;
}


template<typename T>
CList<T>::CList()
	: m_pHead(nullptr)
	, m_pTail(nullptr)
	, m_iCount(0)
{
}

template<typename T>
 CList<T>::~CList()
{
	 tListNode<T>* pDeletNode = m_pHead;

	 while (pDeletNode)
	 {
		 tListNode<T>* pNext = pDeletNode->pNext;
		 delete(pDeletNode);
		 pDeletNode = pNext;
	 }
}

https://youtu.be/Pg-3Fzp5G7k

#include <iostream>

template<typename T>
T getArraySum(const T arr[], int n);

int main()
{
	float faee[] = {1.12,2.121,3.2};
	float i = getArraySum<float>(faee, sizeof(faee) / sizeof(float));
	printf("%f", i);
	return 0;
}

template<typename T>
T getArraySum(const T arr[], int n)
{
	T sum = 0;
	for (int i = 0; i < n; i++) {
		sum += arr[i];
	}
	return sum;
}

https://youtu.be/LfFQ0ezVuZM

main.cpp

#include <iostream>

#include "Arr.h"
#include "CArr.h"

class CTest // 기본 private:
{
private://비공개
	int a;

public://공개
	CTest()
		:a(10)
	{

	}
public://공개

};

int main()
{
	{
		CTest* pTest = new CTest;
		delete pTest;

		tArr arr = {};
		InitArr(&arr);

		PushBack(&arr, 10);
		PushBack(&arr, 20);
		PushBack(&arr, 30);

		ReleaseArr(&arr);


		CArr<int> carr;
		carr.push_back(10);
		carr.push_back(20);
		carr.push_back(30);


		CArr<float> carr1;
		carr1.push_back(10.1232);
		carr1.push_back(22.310);
		carr1.push_back(32.3330);

		float iData = carr1[2];
		printf("%0.2f", iData);
	}

	return 0;
 }

CArr.h

#pragma once

#include <assert.h>

template<typename T>
class CArr
{
private:
	T*		m_pData;
	int		m_iCount;
	int		m_iMaxCount;

public:
	void push_back(const T& _Data);
	void resize(int _iResizeCount);

	T& operator[](int idx);

public:
	CArr();
	~CArr();
};

template<typename T>
void CArr<T>::push_back(const T& _Data)
{
	int i = 0;

	// 힙 영역에 할당한 공간이 다 참 확인
	if (m_iMaxCount <= m_iCount)
	{
		//재할당
		resize(_Data);
	}

	// 데이터 추가
	m_pData[m_iCount++] = _Data;
}

template<typename T>
void CArr<T>::resize(int _iResizeCount)
{
	// 현재 최대 수용량 보다 더 적은 수치로 확정하려는 경우
	if (m_iMaxCount >= _iResizeCount)
	{
		assert(nullptr);
	}


	//1. 리사이즈 시킬 개수만큼 동적할당 한다
	T* pNew = new T[_iResizeCount];

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < m_iCount; ++i)
	{
		pNew[i] = m_pData[i];
	}
	//3. 기존 공간은 메모리 해제
	delete[] m_pData;

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	m_pData = pNew;

	//5. MaxCount 변경점 적용
	m_iMaxCount = _iResizeCount;
}
template<typename T>
T& CArr<T>::operator[](int idx)
{
	return m_pData[idx];
}

template<typename T>
CArr<T>::CArr()
	:m_pData(nullptr)
	, m_iCount(0)
	, m_iMaxCount(2)
{
	m_pData = new T[2];
}

template<typename T>
CArr<T>::~CArr()
{
	delete[] m_pData;

}

Arr.h

#pragma once

//ints
typedef struct _tagArr
{
	int*		pInt; // 포인터
	int			iCount; // 카운터
	int			iMaxCount; // 최대 카운터
}tArr;

// 배열 초기화 함수
void InitArr(tArr* _pArr);

//데이터 추가 함수
void PushBack(tArr* _pArr, int _iData);

//공간 추가 확장
void Reallocate(tArr* _pArr);

//배열 메모리 해제 함수
void ReleaseArr(tArr* _pArr);

//데이터 정렬 함수
void Sort(tArr* _pArr,void(*SortFunc)(int*, int));

Arr.cpp

#include "Arr.h"
#include <iostream>

//초기화
void InitArr(tArr* _pArr)
{
	_pArr->pInt = (int*)malloc(sizeof(int) * 2);
	//(*_pArr).iCount = 0;
	_pArr->iCount = 0;
	_pArr->iMaxCount = 2;
}

void Reallocate(tArr* _pArr)
{
	//1. 2배 더 큰 공간을 동적할당한다.
	int* pNew = (int*)malloc(_pArr->iMaxCount * 2 * sizeof(int));

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < _pArr->iCount; ++i)
	{
		pNew[i] = _pArr->pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	free(_pArr->pInt);

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	_pArr->pInt = pNew;

	//5. MaxCount 변경점 적용
	_pArr->iMaxCount *= 2;
	
}

void PushBack(tArr* _pArr, int _iData)
{
	// 힙 영역에 할당한 공간이 다 참 확인
	if (_pArr->iMaxCount <= _pArr->iCount)
	{
		//재할당
		Reallocate(_pArr);
	}

	// 데이터 추가
	_pArr->pInt[_pArr->iCount++] = _iData;
	
}

// 힙 영역 할당 제거
void ReleaseArr(tArr* _pArr)
{
	free(_pArr->pInt);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 0;
}

void Sort(tArr* _pArr, void(*SortFunc)(int*, int))
{
	_pArr;
	SortFunc(_pArr->pInt, _pArr->iCount);

}

1. 포인터 (pointer)

메모리의 주소

#include <iostream>

int main() {
	{

		int a = 10;
		int* p;
		p = &a;
		printf("%d",*p);
	}
}

#include <iostream>
#include <setjmp.h>
#include <string>
using namespace std;

class TestFunc
{
public:

};


int main()
{
int i = -20;
    int* ptr = &i;
    cout << "i = " << i << endl;
    cout << "&i = " << &i << endl;
    cout << "ptr = " << ptr << endl;
    cout << "*ptr = " << *ptr << endl;
    cout << "&ptr = " << &ptr << endl;
    cout << "*&ptr = " << *&ptr << endl;
    cout << "**&ptr = " << **&ptr << endl;
    return 0;
}

2. 레퍼런스 (reference)

별명 / 바로가기 / 참조한 변수와 동일한 변수

#include <iostream>

int main() {
	{

		int a = 10;
		int& r = a ;
		printf("%d",r);
	}
}

int Add(int a, int b)
{
	return a + b;
}

int Add(float f, float f1)
{
	return f + f1;
}

템플릿이라는 용어는 워드 프로세싱 소프트웨어의 맥락에서 사용될 때, 이미 일부 세부 정보가 있는 샘플 문서를 나타냅니다. 이러한 작업은 손으로 수행하거나 소프트웨어 지원과 같은 자동화된 반복 프로세스를 통해 수행할 수 있습니다.

template<typename T>
T Add(T a, T b)
{
	return a + b;
}

template<typename T> /  template<class T>

template<typename T, typename T1>
T Add(T a, T1 b)
{
	return a + b;
}

int main()
{
	float i = Add<float, int>(10.22, 200.23); // Add<float, int> 자동 생성
	printf("%0.2f", i);
	printf("\n");

	i = Add<int, float>(10.22, 200.23);
	printf("%0.2f", i);


	return 0;
}

https://youtu.be/W0sSAdUKhKE

https://youtu.be/xpdNpukDrbw

https://youtu.be/pYTaO0paOfI

https://youtu.be/v4Nn_EeCVKA

main.cpp

#include <iostream>

#include "Arr.h"
#include "CArr.h"

class CTest // 기본 private:
{
private://비공개
	int a;

public://공개
	CTest()
		:a(10)
	{

	}
public://공개

};



int main()
{
	CTest* pTest = new CTest;
	delete pTest;



	tArr arr = {};
	InitArr(&arr);

	PushBack(&arr, 10);
	PushBack(&arr, 20);
	PushBack(&arr, 30);

	ReleaseArr(&arr);


	CArr carr;
	carr.push_back(10);
	carr.push_back(20);
	carr.push_back(30);

	int iData = carr[1];
	carr[1] = 100;

	return 0;
 }

CArr.h

#pragma once
class CArr
{
private:
	int*	m_pInt;
	int		m_iCount;
	int		m_iMaxCount;

public:
	void push_back(int _Data);
	void resize(int _iResizeCount);


	int& operator[](int idx);
public:
	CArr();
	~CArr();


};

CArr.cpp

#include "CArr.h"

#include <assert.h>

void CArr::push_back(int _Data)
{
	int i = 0;

	// 힙 영역에 할당한 공간이 다 참 확인
	if (m_iMaxCount <= m_iCount)
	{
		//재할당
		resize(_Data);
	}

	// 데이터 추가
	m_pInt[m_iCount++] = _Data;
}

void CArr::resize(int _iResizeCount)
{
	// 현재 최대 수용량 보다 더 적은 수치로 확정하려는 경우
	if (m_iMaxCount >= _iResizeCount)
	{
		assert(nullptr);
	}


	//1. 리사이즈 시킬 개수만큼 동적할당 한다
	int* pNew = (int*) new int[_iResizeCount];

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < m_iCount; ++i)
	{
		pNew[i] = m_pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	delete[] m_pInt;

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	m_pInt = pNew;

	//5. MaxCount 변경점 적용
	m_iMaxCount = _iResizeCount;
}

int& CArr::operator[](int idx)
{
	return m_pInt[idx];
}

CArr::CArr()
	:m_pInt(nullptr)
	, m_iCount(0)
	, m_iMaxCount(2)
{
	m_pInt = new int[2];

}

CArr::~CArr()
{
	delete[] m_pInt;

}

C++ 클래스 특징

접근제한 지정자

클래스 내의 맴버변수 or  맴버함수 의 접근 레벨

생성자, 소별자

객체 생성, 소멸 시 자동으로 호출

직접 만들지 않으면 기본 생성자, 기본 소멸자가 만들어짐

맴버함수

해당 클래스가 사용하는 전용 함수

해당 클래스의 개체가 필요함.

맴버함수를 객체를 통해서 호출하며, 해당 객제의 주소가  this 포인터로 전달

https://youtu.be/8HVfEul9nqk

https://youtu.be/rbB3xbJN4qE

https://youtu.be/V9mByvOuCac

main.cpp

#include <iostream>

#include "LinkedList.h"

int main()
{
	tLinkedList	list = {};
	InitList(&list);

	PushBack(&list, 100);
	PushBack(&list, 200);
	PushBack(&list, 300);


	ReleaseList(&list);

	return 0;
}

LinkedList.h

#pragma once


typedef struct _tagNode
{
	int		iData;
	struct _tagNode*	pHeadNode;

}tNode;


typedef struct _tagList
{
	tNode*	pHeadNode;
	int		iCount; // 카운터
}tLinkedList;

//연결형 리스트 초기화
void InitList(tLinkedList* _pList);


//연결형 리스트 테이터 추가
void PushBack(tLinkedList* _pList, int _iData);


//연결형 리스트 메모리 해제
void ReleaseList(tLinkedList* _pList);

LinkedList.cpp

#include <iostream>
#include "LinkedList.h"

void InitList(tLinkedList* _pList)
{
	_pList->pHeadNode = nullptr;
	_pList->iCount = 0;
}

void PushBack(tLinkedList* _pList, int _iData)
{
	//데이터를 저장할 노드 생성
	//데이터 복사
	tNode* pNode = (tNode*)malloc(sizeof(tNode));
	(*pNode).iData = _iData;
	(*pNode).pHeadNode = nullptr;

	//추가한 데이터가 처음인지 아닌지
	if (0 == _pList->iCount)
	{
		_pList->pHeadNode = pNode;
	}

	else
	{
		//현재 가장 마지막 노드를 찾아서
		//해당 노드의 pNext를 생성시킨 노드의 주소로 채움
		tNode* pCurFinalNode = _pList->pHeadNode;
		while (pCurFinalNode->pHeadNode)
		{
			pCurFinalNode = pCurFinalNode->pHeadNode;
		}
		pCurFinalNode->pHeadNode = pNode;
	}

	++_pList->iCount;
}

void Release(tNode* _pNode)
{
	if (nullptr == _pNode)
		return;

	Release(_pNode->pHeadNode);
	free(_pNode);
}

// 힙 영역 할당 제거
void ReleaseList(tLinkedList* _pList)
{
	//Release(_pList->pHeadNode);

	tNode* pDeletNode = _pList->pHeadNode;

	while (pDeletNode)
	{
		tNode* pNext = pDeletNode->pHeadNode;
		free(pDeletNode);
		pDeletNode = pNext;
	}
}

https://youtu.be/MzsOdFqtK7M

maim.cpp

#include <iostream>
#include <time.h>

#include "Arr.h"
#include "LinkedList.h"

void BubblsSort(int* _pData, int _iCount )
{
	//데이타가 1개 이하인
	if (_iCount <= 1)
		return;

	//오름차순 정렬

	while (true)
	{
		bool bFinish = true;
		int iLoop = _iCount - 1;
		for (int i = 0; i < iLoop; ++i)
		{
			if (_pData[i] > _pData[i + 1])
			{
				int iTemp = _pData[i];
				_pData[i] = _pData[i + 1];
				_pData[i + 1] = iTemp;
				bFinish = false;
			}
		}

		if (bFinish)
			break;
	}
}

//void Test()
//{
//
//}


int main()
{
	//함수 포인트
	//void(*pFunc)(void);
	//pFunc = Test;
	//pFunc();

	int iArrp[10] = {123,145,13,46,231,885};
	BubblsSort(iArrp, 10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d\n", iArrp[i]);
	}

	printf("정렬\n");


	tArr s1 = {};

	InitArr(&s1);
	
	//난수(렌덤)
	srand(time(nullptr));
	printf("난수\n");
	for (int i = 0; i < 10; ++i)
	{
		int iRand = rand() % 100 + 1;

		PushBack(&s1, iRand);
	}

	for (int i = 0; i < s1.iCount; ++i)
	{
		printf("%d\n",s1.pInt[i]);
	}

	printf("정렬\n");
	Sort(&s1, &BubblsSort);

	for (int i = 0; i < s1.iCount; ++i)
	{
		printf("%d\n", s1.pInt[i]);
	}

	ReleaseArr(&s1);

	// 연결형 리스트

	return 0;
}

Arr.h

#pragma once

//ints
typedef struct _tagArr
{
	int*		pInt; // 포인터
	int			iCount; // 카운터
	int			iMaxCount; // 최대 카운터
}tArr;

// 배열 초기화 함수
void InitArr(tArr* _pArr);

//데이터 추가 함수
void PushBack(tArr* _pArr, int _iData);

//공간 추가 확장
void Reallocate(tArr* _pArr);

//배열 메모리 해제 함수
void ReleaseArr(tArr* _pArr);

//데이터 정렬 함수
void Sort(tArr* _pArr,void(*SortFunc)(int*, int));

Arr.cpp

#include "Arr.h"
#include <iostream>

//초기화
void InitArr(tArr* _pArr)
{
	_pArr->pInt = (int*)malloc(sizeof(int) * 2);
	//(*_pArr).iCount = 0;
	_pArr->iCount = 0;
	_pArr->iMaxCount = 2;
}

void Reallocate(tArr* _pArr)
{
	//1. 2배 더 큰 공간을 동적할당한다.
	int* pNew = (int*)malloc(_pArr->iMaxCount * 2 * sizeof(int));

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < _pArr->iCount; ++i)
	{
		pNew[i] = _pArr->pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	free(_pArr->pInt);

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	_pArr->pInt = pNew;

	//5. MaxCount 변경점 적용
	_pArr->iMaxCount *= 2;
	
}

void PushBack(tArr* _pArr, int _iData)
{
	// 힙 영역에 할당한 공간이 다 참 확인
	if (_pArr->iMaxCount <= _pArr->iCount)
	{
		//재할당
		Reallocate(_pArr);
	}

	// 데이터 추가
	_pArr->pInt[_pArr->iCount++] = _iData;
	
}

// 힙 영역 할당 제거
void ReleaseArr(tArr* _pArr)
{
	free(_pArr->pInt);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 0;
}

void Sort(tArr* _pArr, void(*SortFunc)(int*, int))
{
	_pArr;
	SortFunc(_pArr->pInt, _pArr->iCount);

}

[요약]

void Test()
{

}

int main()
{
	//함수 포인트
	void(*pFunc)(void) = nullptr;
	pFunc = Test;
	pFunc();
    
    return 0;
 }

https://youtu.be/osL_ngXRmA4

https://youtu.be/UV30FZqQsAM

https://youtu.be/DH_sIesP0zs

main.cpp

#include <iostream>
#include "Arr.h"

int main()
{
	tArr s1 = {};

	InitArr(&s1);

	for (int i = 0; i < 10; ++i)
	{
		PushBack(&s1, i);
	}

	for (int i = 0; i < s1.iCount; ++i)
	{
		printf("%d\n",s1.pInt[i]);
	}
	ReleaseArr(&s1);

	return 0;
}

Arr.h

#pragma once

//ints
typedef struct _tagArr
{
	int*		pInt; // 포인터
	int			iCount; // 카운터
	int			iMaxCount; // 최대 카운터
}tArr;

// 배열 초기화 함수
void InitArr(tArr* _pArr);


//데이터 추가 함수
void PushBack(tArr* _pArr, int _iData);

//공간 추가 확장
void Reallocate(tArr* _pArr);

//배열 메모리 해제 함수
void ReleaseArr(tArr* _pArr);

Arr.cpp

#include "Arr.h"
#include <iostream>

//초기화
void InitArr(tArr* _pArr)
{
	_pArr->pInt = (int*)malloc(sizeof(int) * 2);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 2;
}

void Reallocate(tArr* _pArr)
{
	//1. 2배 더 큰 공간을 동적할당한다.
	int* pNew = (int*)malloc(_pArr->iMaxCount * 2 * sizeof(int));

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < _pArr->iCount; ++i)
	{
		pNew[i] = _pArr->pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	free(_pArr->pInt);

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	_pArr->pInt = pNew;

	//5. MaxCount 변경점 적용
	_pArr->iMaxCount *= 2;
	
}

void PushBack(tArr* _pArr, int _iData)
{
	// 힙 영역에 할당한 공간이 다 참 확인
	if (_pArr->iMaxCount <= _pArr->iCount)
	{
		//재할당
		Reallocate(_pArr);
	}

	// 데이터 추가
	_pArr->pInt[_pArr->iCount++] = _iData;
	
}

// 힙 영역 할당 제거
void ReleaseArr(tArr* _pArr)
{
	free(_pArr->pInt);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 0;

}

두가지 방법은 동일합니다.  포인트를 선택 할 수 있습니다.

_pArr->iCount = 0;
(*_pArr).iCount = 0;

구조체 포인트 선택

Arr.cpp (정렬) 추가

https://youtu.be/FiqrUZHpAOQ

#include "Arr.h"
#include <iostream>

//초기화
void InitArr(tArr* _pArr)
{
	_pArr->pInt = (int*)malloc(sizeof(int) * 2);
	//(*_pArr).iCount = 0;
	_pArr->iCount = 0;
	_pArr->iMaxCount = 2;
}

void Reallocate(tArr* _pArr)
{
	//1. 2배 더 큰 공간을 동적할당한다.
	int* pNew = (int*)malloc(_pArr->iMaxCount * 2 * sizeof(int));

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < _pArr->iCount; ++i)
	{
		pNew[i] = _pArr->pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	free(_pArr->pInt);

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	_pArr->pInt = pNew;

	//5. MaxCount 변경점 적용
	_pArr->iMaxCount *= 2;
	
}

void PushBack(tArr* _pArr, int _iData)
{
	// 힙 영역에 할당한 공간이 다 참 확인
	if (_pArr->iMaxCount <= _pArr->iCount)
	{
		//재할당
		Reallocate(_pArr);
	}

	// 데이터 추가
	_pArr->pInt[_pArr->iCount++] = _iData;
	
}

// 힙 영역 할당 제거
void ReleaseArr(tArr* _pArr)
{
	free(_pArr->pInt);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 0;
}

void Sort(tArr* _pArr)
{
	//데이타가 1개 이하인
	if (_pArr->iCount <= 1)
		return;

	//오름차순 정렬

	while (true)
	{
		bool bFinish = true;
		int iLoop = _pArr->iCount - 1;
		for (int i = 0; i < iLoop; ++i)
		{
			if (_pArr->pInt[i] > _pArr->pInt[i + 1])
			{
				int iTemp = _pArr->pInt[i];
				_pArr->pInt[i] = _pArr->pInt[i + 1];
				_pArr->pInt[i + 1] = iTemp;
				bFinish = false;
			}
		}

		if (bFinish)
			break;
	}

}

구조체의 뜻과 종류; struct와 typedef struct

struct student_info{
    int number;
    char name[20];
    int age;
}
 
int main(){
    struct student_info s = {1, "Hong gill dong", 12};
    s.number = 10;
}

typedef struct {
    int num;
    char grade;
}student;
 
int main(){
    student s = {1, 'A'};
}​

출처 : https://opentutorials.org/module/5371/30564

struct

구조체란? 구조체(structure type)란 사용자가 C언어의 기본 타입을 가지고 새롭게 정의할 수 있는 사용자 정의 타입입니다. 구조체는 기본 타입만으로는 나타낼 수 없는 복잡한 데이터를 표현할 수 있습니다.

typedef

typedef는 기존의 존재하는 자료형에(구조체) 새 이름(별명)을 부여하는 것입니다. 정수 자료형 int를 다른 이름으로 설정할 수 있다는 뜻입니다. typedef int InT; int의 또 다른 이름 InT가 됩니다.

static
모든 객체가 한 메모리를 공유하는 멤버 변수. 객체 별로 각각 할당되는 멤버가 아니라 모든 객체가 공유하는 멤버다.

https://www.youtube.com/watch?v=Nrtg_YSqwu4&list=PL4SIC1d_ab-aOxWPucn31NHkQvNPHK1D1&index=22&ab_channel=%EC%96%B4%EC%86%8C%ED%8A%B8%EB%9D%BD%EA%B2%8C%EC%9E%84%EC%95%84%EC%B9%B4%EB%8D%B0%EB%AF%B8 

sizeof