pds.devpia.compds.devpia.com/maeul/top_pds/20000/19542/chap-pointer... · web view5)포인터와...

2. POINTER----------------------------------------------------------------------------------------------------------------------------------3

2.1.POINTER기 능 ------------------------------------------------------------------------------------------------------------------ 32.2.POINTER종 류 ------------------------------------------------------------------------------------------------------------------ 6

2.2.1. <1 차 원 포 인 터 변 수 VS. 변 수 , 1 차 원 배 열 , 2 차 원 배 열 >-----62.2.1.1. <1 차원포인터 변수 VS. 변수>-------------------------------------------------------------------------------------------------62.2.1.2. <1 차원포인터 변수 VS. 1 차배열>-------------------------------------------------------------------------------------------8

2.2.1.2.1. <1 차원포인터변수 와 1 차배열( 전역변수, 지역변수)>---------------------------------------------------------82.2.1.2.2. <1 차원포인터변수 와 MALLOC >---------------------------------------------------------------------------------------112.1.2.1.3. <1 차원포인터 변수 VS. 2 차배열> (2 차배열 -> 1 차배열로 표현)---------------------------------------13

2.2.1.3. 응용문제------------------------------------------------------------------------------------------------------------------------------- 152.2.2. <1 차 원 포 인 터 배 열 과 2 차 원 배 열 >------------------------------------------------------16

2.2.2.1. <1 차원포인터배열과 로컬변수인 1 차배열>------------------------------------------------------------------------------162.2.2.2.<1 차원포인터배열과 malloc 활용>----------------------------------------------------------------------------------------------182.2.2.3. 응용문제------------------------------------------------------------------------------------------------------------------------------- 19

2.2.3. < 2 차 원 포 인 터 변 수 와 배 열 >-----------------------------------------------------------------202.2.3.1. <2 차원 포인터변수와 1 차원포인터 변수>------------------------------------------------------------------------------202.2.3.2. <2 차원 포인터변수와 1 차원 포인터 배열>---------------------------------------------------------------------------24

2.1.2.3.1. <2 차원포인터변수와 1 차원 포인터배열>---------------------------------------------------------------------------242.1.2.3.2. < 2 차원포인터변수와 malloc >----------------------------------------------------------------------------------------------34

2.2.4. int (*py)[max]------------------------------------------------------------------------------------------------------------------392.3. PARAMETER전 달 방 법 ----------------------------------------------------------------------------------------------- 40

2.3.1. Call by value--------------------------------------------------------------------------------------------------------------------402.3.2. call by reference[ 포 인 터 를 사 용 하 는 이 유 ] – 예 제 추 가 필 요 - - 412.3.3. call by address(C++ &)----------------------------------------------------------------------------------------------------432.3.4. 동 일 한 의 미 의 call by reference-------------------------------------------------------------------------452.3.5. Dangling Pointer : Loacl Variable Pointer Return(X)-------------------------------------------------------------------45

2.4. WINDOW,LINUX,UNIX 저 장 방 식 차 이 (BIG ENDIAN, LITTLE ENDIAN)----------------------------------------462.4.1.Intel Cpu Based Windows(or Linux)- (char 나 Int 형 이 다 른 저 장 방 식 )----------------482.4.2.Unix(SunSparc CPU) – 동 일 저 장 char 내 bit( 상 위 -> 하 위 ), int 내 bit( 상 위 -> 하위 )-------------------------------------------------------------------------------------------------------------------------------------512.4.3. BitMap( Bitwise Operation 의 응 용 )----------------------------------------------------------------------54

2.4.3.1. BIT MAP 의미------------------------------------------------------------------------------------------------------------------------- 542.4.3.2. BITMAP 관리 기법---------------------------------------------------------------------------------------------------------------- 54

2.4.4.C 언 어 메 모 리 연 산 함 수 ---------------------------------------------------------------------- 702.6.VOID POINTER 와 CAST 연 산 -------------------------------------------------------------------------------------- 71

2.6.1.Cast 연 산 개 념 과 수 식 연 산 ---------------------------------------------------------------------- 712.6.2.Cast 연 산 : String => 구 조 체 ---------------------------------------------------------------------------- 75

2.6.2.1.소스---------------------------------------------------------------------------------------------------------------------------------------- 752.6.2.2.분석---------------------------------------------------------------------------------------------------------------------------------------- 77

2.6.3.char, int, void pointer 의 수 식 연 산 ---------------------------------------------------------------------- 792.6.3.1.소스---------------------------------------------------------------------------------------------------------------------------------------- 792.6.3.2.분석---------------------------------------------------------------------------------------------------------------------------------------- 80

2.6.4.__int16(short,word) 과 int 형 (dword) 사 이 의 cast 연 산 과 Pointer 연 산 [G]--------802.6.4.1.소스---------------------------------------------------------------------------------------------------------------------------------------- 802.6.4.2.실행결과---------------------------------------------------------------------------------------------------------------------------------- 822.6.4.3.분석---------------------------------------------------------------------------------------------------------------------------------------- 83

2.6.5. 예 제 1. Linux Kernel 2.3.0 분 석 소 스 ------------------------------------------------------------------- 842.6.5.1.소스---------------------------------------------------------------------------------------------------------------------------------------- 842.6.5.2.분석---------------------------------------------------------------------------------------------------------------------------------------- 86

2.6.5.2.1. 동일 구조체 Array 에서 Pointer 의 수식연산 ( +/- n)------------------------------------------------------------862.6.5.2.2. 동일 구조체 Array 에서 pointer 들간의 연산--------------------------------------------------------------------- 862.6.5.2.3. 구조체내의 Attribute 들의 상대적 Offset 구하기.------------------------------------------------------------------87

2.6.6. 예 제 2. 구 조 체 내 attribute 의 offset 구 하 기 ------------------------------------------- 88

1

2.6.6.1.소스: list_entry()함수------------------------------------------------------------------------------------------------------------------- 882.6.6.2.분석---------------------------------------------------------------------------------------------------------------------------------------- 88

2.6.7. Void Pointer 예 제 3(Swap,Copy, Reverse)[G]-----------------------------------------------------------892.6.7.1. 소스( chap_pointer_10)----------------------------------------------------------------------------------------------------------------89

2.7. 함 수 의 포 인 터 변 수 ------------------------------------------------------------------------------------ 942.7.1. C++ 함 수 의 포 인 터 변 수 ------------------------------------------------------------------------- 942.7.2. C 함 수 의 포 인 터 변 수 ------------------------------------------------------------------------------ 95

2.7.2.1. 함수의 포인터변수 선언방법------------------------------------------------------------------------------------------------- 952.7.2.2. 함수포인터 예제------------------------------------------------------------------------------------------------------------------- 97

2.7.2.2.1. 예제1( 일반적 함수 포인터변수 예제)---------------------------------------------------------------------------------972.7.2.2.2. 예제 2( 사칙연산)----------------------------------------------------------------------------------------------------------------982.7.2.2.4. 예제4(BubbleSort)----------------------------------------------------------------------------------------------------------------103

ANNEX A. Version관 리 ------------------------------------------------------------------------------------------------------------ 104

2

2. pointer 2.1.pointer 기능 1)1 차 원 포 인 터 변 수 - 포 인 터 는 주 소 를 가 리 키 는 것 으 로 서 1차 원 적 ( 정 수 ,char 등 등 ) 배 열 을 가 리 킨 다 .2)1 차 원 배 열 - 문 자 열 경 우 는 NULL 문 자 가 나 오 면 문 자 의 끝 이 된 다 .3) 의 미

Data type포 인 터 변 수 명

Elemet( 요 소 )크 기

char short int long G_Record void

* P;

단 . Array : n 개 배 열 . (n: 자 연 수 )가 . char *p; charater type 의 Array를 point( 가 리 키 는 ) 하 는 주 소 값 을 담 고

있 는 변 수 p(4bytes)P 가 가 리 키 는 곳 이 일 차 원 배 열 이 고 요 소 (element)하 나 의 크 기 가 char형 이 다

나 . int *p; int type 의 Array를 point( 가 리 키 는) 하 는 주 소 값 을 담 고 있 는 변 수 p(4bytes)P 가 가 리 키 는 곳 이 일 차 원 배 열 이 고 요 소 (element)하 나 의 크 기 가 int 형 이 다

다 . G_Record *p;

G_Reocrd type 의 Array를 point( 가 리 키 는) 하 는 주 소 값 을 담 고 있 는 변 수 p(4bytes)P 가 가 리 키 는 곳 이 일 차 원 배 열 이 고 요 소 (element)하 나 의 크 기 가 G_Record 형 이 다

typedef struct Record{int index;char number[10];char name[30];char *next;

}G_Record; // 48bytes == 0x30bytes

라 . void *p; P 가 가 리 키 는 곳 이 일 차 원 배 열 이 고 요 소 (element)하 나 의 크 기 가 void형 ( 없 다) 이 다 즉 크 기 가 결 정 되 지 않 았 다 .p 가 담 고 있 는 주 소 값 으 로 Point 하 는 곳 이 int 형 인 지 char 형 인 지 Structure(Descriptor) 인 지 혹 은 Class인 지 는 알 수 없 다 . 다 만 모 든 Data type 의 pointer를 저 장 하 는 변 수 p(4bytes) 이 다 이 곳 에 저 장 된 값 을 이 용 할 때 는 Cast 연 산 (Pointer Type변 환 ) 을 이 용 하 여 사 용 한 다 .

[사 용 예 ] typedef void *HANDLE; // Visual C++ 에 정 의 된 HANDLE type char *char_ptr, char_string[100]; char_ptr = char_string;

3

void * void_ptr = (char *) char_ptr;

4)주 의 점int *p 혹 은 char *p 혹 은 G_Record *p 변 수 가 local variable 일 때 Garbage 값 이 들 어 간 다 .Global variable 로 선 언 되 어 있 다 면 0(‘\0’ = NULL)로 자 동 으 로 컴 파 일 러 에 의 해 초 기 화 된 다 .만 약 garbage 주 소 값 이 “ < 메 모 리 영 역 을 벗 어 난 곳 > 을 가 리 키 거 나 < 시 스 템 영 역 을 가 리 킨 > 상 태 에 서point 하 는 곳 의 값 들 을 고 치 려 고” 하 거 나 “ 메 모 리 영 역 을 벗 어 난 곳 을 읽 으 려 할 때 ” 시 스 템 다 운문 제 가 발 생 한 다 .

5) 포 인 터 와 배 열 의 차 이 점① 공 통 점 : 포 인 터 는 1 차 원 array를 가 리 킨 다. 무 조 건 1 차 원 Array 를 가 리 킨 다② 차 이 점배 열 컴 파 일 할 때 배 열 의 주 소 는 결 정 되 어 서 임 의 의

주 소 값 으 로 수 정 될 수 없 다 .( 포 인 터 상 수 다 )요 소 (element) 의 크 기 즉 총 개 수 에 대 한 표 현 이 있 다 ex) int a[100]; // 요 소 의 크 기 는 100 개 다

포 인터 변수

포 인 터 변 수 임 의 의 주 소 값 으 로 변 경 할 수 있 다 .요 소 (element) 의 크 기 즉 총 개 수 에 대 한 표 현 이 없 다 ex) int *P; // 요 소 의 크 기 는 무 한 대 다

③ 포 터 변 수 의 특 징 따 라 서 포 인 터 에 특 정 번 지 를 넘 기 면 모 두 array로 인 식 한 다 . 결 과 적 으 로 예 상 치 못 한 영 역 도 가 리 킬 위 험 성 이 있 다 . 결 국 프 로 그 래 머 는 포 인 터 가 가 리 키 는 영 역 의 범 위 (element의 범 위 )를 명 시 할 때 유 효 한 적 절 한 범 위 내 에 서 사 용 될 수 있 도 록 프 로 그 램 을 만 들 어 야 한 다 .

4

2. pointer 용 도 : call by reference를 응 용 하 여 작 업 을 한 다 . Call by reference 는 주 소 값 을 이 용 하 여 실 제 데 이 터 들 에 접 근 한 다 . 1)string 관 련 기 능 - source data 를 destiny 에 복 사 : ex) string copy, memory copy - string search - string compare 2) memory swap 3) function pointer 4) memory (graphic, game 에 서 sprite 복 사 등 에 응 용 ) - allocate - copy - move

