🤳 [C]_23.03.27

🧡 보충 설명

• 이중 포인터 변수의 이해
  https://better-tomorrow.tistory.com/entry/%ED%8F%AC%EC%9D%B8%ED%84%B0%EC%9D%98-%ED%8F%AC%EC%9D%B8%ED%84%B017-1-%ED%8F%AC%EC%9D%B8%ED%84%B0%EC%9D%98-%ED%8F%AC%EC%9D%B8%ED%84%B0%EC%97%90-%EB%8C%80%ED%95%9C-%EC%9D%B4%ED%95%B4

• 문자열은 하나의 주소값을 지닌다. (문자열을 매개변수로 넘겨받는 방법)

• 문자열이 함수의 인수로 넘어간다면 주소가 넘어가는 것입니다.

• 전달받는 쪽에서는 포인터변수가 준비되어 있어야 하죠.

  • void aa(char x[])
  • void aa(char x[20])
  • void aa(char* x;)

위 세 문장은 같습니다.

• *과 & 표기법
  • 정확히 말하면 *는 *다음에 오는 것이 가리키는 주소를 의미한다.
  • char *p는 그렇다면 p라는 변수가 가리키는 주소를 의미하는 것이다.
  • 따라서 *p = &addr로 사용 가능하다.

배열 표기법과 포인터 표기법의 관계

아래는 같은 표현임

• data[1] = 5;

• *(data +1) = 5;

• *(data +0) 은 *(data)로 줄여서 쓸 수 있다.

• *p = 3;

• p[0] = 3;

• 배열과 포인터 변수와의 관계에서 다음과 같은 표현은 모두 동일한 표현이라는 것을 기억해두자!

  • count+i = ptr+i = &count[i] = &ptr[i] : 배열의 i+1 번째 위치의 주소(배열의 시작은 0)
  • *(count+i) = *(ptr+i) = count[i] = ptr[i] : 배열의 i+1번째 위치의 데이터

• 배열과 포인터가 본질적으로 같다는 것은 배열에 저장된 데이터를 더 세밀하게 조작할 수 있다는 것을 의미한다.

• 이는 포인터의 형변환을 통해 가능하다.

• 시작주소 1바이트에 저장된 0x78을 0x22로 바꾸고 싶을때 어떻게 할까?

  int arr[0] = 0x22;

• 배열은 선언된 자료형태에 따라 연산된다. 따라서 위와 같은 코드는 첫 메모리 뭉텅이, 그러니까 int에 해당하는 4바이트를 0x22로 바꾼다는 것을 의미하고, 0x12345678이 저장되어있던 4바이트는 0x00000022 가 되어버린다.

  • 이 문제는 포인터를 활용해서 해결할 수 있다.

*(char *)(arr) = 0x22;

• 포인터의 형태를 1바이트인 char로 변환하고 (이는 일시적이다.) arr[0]을 주소로 주면 arr[0]의 첫 1바이트를 0x22로 변경하게된다.

• *p = (char *)&tips; : 1바이트 단위로 쪼개서 주소를 부여.

• sum = *(p+0) + *(p+1) + *(p+2) + *(p+3); : 각 바이트값을 합산(포인터 표기)

• sum = p[0] + p[1]+ p[2] + p[3]; : 각 바이트값을 합산(배열 표기)

char data;
char *p = &data; //data 변수의 주소를 p에 저장함
*p = 3; //p가 가리키는 data 변수에 3을 대입함
p[0] = 3; //*p = 3; 과 같음

+)

• while 문 안의 조건은 값이 나올 떄 까지!!(주소값이 들어가면 무한루프)

• 선언된 문자 배열에 null이 있고, 이를 출력하는 while문에서 while(**ptr) 시 run time error 발생 ( "" 로 기재하면 가능)

• while(*ptr) =while(*ptr[0])

🧡 이중 포인터 변수

ref. https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=sharonichoya&logNo=220496504183&view=img_2

• int i =30;
• int* p =&i;
• int **q = &p;

🔽

• 더블 포인터를 참조하게 되면 매개변수로 전달된 포인터 변수 안에 있는 값을 얻을 수 있음.

• 이중포인터 사용 이유:

  • 포인터 배열(char* ptr[])을 실인수로 전달하기 위해서는, 매개변수를 더블 포인터로 선언 필 (char** ptr)

  https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=kails_&logNo=220165702409

