theCEED.com - Research your Interests!!
  • MEMBERSHIP PROFILE
  • bar
  • No member information.
  • login_button
  • sign_up_button
no_image

c코딩!!!!

About the ceed

모든 c코딩을 이곳에 퍼부으세요!!
Recommend : 0 I Total List : 20 I 2016-07-20
favorite
기초) 포인터 배움터1 2016.12.07 16:17:02
Nickname : 81. theceed Recommend : 0 View : 339 btn_recommend.png declaration

Please enter reasons of report.

declaration

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
#include<stdio.h >
 
void print_ez_pointer(int arr[], int n);            // 포인터를이용해 배열 컨트롤하기
void change_value(int  *p);                            // 포인터를 이용해서 메인에 있는 변수 만지기
void swap(int  *a, int  *b);                            // 스왑!
void func_arr(int funcArr[], int n);                    // 함수에서 포인터를 이용해 값 변경
void func_arr2(int  *p, int n);
 
 
// 한번 포인터에 대해 잘 알아봅시다! 하하하하하
 
// 포인터란, 변수와는 달리 컴퓨터의 메모리 영역 주소를 직접 다루면서 사용하는 막강한 기능입니다.
// '*' 은 간접 참조 연산자라고 합니다. 보통 그냥 포인터라고도 함<^><<<<<
// 그리고 증감연산자(++, --)보다 우선순위가 낮기 때문에 사용에 주의를 해야 한다
// 그래서 괄호를 써야함
 
