또리야 개발하자

#include 
#define BUF_SIZE 5

using namespace std; 

// 배열을 추상화한 클래스 !! 
class vector
{
//배열의 행동과 속성 
private: 
	int m_buf[BUF_SIZE]; 
	int m_size; 
public : 
	int getSize() { return m_size; }
	vector() 
	{
		memset(m_buf, 0, BUF_SIZE);
		m_size = 0; 
	}
	// 배열의 행동들... 
	//1) 인덱스를 통한 접근 !! 
	int & operator[](int index)
	{
		return m_buf[index]; 
	}
	void push_back(int data)
	{
		if( m_size <= BUF_SIZE-1) 
		{
			m_buf[m_size] = data;
			m_size++;
		}
	}
	void pop_back()
	{
		if( m_size > 0)
		{
			m_buf[m_size-1] = 0;
			m_size--;
		}
	}
	void Insert(  int * Where,   int data) 
	{   
		int * p = m_buf + m_size; 

		if( m_size <= BUF_SIZE-1) 
		{
			while( p != Where)
			{
				*p = *(p-1);
				 p--;
			}
			*(Where+1) = data; 
			m_size++;
		}					
	}
	void erase(  int * Where ) 
	{
		int * p =  Where; 

		while(  p != m_buf + m_size) 
		{
			*p = *(p+1);
			 p++;
		}
		m_size--;
	}