• main() 에서 전달하는 변수가 포인터변수였고, 그 포인터변수의 주소값을 넘겨야 하므로, &refer가 되어야 하는 게 맞으며, 그에 맞춰서 call_by_refer(int **ref) 처럼 이중포인터가 되는게 맞겠지요.

• printf("sizeof((double *)ptr): %d \n", sizeof((double *)ptr) ); => 4byte // 포인터가 가리키는 자료형 변환 , 포인터의 크기를 구했으므로 자료형 상관없이 4byte 출력

• printf("sizeof(*(double *)ptr): %d \n", sizeof(*(double *)ptr) ); => 8byte // 형 변환된 자료형 크기 확인

pointer7.c

//pointer7.c
#include <stdio.h>


// ptr의 문자열을 출력 // 포인터 배열의 `주소값`을 전달하기 위해 이중 포인터 사용 
funcA(char** ptr) //3000번지 // funcA(char*ptr[]) // 더블 포인터를 참조하게 되면 매개변수로 전달된 포인터 변수 안에 있는 값을 얻을 수 있음. 
{
	while (*ptr) //3000번지가 가리키는 7000 
	{
		printf("%u, %u : %c \n", ptr, *ptr, **ptr); // 7000번지에 입력된 단일 문자 출력 
		// printf("%u, %u : %s \n", ptr, *ptr, *ptr); // 7000번지에 입력된 문자열 출력 
		ptr++; // 다음 문자열 요소 출력  // *(ptr++); // (*ptr)++  
	} 
}

int main()
{
	int num, * ip, ** mip;		// 이중포인터 변수		
	// 한 번만 찾아가면 데이터 -> 싱글포인터 
	// 한 번 찾아갔을 때 주소, 두 번 찾아갔을 때 데이터 -> 이중포인터

	printf("%d, %d, %d \n", sizeof(num), sizeof(ip), sizeof(mip));

	ip = &num;
	mip = &ip;
	
	**mip = 350;

	printf("%d, %d, %d \n", num, *ip, **mip);

	char* ptr[8] = { "kingdom test",
					"Advance C programming",
					"C++ programming",
					"one two three",
					"multi campus",
					"seoul 서울시 강남구 양재동 100번지",
					"busan 부산시 해운대구 해운대동 바다 2 번지",
					NULL };

	funcA(ptr);

	return 0;
}

// 이중포인터 사용 이유: 
//  포인터 배열(char* ptr[])을 실인수로 전달하기 위해서는, 매개변수를 더블 포인터로 선언 필 (char** ptr)


// main() 에서 전달하는 변수가 포인터변수였고, 그 포인터변수의 주소값을 넘겨야 하므로, &refer가 되어야 하는 게 맞으며, 그에 맞춰서 call_by_refer(int **ref) 처럼 이중포인터가 되는게 맞겠지요. 

🧡 void 형 포인터

void_pointer1.c

//void_pointer1.c 

#include <stdio.h>

int main()
{
	char ch = 'A'; 
	int num = 100;
	double dnum = 5.6; 

	void* ptr; //void형 포인터 

	printf("ptr sizeof : %d \n", sizeof(ptr));  

	ptr = &ch; 
	printf("%c \n", *(char*)ptr); // 'A' // void형 포인터는 바로 포인터 연산 불가능 
	ptr = &num; 
	printf("%d \n", *(int*)ptr); // 'A' // void형 포인터는 바로 포인터 연산 불가능 
	ptr = &dnum;
	printf("%.3lf \n", *(double*)ptr); // 'A' // void형 포인터는 바로 포인터 연산 불가능 

	return 0; 

}
//void 형 포인터를 사용하는 경우 
//프로그램 실행중 다양한 타입의 주소값을 받을 포인터를 선언해줄 때

🧡 Generic 함수구현 : void 포인터와 함수 포인터 활용

• Generic Function (자료형에 구애받지 않고 하나의 로직으로 여러 데이터를 처리하는 함수)
• https://kaspyx.tistory.com/60

dataSwap.c

// dataSwap.c

#include <stdio.h>
void swap(void* sour, void* targ, int size);