int main()
{
    int number =10;            // int 형 변수로 선언 후 10을 대입한다.
    char name ='a';            // char 형 변수로 선언 후 'a'를 대입한다.
    float pi =3.141592;        // float 형 변수로 선언 후 3.141582를 대입한다.
    int arr[]  = {1020304050};
    int  *pArr;
    int i;
 
    ///////
    int dataA, dataB;
    ///////
 
    // 테스트에 사용할 포인터 변수
    char  *ptc;
    int  *pti;
    double  *ptd;
 
    // 1) 방법 1. 포인터형 변수 선언 후 바로 변수 삽입
    int  *pd = &number;        // int 형 포인터 변수를 선언한다.
                            // 이 방법에는 포인터 *변수 = &(앤드연산)변수 형태로 구성한다.
    char  *pc = &name;            // char 형 포인터 변수를 선언후 변수(name)의 주소를 저장한다.
 
    // 2) 방법 2. 포인터 형 변수 선언 후 이후에 변수 적용
    float  *pf;            // float 형 포인터 변수를 선언한다.
    pf  =  &pi;            // 대상이 되는 포인터 변수에는 *을 붙이지 않고 사용한다.
 
 
    /////////////////////////////////////////////////////////////////////////////////////////
    // ** 포인터 변수는 대상이 되는 변수의 형을 따라 가야 한다.
    // ex ) int 형 변수의 포인터 변수는 int *p 형식으로 해야 한다.
    printf("각각의 변수의 값을 포인터를 이용해 출력하기\n");
    printf("변수 Number의 값은 : %d\n" *pd);    // 출력은 속성에 따르며, 포인터 변수를 사용하기 때문에 *을 붙인다.
    printf("변수 name의 값은 : %c\n" *pc);
    printf("변수 pi의 값은 : %f\n\n" *pf);    // 실수형(float)흥 %f를 사용하며, 포인터 변수의 앞에 *을 붙인다.
 
    // 포인터의 주소 출력해보기
    printf("\n포인터 변수의 주소값을 출력해보자\n");
    printf("포인터 변수 pd의 주소값은 : %p\n", pd);        // 포인터 변수 pd의 주소값을 출력하기 (16진수 형태)
    printf("포인터 변수 pd의 주소값은 : %p\n", pc);        // 
    printf("포인터 변수 pd의 주소값은 : %p\n\n", pf);        //
 
    printf("포인터 변수 pd의 주소값은 : %u\n", pd);        // 포인터 변수 pd의 주소값을 출력하기 (10진수 형태)
    printf("포인터 변수 pd의 주소값은 : %u\n", pc);        // 
    printf("포인터 변수 pd의 주소값은 : %u\n\n", pf);        //
 
    // 포인터와 변수의 출력
    printf("포인터가 가르키는 변수와 내용\n");
    printf("변수 number의 값은 : %d\n", number);            // 변수의 값 출력
    printf("포인터가 가르키는 주소의 값은 : %d\n\n" *pd);    // 포인터를 통한 간접 참조 값 출력
 
    printf("변수 number의 주소는 : %p\n" &number);            // 변수의 주소값 출력
    printf("포인터의 주소 값은 : %p\n\n", pd);                    // 포인터의 주소 값 출력
 
 
    ////////////////////////////////////////////////////////////////////////////////////
    // 포인터를 이용한 값 증가/감소(정수형)
    printf("-----포인터를 이용한 값 증가/감소(정수형)\n");
    number  = 100;            // number 변수 값 변경
    printf("원래 값은 : %d\n" *pd);    // 변경 전 포인터가 가르키는 값(100)
    ( *pd) + +;                            // 포인터를 이용한 값 증가(포인터를 포함한 포인터 변수를 괄호로써 묶어준다::포인트임!)
                                        // 증감연산자를 이용할때는 꼭! 괄호! 괄호! 소괄호!!!! 중요 별표 100개!
 
    printf("1을 더하면 : %d\n" *pd);    // 변경 후 포인터가 가르키는 값(101)
     *pd  =  *pd  + 5;                                    // 일반적으로 이렇게 사용가능하다.
                                                    // 단순 연산때와 비슷하지만 포인터를 붙여주는 것이 다름!
 
    printf("5를 더하면 : %d\n" *pd);            // 변경 후 포인터가 가르키는 값(106)
     *pd  + = 100;                                // 물론 이렇게도 접근 가능하다.
    printf("100을 더하면 : %d\n\n" *pd);            // 출력! 출ㅋ력ㅋ
 
    // 포인터를 이용한 값 증가/감소(실수 및 문자형)
    name  = 'A';
    printf("-----포인터를 이용한 값 증가/감소(실수 및 문자형)\n");
    printf("시작 문자는 : %c\n" *pc);    // 시작 문자는 이것!
    ( *pc) + +;
    
    printf("하나 증가 시킨 문자는 : %c\n" *pc);    // 하나 증가시킨 값
     *pc  =  *pc  + 5;
 
    printf("다섯 증가 시킨 문자는 : %c\n" *pc);    // 다섯 증가시킨 값
     *pc + =10;
    printf("열개 증가 시킨 문자는 : %c\n\n" *pc);    // 열개 증가시킨 값
 
    pi  = 31.41592;
    printf("처음 실수값은 : %f\n" *pf);            // 처음 실수값
    ( *pf) + +;
    printf("증감연산자를 뭍혔다 : %f\n" *pf);        // 증감연산자
 
     *pf  =  *pf  + 5;
    printf("다섯 증가 : %f\n" *pf);                // 다섯증가
 
     *pf + =100;
    printf("100 증가 : %f\n" *pf);                    // 100 증가
 
 
    ////////////////////////////////////////////////////////////////////////////////////////
    /*
    포인터 타입에 따른 ++연산 후 증가되는 값
    포인터는 대상이 어떤 형태인지 모르기 때문에, 포인터를 선언할때 타입을 설정해주어야 한다.
    예시 ) int *pi;
 
    다음은 포인터 타입에 따른 ++ 연산 후 증가되는 값이다.
 
    포인터 타입        |        ++연산 후 증가되는 값
    ----------------------------------------------
    char                    1
    short                    2
    int                        4
    float                    4
    double                    8
    ----------------------------------------------
    변수가 갖는 비트의 값과 같다
    
    */
 
    printf("포인터 변수의 주소값을 변경시켜봅시다(증감)\n");
    ptc  = (char  *)10000;                // ptc의 주소를 임의로 지정한다(10000)
    pti  = (int  *)10000;                    // pti의 주소를 임의로 지정한다(10000)
    ptd  = (double  *)10000;                // ptd의 주소를 임의로 지정한다(10000)
    printf("증가 전 각각의 값\n");
    printf("ptc : %d\n", ptc);            // 확인
    printf("pti : %d\n", pti);
    printf("ptf : %d\n\n", ptd);
 
    ptc + +;                                // 증가
    pti + +;                                // 주소를 증가시키는 것이기 때문에 포인터(*)를 적지 않아도 된다.
    ptd + +;
    printf("증가 후 각각의 값\n");
    printf("ptc : %d\n", ptc);            // 확인
    printf("pti : %d\n", pti);
    printf("ptf : %d\n\n", ptd);
 
    printf("이렇게도 사용 가능함(+5)\n");
    printf("ptc : %d\n", ptc +5);        // 임시로 이렇게 해도 상관없다.
    printf("pti : %d\n", pti +5);
    printf("ptf : %d\n\n", ptd +5);
    
    printf("재확인\n");
    printf("ptc : %d\n", ptc);        // 원본이 변한 것은 절대 아닙니다람쥐
    printf("pti : %d\n", pti);        // 
    printf("ptf : %d\n", ptd);
 
 
    //////////////////////////////////////////////////////////////////////////////
    // 포인터끼리의 비교
    // ptc 와 ptd의 비교를 해본다
    printf("\n포인터간의 비교연산자를 이용해봅시다 :)\n");
    if(ptc  ! = NULL)    printf("ptc는 NULL이 아닙니다 고갱님\n");                    // null인지 아닌지 판단하기 참 쉽죠잉?
    if(ptc  ! = ptd)    printf("ptc는 ptd와 같지 않음\n");                            // 포인터의 주소를 비교함
    if(ptc  > ptd)    printf("ptc(%d)는 ptd(%d)보다 앞에 있지 않음\n", ptc, ptd);    // 포인터에서는 수가 작을수록 앞에 있는 것임
    else            printf("ptc(%d)는 ptd(%d)보다 앞에 있음\n\n", ptc, ptd);        // 큰수 일수록 뒤에 있는 것으로 판단함
    // 해보니까 형식이 맞지는 않아도 비교는 되는 것을 알 수 있음
    // 물론 맞추면 좋긴 한데, 때에 따라서는 안맞을 수도 있으니까 이점 유의하세요.
 
    ///////////////////////////////////////////////////////////////////////////////
    // 증감연산자와 간접 참조 연산자의 우선 순위 확인
    // 맨 위에서 증감연산자와 간접 참조 연산자의 우선 순위가
    // 증감연산자가 더 높다고 말했었는데, 그럼 어떻게 바뀌는지 한번 알아봅시다 :)
    // 1. *p++;
    // 2. (*p)++;
    // 의 차이 실습
    // number = 10;
 
    printf("증감연산자와 간접 참조 연산자의 우선순위에 따른 변화\n");
    number  = 10;                                    // initialized
    printf("number : %d, pd : %p\n", number, pd);    // 변수 number의 값과 포인터 pd의 주소 확인
    ( *pd) + +;                                        // 괄호 여부 확인
    printf("number : %d, pd : %p\n", number, pd);    // 확인하기(변수가 바뀐다)
     *pd + +;                                            // 괄호 여부 확인
    printf("number : %d, pd : %p\n\n", number, pd);    // 확인하기(주소가 바뀐다:그 안에 들어 있는 타겟은 바뀌지 않는다)
 
    ///////////////////////////////////////////////////////////////////////////////
    // 배열을 포인터로 접근하기!
    //우선 배열의 각각의 주소 확인해보기
    printf("배열과 포인터의 관계\n");
    printf("arr[0] >> %u\n" &arr[0]);        // 확인하기 쉽게 10진수로 주소 확인하기
    printf("arr[1] >> %u\n" &arr[1]);        // 배열의 특성상 일정 간격으로 배열이 구성되어 있음
    printf("arr[2] >> %u\n" &arr[2]);        // 참 단정하구나
 
    // 배열의 시작 주소를 알아보자
    printf("arr >> %u\n\n", arr);            // arr[0]과 같은 주소임을 알 수 있다.
 
    // 그럼 포인터로 배열의 값에 접근하여 보자. 살금 살금 다가가 장미꽃으...ㄹ
    // arr[] = {10, 20, 30, 40, 50};        // 위에 확인하세여
    printf("위의 배열 주소와 비교/확인해보세요\n");
    printf("arr의 주소값은 >> %u\n", arr);                    // arr배열의 주소값 확인
    printf("arr의 두번째 변수 주소는 >> %u\n", arr +1);        // 배열의 두번째 주소값 확인
    printf("*arr의 값은 >> %d\n" *arr);                    // 배열 첫번째 값 확인
    printf("*arr 두번째 값은 >> %d\n" *(arr +1));            // 배열  n번째 값 확인
    // printf("*arr n번째 값은 >> %d\n", *(arr+n));
 
    ////////////////////////////////////////////////////////////////////////////////
    // 포인터를 배열처럼 사용할 수 도 있음! < 아마 이게 여러분들이 가장 어려워 하는 부분인듯!
    // arr[] = {10, 20, 30, 40, 50};        // 위에 확인하세여
    pArr  = arr;
    
    printf("\n\n포인터를 배열처럼 사용할수도 있다?\n");
    printf("\narr[0] :: %d\tarr[1] :: %d\tarr[2] :: %d\n", arr[0], arr[1], arr[2]);                // 배열의 값 출력
    printf("pArr[0] :: %d\tpArr[1] :: %d\tpArr[2] :: %d\n", pArr[0], pArr[1], pArr[2]);            // 포인터가 가르키는 값 출력
 
    pArr[0 = 70;    // 값 입력
    pArr[1 = 80;    // 값 입력
    pArr[2 = 90;    // 값 입력
 
    printf("\n\n포인터를 배열처럼 사용한 뒤의 값들\n");
    printf("\narr[0] :: %d\tarr[1] :: %d\tarr[2] :: %d\n", arr[0], arr[1], arr[2]);                // 배열의 값 출력
    printf("pArr[0] :: %d\tpArr[1] :: %d\tpArr[2] :: %d\n\n\n", pArr[0], pArr[1], pArr[2]);        // 포인터가 가르키는 값 출력
 
    ///////////////////////////////////////////////////////////////////////////////////
    // 여기까지는 프롤로그
    // 이제 우리 함수와 포인터를 이용해 조물조물 해볼까여?
    // 난 소면을 좋아하니까 비빔국수 스타일로 해볼께여 XD
    // arr[] = {10, 20, 30, 40, 50};
    // 이 자식을 이용해서 해볼거에요
    // 일단 초기화를 해볼게여 :)
    for(i =0; i <5; i + +)    arr[i]  = (i +1) *10;    // 10~50까지 삽ㅋ입ㅋ
 
    // 그리고 과감하게 함수로 날려버린다
    printf("함수를 사용하자! 포인터 변수도 사용하자!\n");
    print_ez_pointer(arr, 5);
    ///////////////////////////////////////////////////////////////////////////////////
 
 
    // 함수의 영향을 온누리에~
    number  = 10;
    ///////////////////////////////////////////////////////////////////////////////////
    // 포인터를 이용해 다른 함수에서 직접 컨트롤하기
    printf("\n\n함수에서 포인터를 이용해서 직접 컨트롤 해보자!\n");
    printf("함수를 거치기 전 number 값 : %d\n", number);
    change_value( &number);
    printf("함수를 거친 후의 number 값 : %d\n\n\n", number);
 
    //////////////////////////////////////////////////////////////////////////////////
    // 포인터를 이용한 스왑!(sawp)
    dataA  = 100;
    dataB  = 200;
 
    printf("스왑하기 전의 각각의 데이터 A : %d, B : %d\n", dataA, dataB);
    swap( &dataA,  &dataB);
    printf("스왑한 후의 각각의 데이터 A : %d, B : %d\n\n\n", dataA, dataB);
 
    ///////////////////////////////////////////////////////////////////////////////////
    // 포인터를 이용한 함수에서의 값 변경 방법 1
    for(i =0; i <5; i + +)    arr[i]  = (i +1) *10;    // 10~50까지 삽ㅋ입ㅋ// 초기화
    printf("포인터를 이용한 함수에서의 값 변경 방법 1\n");
    printf("arr[0] >> %d\tarr[1] >> %d\tarr[2] >> %d\n", arr[0], arr[1], arr[2]);
    func_arr(arr, 5);
    printf("arr[0] >> %d\tarr[1] >> %d\tarr[2] >> %d\n\n", arr[0], arr[1], arr[2]);
 
    /////////////////////////////////////////////////////////////////////////////////////
    // 포인터를 이용한 함수에서의 값 변경 방법 2
    for(i =0; i <5; i + +)    arr[i]  = (i +1) *10;    // 10~50까지 삽ㅋ입ㅋ// 초기화
    printf("포인터를 이용한 함수에서의 값 변경 방법 2\n");
    printf("arr[0] >> %d\tarr[1] >> %d\tarr[2] >> %d\n", arr[0], arr[1], arr[2]);
    func_arr2(arr, 5);        // 보낼때는 배열 처음주소(이름만) 쓰고, 크기를 따로 보낸다.
    printf("arr[0] >> %d\tarr[1] >> %d\tarr[2] >> %d\n", arr[0], arr[1], arr[2]);
}
 
// 포인터를 이용한 역ㅋ순ㅋ출ㅋ력ㅋ!
void print_ez_pointer(int arr[], int n)        // 배열은 형태만 보내도록 하고, 추가로 크기를 보내서 할당한다(n이 크기)
{
    int  * = arr  + n  - 1;        // 포인터 변수에 arr의 주소값의 끝자리 값을 준다.
    
    printf("배열 arr이 가르키는 위치 : %u\t값 : %d\n", arr,  *arr);            // 가장 처음을 알려주는 arr배열
    printf("포인터 p의 값 : %u\t포인터 p가 가르키는 내용 : %d\n", p,  *p);    // 가장 처음인 arr에 n의 값(5)를 대입하고 -1 하면 가장 끝이 된다.(0~4 범위니까)
 
    while(p  > = arr)        // 참과 거짓으로 조건 검색
        printf("p : %u\tarr : %u\tnumber is %d\n", p, arr,  *p - -);        // 괄호 치징않은 증감연산자는 주소에 영향을 미친다.
}
 
 
 
void change_value(int  *p)        // 포인터를 이용해 주소만을 옮겨가고 옮겨간 주소에 접속해 값을 변경한다.
{
     * = 50;        // 포인터로 p가 가르키는 변수의 값을 변경할 수 있다.
    // *p = 0;        // 값을 0을 줄수는 없다고 한다.
}
 
void swap(int  *a, int  *b)    // 포인터(주소)값을 입력 받도록 한다.
{
    int tmp; // temp 변수 하나(임시) 만들어서 스왑에 사용한다.
 
    // 스왑은 일반 변수와 큰 차이는 없다.
    tmp  =  *a;
     * =  *b;
     * = tmp;
}
 
void func_arr(int funcArr[], int n)    // 포인터를 이용해 값 변경하기(in 함수에서)
{
    funcArr[0 = 51;            // 값 변경
    funcArr[1 = 52;            // 리턴이 없어도 충분히 값 변경 가능
    funcArr[2 = 53;            // 오 포인터 개이득
}
 
void func_arr2(int  *p, int n)    // 포인터를 이용해 값 변경하기(in 함수에서)
{
    p[0 = 100;        // 포인터 변수를 일반 배열처럼 사용하여 변경할 수 있다.
    p[1 = 200;
    p[2 = 300;
 
//    *(p+0) = 50;    // 포인터를 이용해 접근 할 수 있다.
//    *(p+1) = 60;    // 포인터를 쓰고 괄호를 이용해 포인터 변수와 숫자를 넣으면 해당 번지의 배열을 직접 컨트롤 가능하다.
//    *(p+2) = 70;    // 총 3가지의 방법이 존재함
}
cs

 

 

#코딩 #C언어 #더시드닷컴 #프로그래밍 #기초프로그래밍 #인터넷 #컬러스크립터 #코딩코딩 #초등코딩
#theceed #web #internet #study #coding #사랑해
 

 

 

list
Comments

name

write a comment
TOTAL  0 Comments
* No comments. Please write comments