5

2.2.pointer 종류 1 차 원 포 인 터 변 수 (1차 원 배 열 의 주 소 값 과 실 제 값 )

① 1차 원 포 인 터 변 수 VS. 변 수② 1차 원 포 인 터 변 수(parameter)VS. 1차 원 배 열

1 차 원 포 인 터 배 열 (2차 원 배 열 의 주 소 값 과 실 제 값 )

1 차 원 포 인 터 배 열vs n 개 의 1 차 원 배 열

2 차 원 포 인 터 변 수 (2차 원 배 열 의 주 소 값 과 실 제 값 )

①2 차 원 포 인 터 변 수(parameter) vs 1차 원 포 인 터 배 열 vs n 개 의 1 차 원 배 열② 2차 원 포 인 터 변 수 vs. malloc

Ex-1) data_type a[10];Sort( data_type *p, int size); // Sort(a, 10);Ex-2) data_type *a[10];Sort( data_type **p, int size); // Sort(a, 10);Ex-3) data_type a[3][10];Data_type *t[3]= { a[0], a[1], a[2] };Sort( data_type **p, int size); // Sort(t, 3);[ 포 인 터 에 서 사 용 되 는 두 연 산 자 *, &]

*p 주 소 값 을 가 진 변 수 P 가 가 리 키 는 곳 의 실 제 값 을 Data type 에 맞 게 얻 는 다

&c 실 제 값 을 가 진 변 수 C 의 주 소 값 을 얻 는 다*(P+n

)P 가 가 리 키 고 있 는 곳 의 n 번 째 요 소 의 실 제 값

P[n] P 가 가 리 키 고 있 는 곳 의 n 번 째 요 소 의 실 제 값

2.2.1. <1 차 원 포 인 터 변 수 VS. 변 수 , 1 차 원 배 열 , 2 차 원 배 열 >

2.2.1.1. <1 차 원 포 인 터 변 수 VS. 변 수 > ex) 파 일 명 : chap_pointer_11 차 원 포 인 터 변수

char *p; int *pt;

변 수 char c; int A;

가 . 소 스#include <stdio.h>void char_1_pointer(){

char *p,C='a';p=&C;printf("%c %c %c\n", C, *p, p[0]);printf("%x %x %x\n", &C, p, &p[0]);

}

void int_1_pointer(){

int *pt, A = 5;pt = &A;printf("%d %d %d\n", A, *pt, pt[0]);printf("%x %x %x\n", &A, pt, &pt[0]);

}void main(){

char_1_pointer();int_1_pointer();

}

6

나 . 그 림

다 . 실 제 값 과 주 소 값 < 실 제 값 > < 주 소 값 > < 실 제 값 > < 주 소 값 >C == *p == p[0] == ‘a’

&C == p== &p[0] A == *pt == pt[0] == 5

&A == pt == &pt[0]

라 . 실 행 화 면a a a 12ff24 12ff24 12ff24 5 5 5 12ff24 12ff24 12ff24

7

2.2.1.2. <1 차 원 포 인 터 변 수 VS. 1 차 배 열 > ① 1 차 원 포 인 터 변 수 와 로 컬 변 수 인 1 차 배 열 ② 1 차 원 포 인 터 변 수 와 malloc활 용

2.2.1.2.1. <1 차 원 포 인 터 변 수 와 1 차 배 열 ( 전 역 변 수 , 지 역 변 수 )> ex) 파 일 명 : chap_pointer_2 가 . 소 스#include <stdio.h>#define MAX_ARRAY 10

// char c[MAX_ARRAY]= "hello";void main(){

int n;char *p;char c[MAX_ARRAY]= "hello";p = &c[0]; // or p = c;// 실 제 값 출 력 , address 출 력for( n = 0; c[n] != NULL; n++)

printf("%c=%c=%c=%c : %x %x %x %x \n", c[n], *(c+n), p[n], *(p+n), &c[n], c+n, &p[n], p+n);

printf("\n");}나 . 그 림

다 . 실 제 값 과 주 소 값

8

( 참 고 )가 . (p+ n ) == &p[n]==p 가 가 리 키 고 있 는 주 소 를 sizeof(char) * n만 큼 이 동 한 곳 이 가 리 키 는 실 제 값

=> p 는 char * 이 므 로 이 동 주 소 는 sizeof(char) *n 이 다 .나 . *p+n == (*p)+n==p[0]+n== p[0] 의 값 에 +n 을 더 하 는 것

라 . 실 행 화 면h=h=h=h : 12ff6c 12ff6c 12ff6c 12ff6ce=e=e=e : 12ff6d 12ff6d 12ff6d 12ff6dl=l=l=l : 12ff6e 12ff6e 12ff6e 12ff6el=l=l=l : 12ff6f 12ff6f 12ff6f 12ff6fo=o=o=o : 12ff70 12ff70 12ff70 12ff70

10

2.2.1.2.2. <1 차 원 포 인 터 변 수 와 MALLOC > ex) 파 일 명 : chap_pointer_3가 . 소 스#include <stdio.h> // printf#include <malloc.h> // malloc#include <string.h> // strcpy#define MAX_ARRAY 10void main(){

int n;char *p;char c[MAX_ARRAY] = "hello";

// mallocif( (p = (char *) malloc(MAX_ARRAY * sizeof(char))) == NULL){

printf("failed to malloc\n");return ;

}

// usestrcpy(p, c); // strcpy(p, "hello")

// 실 제 값 출 력 , address 출 력for( n = 0; c[n] != NULL; n++)

printf("%c=%c : %x(%s) %x(%s) \n",p[n], *(p+n),&p[n], &p[n], p+n, p+n);

printf("\n");

// freefree(p);

}

나 . 그 림

11


라 . 실 행 화 면h=h : 430060(hello) 430060(hello)e=e : 430061(ello) 430061(ello)l=l : 430062(llo) 430062(llo)l=l : 430063(lo) 430063(lo)o=o : 430064(o) 430064(o)

12

2.1.2.1.3. <1 차 원 포 인 터 변 수 VS. 2 차 배 열> (2차 배 열 -> 1차 배 열 로 표 현 )

ex) 파 일 명 : chap_pointer_4 가 . 소 스 #include <stdio.h>#define MAX_ROW 2#define MAX_COLUMN 4

void main(){

int loop;int x, y;char *p;char a[MAX_ROW][MAX_COLUMN] ={

"123","456"

};

// p = &a[0][0];p = a[0];

// printfor(y = 0; y < MAX_ROW ; y++ )

for( x = 0; x < MAX_COLUMN; x++ ){

if(a[y][x] == NULL){

printf("\n");continue;

}printf("%c ", a[y][x]);

}printf("\n");

for( loop = 0; loop < MAX_ROW * MAX_COLUMN; loop++ ){

if( p[loop] == NULL){

printf("\n");continue;

}printf("%c ", p[loop]);

}printf("\n");

}나 . 실 행 결 과1 2 34 5 6

1 2 34 5 6

13

나 . 그 림


15

2.2.1.3. 응 용 문 제

16

2.2.2. <1 차 원 포 인 터 배 열 과 2차 원 배 열 > ① 1차 원 포 인 터 배 열 과 로 컬 변 수 인 1 차 배 열 을 여 러 개 할 당② 1 차 원 포 인 터 배 열 과 malloc활 용

2.2.2.1. <1 차 원 포 인 터 배 열 과 로 컬 변 수 인 1 차 배 열 > ex) 파 일 명 : chap_pointer_5 가 . 소 스 #include <stdio.h> // printf#include <malloc.h> // malloc#include <string.h> // strcpy

#define MAX_ARRAY 3#define MAX_COLUMN 100

void main(){

int loop ;char * s[MAX_ARRAY];char p1[MAX_COLUMN];char p2[MAX_COLUMN];char p3[MAX_COLUMN];

// 주 소 넘 기 기s[0] = p1;s[1] = p2;s[2] = p3;

// 문 자 열 복 사 .strcpy(s[0], "123");strcpy(s[1], "456");strcpy(s[2], "789");

// 출 력for( loop = 0; loop < MAX_ARRAY ; loop++)

printf("문 자 열 : %s ( 주 소 : 0X%x)\n", s[loop], s[loop]);}

17

나 . 그 림


라 . 실 행 화 면문 자 열 : 123 ( 주 소 : 0X12ff0c)문 자 열 : 456 ( 주 소 : 0X12fea8)문 자 열 : 789 ( 주 소 : 0X12fe44)Press any key to continue

18

2.2.2.2.<1차 원 포 인 터 배 열 과 malloc 활 용 > ex) 파 일 명 : chap_pointer_6 가 . 소 스#include <stdio.h> // printf#include <malloc.h> // malloc#include <string.h> // strcpy


void main(){

int loop ;char *s[MAX_ARRAY];

for( loop =0 ; loop < MAX_ARRAY; loop++)if( (s[loop] = (char *) malloc( MAX_COLUMN *sizeof(char)) ) == NULL)

return;

strcpy(s[0], "123");strcpy(s[1], "456");strcpy(s[2], "789");

for( loop = 0; loop < MAX_ARRAY ; loop++)printf("문 자 열 : %s ( 주 소 : 0X%x)\n", s[loop], s[loop]);

for( loop =0 ; loop < MAX_ARRAY; loop++)free(s[loop]);

}

나 . 그 림

19


라 . 실 행 화 면문 자 열 : 123 ( 주 소 : 0X431e00)문 자 열 : 456 ( 주 소 : 0X431d70)문 자 열 : 789 ( 주 소 : 0X431ce0)Press any key to continue

2.2.2.3. 응 용 문 제 quiz.

20

2.2.3. < 2 차 원 포 인 터 변 수 와 배 열 > ① 2 차 원 포 인 터 변 수 와 1 차 원 포 인 터 변 수② 2 차 원 포 인 터 변 수 와 1 차 원 포 인 터 배 열③ 2 차 원 포 인 터 변 수 와 malloc

2.2.3.1. <2 차 원 포 인 터 변 수 와 1 차 원 포 인 터 변 수 > ex) chap_pointer_7 가 . 소 스 #include <stdio.h>void main(){

int a=3, *pa, **paa;pa=&a;paa=&pa;

// print pa 의 주 소printf("1. pa 의 주 소 : paa(%x) == &paa[0](%x) == &pa(%x)\n", paa, &paa[0],

&pa );

// print data 의 주 소printf("2.a 의 주 소 : &a(%x) = pa+0(pa:%x) = &pa[0](%x) \n",

&a, pa, &pa[0]);printf(" paa[0](%x) = &paa[0][0](%x) = *(paa+0)(%x) = paa[0]+0(%x)\n",

paa[0], &paa[0][0], *(paa+0), paa[0]+0);

// print dataprintf("2.a 의 data : a(%d) = *(pa+0)(*pa:%d) = pa[0](%d) \n",

a, *pa, pa[0]);printf("\t paa[0][0](%d) = *(paa[0]+0)(%d) = *paa[0](%d)\n",

paa[0][0], *(paa[0]+0), *paa[0]);printf("\t = *(*(paa+0) +0)(%d) = **paa(%d)\n",

*(*(paa+0) +0) , **paa );}나 . 그 림

21


라 . 실 행 화 면1. pa 의 주 소 : paa(12ff78) == &paa[0](12ff78) == &pa(12ff78) 2.a 의 주 소 : &a(12ff7c) = pa+0(pa:12ff7c) = &pa[0](12ff7c)

paa[0](12ff7c) = &paa[0][0](12ff7c) = *(paa+0)(12ff7c) = paa[0]+0(12ff7c) 2.a 의 data : a(3) = *(pa+0)(*pa:3) = pa[0](3)

paa[0][0](3) = *(paa[0]+0)(3) = *paa[0](3) = *(*(paa+0) +0)(3) = **paa(3)