int main()
{
	short int x = 100, y = 200; 
	int n1 = 500, n2 = 900; 
	double d1 = 1.1, d2 = 5.9; 
	char names[2][20] = { "kim ??", "lee ??" }; 
	
	// swap(&x, &y);  // short int *x = &x , 주소값을 넘겨주지 않으면 swap 내 변경된 값은 전달되지 않음(지역 변수로 소멸) 
	// swap2, swap3, ,,, 함수 4번 호출 필 => void로 함수 템플릿 만들기!! 
	swap(&x, &y, sizeof(x)); 
	swap(&n1, &n2, sizeof(int));
	swap(&d1, &d2, sizeof(double));
	swap(names[0], names[1], sizeof(names[0]));


	printf("x : %d, y: %d \n", x, y); 
	printf("n1 : %d, n2: %d \n", n1, n2);
	printf("d1 : %lf, d2: %lf \n", d1, d2); 
	printf("%s, %s \n", names[0], names[1]); 


	return 0; 
}


// Generic Function (자료형에 구애받지 않고 하나의 로직으로 여러 데이터를 처리하는 함수) 
void swap(void* sour, void* targ, int size) // 매개변수로 주소값을 전달
{  
	char tmp, i; // char형 i는 작은 정수를 담을 수 있음

	for(i=0;i<size;i++)
	{ 
		tmp = *((char*)sour+i);  // void형 포인터 변수에서 값을 사용시 반드시 캐스트 연산자를 통해 포인터 자료형 명시 
		*((char*)sour + i) = *((char*)targ+i);
		*((char*)targ + i) = tmp; 
	} 

} 

cf. 일반화하지 않는 경우

• https://dojang.io/mod/page/view.php?id=1961

🧡 함수 포인터

function_pointer1.c

//function_pointer1.c
#include <stdio.h>
/*
함수 포인터: 포인터 변수가 함수의 주소를 저장하여,
포인터 변수로 함수를 호출하게 한다.

형식: 자료형(*변수명)(인자리스트);
*/


void myFunc(char* ptr); // 함수 포인터 선언문 기재 필 (정의와 동시에 선언하는 경우에는 생략 가능) 


int main()
{

	void(*fPtr)(char* ); //함수 포인터 변수 선언 [  자료형(*변수명)(인자리스트);  ] 
	// cf. int(*ptr)[3]; // 배열 포인터 변수 선언 => 2차원 배열의 주소를 저장 

	printf("fPtr sizeof : %d \n", sizeof(fPtr)); // 주소값을 1개 보관 => 함수의 주소를 저장하고 있음을 컴파일러에게 알림 => return value 가 void 타입,  char * 받아들이는 함수 
	fPtr = myFunc;       // 함수 주소 할당(함수명은 함수의 시작주소이다)  
	// myFunc("this is a test."); //문자열 상수는 문자열의 저장된 주소값을 지님  
	(*fPtr)("multi campus");  // 함수 호출 
	fPtr("Advanced C Programming");  // 함수 호출 
	(*fPtr)("Advanced C Programming"); // 함수 호출  

	return 0;
}

void myFunc(char *ptr)
{
	printf("myFunc() : %p, %s \n",ptr, ptr); 
}

#include <stdio.h>

int add(int x, int y);
int sub(int x, int y);
int mul(int x, int y);
int div(int x, int y);

int main()
{
	int (*ptrArr[4])(int x, int y)={ add, sub, mul, div }; // 함수 포인터 배열 선언과 동시에 초기화 
	//int (*ptrArr)(int , int ); // ptrArr는 함수 포인터 변수, 함수의 주소값을 1개 저장 => 4byte 할당 
	//int (*ptrArr[4])(int, int); //ptrArr는 함수 포인터 배열, 함수의 주소값을 1개 저장 => 16byte 할당 

	int menu_no, num1, num2, result;
	char op[4] = { '+', '-', '*', '/' };
	char tmp[10];

//	ptrArr[0] = add;

   while(1)
	{
	    printf("\n1. add\n");
   		printf("2. subtract\n");
   		printf("3. multiply\n");
   		printf("4. divide\n");
   		printf("5. end\n");
		do {
   		      printf("\nSelect(1-5) --> ");
   	          scanf("%d%*c",&menu_no); //1, 3, abc
			      //gets(tmp); //1, abc
			     // menu_no = atoi(tmp);
        } while(menu_no<0 || menu_no >5);

		   if(menu_no==5)
				break;

   		printf("Input the two numbers --> ");
   		scanf("%d %d%*c",&num1, &num2); //100 30[enter]

		// 함수 포인터 배열로 
		result = (*ptrArr[menu_no - 1])(num1, num2); // 1=> 배열[1]에 덧셈 함수의 메모리 주소 저장 => 덧셈 함수 내 num1, num2 대입 수행  
   		printf(" %d %c %d = %d \n", num1, op[menu_no-1], num2, result);

    }

	return 0;
}

