또리야 개발하자

//*********************************************************************************************
// 배열을 함수로 전달하기 ( 매개변수로)
//*********************************************************************************************

#include 
//배열을 전달 받아서 배열을 화면에 출력하는 함수
//void parr(int pArr[])// []을 이용해서 배열임을 알린다!!


void parr(int* pArr) // * 포인터 변수를 이용해서 주소값임을 알린다.
{
	int i;
	for(i=0;i<5;i++)
	{
		printf("%d ",pArr[i]);
	}
}
// 사용자에게 이름을 입력 받는 함수 !!
void inputname(char* name)
{
	gets(name);
}
// 배열을 전송받아서 문자열을 출력하는 함수 !!
void Showname(char* name)
{
	puts(name);
}


void main()
{
	//배열의 이름 ?? 주소값 --> 배열이 메모리상에 위치하는 위치값!!
	int pArr[5] = {0,1,2,3,4};
	parr(pArr);
	char name[32];
	inputname(name);
	Showname(name);
}

//*********************************************************************************************
// 문자열과 배열 !!
//*********************************************************************************************
// C언어에서 문자열을 표현하기 위한 타입?? 없다 !!
// 문자배열에 문자를 넣고 마지막에 NULL을 붙여서
// 문자열을 표현한다!!
#include 

void main()
{
	char buf[16] = {'H','e','\0','l','o'}; // 문자배열 !!
	//문자열 배열 초기화

	char buf_1[10] = "hello"; // "": 자동으로 NULL값을 추가한다 !!
	char buf_2[10] = "A"; //문자열
	char buf_3[10] ={"hello"};
	//문자열 출력 함수 !
	// 사용자로부터 하나의 문자열을 입력 !!
	char buf_4[32];
	//scanf("%s",buf_4); //배열의 이름의 경우 주소값 &없어도 된다..
	//문자열 전용 입력 함수
	//gets(buf_4); // scanf : 공백문자(space)까지만 입력
				 // gets : enter까지 입력을 받는다 !!
	//puts(buf_4);

	char buf_5[26];
	for(int i =0;i<26;i++)
	{
		buf_5[i] = i+65;
	}
	buf_5[25] = '\0';
	puts(buf_5);
}

#include 
#include 
//*********************************************************************************************
// 배열
// 정의: 연속된 메모리 공간에 같은타입의 데이터들의 집합
//*********************************************************************************************
// 배열을 선언하고 정의하는 방법 !!
//*********************************************************************************************
/*
int a;

// 데이터 타입 배열의 이름[배열의크기];

// 배열의 특징 !!
// 1) 크기가 고정이다 !! -> 배열의 크기는 항상 상수값만을 준다 !!
	int No = 10;
	int Array[No];
	// - 실제 상수를 이용하는 방법
	int array[5];
	// - 기호상수를 이용하는 방법
#define MAX 100
	int Array[MAX];
	// - 배열의 크기는 프로그래머가 선언할때 준 크기를 계속해서 유지한다 !!
	// --> 동적 메모리 --> 동적배열을 이용해 해결하거나 연결리스트 사용 !!

// 2) 배열은 인덱스를 통해 랜덤 엑세스를 제공 !!
// --> 인덱스 --> []연산자를 사용해서 배열의 각각의 요소에 접근 한다 !!
	int p[5];
	[][][][][]
	p[0],p[1],p[2],p[3],p[4]

	p[0] = 100;
	p[4] = 200;
	p[5] = 500; // 말뚝넘기 오류 --> 예기치 못한 결과가 나옴
	// 배열의 인덱스값은 항상 0부터 시작한다.
	0~ 크기 -1
	*/
//*********************************************************************************************
//배열의 선언과 초기화 !!
//*********************************************************************************************
void main()
{
	//int Array[5] = {0,1,2,3,4};
	//int Array[5] = {0,}; // 나머지 공간은 0으로 초기화
	int Array[5];
	//메모리를 직접 초기화 하는 방법!!
	//memset(Array,0,20);
	for(int i=0;i<5;i++)
	{
		//Array[i] =0;
		//memset(Array,0,20);
		printf("%d " ,Array[i]); // 인덱스를 통한 접근
	}
}