마 . 위 의 예 처 럼 사 용 했 다 면 사 용 시 주 의 할 점 : → 포 인 터 는 1 차 원 array를 가 리 키 는 주 소 값 을 담 은 변 수 다. 따 라 서 포 인 터 에 넘 긴 주 소 를 가 진 변 수 (int a) 가 4 바 이 트 변 수 값 이 므 로 사 용 할 때 paa[0][0]==**paa==pa[0] == a; 만 참 조 해 야 한 다 . a 의 주 소 를 벗 어 나 는 참 조 를 해 서 는 안 된 다 . 바 른 사 용 틀 린 사 용 ( 문 법 상 맞 지 만 pa=&a; 로

초 기 화 했 으 므 로 a 외 의 array를 참 조 해 서 는 안 된 다 .) =>시 스 템 영 역 을 건 드 리 거 나 메 모 리 를 벗 어 난 영 역 을 건 드 리 려 고 하 면 다 운 의 원 인 이 된 다 .

paa[0][0]==**paa==pa[0] == a ; <실 제 값 > paa[0] == *paa == pa == &a; <주 소 값 >

paa[x][y]; //<x ,y: [0,n] n:0이 상 의 정 수 이 고 x=y!=0> paa[x]; // paa[1]……paa[x];

pa[x]; //pa[1], ,,,,, pa[x];

23

=> 그 림

24

2.2.3.2. <2 차 원 포 인 터 변 수 와 1 차 원 포 인 터 배 열 > 2.1.2.3.1. <2 차 원 포 인 터 변 수 와 1 차 원 포 인 터 배 열 > (1)chap_pointer_8 가 . 소 스 #include <stdio.h> // printf#include <malloc.h> // malloc#include <string.h> // strcpy


void main(){

int n , m;char **p;char *s[MAX_ARRAY];

// p 초기화p = s;

// s[] 공간 할당(malloc)for( n =0 ; n < MAX_ARRAY; n++)

if( (s[n] = (char *) malloc( MAX_COLUMN *sizeof(char)) ) == NULL)return;

// 문자열 copystrcpy(s[0], "ABC");strcpy(s[1], "DEF");strcpy(s[2], "GHI");

// char *s[]쪽의 주소값들.for (n = 0 ; n <MAX_ARRAY; n++){

printf("&s[%d] 의 주소 = %x=%x=%x=%x\n",n, &s[n], s+n, &p[n], p+n);printf("s[%d] 이 지니고 있는 주소값 = %x=%x=%x=%x\n\n",n, s[n], *(s+n), p[n], *(p+n));

}

// 문자열쪽의 주소값과 실제값 출력for( n = 0; n < MAX_ARRAY ; n++){

for(m=0; m < (int)strlen(s[n]); m++ )printf(" 주소(%x=%x=%x=%x=%x=%x),Data(%c=%c=%c=%c=%c=%c)\n",

&s[n][m], s[n] +m , *(s+n) +m, &p[n][m], p[n]+m, *(p+n)+m,s[n][m], *(s[n] +m) , *(*(s+n) +m), p[n][m], *(p[n]+m), *(*(p+n)+m));

printf("\n");}

// freefor( n =0 ; n < MAX_ARRAY; n++)

free(s[n]);}

25

나 . 그 림

27

다 . 실 제 값 과 주 소 값①

28

②

29

라 . 실 행 화 면 &s[0] 의 주 소 = 12ff68=12ff68=12ff68=12ff68 s[0] 이 지 니 고 있 는 주 소 값 = 431d60=431d60=431d60=431d60

&s[1] 의 주 소 = 12ff6c=12ff6c=12ff6c=12ff6c s[1] 이 지 니 고 있 는 주 소 값 = 431d20=431d20=431d20=431d20

&s[2] 의 주 소 = 12ff70=12ff70=12ff70=12ff70 s[2] 이 지 니 고 있 는 주 소 값 = 431ce0=431ce0=431ce0=431ce0

주 소 (431d60=431d60=431d60=431d60=431d60=431d60),Data(A=A=A=A=A=A) 주 소 (431d61=431d61=431d61=431d61=431d61=431d61),Data(B=B=B=B=B=B) 주 소 (431d62=431d62=431d62=431d62=431d62=431d62),Data(C=C=C=C=C=C)

주 소 (431d20=431d20=431d20=431d20=431d20=431d20),Data(D=D=D=D=D=D) 주 소 (431d21=431d21=431d21=431d21=431d21=431d21),Data(E=E=E=E=E=E) 주 소 (431d22=431d22=431d22=431d22=431d22=431d22),Data(F=F=F=F=F=F)

주 소 (431ce0=431ce0=431ce0=431ce0=431ce0=431ce0),Data(G=G=G=G=G=G) 주 소 (431ce1=431ce1=431ce1=431ce1=431ce1=431ce1),Data(H=H=H=H=H=H) 주 소 (431ce2=431ce2=431ce2=431ce2=431ce2=431ce2),Data(I=I=I=I=I=I)

Press any key to continue

30

4) 배 열 포 인 터 와 포 인 터 배 열 4-1) 포 인 터 배 열 ( *p[i] ) char *p[i], **py; 가 .< 실 제 값 > **py=*p[0]; 나 .< 주 소 값 > *py=p[0];

<주 소 값 > py=&p[0];

=p;

char a[2][3] = {{'a','b'}, {'c','d'}}; char *p[2]; p[0] = &a[0][0]; // == a[0]; p[1] = &a[1][0];// == a[1];

[ Example 1]

31

[Example 2]#include <stdio.h>#include <malloc.h>#include <string.h>

void main(){

char *ptr[2];char **ptr_ptr;

// [2]. algorithms// [2-1]. mallocptr[0] = (char *) malloc(10);ptr[1] = (char *) malloc(10);

strcpy(ptr[0], "12345");strcpy(ptr[1], "abcde");

// [2-2].// 방 법 1ptr_ptr = ptr;

// 방 법 2ptr_ptr = &ptr[0];

/** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** => 안 되 는 경 우 : ptr[0] 의 주 소 값 을 넘 겨 야 하 는 데 "12345"의 시 작 번 지 주 소 를 넘 김 ptr_ptr = ptr[0];** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/

// [2-3]free(ptr[0]);free(ptr[1]);

}

32

=> Debug 화 면

33

=> 분 석 (Analysis)

< 단 i = [0,1], j = [0,9] >

주 소 값 예 제ptr_ptr + i == &ptr[i] ptr_ptr == &ptr[0]

ptr_ptr + i == &ptr[i] ptr_ptr +i == ptr_ptr + sizeof(char) * I

&ptr_ptr[i][j] == &ptr[i][j]== *(ptr_ptr + i) + j == ptr_ptr[I] +j== *(ptr +i) +j == ptr[i] +j

ptr_ptr[I] +j == ptr_ptr[i] + sizeof(char) * jptr[i] +j == ptr[I] + sizeof(char ) * j

실 제 값 예 제ptr_ptr[i][j] == ptr[i][j]== *( *(ptr_ptr +i) + j)== *( *(ptr +i) + j)

ptr_ptr[0][0] == ptr[0][0] == ‘a’ptr_ptr[0][1] == ptr[0][1] == ‘b’ptr_ptr[0][2] == ptr[0][2] == ‘c’ ptr_ptr[0][3] == ptr[0][3] == ‘d’ptr_ptr[0][4] == ptr[0][4] == ‘e’ptr_ptr[1][0] == ptr[1][0] == ‘1’ptr_ptr[1][1] == ptr[1][1] == ‘2’ptr_ptr[1][2] == ptr[1][2] == ‘3’ptr_ptr[1][3] == ptr[1][3] == ‘4’ptr_ptr[1][4] == ptr[1][4] == ‘5’

34

[Example 3]

4-2) 배 열 포 인 터 ( (*py)[i] )int y[][2]={ {1,2}, {3,4}};int (*py)[2];py=y; (why? *py==py[] ) =&y[0]; =y[0] = &y[0][0]; =>suspicious pointer conversion

char a[2][3] ={{'a','b'}, {'c','d'}};char (*p)[3];p = a; // == &a[0];

35

2.1.2.3.2. < 2 차 원 포 인 터 변 수 와 malloc >ex) chap_pointer_9 가 . 소 스 #include <stdio.h> // printf#include <malloc.h> // malloc#include <string.h> // strcpy#define MAX_ARRAY 3#define MAX_COLUMN 100void main(){

int n , m;char **p;

// p 공 간 할 당 (malloc)if( (p = (char **) malloc( MAX_ARRAY *sizeof(char*)) ) == NULL)

return;

for( n =0; n < MAX_ARRAY; n++)if( (p[n] = (char *) malloc( MAX_COLUMN *sizeof(char)) ) == NULL) return;

// 문 자 열 copystrcpy(p[0], "ABC");strcpy(p[1], "DEF");strcpy(p[2], "GHI");

// char *s[] 쪽 의 주 소 값 들 .for (n = 0 ; n <MAX_ARRAY; n++){

printf("&p[%d] 의 주 소 = %x=%x\n",n, &p[n], p+n);printf("p[%d] 이 지 니 고 있 는 주 소 값 =%x=%x\n\n",n, p[n], *(p+n));

}

// 문 자 열 쪽 의 주 소 값 과 실 제 값 출 력for( n = 0; n < MAX_ARRAY ; n++){

for(m=0; m < (int)strlen(p[n]); m++ )printf("주 소 (%x=%x=%x),Data(%c=%c=%c)\n",

&p[n][m], p[n]+m, *(p+n)+m,p[n][m], *(p[n]+m), *(*(p+n)+m));

printf("\n");}

// freefor( n =0 ; n < MAX_ARRAY; n++)

free(p[n]);free(p);

}

36

나 . 그 림

다 . 실 제 값 과 주 소 값①

37

②

39

라 . 실 행 화 면&p[0] 의 주 소 = 431ce0=431ce0 p[0] 이 지 니 고 있 는 주 소 값 =431ca0=431ca0

&p[1] 의 주 소 = 431ce4=431ce4 p[1] 이 지 니 고 있 는 주 소 값 =431c60=431c60

&p[2] 의 주 소 = 431ce8=431ce8 p[2] 이 지 니 고 있 는 주 소 값 =431c20=431c20

주 소 (431ca0=431ca0=431ca0),Data(A=A=A) 주 소 (431ca1=431ca1=431ca1),Data(B=B=B) 주 소 (431ca2=431ca2=431ca2),Data(C=C=C)

주 소 (431c60=431c60=431c60),Data(D=D=D) 주 소 (431c61=431c61=431c61),Data(E=E=E) 주 소 (431c62=431c62=431c62),Data(F=F=F)

주 소 (431c20=431c20=431c20),Data(G=G=G) 주 소 (431c21=431c21=431c21),Data(H=H=H) 주 소 (431c22=431c22=431c22),Data(I=I=I)

Press any key to continue

40

2.2.4. int (*py)[max]

41

2.3. Parameter전달방법 ① Call By Value② Call By Reference③ Call By Address

2.3.1. Call by value 실 제 값 을 Parameter 에 넘 긴 는 방 법 가 . 소 스#include <stdio.h>void _swap(int a, int b); // 함 수 원 형 을 선 언void main(){

int x, y;scanf("%d %d", &x, &y);printf("=> %d %d\n", x, y);_swap(x, y);printf("=> %d %d\n", x, y);

}void _swap(int a, int b) // 함 수 정 의{

int temp = b;b = a;a = temp;printf("=> %d %d\n", a, b);

} 나 . 결 과 : 5 와 9 를 입 력 하 여 실 행 한 결 과 5 9 => 5 9 => 9 5 => 5 9 Press any key to continue

42

2.3.2. call by reference[ 포 인 터 를 사 용 하 는 이 유 ] – 예 제 추 가

필 요 Parameter 에 포 인 터( 주 소 값) 을 넘 겨 서 함 수 가 작 업 을 하 는 경 우 이 다 . Data Function Parameter1 차 원 배 열 1 차 원 포 인 터 변 수 ex) sort( int *p)1 차 원 포 인 터 변 수

1 차 원 포 인 터 변 수 ex) sort( int *p)

1 차 원 포 인 터 배 열

2 차 원 포 인 터 변 수 ex) sort( int **p)

2 차 원 포 인 터 변 수

2 차 원 포 인 터 변 수 ex) sort( int **p)

2 차 원 배 열 1) ① 1차 원 포 인 터 배 열 에 2 차 원 배 열 을 넣 는 다 .② 1 차 원 포 인 터 배 열 을 2 차 원 포 인 터 변 수

Parameter 에 넣 는 다 .2) ① 1차 원 포 인 터 변 수 parameter 와 row parameter, column parameter 에 넣 는 다 .

가 . 소 스 ( 1 차 원 포 인 터 변 수 vs 변 수 )#include <stdio.h>void _swap(int *a, int *b); // 함수원형을 선언void main(){

int x, y;scanf("%d %d", &x, &y);printf("=> %d %d\n", x, y);_swap( &x, &y);printf("=> %d %d\n", x, y);

}

void _swap(int *a, int *b) // 함수 정의{

int temp = *b;*b = *a;*a = temp;printf("=> %d %d\n", *a, *b);

}

43

나 . 분 석

다 . 결 과 : 5 와 9 를 입 력 하 여 실 행 한 결 과 5 9 => 5 9 => 9 5 => 9 5

44

2.3.3. call by address(C++ &) 변 수 명 들 이 같 은 주 소 를 공 유 하 는 현 상 이 다 . 가 . 소 스 .#include <stdio.h>void _swap(int &a, int &b); // 함수원형을 선언void main(){

int x, y;scanf("%d %d", &x, &y);printf("=> %d %d\n", x, y);_swap( x, y);printf("=> %d %d\n", x, y);

}

void _swap(int &a, int &b) // 함수 정의{

int temp = b;b = a;a = temp;printf("=> %d %d\n", a, b);

}

나 . 분 석

다 . 결 과 : 5 와 9 를 입 력 하 여 실 행 한 결 과 5 9 => 5 9 => 9 5 => 9 5

45

2.3.4. 동 일 한 의 미 의 call by reference- 원 래 배 열 과 포 인 터 는 엄 연 히 다 르 지 만 Function 의 parameter로 사 용 될 때 는 배 열 이 포 인 터 처 럼 적 용 된 다 .( 1 차 원 포 인 터 변 수 vs. 1 차 원 배 열 )

char a[10]= " abc";void func1(char *p){

p[1]= '2';

}=> func1(a); 했 을 때 a[1] 의 내 용 변 화

char a[10]="abc";void func2(char p[10]){

p[1] ='1';}

=> func2(a); 했 을 때 a[1] 의 내 용 변 화

< 그 림 1.2.1. void func1(char*p) 의 설 명 >

2.3.5. Dangling Pointer : Loacl Variable Pointer Return(X) ① 로 컬 변 수 는 CPU Register 나 Task 의 Stack 공 간 에 잡 힌 다 . ② 함 수 내 의 Local 변 수 들 중 배 열 의 pointer를 return 해 서 는 안 된 다 . ③ caution_return( 부 함 수 ) 이 종 료 되 면 로 컬 변 수 의 공 간 은 사 라 진 다 . ④ malloc() 은 kernel 에 서 할 당 하 므 로 return 해 도 괜 찮 다 .

Char * caution_return(){

char temp[500] = “1234567890”;

return temp; // return 하고 나서 temp[500] 의 공간은 사라지고 다른 변수에게 할당 될수 있다}

46

2.4. Window,Linux,Unix 저장방식차이 (big endian, Little endian)►Little Endian : LSB( 최 하 위 비 트 :0번 쨰 비 트 ) 에 서 MSB 순 서 로 저 장 되 어 있 다 . (하 위 비 트 --> 상 위 비 트 )►Big Endian : MSB(최 상 위 비 트 ) 부 터 LSB 로 저 장 되 어 있 다 . (상 위 비 트 -->하 위 비 트 )

결 국 Byte Order가 reverse( 역 순 배 열 이 ) 되 어 있 다Intel Cpu Based Windows(Linux)

Big Endian[MSB ~ LSB] Little Endian [LSB ~ MSB]

char O XInt, long X O

Sun Sparc Based UNIX Big Endian[MSB ~ LSB] Little Endian [LSB ~ MSB]char O XInt, long O X

#include <stdio.h>

#define UINT4 unsigned int

typedef struct{

UINT4 ClassA : 8; UINT4 ClassB : 8; UINT4 ClassC : 8; UINT4 ClassD : 8;

}M_BitIpAddr;/* IP Version 4 Address */

// Union 은 int 형 데 이 타 에 서 Shift연 산 없 이 특 정 Byte 나 특 정 Bit 값 을 얻 을 때 유 용 하 다 .typedef union {

UINT4 Ip; M_BitIpAddr BitIp;

}M_IpAddr;// 0xc0a88ec9 == 192.168.142.201