int add(int x, int y)
{
	return x+y;
}

int sub(int x, int y)
{
	return x-y;
}

int mul(int x, int y)
{
	return x*y;
}

int div(int x, int y)
{
	if(y==0)
	{
		printf("can not divide by 0\n");
		return -1;
	}
	return x/y;
}

🧡 변수와 메모리 할당 구조

https://reakwon.tistory.com/20

• stack에서 메모리는 컴파일 시점에서 결정됩니다.
• 힙 영역의 메모리는 실행시점(Run Time)에 결정됩니다.
• heap segment는 재활용 영역, 메모리를 쓰지 않을 경우에 free함수를 써서 메모리 해제 필

• 스택영역

  • 우리는 이제껏 스택영역에 메모리를 할당해 왔습니다. 컴파일 시점에 결정되는 영역입니다.

  • 함수의 지역변수, 매개변수등이 이 메모리에 할당이 됩니다. 그리고 함수가 종료되었을때 할당된 메모리를 반환하게 됩니다.
  • 그러니까 메인 함수안의 변수들은 모두 스택영역에 할당이 된거죠.

• 힙 영역

  • 이 영역의 메모리는 실행시점(Run Time)에 결정됩니다. 프로그래머에 의해서요. 이 영역을 힙영역이라고 합니다.

  • 한가지 더 보충설명을 하자면 스택영역은 높은 주소에서 낮은 주소로 할당이 되고, 힙영역은 낮은 주소에서 높은 주소로 할당이 됩니다. 그래서 재귀함수를 통해 함수를 계속호출하게 되면 힙영역을 침범해 스택오버플로우가 발생하게 됩니다. 그 반대의 경우는 힙오버플로우가 발생합니다.

🧡 Heap 세그먼트와 동적 메모리 할당

동적 메모리 할당

• 사용 경우:
  ● 처음 int배열 100개가 필요하다고 생각했는데 프로그램을 실행하다 보니 int배열이 500개만 필요한 경우
  ● int배열 500개가 모자라 배열 500개를 메모리에 더 할당해야 할 경우

void *malloc(size_t size)

• 이 함수는 size만큼의 메모리를 힙영역에 할당합니다. 어떤 자료형일지 모르니 반환형 데이터는 void포인터입니다.

void free(void *ptr)

• 하지만 그냥 메모리만 할당하고 해제하지 않으면 메모리가 누출됩니다. 우리는 메모리를 이제 쓰지 않을 경우(거의 함수 반환 직전)에 free함수를 써서 메모리를 해제해야합니다.

• 💛 할당된 공간의 일부만을 해제할 수 없음.

• 💛 free 는 heap segment 에서만 해제 권한을 가짐

• 💛 즉, free()함수의 인수는 malloc(), calloc(), realloc() 호출에서 반환받은 값, 즉 메모리 주소여야 함. (다른 메모리는 해제 대상이 아님)

malloc1.c

//malloc1.c 

#include <stdio.h>

int main()
{
	char* ptr; 

	ptr = (char*)malloc(100); 
	if (ptr == NULL)
	{
		perror("Error : ");
		exit(1); 
	}
	printf("input string? ");
	gets(ptr); //campus => 입력된 문자열이 괄호안의 주소(ptr)에 대입 , heap segment 에 메모리 할당됨 

	printf("ptr: %p, %s \n", ptr, ptr); 

	free(ptr); // 더 이상 접근 불가한 주소값으로 바뀜 (null pointer) 
	// free(ptr); 

	printf("ptr: %p, %s \n", ptr, ptr);

	return 0; 

}

🔽 free(ptr); 실행 전 출력

🔽 free(ptr); 실행 후 출력