//*************************************************************
// 포인터 배열
//*************************************************************
// --> 배열의 원소로 포인터를 갖는 배열 !!
//		[10][20][30][0][0] => 일반 배열은 실제 값을 갖는다 !!
//*************************************************************
// 포인터 4*5 = 20byte
// [ ][ ][ ][ ]
//
//*************************************************************
#include 
#include 

void foo(int** Array)
{
	int no1 = 10,no2 =20;
	
	Array[0] = (int*)malloc(sizeof(int));
	Array[1] = (int*)malloc(sizeof(int));
	*Array[0] = 10;
	*Array[1] = 20;
}

void insert(int** Array,int index,int value)
{
	if(Array[index] != NULL)
	{
		puts("쓰고있는 공간");
	}
	else
	{
		Array[index] =(int*)malloc(sizeof(int));
		*Array[index] = value;
	}
}

void print(int** Array)
{
	int i;
	for(i=0;i<5;i++)
	{
		if(Array[i] != NULL)	
		printf("%d ",*Array[i]);
		else
			printf("[ ] ");
		
	}
	puts("");
}
// 배열과 인덱스를 전달 받아서 인덱스를 삭제하는 함수
void del(int **Array,int index)
{
	if(Array[index] != NULL)
	{
		free(Array[index]);
		Array[index] = NULL;
	}
}