	int * find( int val) 
	{
		for(int i = 0; i


#include 


using namespace std; 

// 배열을 추상화한 클래스 !!
// 1차 버전에 대한 개선 !! 
//  - 정적 --> 동적 형태의 자료구조로 개선 !! 
class vector
{
//배열의 행동과 속성 
private: 
	int * m_buf ; 
	int   m_capa; //전체 크기
	int   m_size; // 현재 아이템의 개수 
public : 
	int getSize() { return m_size; }
	vector( int capa =  16 ) 
	{
		m_buf = new int[capa];
		m_capa = capa; 
		memset(m_buf, 0, m_capa);
		m_size = 0;
	}
	// 복사 생성자 !!  
	vector( const vector & v  )
	{
		// 앑은 복사 !!  -->m	m_buf  = v.m_buf; 
		m_buf = new int[ v.m_capa ]; 
		m_size = v.m_size; 
		m_capa = v.m_capa;
		memcpy( m_buf, v.m_buf, m_capa); 
	}


	// 배열의 행동들... 
	//1) 인덱스를 통한 접근 !! 
	int & operator[](int index)
	{
		return m_buf[index]; 
	}
	void push_back(int data)
	{
		if( m_size <= m_capa -1) 
		{
			m_buf[m_size] = data;
			m_size++;
		}
	}
	void pop_back()
	{
		if( m_size > 0)
		{
			m_buf[m_size-1] = 0;
			m_size--;
		}
	}
	void Insert(  int * Where,   int data) 
	{   
		int * p = m_buf + m_size; 

		if( m_size <= m_capa-1) 
		{
			while( p != Where)
			{
				*p = *(p-1);
				 p--;
			}
			*(Where+1) = data; 
			m_size++;
		}					
	}
	void erase(  int * Where ) 
	{
		int * p =  Where; 

		while(  p != m_buf + m_size) 
		{
			*p = *(p+1);
			 p++;
		}
		m_size--;
	}

	int * find( int val) 
	{
		for(int i = 0; i

#include 
#include 

using namespace std; 

// 배열을 추상화한 클래스 !!
// 2차 버전에 대한 개선 !! 
//  - int 데이타만 저장 가능한 배열 클래스를 템플릿을 이용하여 
 
template < typename T > 
class vector
{
//배열의 행동과 속성 
private: 
	T * m_buf ; 
	int   m_capa; // 전체 크기
	int   m_size; //  현재 아이템의 개수 
public : 
	int getSize() { return m_size; }
	vector( int capa =  16 ) 
	{
		m_buf = new T[capa];
		m_capa = capa; 
		memset(m_buf, 0, m_capa);
		m_size = 0;
	}
	// 복사 생성자 !!  
	vector( const vector & v  )
	{
		// 앑은 복사 !!  -->m	m_buf  = v.m_buf; 
		m_buf = new T[ v.m_capa ]; 
		m_size = v.m_size; 
		m_capa = v.m_capa;
		memcpy( m_buf, v.m_buf, m_capa); 
	}


	// 배열의 행동들... 
	//1) 인덱스를 통한 접근 !! 
	T & operator[](int index)
	{
		return m_buf[index]; 
	}
	void push_back(T data)
	{
	//	if( m_size <= m_capa -1) 
	//	{
		//	m_buf[m_size] = data;
		//	m_size++;
	//	}
		Insert( End(), data); 

	}
	void pop_back()
	{
	//	if( m_size > 0)
	//	{
	//		m_buf[m_size-1] = 0;
	//		m_size--;
	//	}
		erase( End());
	}
	void Insert(  T * Where,   T data) 
	{   
		T * p = m_buf + m_size; 

		if( m_size <= m_capa-1) 
		{
			while( p != Where)
			{
				*p = *(p-1);
				 p--;
			}
			*(Where+1) = data; 
			m_size++;
		}					
	}
	void erase(  T * Where ) 
	{
		T * p =  Where; 

		while(  p != m_buf + m_size) 
		{
			*p = *(p+1);
			 p++;
		}
		m_size--;
	}

	T * find( T val) 
	{
		for(int i = 0; i v;


	v.push_back("10");
	v.push_back("30");
	v.Insert( v.find("10") ,"20");
		
	for( string * str = v.Begin(); str != v.End(); str++) 
	{
		cout <<  *str <

/**************************************************************
// 동적 배열은 크기가 얼마인지 모르는 경우에 유용하게 사용된다 !! 
//**************************************************************
// 네이버 카페 --> 메뉴의 항목들을 관리 할경우 !!

// 동적 배열을 이용한 함수들 작성 !! 

// 전체적인 카운트 관리가 필요 !! 
// 1) 동적 배열을 할당하는 함수 !! 
  void main()
  {
	int * buf; 
	InitArray( &buf, 10); 
  }

  void InitArray( int ** buf , int size); 
  {	
	  *buf =  (int*)malloc(sizeof(int)*size); 
  }
// 2) 동적배열에 값을 저장하는 함수 --> 맨뒤에 저장 
  void Add( int * buf,  int data );
  {




  }
  //[10][20][30][40][50][60] 
// 3) 동적배열에 값을 지정한 위치에 저장하는 함수  
  void insert( int index, int data);
 // 1 , 10
//  [1][10][10][10][2][3] 
  void erase( int index); 
//0
//[0][0][0] //배열에 아무값도 남아 있지 않으면 동적 배열을 해제 !!  
*/

#include 
#include 
// 동적배열을 이용한 함수들 작성

// 1) 동적 배열을 할당하는 함수
// 2) 동적배열에 값을 저장하는 함수 -> 맨뒤에 저장(리사이즈)
//   [10][20][30][40][50]
// 3) 동적배열에 값을 지정한 위치에 저장하는 함수
// 4) 삭제 -> 배열에 아무값도 남아있지않으면 배열 해제

int cnt=0;
// 1) 동적 배열을 할당하는 함수
void initArr(int *buf,int size)
{
   if(size == 0)
   {
      puts("'0'으로는 할당할 수 없습니다");
      return;
   }
   buf = (int *)realloc(buf,sizeof(int)*size);
}
// 2) 동적배열에 값을 저장하는 함수 -> 맨뒤에 저장(리사이즈)
void add(int *buf, int data)
{
   if(cnt < _msize(buf)/sizeof(int))
   {
      buf[cnt] = data;
      cnt++;
   }
   else
   {
      buf = (int*)realloc(buf,_msize(buf)+sizeof(int)*100);
      //buf = (int*)realloc(buf,(cnt+1)*sizeof(int));
      buf[cnt] = data;
      cnt++;
   }
}
// 3) 동적배열에 값을 지정한 위치에 저장하는 함수
void insert(int *buf, int index, int data)
{
   int *temp = (int*)malloc(sizeof(int)*(cnt-index+1));
   for(int i=0; i 배열에 아무값도 남아있지않으면 배열 해제
void erase(int index)
{
}

void main()
{
   int *buf=(int*)malloc(sizeof(int));
   initArr(buf,4);
   printf("buf : %d\n", _msize(buf));
   
   add(buf,1);
   add(buf,2);
   add(buf,3);
   add(buf,4);
   add(buf,5);
   add(buf,6);
   //insert(buf,0,10);
   for(int i=0; i<10; i++)
      printf("buf[%d] : %d\n",i,buf[i]);

   

}

//********************************************************
// 동적 배열  
//*******************************************************
// 1) C언어 !! 
// --> malloc, calloc , realloc 
//********************************************************
//********************************************************
#include 
#include  
void printArray( int * buf )
{
	for(int i = 0; i< _msize(buf)/sizeof(int) ; i++)
	{
		printf("%d", *(buf+i));
	}
	puts("");
}
void main()
{
	// malloc --> heap메모리에 내가 원하는 만큼의 메모리 공간을 할당하고
	// 공간의 시작 주소값을 리턴해주는 함수 !! 
	//int * buf  = (int*)malloc( sizeof( int) * 10 );
	//  malloc + memset  
//	int * buf  =  (int*)calloc( 10, sizeof(int));
	// _msize : heap에 할당된 메모리의 크기 
	/*
	printf("buf : %d\n" ,  _msize( buf));
	printArray( buf);
	buf  = (int*)realloc(buf, _msize(buf)*2); 
	printArray( buf);
	printf("buf : %d\n" ,  _msize( buf));

	free( buf); 
	*/ 
	 int * buf = new int[10]; 

	 printf("buf : %d\n" ,  _msize( buf));

	 // 메모리 해제 !! 
	 delete [] buf; 


}

//************************************************************
// 배열 !! 
//************************************************************
// 정적배열 !! 
//************************************************************
// c/c++에서 제공해주는 배열을 정적배열 !! 
//     --> int p[10];  
//************************************************************
// 장점  :  속도가 가장 빠르다 !! --> 한번 할당을 하게되면 더이상 할당 해제 필요없음
//       :  시스템 호환성이 좋다..-->   
//       :  랜덤 엑세스가 가능하다 !! [1][2][3][4][5] -->p[1]	
// 단점 
//       :  고정된 크기 !! --> 메모리 낭비, 
//						  --> 유지보수성이 떨어진다. 
//							  Student list[40];  -->
//**********************************************************************
// 정적 배열을 사용하는 경우 !! 
// 1. 크기 완전 고정된 크기일 경우 !! ---> 주민번호, 전화번호 
// 2. 고성능이 필요한 경우 !!         ---> [200]
// 3. 일반적인 지역변수로 변수로 사용되는 경우 !!   
//**********************************************************************
/*  
***********************************************************************/
#include 

void printArray( int * buf )
{
	for(int i = 0; i<5; i++)
	{
		printf("%d", *(buf+i));
	}
}
int * InputArray()
{
	// 지역 변수로 선언된 배열의 포인터는 리턴하면 안된다 !! 
	int buf[5]; 
	for(int i = 0; i<5; i++)
	{
		printf("input number: ");			
		scanf("%d", buf+i);
	}
	return buf; 
}
void main()
{	
	int * buf =  InputArray(); 
	printArray(buf); 
		
}

//**********************************************************
// 포인터 연산 
//**********************************************************
// 포인터 +1 :  100 +1  100 + sizeof(type)*1; 

#include 

void main()
{
	int p[5] = {1,2,3,4,5};
/*	printf("p =  %d\n" , p);
	printf("p +1 =  %d\n" , p+1); // &p[1]
	printf("p +2 =  %d\n" , p+2); // &p[2] 
	*/
	
	printf(" *p+1 =  %d\n" , *(p + 1) );

}

//********************************************************
// 다차원 배열과 포인터 !! 
//********************************************************
#include 

void main()
{
	int p[3][4]={ {1,2,3,4},
					{5,6,7,8},
					{9,10,11,12}};

	int * p1;
	// 2차원 배열 포인터 !! 
	int (*p2)[4]; 
	p2 = p; // 가르키는 대상이 다르다 !! 

	printf("p = %d\n" , p2); // 2차원 배열의 이름 --> 시작 주소값 
	printf("p = %d\n" , p2 + 1);
	// 2차원 배열 포인터를 통해 실제 값에 접근 !! 
	printf("%d\n" ,  p2);
	printf("%d\n" ,  *(*(p2+2)+2) );
	printf("%d\n",  &p2[2][2]);
//	[][] ==  **
}

//----------------------------------------------------
//  C언어 에서는 mem~~ 시작하는 함수들을 제공한다 !! 
//----------------------------------------------------
// memcpy : 복사 
// memset : 초기화 
// memmove: 이동 
// memcmp : 비교 
// msdn을 통해서 찾아보고 직접 구현 !! 
//----------------------------------------------------
/*  2D게임 작성 !! 
//  2048 게임   


*********************************************************/

//************************************************
//  포인터 정복 !! 
//************************************************
// 1. 참조와 역참조의 개념을 정확히 이해하자 !! 
// 2. 연산자 우선순위에 대해 정확히 이해하자 !! 
// 1) 괄호의 변경 --> 우선 순위 개념 !! 
// 2) *의 갯수 :  참조와 역참조의 개념 !! 
//		 p[0]->a;
// 3. 무엇의 주소인가 ?? 
//   - 가르키는것이 무엇인가? !! 
//    int  * -->  4byte 
//   char * --> 1byte
//************************************************
// 배열과 포인터 !! 
//************************************************
// 배열 --> 연속된 메모리공간에 같은 타입의 데이타들의 집합 !! 

#include 
#include  
void main()
{
	//int p[3]; // [ ][ ][ ] 
	// 쓰레기 값때문에 초기화 불가능하다 !! 
	//printf("%d %d %d\n" ,  p[0] , p[1], p[2]);
	//printf("%d %d %d\n" ,  &p[0] , &p[1], &p[2]);
	// 인덱스를 통한 젒근 
	//	p[0] = 10; 
	//	printf("%d %d %d\n" ,  p[0] , p[1], p[2]);
/*	int p[3] = {0}; //1)
	int p1[] = {0,1,2}; //배열의 크기를 컴파일러에 할당을 위임 !! 
	p[0] = 0; //2) 
	p[1] = 0;
	p[2] = 0;
	//3)
	for(int i = 0; i<3; i++  )
		p[i] = 0; 
	//4) 
	memset(p,0,3);*/
	 
	//다차원 배열 !! 
	/*int p[3][3] ={ {0,1,2},
					{0,1,2},
					{0,1,2}};*/ //[10][20][30]
	// 배열의 배열의 의미한다 !!
/*	int p[20][50][18][14][4]; // [2][1][3][3]
								// [2][1][3][3]
	
	struct car
	{
		int seat[14][4];
	}

	struct KTX
	{ 
		car carlist[10]
	}
	struct S_to_p
	{
		KTX TheKtx[50]; 
	}
		
	S_to_p[0].carlist[7].seat[7][3]; 
*/
	// [2][1][3][3]
	// [2][1][3][3]
  
	// [2][1][3][3]
	// [2][1][3][3]
  
	// [2][1][3][3]
	// [2][1][3][3]
	
	// 배열과 포인터의 관계 !! 

	// 1차원 : 
	int Array[3] = {0,1,2}; 

	int *  p; 

	p = Array; // 배열의 시작 위치의 주소값!! 

	printf("Array = %d\n", Array);
	printf("p  = %d\n" , p);
	printf("p  = %d\n" , *p); 
	printf("p[0]  = %d\n" , p[0]); 
	// * == [] == 
  




}

// -----------------------------------------------------------
//   포인터 !! 
// -----------------------------------------------------------
// 포인터 --> 메모리 주소에 대한 기호화된 표현이다 !! 
// 주소 ---> 이름 !!  
// 63빌딩   --> 서울시 영등포구 여의도동 1111-1번지
// 실제로 모든 변수는 메모리 상의 자기만의 고유한 번지위치를 갖는다 !! 
// 하지만, 주소번지를 직접사용하기에는 난감하기때문에... 주소에 대한 이름 !!  

// 포인터 변수 !! 
// 자기 자신의 값으로 메모리의 주소값만을 갖는 변수 !! 

// 포인터 변수 선언 !! 
	// 타입 *  이름;
/*	 int* p; 
	 char * ch; 
	 double * d; */
// 대상체 * 변수이름 ; 
//**********************************************************
//   int * p = 10;  //포인터 변수에는 오직  주소값만 저장할 수 있다.
//**********************************************************

#include 

void main()
{
	//*****쓰레기 값 *****************************************************
	//int * p; //  stack에저장되어지는 변수는 모두 쓰레기값으로 초기화 !!  
	//printf("%d\n" , p);
	//printf("%d\n" , &p);
	// 1) & 주소 연산자 !! 
	// ---> 변수의 실제 주소값을 얻어올때 사용한다 !! 
	//**********************************************************
	int * p; // 포인터 변수 선언 !! 
	
	int val = 10;
		
	printf("&val = %d\n" ,  &val);
	// 포인터 변수에 변수의 주소값을 할당한다.. 
	//( 참조한다. 가르킨다.)
	p = &val; 
	// 2) * 역참조 연산자 
	// --> 주소값을 역참조해서 실제 값이 있는 곳으로 이동 !! 
	// --> 주소값이 실제 가르키는 곳의 값을 가져올때 사용 !! 

	//printf("val = %d  \n" , val) ;
	//printf("*p = %d\n " ,  *p );
	 
	//기타  
	printf("%d\n",  p );
	printf("%d\n",  *p );
	printf("%d\n",  &*p );





	

}