기록하며 성장하기

#include<stdio.h>
#define PI 3.1415
void Greeting();
double GetCircleArea(int);

void main(void)
{
	void (*ptr1)();
	double (*ptr2)(int);
	int radius;
	double area;

	ptr1 = &Greeting;
	(*ptr1)();

	ptr2 = &GetCircleArea;
	radius = 10;
	area = (*ptr2)(radius);
	printf("반지름이 %d인 원의 면적은 %.2f \n", radius, area);

}

void Greeting(){
	printf("Hello CodeIn!! \n");
}

double GetCircleArea(int radius){
	double area = PI*radius*radius;
	return area;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void main()
{
	char* ptr1;
	char* ptr2 = "korea";
	char* ptr3 = NULL;
	ptr3 = (char *)malloc(sizeof(char)*20);

	//strcpy(ptr1, "Good Korea"); //warning 초기화하지 않고 씀 
	//strcpy(ptr2, "Good Korea"); //warning 이미 korea가 할당되어 korea가 상수이므로 
			           //korea를 수정할 수 없음 문자열 상수
	strcpy(ptr3, "Good Korea");

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

	free(ptr3);

}

ptr2 는 "korea"가 이미 할당되어 문자열 상수를 가르키는 포인터가 된다.
문자열 상수는 내용을 고칠 수 없으므로 사용할 수 없다.

하지만
ptr2 = "hi korea";
로 바꿀 수는 있다.

#include<stdio.h>

void main()
{
	int a = 10;
	int b = 20;

	const int *pa = &a;
	//*pa = 20; //값을 변경할 수 없다. (Error)
	pa = &b;	//주소 변경 가능
	
	int const *pb = &b;
	pb = &a;

	int* const p = &a;
	*p = 30;
	
}

배열과 포인터가 완전 같지는 않다고 한다. 그럼 차이점은 무엇일까?

int ar[n];
int *pi;

1. 포인터는 변수인데 비해 배열은 상수이다.
  pi는 고유의 메모리를 차지하고 있고 언제든지 다른 대상을 가리킬 수 있지만 ar은 선언할 때 그 위치가 이미 고정되므로 다른 대상을 가리킬 수 없다. ar로는 오로지 배열의 선두 번지를 읽을 수 있을 뿐이다.

2. pi가 가리키는 배열의 크키는 동적으로 결정할 수 있지만 ar이 가리키는 배열의 크기는 선언할 때 정적으로 결정된다.
 고정된 길이의 배열이 필요하면 int ar[n]; 선언문으로 배열을 생성하는 것이 편리하고 가변길이의 배열이 필요하면 int *형의 포인터 변수를 선언한  후  malloc으로 할당해서 사용해야 한다. 포인터로 할당한 배열은 실행 중에라도 realloc으로 크기를 재할당하여 변경할 수 있다.
 
3. 배열은 그 자체가 크기 때문에 함수의 인수로 전달할 수 없지만 포인터는 대상체가 무엇이든간에 4바이트의 크기밖에 차지하지 않으므로 함수로 전달할 수 있다.
 그래서 배열을 함수로 전달할 때는 반드시 포인터를 사용해야 한다.

4.배열로 요소를 읽는 것과 포인터로 대상체를 읽는 동작의 속도 차이가 있다.
 배열의 첨자 연산은 매번 배열선두에서부터 출발하지만 포인터는 대상체로 직접 이동해서 바로 읽으므로 액세스 속도가 빠르다. *pi는 pi가 가리키는 곳을 바로 읽지만 ar[n]은 *(ar+n)으로 일단 번지를 더한 후 읽어야 하므로 조금 느리다. 포인터가 배열보다 두배 정도 빠르다.

#include <Turboc.h>

void main(void)
{
	int ar[5]={1,2,3,4,5};

	printf("ar[2]=%d\n", ar[2]);
	printf("ar[2]=%d\n", *(ar+2));
	printf("ar[2]=%d\n", 2[ar]);
}

#include <Turboc.h>

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

	printf("ar[2][1]=%d\n", ar[2][1]);
	printf("ar[2][1]=%d\n", *(*(ar+2) +1));

	//부분 배열을 가르키는 포인터
	printf("sizeof(ar+2)=%d\n", sizeof(ar+2));
	//선두번지의 포인터 상수 즉 부분 배열이 된다. 
	printf("sizeof(*(ar+2))=%d\n", sizeof(*(ar+2)));
	printf("sizeof(*(ar+2)+1)=%d\n", sizeof(*(ar+2)+1));
	

	printf("ar[2][0]=%d\n", *(ar+2));
	printf("ar=%d\n",ar);
	printf("*ar=%d\n",*ar);
	printf("**ar=%d\n",**ar);
	printf("ar[0][3]=%d\n", *(*ar + 1));
	printf("sizeof(*(ar+2)+0)=%d\n", sizeof(*(ar+2)+0));
}

#include <Turboc.h>

void main(void)
{
	int ar[4]={10,20,30,40};

	printf("%d\n", *ar+2);
	printf("%d\n", *(ar+2));
}

#include <Turboc.h>

void main(void)
{
	int arr[2] = {1,2};
	int *pArr=arr;

	printf("%d, %d \n", arr[0], *(arr+1));

	printf("%d, %d \n", pArr[0], *(pArr+1));
}

배열의 내부적 처리
 C에서 다차원 배열이란 1차배열의 연장선을 말한다. 내부적으로는 하나로 쭉 연결된 구조이다. 하지만 부분 배열이 온전하게 배열로 대접받는다

#include <Turboc.h>

void arDump(void *array, int length);

void main(void)
{
	unsigned char ari[2][3] = {{1,2,3},{4,5,6}};

	arDump(ari, sizeof(ari));
	arDump(ari[0], sizeof(ari[0]));
	arDump(ari[1], sizeof(ari[1]));
}

void arDump(void *array, int length)
{
	int i;
	for(i=0;i<length;i++){
		printf("%02X ", *((unsigned char *)array+i));
	}

	printf("\n");
}

#include "Turboc.h"
#include "math.h"

void main(void)
{
	int r;

	for(r=0;r<=90;r+=10){
		printf("sin(%d도)=%f\n",r,sin(r*3.1416/180));
	}
}

#include "Turboc.h"
#include "math.h"

void main()
{
	double angle;
	int x=-1,y=-1;

	clrscr();
	gotoxy(40,12);
	putch('S');
	for(angle=0;;angle+=10){
		if(angle==360) angle=10;
		//if(kbhit()) break;
		gotoxy(40+x,12+y); 
		putch(' ');
		x=int(cos(angle*3.1416/180)*20);
		y=int(sin(angle*3.1416/180)*10);
		gotoxy(40+x,12+y); putch('E');
		delay(100);
	}
}

이런걸 만들 수 있다. 와우 신기하구나... 꿀꺽