void print2array(int* (*Array)[4])
{
	Array[1][2] =(int*)malloc(sizeof(int));
	// index 이용한 방법
	*Array[1][2] = 10;  
	// 포인터를 이용한 방법
	**(*(Array+1)+2) = 10;
}
void print2(int* (*Array)[4])
{
	int i;
	for(i=0;i<5;i++)
	{
		if(Array[i] != NULL)	
		printf("%d ",*Array[i]);
		else
			printf("[ ] ");
		
	}
	


void main()
{
	int* Array2[3][4] = {NULL};
	int* Array[5]={NULL}; //int가 5개 모여있는 배열

	/*insert(Array,0,10);
	print(Array);
	insert(Array,0,20);
	print(Array);*/
	print2array(Array2);
	print(Array2);
	/*foo(Array);
	print(Array);
	del(Array,0);
	print(Array);
	del(Array,1);
	print(Array);*/

}

//****************************************************************
// 동적 배열 사용 예 !!
//****************************************************************
// 1. 크기를 모를 경우에 사용 !!

#include 
#include 
#include 
#include 

//void main()
//{
//	char *str;
//	char addr[128];
//
//	str = (char*)malloc(strlen(addr)+1);
//	strcpy(str,addr);
//	printf("주소 :");
//	gets(addr);
//	puts(addr);
//}

//****************************************************************
// 2. 크기가 변경되어야 하는 경우 !!

	//주차장 !!
void main()
{
	//int* parking,i;
	//int* temp;
	//parking =(int*)malloc(sizeof(int)*100);
	//parking[0] = 10;
	//parking[1] = 20;
	//parking[2] = 30;
	//// printf("%d\n",_msize(parking));
	//temp =(int*)malloc(_msize(parking)*2);
	//// 1) 수작업 !!
	//for(i =0;i<3;i++)
	//{
	//	temp[i] = parking[i];
	//}
	//free(parking);

	//parking = temp;

	//for(i =0;i<3;i++)
	//{
	//	printf("%d\n",parking[i]);
	//}
	char (*V1)[20];    char V2[20] ="hello";
	V1 = &V2;



}

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

/*	1. *p++
	2. p[0].name
	3. *(*p)+1
	4. *(p+1)[0]
	5. *(p++).name[0]
	6. &p[0] ->a
	7. **p+1
	8. *p+(1+2)[4].a
	9. *(*p)++
	10. p[0] -> name
	*/

//****************************************************************
// 동적 메모리와 포인터 !!
//****************************************************************
// 동적메모리 : 실행시간에 필요한 만큼의 메모리를 할당해 내는것
// heap메모리를 사용하는 것!
// 일반 배열 ? ==> 항상 같은 크기의 메모리 공간을 갖는다 !!
// 동적 배열 ? ==> 실행시간에 만들어지는 동적으로 생성되는 배열 !!
// malloc : memony allocation !! 메모리 할당 !!
// free : 메모리 해체 !!
#include 
#include 

void main()
{
	char *parking;
	int size,i;
	printf("주차장의 크기는 얼마인가요? ");
	scanf("%d",&size);

	// 할당할 메모리 크기 : byte
	parking = (char*)malloc(size * sizeof(int));
	// 동적 메모리 초기화 !
	for(i=0;i

#include 
//***********************************************************
// call by value
// --> 값의 복사본에 의한 변수의 전달 !!
// --> 원본값에 변화가 없다 !!
//***********************************************************
void swap(int x, int y)
{
	int temp =x;
	x =y;
	y = temp;
}









//***********************************************************
// call by reference
// 원본값은 그대로 두고 원본의 주소값을 전달
//***********************************************************
void swap_1(int* x,int* y)
{
	int temp = *x;
	*x = *y;
	*y= temp;
}
//***********************************************************
// 배열을 함수로 전달하기 !!
//***********************************************************

void init(int* Array)
{
	*Array = 10;
}





void main()
{
	int x=1,y=2;

	printf("%d %d \n",x,y);
	swap(x,y);
	printf("%d %d \n",x,y);

	printf("%d %d \n",x,y);
	swap_1(&x,&y);
	printf("%d %d \n",x,y);


}

//************************************************************
// 문자열과 포인터
//************************************************************
// --> c언어에서 문자열을 다룰수 있는 타입??
// --> 없다 --> 배열에 문자를 담고 마지막에 NULL문자 !!

#include 
#include 

void main()
{
	char buf[32];
	// 배열의 크기를 컴파일러에게 할당을 요청 !!
	// --> 권장하는 방법은 아님 !!
	char name[] ={"kim"};
	// 스트링테이블 !!
	// --> 프로그램상에 나타나는 문자열 상수들이 저장되는 테이블

	char *str = "l am a boy";

	// 1. 배열을 이용하는 방법
	// 2. char *를 이용하는 방법 !!
	name[0] ='l';

	//str[7] ='g';
	//str[8] = 'i';

	str = name;

	printf("%s\n",str);

	//************************************************************
	// 문자열을 다루는 함수들..
	//************************************************************

	// strlen : 문자열의 길이
	printf("%d\n",strlen(str));
	
	// strcmp : 문자열 비교
	if(strcmp(str,name) ==0) // 같으면 0 !!
	{
		printf("참 \n");
	}

	// strcpy : 문자열 복사
	strcpy(buf,"ABC");

	puts(buf);


	// strcat : 문자열 붙이기
	// 
	strcat(buf,name);

	puts(buf);

}

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

// 1차원 배열을 전달 받아서 초기화 하는 함수 !!
void lnit(int p[])
{

}

void main()
{
	int p[3][4]; //?? int[4] 1차원 배열이 3개의 배열 !!
	// 인덱스를 통해서 접근 !!
	p[1][2] =10;
	// 포인터를 통한 접근 !!

	lnit(p[0]);
	

	//printf("%d\n",p);
	//printf("%d\n",p+1); // 행단위로 움직이고있다.
	//printf("%d\n",p+2);
	//printf("%d\n",*p);
	//printf("%d\n",*p+1);
	//printf("%d\n",*p+2);

	//*(p+1)+2;
	printf("%d\n",&p[1][2]);
	printf("%d\n",*(*(p+1)+2));

	//p[1][2] == *(*(p+1)+2)
	// [][] == **
	// []하나는 *와 동일 하다 !!

	printf("");
}

//*********************************************************
// 포인터의 포인터 !!
//*********************************************************
// 주소값의 주소값 !!
// ***, ** --> 실제값에 도달하기 위해서 몇번의 역참조가 필요한 포인터 인가 !!
// 포인터의 깊이
// --> 주소값이 값에 가기위해서 몇번의 역참조 필요한가 !!

#include 

void main()
{
	int no = 10;
	int* p;
	int** pp;

	p =&no;
	pp = &p;
	printf("%d",**pp);

}