void IntToM_IpAddr(M_IpAddr *IpAddress, UINT4 Ip){

char bit_mask[5]; int *cast;

// [2-1]. union type 의 저 장 소 비 교 .IpAddress->Ip = Ip; printf("\n1. Ip : 0x%x, IpAddress->Ip : 0x%x\n", Ip, IpAddress->Ip); printf("IpAddress->BitIp.ClassA :(0x%x) \n",IpAddress->BitIp.ClassA); printf("IpAddress->BitIp.ClassB :(0x%x) \n",IpAddress->BitIp.ClassB); printf("IpAddress->BitIp.ClassC :(0x%x) \n",IpAddress->BitIp.ClassC); printf("IpAddress->BitIp.ClassD :(0x%x) \n",IpAddress->BitIp.ClassD);

// [2-2]. Cast연 산 을 통 한 값 비 교 : char -> intbit_mask[0] = 0x21; bit_mask[1] = 0x32;

47

bit_mask[2] = 0x43; bit_mask[3] = 0x84;

cast= (int*)bit_mask;printf("\n2. cast : 0x%x\n", cast[0]);

}

void main(){

M_IpAddr m_ipaddress;IntToM_IpAddr( & m_ipaddress, 0xC0A88EC9);

}

48

2.4.1.Intel Cpu Based Windows(or Linux)- (char 나 Int형 이 다 른

저 장 방 식 ): 하 위 에 서 상 위 로 기 록 방 식 이 다. 문 제 는 Int 형 이 하 위 바 이 트 부 터 기 록 된 다 .

=> 실 행 결 과 .1. Ip : 0xc0a88ec9, IpAddress->Ip : 0xc0a88ec9IpAddress->BitIp.ClassA :(0xc9)IpAddress->BitIp.ClassB :(0x8e)IpAddress->BitIp.ClassC :(0xa8)IpAddress->BitIp.ClassD :(0xc0)2. cast : 0x84433221

49

< 그 림 2.4.1.가 . M_IpAddr test;의 메 모 리 구 조 >

50

s<그 림 2.5.1. 나 . char -> int 형 으 로 cast 한 결 과 >

51

2.4.2.Unix(SunSparc CPU) – 동 일 저 장char 내 bit( 상 위-> 하 위), int 내 bit(

상 위 -> 하 위 )메 모 리 에 기 록 될 것 을 먼 저 기 록 하 는 방 식 ( 산 수 기 록 방 식 )

=> 결 과fplmts[scwpark: /home/user/scwpark/test/test 123 ] a.out1. Ip : 0xc0a88ec9, IpAddress->Ip : 0xc0a88ec9IpAddress->BitIp.ClassA :(0xc0) IpAddress->BitIp.ClassB :(0xa8) IpAddress->BitIp.ClassC :(0x8e) IpAddress->BitIp.ClassD :(0xc9)

2. cast : 0x21324384fplmts[scwpark: /home/user/scwpark/test/test 124 ]

<2.4.2. 가 . M_IpAddr test;의 메 모 리 구 조 >

52

<1.5.2. 나 . char -> int 형 으 로 cast 연 산 >

53

2.4.3. BitMap( Bitwise Operation 의 응 용 )2.4.3.1. BIT MAP 의 미

① 그 림 BMP 포 멧 을 말 하 는 것 이 아 니 라 data 에 대 한 각 Bit 열 에 1 과 0 을 저 장 하 고 정 보 를 얻 는 기 능 을 말 한 다 .1 Using 정 보0 Not Using

정 보② Primary Key, resource 관 리 , Process ID, File system 의 Free Block 관 리 에 많 이 사 용 된 다 .2.4.3.2. BITMAP 관 리 기 법

1) Char 1byte 관 리 기 법

55

2) Char/INT 배 열 을 이 용 하 여 많 은 자 원 을 관 리 하 는 기 법

59

3. 예 제가 . 소 스BitSet.h#ifndef _BITSET_H_#define _BITSET_H_

// [1]. Macro#define SUCCESS 1#define FAIL -1

// [2]. user defined Data type/*================================================================ * 내 용 : 기 본 자 료 구 조 ================================================================*/typedef unsigned int UI;typedef unsigned short US;typedef unsigned char UC;

/*================================================================* 내 용 : ================================================================*/typedef enum { NOT_USING, USING } Resource_status_type; // resource status#define NOT_USING 0#define USING 1

/*================================================================* 내 용 : ================================================================*/typedef struct {

int pid_status; } PID_Status_type;

// [3]. Extern#define CPU_MAX_NO 1 #define PROCESSORID_MAX_NO 33 // [0,2047]#define INT_SLICE 32 // 32bit#define SHORT_SLICE 16#define CHAR_SLICE 8

extern PID_Status_type ProcessorID_CH_BYTE_STS[CPU_MAX_NO][PROCESSORID_MAX_NO]; // [1][2048]

// 각 Processor 의 상 태 를 4bytes 의 비 트 배 열 로 관 리 2048/32

60

만 큼 의 배 열 공 간 필 요 .// bit 1: Processor ID Using , bit 0 : Processor ID Never been Usedextern UI ProcessorID_CH_BIT_STS[CPU_MAX_NO][PROCESSORID_MAX_NO/INT_SLICE];

// [4]. Function// [4-1]. Bit Setting Function// x 번 째 비 트 (0~31)를 1 로 세 팅 #define pd_xSet_PID_USE_TBL(src, x) (src |= (0x80000000 >> x ))#define pd_Set_IntBit(src, x) (src |= (0x80000000 >> x ))#define pd_Set_ShortBit(src,x) (src |= (0x8000 >> x ))#define pd_Set_CharBit(src,x) (src |= (0x80 >> x ))

// x 번 째 비 트 (0~31)를 0 으 로 세 팅 .#define pd_xClear_PID_USE_TBL(src, x) (src &= ~(0x80000000 >> x ))#define pd_Clear_IntBit(src, x) (src &= ~(0x80000000 >> x ))#define pd_Clear_ShortBit(src, x) (src &= ~(0x8000 >> x ))#define pd_Clear_CharBit(src, x) (src &= ~(0x80 >> x ))

// x 번 째 비 트 (0~31)값 이 1 이 면 return 1,0 이 면 return 0#define pd_xGet_PIDStaus_USE_TBL(src, x) ((src & (0x80000000 >> x ))? USING :NOT_USING)#define pd_Get_IntBitStatus(src, x) ((src & (0x80000000 >> x ))? USING :NOT_USING)#define pd_Get_ShortBitStatus(src, x) ((src & (0x8000>> x ))? USING :NOT_USING)#define pd_Get_CharBitStatus(src, x) ((src & (0x80>> x ))? USING :NOT_USING)

// (int형 src 값 > value 면 ) return 1,(src == value 면 ) return 0, (src < value 면 ) return -1 #define pd_CompareValue_PID_USE_TBL(src,value) ((src>value)?1:((src==value)?0:-1))

//****************************************************// [4-2]. Bit Set 과 Rotatationint pd_Get_PID_Staus(int cpu_no,int pid_no);int pd_Set_PID_Staus(UI cpu_no, UI pid_no, int pid_status);int pd_Find_Free_PID(int cpu_no);

int Bit_Rotation(int src, int n_bit);

int Int_Bit_RightRotation(unsigned int src, int n_bit);int Int_Bit_LeftRotation(unsigned int src, int n_bit);

unsigned short Short_Bit_RightRotation(unsigned short src, int n_bit);unsigned short Short_Bit_LeftRotation(unsigned short src, int n_bit);