• free(ptr); : 더 이상 접근 불가한 주소값으로 바뀜 (null pointer)

• 메모리 릭(Memory Leak)

  • 힙 영역에 할당된 메모리는 함수호출이 종료되어도 해제되지 않는다.
  • 대신 free() 등을 이용해서 사용이 완료된 메모리를 명시적으로 해제해야 한다.
  • 그러나 이 메모리가 해제되지 않으면 메모리 릭이 발생한다.

  void *calloc(size_t n, size_t size)

  • calloc은 malloc과 힙영역에 할당하는 것을 똑같습니다. 사용법과 초기값이 다른데요.
  • calloc은 할당된 메모리를 전부 0으로 초기화합니다.

  void *realloc(void *memblock, size_t size)

  • realloc함수는 할당된 메모리를 다시 할당할때 쓰입니다.
  • 기존에 할당했던 포인터와 다시 할당할 size를 매개변수로 전달합니다.
  • 기존에 있던 값은 변함이 없습니다.(기존 데이터 보장)
  • 기존 메모리를 포함한 크기만큼 증가시킴 (기존이 100, 선언이 500 => 400만큼 증가시킴)

  🔽

  ptr = malloc(100); 
  ptr = calloc(20, sizeof(double)); 
  ptr = realloc(ptr, 500); 
  

🧡 복습 문제

enum_pointerEx.c

//enum_pointerEx.c
#include <stdio.h>
#include <string.h>
typedef enum Season
{
    SPRING,
    SUMMER,
    FALL,
    WINTER,
} SEASON;

GetSeason(int season)
{
    switch (season)
    {
    case 0:
        return("SPRING");
    case 1:
        return("SUMMER");
    case 2:
        return("FALL");
    case 3:
        return("WINTER");
    default:
        break;
    }
}

int main()
{
    char* ptr;
    enum  Season season = SPRING; // 1
    ptr = GetSeason(season);
    printf("선택한 계절: %s \n", ptr);
    return 0;
}

//enum_pointerEx.c
#include <stdio.h>
#include <string.h>
typedef enum Season
{
    SPRING=1,
    SUMMER,
    FALL,
    WINTER,
} SEASON;

GetSeason(int season)
{
    switch (season)
    {
    case 1:
        return("SPRING");
    case 2:
        return("SUMMER");
    case 3:
        return("FALL");
    case 4:
        return("WINTER");
    default:
        break;
    }
}

int main()
{
    char* ptr;
    enum  Season season = SPRING; // 1
    ptr = GetSeason(season);
    printf("선택한 계절: %s \n", ptr);
    return 0;
}

//enum_pointerEx.c
#include <stdio.h>
#include <string.h>
typedef enum Season
{
    SPRING=1,
    SUMMER,
    FALL,
    WINTER,
} SEASON;

GetSeason(int season)
{
    switch (season)
    {
    case SPRING:
        return("SPRING");
    case SUMMER:
        return("SUMMER");
    case FALL:
        return("FALL");
    case WINTER: 
        return("WINTER");
    default:
        break;
    }
}

int main()
{
    char* ptr;
    enum  Season season = SPRING; // 1
    ptr = GetSeason(season);
    printf("선택한 계절: %s \n", ptr);
    return 0;
}

double_pointerEX.c

// double_pointerEX.c 


#include <stdio.h>



void funcA(char** ptr)  // 포인터 배열을 가리키는 포인터, 이중 포인터 사용 필 
{
	int i;

	while (*ptr)
	{
		printf("%u : ", ptr);
		for (i = 0; i <= ptr[i][0]; i++) // for (i = 0; *(*ptr + i); i++)
		{
			printf("%c", ptr[i][0]);
		}
		printf(" // length : %d \n", i);
		ptr++;
	}

	// *(*ptr + i)= > * ptr: 행의 시작 주소 = > * ptr + i : 다음 행 호출 = > * (*ptr + i) 할당된 행에 대입된 값 출력 // ptr[i][0]
}

int main()
{

	char* ptr[] = { "kingdom test",
					"Advance C programming",
					"C++ programming",
					"one two three",
					"multi campus",
					"seoul 서울시 강남구 양재동 100번지",
					"busan 부산시 해운대구 해운대동 바다 2 번지",
					NULL };

	funcA(ptr);

	return 0;
}