unsigned char Char_Bit_RightRotation(unsigned char src, int n_bit);unsigned char Char_Bit_LeftRotation(unsigned char src, int n_bit);

#endif

61

Bitset.cpp

#include <stdio.h>#include "bitset.h"

// [1]. Bit Setting Function#if 0// x 번째 비트(0~31) 를 1 로 세팅 #define pd_xSet_PID_USE_TBL(src, x) ((UI)src |= (0x80000000 >> x ))#define pd_Set_Bit(src, x) (((UI)src) |= (0x80000000 >> x ))

// x 번째 비트(0~31) 를 0 으로 세팅.#define pd_xClear_PID_USE_TBL(src, x) ((UI)src &= ~(0x80000000 >> x ))#define pd_Clear_Bit(src, x) ((UI)src &= ~(0x80000000 >> x ))

// x 번째 비트(0~31) 값이 1 이면 return 1,0이면 return 0#define pd_xGet_PIDStaus_USE_TBL(src, x) (((UI)src & (0x80000000 >> x ))? USING :NOT_USING)#define pd_Get_BitStatus(src, x) (((UI)src & (0x80000000 >> x ))? USING :NOT_USING)

// (int 형 src 값 > value 면) return 1,(src == value 면) return 0, (src < value 면) return -1 #define pd_CompareValue_PID_USE_TBL(src,value) (((UI)src>(UI)value)?1:(((UI)src==(UI)value)?0:-1))#endif//****************************************************

// [2]. 수학함수.// x / divider한후 ceiling 시킨다. ex) Ceil(10,3) == 4 <= 3.33333 #define Ceiling(x,divider) ( (int) ( x/divider + ((x%divider==0)?0: 1) ) )#define Floaring(x, divider) ( (int) ( x/divider) )

// [3]. Data 와 관련 Function

// [3-1]. Bit Set & Get// [3-1-1]. Data/*======================================================================== * * 내 용 : fast 검색을 위한 목적 * * 참 고 : * =======================================================================*/PID_Status_type ProcessorID_CH_BYTE_STS[CPU_MAX_NO][PROCESSORID_MAX_NO]; // [1][2048]

// 각 Processor 의 상태를 4bytes 의 비트배열로 관리 2048/32 만큼의 배열 공간 필요.// bit 1: Processor ID Using , bit 0 : Processor ID Never been UsedUI ProcessorID_CH_BIT_STS[CPU_MAX_NO][PROCESSORID_MAX_NO/INT_SLICE];

// [3-1-2]. Set Channel Status on RTP PORT/************************************************************1. 기 능 : PID_NO 의 Resource 가 사용중인가에 대한 정보를 얻는다.2. 필요한 데이타 :

62

1) 2) pid_no3) cpu_no

3. 필요한 함수 : 4. Parameter :5. return :

USING(1) : NOT_USING(0) : FAIL(-1)

6. algorithm :************************************************************/int pd_Get_PID_Staus(int cpu_no,int pid_no){ // [1]. Data

// [2].// [2-1].check errorif(cpu_no >= CPU_MAX_NO || pid_no >=PROCESSORID_MAX_NO)

return FAIL;

// [2-2]. Get Channel Statusreturn pd_xGet_PIDStaus_USE_TBL(ProcessorID_CH_BIT_STS[cpu_no][pid_no/INT_SLICE],pid_no%INT_SLICE);// return ProcessorID_CH_BYTE_STS[cpu_no][pid_no].pid_status;

}

/************************************************************1. 기 능 : Set NOT_USING/Using2. 필요한 데이타 : 1) ProcessorID_CH_BYTE_STS[][], ProcessorID_CH_BIT_STS[][]2) pid_no3) cpu_no4) pid_status : USING or NOT_USING

3. 필요한 함수 :4. Parameter :5. return : SUCCESS FAIL

6. algorithm :************************************************************/ int pd_Set_PID_Staus(UI cpu_no, UI pid_no, int pid_status){

// [1]. DATAUI pid_array_no;UI slice_pid_no;

// [2].// [2-1].check error

if(cpu_no <0 || cpu_no >= CPU_MAX_NO)

63

{printf("pd_Set_PID_Staus] Error cpu_no(%d)\n\n",cpu_no);return FAIL;

}

// 0 ~ 2047if(pid_no < 0 || pid_no >= PROCESSORID_MAX_NO){

printf("pd_Set_PID_Staus] Error pid_no(%d)\n\n",pid_no);return FAIL;

}

// [2-2].// ex) pid_no =500, slice_no= 15, slice_pid_no = 20pid_array_no = pid_no / INT_SLICE; // #define INT_SLICE (sizeof(int)*8)==32bytesslice_pid_no = pid_no % INT_SLICE; // set to ProcessorID_CH_BYTE_STS, ProcessorID_CH_BIT_STSswitch(pid_status){

case NOT_USING :{

// check if already NOT_USINGif(pd_xGet_PIDStaus_USE_TBL(ProcessorID_CH_BIT_STS[cpu_no][pid_array_no],slice_pid_no)

== NOT_USING){

printf("pd_Set_PID_Staus]pid_no(%d) already was NOT_USING\n", pid_no);

return FAIL;}// set NOT_USINGprintf("pd_Set_PID_Staus] pid_no(%d) set as NOT_USING\n",pid_no);pd_xClear_PID_USE_TBL(ProcessorID_CH_BIT_STS[cpu_no][pid_array_no],slice_pid_no);ProcessorID_CH_BYTE_STS[cpu_no][pid_no].pid_status = NOT_USING;return SUCCESS;

}break;

case USING :{

// check if already NOT_USINGif(pd_xGet_PIDStaus_USE_TBL(ProcessorID_CH_BIT_STS[cpu_no][pid_array_no],slice_pid_no)

==USING){

printf("pd_Set_PID_Staus]pid_no(%d) already was USING\n",pid_no);

return FAIL;}

// set NOT_USINGprintf("pd_Set_PID_Staus] pid_no(%d) set as USING\n",pid_no);pd_xSet_PID_USE_TBL(ProcessorID_CH_BIT_STS[cpu_no][pid_array_no],slice_pid_no);

64

ProcessorID_CH_BYTE_STS[cpu_no][pid_no].pid_status = USING;return SUCCESS;

}break;}

return FAIL;

}

/************************************************************1. 기 능 : idle 한 Pid_no 를 return 한다.2. 필요한 데이타 : 1) cpu_no

3. 필요한 함수 : 4. Parameter :5. return :

return idle 한 pid number (0~2047)FAIL(-1) : idle 한 채널이 없다. -1(FAIL) : fail to find

6. algorithm :************************************************************/int pd_Find_Free_PID(int cpu_no){

return 1;}

// [3-1-2]. Bit Roatation/************************************************************1. 기 능 : n_bit 만큼 right 이동하고 전체적으로 rotatation한다. 2. 필요한 데이타 : 3. 필요한 함수 :

4. Parameter :1) unsigned int src : 2) unsigne int n_bit : n_bit 만큼 right 이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.32 의 배수 : 원래 Src 를 return1~31 : 전체적으로 Right Rotation

5. return : SUCCESS FAIL

6. algorithm :************************************************************/

65

int Int_Bit_RightRotation(unsigned int src, int n_bit){

// [1]. Dataunsigned int left_temp=0;unsigned int right_temp=0;unsigned int bit_mask=0;

int loop = 0;

// [2]. Algorithms// [2-1]. if(n_bit ==0) rotation 할 필요가 없다.

// n_bit 의 값은 1~31 로 못박음...n_bit %= INT_SLICE;

if(n_bit ==0)return src;

// [2-2]. Make a BitMask// 상위 비트를 n_bit 만큼 하위비트로 이동...right_temp = (src >> n_bit) & ( 0xFFFFFFFF >> n_bit);

// 하위 n 비트를 추출하여 상위 비트로 이동.for(loop =0; loop < n_bit; loop++){

bit_mask |= (0X00000001 << loop);}

left_temp = (src & bit_mask);

left_temp = left_temp << (INT_SLICE - n_bit);

return left_temp | right_temp ;

}

/************************************************************1. 기 능 : n_bit 만큼 left 이동하고 전체적으로 rotatation한다.

2. 필요한 데이타 : 3. 필요한 함수 :

4. Parameter :1) unsigned int src : 2) unsigne int n_bit : n_bit 만큼 Left이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.32 의 배수 : 원래 Src 를 return1~31 : 전체적으로 Left Rotation


66

6. algorithm :************************************************************/ int Int_Bit_LeftRotation(unsigned int src, int n_bit){

// [1]. Dataunsigned int left_temp=0;unsigned int right_temp=0;unsigned int bit_mask=0;

int loop = 0;


// n_bit 의 값은 1~31 로 못박음...n_bit %= INT_SLICE;


// [2-2]. Make a BitMask// 하위 비트를 n_bit 만큼 상위비트로 이동...left_temp = (src << n_bit) & (0xFFFFFFFF << n_bit);

// 상위 n 비트를 추출하여 상위 비트로 이동.for(loop =0; loop < n_bit; loop++){

bit_mask |= (0X80000000 >> loop);}

right_temp = (src & bit_mask);

right_temp = right_temp >> (INT_SLICE - n_bit);

return left_temp | right_temp ;

}

/************************************************************1. 기 능 : n_bit 만큼 right 이동하고 전체적으로 rotatation한다. 2. 필요한 데이타 : 3. 필요한 함수 :

4. Parameter :1) unsigned short src : 2) unsigned short n_bit : n_bit 만큼 right 이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.16 의 배수 : 원래 Src 를 return1~15 : 전체적으로 Right Rotation

5. return :

67

SUCCESS FAIL

6. algorithm :************************************************************/ unsigned short Short_Bit_RightRotation(unsigned short src, int n_bit){

// [1]. Dataunsigned short left_temp=0;unsigned short right_temp=0;unsigned short bit_mask=0;

int loop = 0;


// n_bit 의 값은 1~15 로 못박음...n_bit %= SHORT_SLICE;


// [2-2]. Make a BitMask// 상위 비트를 n_bit 만큼 하위비트로 이동...right_temp = (src >> n_bit) & ( 0xFFFF >> n_bit);


bit_mask |= (0X0001 << loop);}


left_temp = left_temp << (SHORT_SLICE - n_bit);

return (short) (left_temp | right_temp);

}



4. Parameter :1) unsigned short src : 2) unsigned short n_bit : n_bit 만큼 left 이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.16 의 배수 : 원래 Src 를 return1~15 : 전체적으로 left Rotation

68


6. algorithm :************************************************************/ unsigned short Short_Bit_LeftRotation(unsigned short src, int n_bit){

// [1]. Dataunsigned short left_temp=0;unsigned short right_temp=0;unsigned short bit_mask=0;

short loop = 0;


// n_bit 의 값은 1~31 로 못박음...n_bit %= SHORT_SLICE;


// [2-2]. Make a BitMask// 하위 비트를 n_bit 만큼 상위비트로 이동...left_temp = (src << n_bit) & (0xFFFF << n_bit);


bit_mask |= (0X8000 >> loop);}


right_temp = right_temp >> (SHORT_SLICE - n_bit);

left_temp |= right_temp;

return left_temp;

}

/************************************************************1. 기 능 : n_bit 만큼 right 이동하고 전체적으로 rotatation한다. 2. 필요한 데이타 : 3. 필요한 함수 :1) pd_Get_BitStatus()

69

2) pd_Set_Bit()

4. Parameter :1) unsigned char src : 2) unsigned char n_bit : n_bit 만큼 right 이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.8 의 배수 : 원래 Src 를 return1~7 : 전체적으로 right Rotation


6. algorithm :************************************************************/ unsigned char Char_Bit_RightRotation(unsigned char src, int n_bit){

// [1]. Dataunsigned char left_temp=0;unsigned char right_temp=0;unsigned char bit_mask=0;

int loop = 0;


// n_bit 의 값은 1~15 로 못박음...n_bit %= CHAR_SLICE;


// [2-2]. Make a BitMask// 상위 비트를 n_bit 만큼 하위비트로 이동...right_temp = (src >> n_bit) & (0xFF >> n_bit);


bit_mask |= (0X01 << loop);}


left_temp = left_temp << (CHAR_SLICE - n_bit);

return (char)(left_temp | right_temp) ;

}


70


4. Parameter :1) unsigned char src : 2) unsigned char n_bit : n_bit 만큼 left 이동하고 하위 n_bit 는 상위 n_bit 로 바뀐다.8 의 배수 : 원래 Src 를 return1~7 : 전체적으로 left Rotation


6. algorithm :************************************************************/ unsigned char Char_Bit_LeftRotation(unsigned char src, int n_bit){

// [1]. Dataunsigned char left_temp=0;unsigned char right_temp=0;unsigned char bit_mask=0;

int loop = 0;


// n_bit 의 값은 1~31 로 못박음...n_bit %= CHAR_SLICE;


// [2-2]. Make a BitMask// 하위 비트를 n_bit 만큼 상위비트로 이동...left_temp = (src << n_bit) & ( 0xFF << n_bit);


bit_mask |= (0X80 >> loop);}


right_temp = right_temp >> (CHAR_SLICE - n_bit);

return (char)(left_temp | right_temp) ;

71

}

#include <stdio.h>#include "bitset.h"void main(){

int m_task = 0;int loop =0x80000000;int status;short s_status = 0;char c_status = 0;

// [2-1]. set & get Bitstatus = pd_Set_IntBit(loop, 1);printf("0x%X 0x%X\n", status, loop);

status = pd_Set_IntBit(loop, 8);printf("0x%X 0x%X\n", status, loop);

for (loop = 0; loop < 33; loop++){

m_task |= (0x00000001 << loop) ;printf("0x%X\n", m_task);

}}

72

나 . 실 행 결 과0xC0000000 0xC00000000xC0800000 0xC08000000x000000010x0000003F0x000007FF0x0000FFFF0x001FFFFF0x03FFFFFF0x7FFFFFFF

0x000000030x0000007F0x00000FFF0x0001FFFF0x003FFFFF0x07FFFFFF0xFFFFFFFF

0x000000070x000000FF0x00001FFF0x0003FFFF0x007FFFFF0x0FFFFFFF0xFFFFFFFF

0x0000000F0x000001FF0x00003FFF0x0007FFFF0x00FFFFFF0x1FFFFFFF

0x0000001F0x000003FF0x00007FFF0x000FFFFF0x01FFFFFF0x3FFFFFFF

73

2.4.4.C언 어 메 모 리 연 산 함 수int 형 데 이 터 에 서 c 언 어 의 Shift 연 산 의 의 미 는 Windows 나 Unix 나 동 일 한 의 미 를 나 타 낸 다 .마 치 Unix 메 모 리 모 양 방 식 인 것 처 럼 Windows Program이 실 행 된 다 .그 러 나 windows program 에 서 실 제 저 장 되 는 방 식 은 int 타 입 에 서 차 이 가 난 다 .

<< : 곱 셈>> : 나 눗 셈int 내 에 서 특 정 bit 번 째 1 이 나 0 으 로 세 팅 하 는 함 수 .

74

2.6.Void Pointer 와 Cast연산

2.6.1.Cast 연 산 개 념 과 수 식 연 산Cast연 산 ( 포 인 터 든 지 실 제 Data 이 던 지 ) 은 Data Type 에 맞 춰 서 Data Size를 Segmentation 한 다 .예 를 들 어 서 int 형 ,long 형 은 4byte 이 고 char형 은 1byte 이 다 .포 인 터 변 수 간 에 Cast연 산 은 포 인 터 연 산을 통 해 서 원 하 는 정 보 를 추 출 하 는 데 가 장 많 이 사 용 된 다 .“(data type *) pointer 변 수 ”의 의 미 는 Pointer 변 수 (1차 원 Array)를 어 떻 게 Segmentation 하 는 가 이 다 .

Cast연 산 의 종 류 Description►Int * <-> char *

►int * <-> 구 조 체 *

►char * <-> 구 조 체 *

►void * <-> char *

►void * <->int *

►void * <-> 구 조 체 *

►void * <-> class *

Void * 는 단 순 히 다 양 한 Data Type(int *, char *, 구 조 체 *, class *) 의 Pointer를 저 장 하 는 역 할 을 한 다 .

CC C p CCCCC][ha 의 실 제 적 사 용 을 참 조 하 세 요

If a pointer's type is void *, the pointer can point to any variable that is not declared with the const or volatile keyword. A void pointer cannot be dereferenced unless it is cast to another type. A void pointer can be converted into any other type of data pointer.A void pointer can point to a function, but not to a class member in C++.[ 출 처 : MSDN] : [Visual C++ Documentation] -> [Using Visual C++] -> [Language Quick Reference]

C Cast 연 산 은 변 수 에 따 른 두 가 지 방 식 이 있 다 .

► 포 인 터 변 수 의 Cast연 산 :Pointer 간 의 Cast연 산 은 명 시 적 인 Cast연 산 을 사 용 한 다 .

(Data_Type *)포 인 터 변 수

► 일 반 변 수 의 Cast 연 산

C Cast 연 산 은 암 묵 적( 자 동 형 변 환) 이 냐 명 시 적 이 냐 에 따 른

두 가 지 방 식 이 있 다

► 자 동 형 변 환 (automatic conversion)서 로 다 른 형 을 가 지 는 데 이 터 끼 리 의 이 항 연 산형 이 일 치 하 지 않 는 변 수 에 의 대 입 연 산

75

함 수 호 출 에 서 실 인 자 와 형 식 인 자 의 형 불 일 치► 형 변 환 연 산 (cast operation)명 시 적 으 로 형 변 환 을 수 행

76

실 제 적 사 용종 류 설 명char *char_ptr; Help 1

char_ptr += N;==&char_ptr[N];의 미 :char_ptr이 Point 하 는 곳 에 서 N * sizeof(char) 만 큼 계 산 된 Offset 의 주 소 값 .Help 2char * test;test = ((int*) char_ptr +N); // 이 건 char* → int*형 으 로 cast 연 산 된 상 태=>[ 결 과 ] test ==&char_ptr[4N]; 으 로 해 석 되 어 진 다 .의 미 : (int*) 라 는 cast 연 산 (pointer 가 가 리 키 곳 의 실 제 Data type size변 경 ) 이 이 뤄 졌 다 .따 라 서, char_ptr 이 Point 하 는 곳 에 서 N*sizeof(int)만 큼 계 산 된 Offset 의 주 소 값

int *int_ptr; Help 1char_ptr = (char *) int_ptr; // 이 건 int* →char* 형 으 로 cast 연 산 된 상 태int_ptr +=N; // cast 연 산 을 않 하 고 N*sizeof(int)형 만 큼 Jump=>[ 결 과 ] int_ptr== &int_ptr[N];=>[ 결 과 ] int_ptr== &char_ptr[4N];의 미 : int_ptr 이 Point 하 는 곳 에 서 N * sizeof(int) 만 큼 계 산 된 Offset 의 주 소 값Help 2char_ptr = ((char *) int_ptr +4N); // int* → char* 형 으 로 int_ptr 을 cast연 산 이 동=>[ 결 과 ] char_ptr == &int_ptr[N]; 으 로 해 석 되 어 진 다 .

void *void_ptr; 의 미: void_ptr 이 Point 하 는 곳 의 Data type 이 무 엇 인 지 는 모 른 다 .따 라 서 사 용 시 에 는 단 지 pointer 값 만 저 장 할 때 사 용 된 다 .그 리 고 원 래 타 입 의 Pointer 변 수 에 게 포 인 터 값 을 넘 겨 줄 때 사 용 된 다 .[Wrong Usage] void_ptr = (char *)char_ptr; void_ptr = (int *)int_ptr;void_ptr+=N;// Error?int or char or 특 정 Structure 의 N 개 만 큼 을 Jump해 야 하 는 지 알 수 없 다

[Right Usage case 1 ]void_ptr = (int *)int_ptr;char_ptr =((char *) void_ptr +12); // char_ptr == &int_ptr[3]; 와 동 일 해 진 다 .

[Right Usage case 2 ]void_ptr = (char*)char_ptr;int_ptr =((int *) void_ptr +12); // int_ptr == &char_ptr[12*4 ]; 와 동 일 해 진 다 .

ex) typedef void * HANDLE; typedef void * HWND;( 단 . N: 정 수 )

77

2.6.2.Cast 연 산 : String => 구 조 체String(char *) 를 구 조 체 로 포 인 터 형 변 환 (Cast 연 산 ) 을 실 행 한 다 .

78

2.6.2.1. 소 스

1. 넘 길 데 이 터 : char m_Buffer[1000];2. 받 는 구 조 체 포 인 터 : LPcasttest m_cast3. cast : m_cast =(LPcasttest)m_Buffer;4. 사 용 (get from m_Buffer, put to m_Buffer , using m_cast): 단 m_Buffer 를 벗 어 난 곳 을 참 조 말 자 .

( 단 n: 0 – 9)1) m_cast->a == m_cast[0].a

m_cast->b == m_cast[0].bm_cast->p == m_cast[0].pm_cast->p[n] == m_cast[0].p[n]

2) m_cast[1].am_cast[1].b

m_cast[1].pm_cast[1]->p[n] == m_cast[1].p[n]

( 단 n: 0 – 9), ( 단 m : 정 수 )3) m_cast[m].a

m_cast[m].bm_cast[m].p m_cast[m]->p[n] == m_cast[m].p[n]

#include <stdio.h>

#include <string.h>

typedef struct CastTest{

unsigned char a;

unsigned char b;

char p[10];

}casttest, *LPcasttest;

LPcasttest m_cast;

char m_buffer[800];

int main()

{

// [1]. copy any string to m_buffer and cast m_buffer to the type of casttest

strcpy(m_buffer, "120123456789ababcdefghij");

m_cast = (LPcasttest) m_buffer;

// [3], get info

printf("%c, %c, %s",m_cast[1].a, m_cast[1].b, m_cast[1].p);

// [4]. write

m_cast[1].p[9] = 'z' ;

printf("%c, %c, %s",m_cast[1].a, m_cast[1].b, m_cast[1].p);

return 0;

}

79

2.6.2.2. 분 석

80

2.6.3.char, int, void pointer 의 수 식 연 산

2.6.3.1. 소 스

#include <stdio.h>#include < string.h>void main(){

char char_temp[30] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";char *char_ptr1 , *char_ptr2;

int int_temp[30];int *int_ptr1, *int_ptr2;

void *void_ptr1, *void_ptr2, *void_ptr3, *void_ptr4;

memset(int_temp, 0, 30);int_temp[0] = 0x44434241;int_temp[1] = 0x48474645;int_temp[2] = 0x4C4B4A49;int_temp[3] = 0x504F4E4D;int_temp[4] = 0x54535251;

// char string -> (int *)void_ptr1 = (int *)char_temp + 2; int_ptr1 = (int *)void_ptr1;

void_ptr2 = (char*)char_temp + 2;char_ptr1 = (char*)void_ptr2;

// (int *)void_ptr3 = (char*)int_temp + 2;char_ptr2 = (char*)void_ptr3;

void_ptr4 = (int *)int_temp + 2;int_ptr2 = (int *)void_ptr4;

}

82

2.6.3.2. 분 석

2.6.4.__int16(short,word) 과 int형 (dword) 사 이 의 cast 연 산 과

Pointer 연 산 [G]2.6.4.1. 소 스

/***********************************************************1. 기 능 : Pointer 연 산char *char_ptr;int *int_ptr;1) char_ptr + n =>2)int_ptr = (int *) char_ptr;int_ptr + n == (int *)((char *)char_ptr + (n*sizeof(int)))== &int_ptr[n]************************************************************/typedef union { unsigned long arg; unsigned long val; void *addr; void (*func)( void );

83

void (*task)( unsigned long ); void (*preamble)( void (*func)(unsigned long), unsigned long );} cpu_register_type;

/* ------------------------------------------------------------------------** Context Frame** ------------------------------------------------------------------------ */typedef struct { cpu_register_type spsr; cpu_register_type r[13]; /* r0-r7, r8-r12 */ cpu_register_type lr; /* r14 */ cpu_register_type pc; /* r15 */} context_frame_type;

typedef char byte;typedef int dword; // 32bits == 4bytestypedef dword stack_word_type;

typedef _int16 word; // 16bits == 2bytes#define STACK_SIZ 1024 //922word stack [STACK_SIZ];

void main(){

int size;byte *stack_ptr;int p_stksiz = STACK_SIZ;void *p_stack = (char *)stack;int array_num = (p_stksiz*sizeof(word)/sizeof(stack_word_type)) - 1;

// &stack[1022] == stack_ptr;stack_ptr = (byte *)((stack_word_type *)p_stack + array_num );

// &stack[1022-32] == stack_ptr;stack_ptr -= sizeof(context_frame_type); // -64bytessize = sizeof(context_frame_type);

}

84

2.6.4.2. 실 행 결 과

85

2.6.4.3. 분 석

86

2.6.5. 예 제 1. Linux Kernel 2.3.0분 석 소 스

2.6.5.1. 소 스

typedef struct kmem_slab_s {

struct kmem_bufctl_s *s_index;void *s_mem; /* addr of first obj in slab */char garbage[300];

} kmem_slab_t;

typedef struct kmem_bufctl_s {

union{

kmem_slab_t *buf_slabp; /* slab for obj */void *buf_objp;

} u;} kmem_bufctl_t;

#define object char

// 구 조 체 내 의 Attribute 의 상 대 적 크 기 구 하 기 .// 동 일 한 방 식 == (int) (& ((type*)0)->member)#define slab_size(type, member) (int) (& ((type*)0)->member)

void main(){

object* p;int object_size =5, start , dest;int value;

char temp[100] ="0123456789abcd";kmem_bufctl_t a[5], *bufp;kmem_slab_t slabp;

// [1]. pointer 내 의 Index 값 을 얻 기 .// [1-1]. test 1.start = slabp.s_index = &a[0];dest = bufp = &a[2];

printf("\n1.포 인 터 간 의 뺄 셈((kmem_bufctl_t*)&a[0]:%x)-((kmem_bufctl_t*)&a[2] : %x) == %d\n2.int형 뺄 셈 : %d",

bufp, slabp.s_index, bufp - slabp.s_index, dest - start);

// [1-2]. test2 : test 1과 동 일 한 테 스 트slabp.s_mem = (char *)temp;p = (char *)slabp.s_mem + object_size * (bufp - slabp.s_index);

87

printf("\n3. p = (char *)slabp.s_mem + object_size * (bufp - slabp.s_index)==%s\n", p);

// [2]. 구 조 체 내 Attributes 사 이 즈 구 하 기 .// [2-1]. 구 조 체 내 Attribute사 이 즈 구 하 기 1value = &(slabp.s_mem) - &(slabp);printf("\n4. %d %d\n", value, slab_size(kmem_slab_t, s_mem)); // 틀 린 값 으 로 출 력 한 다 .printf("\n5. %d\n",( &(slabp.garbage[0]) - &(slabp)) );printf("\n6. %d\n",( &(slabp.garbage[5]) - &(slabp)) );

// [2-1]. 구 조 체 내 Attribute사 이 즈 구 하 기 2printf("\n7. %d\n",slab_size(kmem_slab_t,s_index));printf("\n8. %d\n",slab_size(kmem_slab_t,s_mem ));printf("\n9. %d\n",slab_size(kmem_slab_t,garbage ) );printf("\n10. %d\n",slab_size(kmem_slab_t,garbage[5] ) );

}=> 실 행 결 과

1. 포 인 터 간 의 뺄 셈 ((kmem_bufctl_t*)&a[0] : 12fefc)-((kmem_bufctl_t*)&a[2] : 12fef4) == 22.int 형 뺄 셈 : 83. p = (char *)slabp.s_mem + object_size * (bufp - slabp.s_index)==abcde4. 1 45. 86. 13

88

7. 08. 49. 810. 13

2.6.5.2. 분 석

2.6.5.2.1. 동 일 구 조 체 Array에 서 Pointer 의 수 식 연 산 ( +/- n)수 식 대 상 : kmem_bufctl_t a[5];Kmem_bufctl_t *od = s_index;

od +=2; == &a[2] == &s_index[2] bufp =bufp - 2; == &a[0] == s_index;

2.6.5.2.2. 동 일 구 조 체 Array에 서 pointer 들 간 의 연 산수 식 대 상 : kmem_bufctl_t a[5];포 인 터 간 의 연 산 결 과 포 인 터 값 을 int 형 에 담 아 서

뺄 셈 한 결 과 = 실 제 bytes 값

&a[2] - &a[0] == bufp – slabp.s_index == 2== 실 제 크 기 8bytes/sizeof(kmem_bufctl_t)

dest – start == 2 * sizeof(kmem_bufctl_t)== 8

89

2.6.5.2.3. 구 조 체 내 의 Attribute 들 의 상 대 적 Offset 구 하 기 .

void main(){

…….// [2-1]. 구 조 체 내 Attribute사 이 즈 구 하 기 2printf("\n7. %d\n",slab_size(kmem_slab_t,s_index));printf("\n8. %d\n",slab_size(kmem_slab_t,s_mem ));printf("\n9. %d\n",slab_size(kmem_slab_t,garbage ) );printf("\n10. %d\n",slab_size(kmem_slab_t,garbage[5] ) );

}=> 실 행 결 과7. 08. 49. 810. 13

90

2.6.6. 예 제 2. 구 조 체 내 attribute 의 offset 구 하 기메 모 리 Alignment 구 하 기 .

2.6.6.1. 소 스 : list_entry() 함 수

#include <stdio.h>

typedef struct list{ int data; int sex; int face;} Link;

// the offset of member in structure type/****************************************************************1. 기 능 : Class나 Structure 내 의 Member Method(Only Data) 의 Offset Bytes 를 계 산 한 다 .2. 필 요 한 데 이 타 . 3. 필 요 한 함 수 .4. Parameter 5. Return 6. Algorithms*****************************************************************/#define OffsetSize(data_type, member) (int) (& ((data_type*)0)->member)#define OFFSET OffsetSize#define list_entry(ptr , type, member ) (int) ( &((type *)0)->member) // the offset of member in structure type

int main(){ Link a;

printf("\n array num of pointer: %x , real offset %x \n", &a.sex - &a.data , list_entry(0,Link,sex)); return 0;}

=> 실 행 결 과array num of pointer: 1 , real offset 4

2.6.6.2. 분 석

=> 2.6.5.2.3. 을 참 조①②③

91

2.6.7. Void Pointer 예 제 3(Swap,Copy, Reverse)[G]1) 기 능 : 모 든 종 류 의 data type 을 swap, copy, reverse 할 수 있 는 코 드 이 다 .① Swap : 두 데 이 터 를 서 로 교 체 하 는 기 능 을 한 다 .② Copy : 1 차 원 배 열 의 데 이 터 를 다 른 곳 으 로 copy 한 다 .③ Reverse : 오 름 차 순( 혹 은 내 림 차 순) 으 로 소 팅 된 1 차 원 배 열 을 내 림 차 순 ( 혹 은 오 름 차 순 ) 으 로 만 든 다 . 재 소 팅 할 시 간 을 줄 일 수 있 다 .2.6.7.1. 소 스 ( chap_pointer_10)Array.h#ifndef _ARRAY_H_#define _ARRAY_H_

typedef unsigned int UINT;

void Copy_Array(void * destination, void *source, UINT count, UINT element_nbyte);

int Swap_data(void *a, void *b, UINT data_total_size );int Swap_Array(void *a, void *b, UINT count, UINT element_nbyte);

int Reverse_Array( void * a, UINT count, UINT element_nbyte);

#endif

Array.cpp#include <string.h>#include "Array.h"

// [1]. C O P Y , S W A P, R E V E R S E

/*----------------------------------------------------1. 기 능 : 요 소 한 개 의 byte 크 기 가 element_nbyte 일 때count 개 의 source array 의 요 소 (element) 를destination array 에 copy하 기 .----------------------------------------------------*/void Copy_Array(void * destination, void *source, UINT element_count, UINT element_nbyte){#if 1

memcpy( destination, source, element_count * element_nbyte);#else

UINT loop = 0;

for( loop =0 ; loop < element_count* element_nbyte; loop++){

*((char*)destination + loop ) = *( (char*)source +loop );}

#endif}

92

/*----------------------------------------------------1. 기 능 : data_type에 상 관 없 이 일 정 크 기 만 큼 을 swap 하 는 함 수2. parameter1) void *a2) void *b3) UINT data_total_size : data 의 총 사 이 즈 ----------------------------------------------------*/#define MAX_STACK 1024*2 // structure 쪽 HeapSwapint Swap_data(void *a, void *b, UINT data_total_size ){ char temp[MAX_STACK];

if( data_total_size > MAX_STACK )return 0;

memcpy(temp, a, data_total_size);memcpy(a, b, data_total_size);memcpy(b, temp, data_total_size);

return 1;}

/*----------------------------------------------------1. 기 능 : data_type에 상 관 없 이 일 정 크 기 만 큼 을 swap 하 는 함 수2. parameter1) void *a2) void *b3) UINT count : element 총 갯 수4) UINT element_nbyte : element 의 하 나 의 크 기 ----------------------------------------------------*/int Swap_Array(void *a, void *b, UINT element_count, UINT element_nbyte){

return Swap_data(a, b, element_count*element_nbyte);}

/*--------------------------------------------------------------------1. 기 능 : 1) element_count(=4) 자 료 경 우 : 0(first) 과 3(last), 1 과 2 의 swap =>(합 3)2) element_count(=3) 자 료 경 우 : 0 과 2, 1 과 1 의 swap =>(합 2)---------------------------------------------------------------------*/inline static int Get_Num(int element_count, int first){

first %= element_count; // first < element_countreturn (element_count - 1) - first ;

}

/*----------------------------------------------------1. 기 능 : data_type에 상 관 없 이 모 든 data 를 reverse 하 는 함 수 .2. parameter1) void *a2) UINT element_count : element 총 갯 수3) UINT element_nbyte : element 의 하 나 의 크 기 3. return1) 1 : success2) -1 : Fail

93

4. 경 우 의 수1) 자 료 수 가 한 개 , 자 료 수 가 짝 수 , 자 료 수 가 홀 수2) n(=4) 자 료 경 우 : 0 과 3( 합 3), 1과 2( 합 3) 의 swap3) n(=3) 자 료 경 우 : 0 과 2( 합 2), 1과 1( 합 2) 의 swap----------------------------------------------------*/#if 1int Reverse_Array( void * a, UINT element_count, UINT element_nbyte){

UINT first;UINT last;

// [2]. Algorithmsif( element_count == 0 )

return -1;if( element_count == 1)

return 1;

for( first = 0; first <= (element_count - 1)/2 ; first++ ){

last = Get_Num(element_count, first) ;if( first != last)

Swap_data( (char*)a + first * element_nbyte, (char*)a + last * element_nbyte, element_nbyte );

}return 1;

}#elseint Reverse_Array( void * a, UINT element_count, UINT element_nbyte){

UINT first;UINT last ;

// [2]. Algorithmsif( element_count == 0 )

return -1;if( element_count == 1)

return 1;

for( first = 0, last = element_count –1 ; first < last ; first++, last--)Swap_data( (char*)a + first * element_nbyte,

(char*)a + last * element_nbyte, element_nbyte );

return 1;}#endif

94

Main.cpp#include <stdio.h>#include "Array.h"

////////////////////////////////////////////#define MAX_ARRAY 5

int a[MAX_ARRAY] ={ 1,2,3,4,5};int b[MAX_ARRAY] ={ 5,4,3,2,1};

typedef struct student{

int id;char name[100];

}Student, *St;

Student s1[MAX_ARRAY]={

{ 1, "111" },{ 2, "222" },{ 3, "333" },{ 4, "444" },{ 5, "555" },

};Student s2[MAX_ARRAY]={

{ 5, "555" },{ 4, "444" },{ 3, "333" },{ 2, "222" },{ 1, "111" }

};

void Print_INT(char *str, void *p, int count){

int loop;printf("%s\n",str);for(loop = 0; loop < count; loop++)

printf("%d ", *((int*)p+loop));printf("\n\n");

}

// 1차 원 pointer 변 수 vs 1 차 원 structure 배 열void Print_ST(char *str, void * p, int count){

int loop;printf("%s\n",str);for(loop = 0; loop < count; loop++)

printf("%d %s\n", ((Student*)p+loop)->id, ((Student*)p+loop)->name);printf("\n");

}

95

void main(){

// [1]. int type swap, copyprintf("[1-1]. swap int --------------- \n");Swap_Array(a, b, MAX_ARRAY, sizeof(int) );Print_INT("==[a]==", a, MAX_ARRAY);Print_INT("==[b]==", b, MAX_ARRAY);

printf("[1-2]. copy int --------------- \n");Copy_Array(a, b, MAX_ARRAY, sizeof(int) );Print_INT("==[a]==", a, MAX_ARRAY);Print_INT("==[b]==", b, MAX_ARRAY);

printf("[1-3]. reverse int --------------- \n");Reverse_Array(a, MAX_ARRAY, sizeof(int) );Print_INT("==[a]==", a, MAX_ARRAY);

// [2]. structure type swap, copyprintf("[2-1]. swap structure --------------- \n");Swap_Array(s1, s2, MAX_ARRAY, sizeof(Student));Print_ST("[==s1==]", s1, MAX_ARRAY);Print_ST("[==s2==]", s2, MAX_ARRAY);

printf("[2-2]. Copy structure --------------- \n");Copy_Array(s1, s2, MAX_ARRAY, sizeof(Student) );Print_ST("[==s1==]", s1, MAX_ARRAY);Print_ST("[==s2==]", s2, MAX_ARRAY);

printf("[2-3]. reverse structure --------------- \n");Reverse_Array(s1, MAX_ARRAY, sizeof(Student) );Print_ST("[==s1==]", s1, MAX_ARRAY);

}

2.6.7.2. 분 석 과 실 행 결 과1. 분 석 ( 함 수 Parameter 의 포 인 터 관 계 )

96

2. 실 행 결 과

97

2.7. 함수의 포인터변수

2.7.1. C++ 함 수 의 포 인 터 변 수

98

2.7.2. C 함 수 의 포 인 터 변 수

2.7.2.1. 함 수 의 포 인 터 변 수 선 언 방 법 1) 함 수 의 포 인 터 변 수 : 포 인 터 변 수 (4bytes) 인 데 함 수 의 주 소 를 가 리 킨 다 .- Macro Function 과 유 사 하 다 . 예 ) #define DBG printf- 함 수 명 은 함 수 의 시 작 주 소 를 가 지 고 있 다 .

2) typedef( 형 정 의 ) 와 함 수 의 포 인 터 변 수 , 함 수 의 포 인 터 배 열

99

3. 함 수 의 포 인 터 변 수 , 배 열 간 단 한 예 제#define MAX_FUNCTION 5typedef int (*PFI)(char*, char*);typedef int (*ARRAY_PFI [ MAX_FUNCTION ] )(char*, char*); ----------------------PFI Test_Function; // 함 수 의 포 인 터 변 수 Test_Function 의 공 간 확 보// => int (*Test_Function)(char*, char*); 와 같 다 .

// 함 수 의 포 인 터 배 열 의 공 간 확 보PFI P[MAX_FUNCTION]; // P[0], P[1], P[2], P[3], P[4]ARRAY_PFI A; // A[0], A[1], A[2], A[3], A[4] // => int (*A[ MAX_FUNCTION ])(char*, char*); 와 같 다 .

100

2.7.2.2. 함 수 포 인 터 예 제 2.7.2.2.1. 예 제 1(일 반 적 함 수 포 인 터 변 수 예 제 ) #include <stdio.h>

int (*m_pFunc)(char *p);

int test(char *p){

printf("%s\n", p);return 0;

}

#define M_TEST test

void main(){

// 포 인 터 함 수m_pFunc = test; // 함 수 명 은 함 수 의 시 작 주 소 를 가 리 킨 다 . m_pFunc("hello");M_TEST("hello");

}

101

2.7.2.2.2. 예 제 2(사 칙 연 산 ) 가 . 소 스 // Function 포 인 터 배 열#include <stdio.h>

// [1]. Dataint (*Calculates[3])(int *a, int *b);double (*div_func)(int *a, int *b);

// [2]. Declare Functionint sum(int *a, int *b);int sub(int *a, int *b);int mul(int *a, int *b);double div(int *a, int *b);

// [3]. 함 수 정 의int sum(int *a, int *b){

return (*a + *b);}

int sub(int *a, int *b){

return (*a - *b);}

int mul(int *a, int *b){

return (*a) * (*b);}

double div(int *a, int *b){

return (double)(( double)*a / (double)*b);}

void main(){

float a;int b, c;b = 5;c = 2;

// [2-1].Calculates[0] = sum;Calculates[1] = sub;Calculates[2] = mul;div_func = div;

printf(" %d\n", Calculates[0](&b, &c));printf(" %d\n", Calculates[1](&b, &c));printf(" %d\n", Calculates[2](&b, &c));

102

printf(" %f\n", div_func(&b, &c));}

103

나 . Analyse

다 . 실 행 결 과73102.500000

104

2.7.2.2.3. 예 제 3(4 칙 연 산 함 수 의 포 인 터 변 수 와 배 열 ) 가 . 소 스 Extern.h#ifndef _EXTERN_H_#define _EXTERN_H_

// -------------------------------------------------// 함 수 포 인 터 변 수 의 형 정 의#define MAX_FUNCTION 6typedef int (*I_FP)(int a, int b); // int 형 Function Pointer typetypedef double (*D_FP)(int a, int b); // Double 형 Function Pointer typetypedef void (*S_FP)(char *); // String 형 Function Pointer type

#define MAX_ARRAY 4typedef int ( *ARRAY_I_FP[MAX_ARRAY]) (int, int);

#define MAX_NAME 50typedef struct command{

char name[MAX_NAME];I_FP i_fp;D_FP d_fp;S_FP s_fp;

} Command, *CommandPtr;

// 함 수 의 포 인 터 변 수 와 배 열 ( 전 역 변 수 )extern void ( *str_fp)(char *s);extern Command g_command[MAX_FUNCTION];extern ARRAY_I_FP g_array_ifp;

// -------------------------------------------------// 함 수 의 원 형 을 선 언

// 함 수 를 정 의// 문 자 열 출 력void DPrintf(char *s);

// 사 칙 연 산int sum(int a, int b);int minus(int a, int b);int multiply(int a, int b);int compare(int a, int b);double divide(int a, int b);

// 함 수 포 인 터 변 수 와 배 열 을 연 결void Set_Function(CommandPtr com,char *name, I_FP i_fp, D_FP d_fp, S_FP s_fp);void Link_Function();

#endif

105

Extern.cpp#include <stdio.h>#include <string.h>#include "extern.h"

// 함 수 의 포 인 터 변 수void ( *str_fp)(char *s);Command g_command[MAX_FUNCTION];ARRAY_I_FP g_array_ifp;

// 함 수 를 정 의// 문 자 열 출 력void DPrintf(char *s){ printf("%s",s); }

// 사 칙 연 산int sum(int a, int b){ return a+b; }

int minus(int a, int b){ return a-b; }

int multiply(int a, int b){ return a*b; }

int compare(int a, int b){ return ( a > b ? 1 : ( a < b ? -1 : 0 ) ) ; }

double divide(int a, int b){ return (double)a/(double)b; }

// 함 수 포 인 터 변 수 와 배 열 을 연 결void Set_Function(CommandPtr com, char *name,

I_FP i _fp, D_FP d_fp, S_FP s_fp){

strcpy(com->name, name);com->d_fp = d_fp;com->i_fp = i_fp;com->s_fp = s_fp;

}

void Link_Function(){

str_fp = DPrintf; // printfSet_Function( &g_command[0], "sum", sum, NULL , NULL);Set_Function( &g_command[1], "minus", minus, NULL , NULL);Set_Function( &g_command[2], "multiply", multiply,NULL , NULL);Set_Function( &g_command[3], "compare", compare, NULL , NULL);Set_Function( &g_command[4], "divide", NULL, divide , NULL);Set_Function( &g_command[5], "DPrintf", NULL, NULL , DPrintf);g_array_ifp[0] = sum;

106

g_array_ifp[1] = minus;g_array_ifp[2] = multiply;g_array_ifp[3] = compare;

}

#include <stdio.h>#include "extern.h"void main(){

int loop;int a=9, b =7;char temp[100] = "Hello";Link_Function();

// 함 수 의 포 인 터 변 수 : 문 자 열 출 력printf("1. 함 수 의 포 인 터 변 수 테 스 트 \n");str_fp(temp);printf("\n");

// 함 수 의 포 인 터 배 열 :printf("2. 함 수 의 포 인 터 배 열 테 스 트 \n");for(loop = 0 ; loop < MAX_FUNCTION ; loop ++){

if(g_command[loop].i_fp){

printf("%s(%d, %d) = %d = %d\n",g_command[loop].name, a, b,g_command[loop].i_fp(a, b) ,g_array_ifp[loop](a, b) );

}else if (g_command[loop].d_fp){

printf("%s(%d, %d) = %f\n",g_command[loop].name, a, b,g_command[loop].d_fp(a, b) );

}else if (g_command[loop].s_fp){

printf("%s(%s) = ",g_command[loop].name, temp );g_command[loop].s_fp(temp);printf("\n");

}}

}나 . Analyse

다 . 실 행 결 과1. 함 수 의 포 인 터 변 수 테 스 트Hello2. 함 수 의 포 인 터 배 열 테 스 트sum(9, 7) = 16 = 16minus(9, 7) = 2 = 2multiply(9, 7) = 63 = 63

107

compare(9, 7) = 1 = 1divide(9, 7) = 1.285714DPrintf(Hello) = Hello

108

2.7.2.2.4. 예 제 4(BubbleSort) Bubble sort 를 이 용 하 여 ascending/descending #include <stdio.h>#define SIZE 10

void swap(int *, int *);void bubble (int *, const int, int (*compare) (const int,const int));int ascending(const int, const int);int descending(const int, const int);

main(){ int a[SIZE]={2, 6, 4, 8, 10, 89, 68, 45,37,99}; int counter; bubble(a, SIZE, ascending); printf("\n 오 름 차 순 으 로 정 렬 된 데 이 터 \n"); for(counter=0; counter<=SIZE-1;counter++)

printf("\n%4d", a[counter]); bubble(a, SIZE, descending); printf("\n 내 림 차 순 으 로 정 렬 된 데 이 터 \n"); for(counter=0; counter<=SIZE-1;counter++)

printf("\n%4d", a[counter]); printf("\ntest");

return 0;}

void bubble(int *work, const int size, int(*compare)(int, int)){ int pass, count; for(pass=0;pass<size-1;pass++) // 여 기 도

for(count=0; count<size-1; count++) // 여 기 도

// 조 건 에 따 른 ascending & descending

if(compare(work[count], work[count+1]))swap(&work[count], &work[count+1]);

}

void swap(int *a, int *b){ int temp;

// ascending( 오 름 차 순 ) : 1,2,3,4,56int ascending(const int a, const int b){ return a>b; // 여 기}

// descending( 내 림 차 순 ) : 56,4,3,2,1int descending(const int a, const int b){

return b>a; // 여 기}

109

temp=*a; *a=*b; *b=temp;}

110

ANNEX A. Version 관리이 문 서 는 Free입 니 다 . 단 이 문 서 의 저 작 권 은 [email protected] 에 게 있 습 니 다 .무 단 복 제 를 금 합 니 다 .

일 시 변경코드 작성자 주 석

2005/4/23 0.9a 박성태 배 열 에 대 한 전 체 적 인 틀 과 내 용 완 성

2005/7/16 0.9B 박성태 노트북하드고장으로 0.9A 의 PDF로 재작성

111

mailto:[email protected]

pds.devpia.compds.devpia.com/maeul/top_pds/20000/19542/chap-pointer... · web view5)포인터와...

Documents