๋ณ์์ ๋ฉ๋ชจ๋ฆฌ
- ๋ณ์๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ค
- ๋ฉ๋ชจ๋ฆฌ๋ ๋ฐ์ดํธ ๋จ์๋ก ์ก์ธ์ค ๋๋ค
- ๋ณ์์ ํฌ๊ธฐ์ ๋ฐ๋ผ์ ์ฐจ์งํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ฌ๋ผ์ง๋ค ex) int 4๋ฐ์ดํธ, char 1๋ฐ์ดํธ ,,,
๋ณ์์ ์ฃผ์
- ๋ณ์์ ์ฃผ์๋ฅผ ๊ณ์ฐํ๋ ์ฐ์ฐ์ : &
- ๋ณ์ i์ ์ฃผ์ : &i
ํฌ์ธํฐ๋?
์ฃผ์๋ฅผ ๊ฐ๊ณ ์๋ ๋ณ์ ( = ๋ณ์์ ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋ณ์)
์ฃผ์๊ฐ์ ๊ฐ์ง ๋ณ์
<ํฌ์ธํฐ์ ์ ์ธ>
int * p ;
- ์ ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ p
ํฌ์ธํฐ์ ๋ณ์์ ์ฐ๊ฒฐ
int i = 10; // ์ ์ํ ๋ณ์ i ์ ์ธ
int *p; // ํฌ์ธํฐ ๋ณ์ p ์ ์ธ
p = &i; // ๋ณ์ i์ ์ฃผ์๊ฐ ํฌ์ธํฐ p๋ก ๋์
&์ฐ์ฐ์์ *์ฐ์ฐ์
&์ฐ์ฐ์ : ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐํํ๋ค
*์ฐ์ฐ์ : ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ ๋ด์ฉ์ ๋ฐํํ๋ค
๊ฐ์ ์ฐธ์กฐ ์ฐ์ฐ์ *
: ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ๊ฐ์ ธ์ค๋ ์ฐ์ฐ์
: ์ง์ ๋ ์์น์์ ํฌ์ธํฐ์ ํ์ ์ ๋ฐ๋ผ ๊ฐ์ ์ฝ์ด๋ค์ธ๋ค.
int i = 10;
int *p;
p = &i;
printf("%d", *p);
// 10์ด ์ถ๋ ฅ๋๋ค.
#include <stdio.h>
int main(void)
{
int i = 10;
int *p;
p = &i;
printf("i = %d\n", i); // 10 ์ถ๋ ฅ
*p = 20; // ํฌ์ธํฐ๋ฅผ ํตํ์ฌ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝํจ
printf("i = %d\n", i); // 20 ์ถ๋ ฅ
return 0;
]
ํฌ์ธํฐ ์ฌ์ฉ์ ์ฃผ์์ (1) ์ฐ๋ ๊ธฐ๊ฐ(data)
- ์ด๊ธฐํ๊ฐ ์๋ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ์๋๋ค.
- ํฌ์ธํฐ๊ฐ ํ๋์จ์ด๋ก ๊ฐ์ง๋ ๊ฒฝ์ฐ, ํดํน๋ ์ํ์ฑ์ด ์๋ค.
int main(void)
{
int *p; // ํฌ์ธํฐ p๋ ์ด๊ธฐํ๊ฐ ์๋์ด์์
*p = 100; // ์ํํ ์ฝ๋
return 0;
}
// ํฌ์ธํฐ๊ฐ ์๋ฌด๊ฒ๋ ๊ฐ๋ฆฌํค๊ณ ์์ง ์๋ ๊ฒฝ์ฐ์๋ null๋ก ์ด๊ธฐํ ํด์ผ ํจ
// null ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ณ ๊ฐ์ ์ฐธ์กฐํ๋ฉด ํ๋์จ์ด๋ก ๊ฐ์งํ ์ ์๋ค
int *p = NULL;
ํฌ์ธํฐ ์ฌ์ฉ์ ์ฃผ์์ (2) ํฌ์ธํฐ์ ํ์ ๊ณผ ๋ณ์์ ํ์ ์ ์ผ์นํ์ฌ์ผ ํ๋ค
#include <stdio.h>
int main(void)
{
int i;
double *pd;
pd = &i; // ์ค๋ฅ! doubleํ ํฌ์ธํฐ์ intํ ๋ณ์์ ์ฃผ์๋ฅผ ๋์
ํ๋ค
*pd = 36.5;
return 0;
}
- ๋ณ์์ ํฌ๊ธฐ์ ๋ฐ๋ผ์ ์ฐจ์งํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ฌ๋ผ์ง๋ค ex) int 4๋ฐ์ดํธ, char 1๋ฐ์ดํธ ,,,
- ๊ทธ๋ฌ๋ฏ๋ก ํ ๋น๋ ์ฃผ์์ ๋ณ์์ ํ์ ์ด ์ผ์นํ์ง ์์ผ๋ฉด ๋ฐ์ดํฐ๊ฐ ๋ง๊ฐ์ง๋ ๋ฑ์ ๋ฌธ์ (์ค๋ฅ)๊ฐ ์๊ธด๋ค.
ํฌ์ธํฐ ์ฐ์ฐ
- ๊ฐ๋ฅํ ์ฐ์ฐ : ์ฆ๊ฐ, ๊ฐ์, ๋ง์ , ๋บ์ ์ฐ์ฐ
- ์ฆ๊ฐ ์ฐ์ฐ์ ๊ฒฝ์ฐ ์ฆ๊ฐ๋๋ ๊ฐ์ (ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด์ ํฌ๊ธฐ)์์ ์ฆ๊ฐ๋๋ค.
- ๋ฐ์ดํธ๋ก ์ฆ๊ฐ๋๋ค.
ํฌ์ธํฐ๋ฅผ ๋ง์ ํ๋ค์ ์๋ฏธ ์์๋ณด๊ธฐ
ex) *(p + 1)
์ฃผ์๋ฅผ ํ์นธ์ ๋ ๊ฐ๋ค(1๋งํผ ๋ํ๋ค์ ์๋ฏธ) -> ํ์นธ์ โ ๋ฐ์ดํธ -> โ ๋ฐ์ดํธ๋ฅผ ๋ํด์ค๋ค
ex) *(p + 2)
์ฃผ์๋ฅผ ๋์นธ์ ๋ ๊ฐ๋ค(2๋งํผ ๋ํ๋ค์ ์๋ฏธ) -> ํ์นธ์ 2xโ ๋ฐ์ดํธ -> 2xโ ๋ฐ์ดํธ๋ฅผ ๋ํด์ค๋ค
ex) *(p + 3)
์ฃผ์๋ฅผ ์ธ์นธ์ ๋ ๊ฐ๋ค(3๋งํผ ๋ํ๋ค์ ์๋ฏธ) -> ํ์นธ์ 3xโ ๋ฐ์ดํธ -> 3xโ ๋ฐ์ดํธ๋ฅผ ๋ํด์ค๋ค
๊ฐ์ ์ฐธ์กฐ ์ฐ์ฐ์์ ์ฆ๊ฐ ์ฐ์ฐ์
*p++;
: p๊ฐ ๊ฐ๋ฆฌํค๋ ์์น์์ ๊ฐ์ ๊ฐ์ ธ์จ ํ p๋ฅผ ์ฆ๊ฐํ๋ค.
: ์๋ณธ๊ฐ์ ๊ทธ๋๋ก ์๊ณ , ํฌ์ธํฐ๊ฐ ๊ฐ์ ธ์จ ๊ฐ๋ง ์ฆ๊ฐํ๋ค.
(*p)++;
: p๊ฐ ๊ฐ๋ฆฌํค๋ ์์น์ ๊ฐ์ ์ฆ๊ฐํ๋ค.
: ์๋ณธ๊ฐ์ด ๋ฌ๋ผ์ง๋ค.
ํฌ์ธํฐ์ ํ๋ณํ
- c์ธ์ด์์๋ ๊ผญ ํ์ํ ๊ฒฝ์ฐ์, ๋ช ์์ ์ผ๋ก ํฌ์ธํฐ์ ํ์ ์ ๋ณ๊ฒฝํ ์ ์๋ค.
double *pd = &f;
int *pi;
pi = (int *)pd; //pd๋ฅผ intํ์ผ๋ก ๋ณํํ์ฌ์ ์ ์ฅํ๊ฒ ๋ค
์ธ์ ์ ๋ฌ ๋ฐฉ๋ฒ
- ํจ์ ํธ์ถ ์์ ์ธ์ ์ ๋ฌ ๋ฐฉ๋ฒ
(1) ๊ฐ์ ์ํ ํธ์ถ (call by value)
- ํจ์๋ก ๋ณต์ฌ๋ณธ์ด ์ ๋ฌ๋๋ค
- ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ
- ๋ฐ์ดํฐ๊ฐ ํฌ๋ฉด ์ ์์ด๋ค. ๋ณต์ฌ๊ฐ ๋๋ฉด ์ฉ๋์ ๋ง์ด ์ฐจ์งํ๋ฏ๋ก.
(2) ์ฐธ์กฐ์ ์ํ ํธ์ถ (call by reference)
- ํจ์๋ก ์๋ณธ์ด ์ ๋ฌ๋๋ค
- C์์๋ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ํ๋ด๋ผ ์ ์๋ค
*px, *py๋ฅผ
(์ฃผ์๋ก ๊ฐ์)
&a, &b
swap (๋ฐ๋๋ฏ๋ก) ๋๋ฏ๋ก,
์๋ณธ์ด ๋ฐ๋๋ ๊ฒ์ด๋ค.
scanf() ํจ์ ๋ค์ ์ดํดํด๋ณด๊ธฐ : ํฌ์ธํฐ์ ๊ฐ๋
scanf("%d", &x)
: ๋ณ์์ ๊ฐ์ ์ ์ฅํ๊ธฐ ์ํ์ฌ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐ๋๋ค
: ์ ๋ฌ๋ ์ฃผ์๋ฅผ ์ด์ฉํด ๋ณ์์ ์ฌ์ฉ์๋ก๋ถํฐ ๋ฐ์ ๊ฐ์ ์ ์ฅํ๋ค.
ํฌ์ธํฐ์ ๋ฐฐ์ด
- ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ๋ ์์ฃผ ๋ฐ์ ํ ๊ด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
- ๋ฐฐ์ด ์ด๋ฆ์ด ๋ฐ๋ก ํฌ์ธํฐ์ด๋ค.
- ํฌ์ธํฐ๋ ๋ฐฐ์ด์ฒ๋ผ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
- ์ธ๋ฑ์ค ํ๊ธฐ๋ฒ์ ํฌ์ธํฐ์ ์ฌ์ฉํ ์ ์๋ค.
%u๋ ์ฃผ์๋ฅผ ์๋ฏธํ๋ค.
int b[]
int *b
- ๊ฐ์ํํ์ด๋ค.
void sub(int b[], int size)
{
*b = 4;
*(b+1) = 5;
*(b+2) = 6;
// ํฌ์ธํฐ b๋ฅผ ํตํ์ฌ ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝํ ์ ์๋ค.
}
ํฌ์ธํฐ๋ฅผ ํตํ ๋ฐฐ์ด์ ๋ณ๊ฒฝ์ ์ฐธ์กฐ์ ์ํ ํธ์ถ (call by reference)๋ก ์๋ณธ์ด ๋ฐ๋๊ฒ ๋๋ค.
ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ฐฉ๋ฒ์ ์ฅ์
- ํฌ์ธํฐ๊ฐ ์ธ๋ฑ์ค ํ๊ธฐ๋ฒ๋ณด๋ค ๋น ๋ฅด๋ค.
- ์ธ๋ฑ์ค๋ฅผ ์ฃผ์๋ก ๋ณํํ ํ์๊ฐ ์๋ค.
=> ์๋๊ฐ ์์ฒญ ๋น ๋ฅธ๊ฒ์ ์๋๋, ํ์์ ๋ฐ๋ผ ์ฌ์ฉํ๋ฉด ๋๋ค.
ํฌ์ธํฐ๋ฅผ ๋ฐํํ ๋ ์ฃผ์์
- ํจ์๊ฐ ์ข ๋ฃ๋๋๋ผ๋ ๋จ์ ์๋ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐํํ์ฌ์ผ ํ๋ค.
- ์ฐ๋ ๊ธฐ๊ฐ์ด ๋จ์์๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํจ์ด๋ค.
- ์ง์ญ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐํํ๋ฉด ํจ์๊ฐ ์ข ๋ฃ๋๋ฉด ์ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
> ์๋ชป๋ ์์ ์ด๋ค.
#include <stdio.h>
int* getLocalVariableAddress() {
int localVar = 10; // ์ง์ญ ๋ณ์
return &localVar; // ์ง์ญ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐํ (๋ฌธ์ ๋ฐ์)
}
int main() {
int* p = getLocalVariableAddress();
// ํจ์ ์ข
๋ฃ ํ ์ง์ญ ๋ณ์๋ ์ฌ๋ผ์ง๋ฏ๋ก p๋ ์ ํจํ์ง ์์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํด
printf("Value at p: %d\n", *p); // ์๋ชป๋ ์ ๊ทผ (์์์น ๋ชปํ ๊ฒฐ๊ณผ ๋ฐ์)
return 0;
}
> ์ฌ๋ฐ๋ฅธ ์์ ์ด๋ค.
#include <stdio.h>
#include <stdlib.h>
int* getDynamicMemoryAddress() {
int* ptr = (int*)malloc(sizeof(int)); // ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
if (ptr == NULL) {
printf("Memory allocation failed\n");
exit(1);
}
*ptr = 10; // ๋์ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ ํ ๋น
return ptr; // ๋์ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๋ฅผ ๋ฐํ (๋ฌธ์ ์์)
}
int main() {
int* p = getDynamicMemoryAddress();
printf("Value at p: %d\n", *p); // ์ฌ๋ฐ๋ฅธ ์ ๊ทผ
free(p); // ๋์ ๋ฉ๋ชจ๋ฆฌ ํด์
return 0;
}
์์ ) 5x5 ์ด๋ฏธ์ง ๋๋ ์์์ ํ๋ ฌ์ ๋ฐ๊ธฐ๋ฅผ 10๋งํผ ์ฆ๊ฐ์ํค๋ ์์
#include <stdio.h>
#define SIZE 5
void print_image(int image[][SIZE])
{
int r, c;
for (r = 0; r < size; r++){
for (c = 0; c < size; c++){
printf("%03d", image[r][c]);
}
printf("\n");
}
printf("\n");
}
void Brightn_image(int image[][SIZE])
{
int r, c;
int *p;
p = &image[0][0];
for (r = 0; r < size; r++){
for (c = 0; c < size; c++){
*p += 10;
p++;
}
}
}
int main(void)
{
int image[5][5] = {
{10, 20, 30, 40, 50},
{10, 20, 30, 40, 50},
{10, 20, 30, 40, 50},
{10, 20, 30, 40, 50},
{10, 20, 30, 40, 50}};
print_image(image);
brighten_image(image);
print_image(image);
return 0;
}
'C Programming Language > C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
C์ธ์ด ๋ฌธ์์ด์ ์ฒ๋ฆฌํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์ (0) | 2024.07.11 |
---|---|
C์ธ์ด ๋ฌธ์์ ๋ฌธ์์ด์ ๋ํด ํ์ตํ๊ธฐ (0) | 2024.07.10 |
C์ธ์ด ์ ๋ ฌ๊ณผ ํ๋ ฌ์ ๋ํด ํ์ตํ๊ธฐ (0) | 2024.07.01 |
C์ธ์ด ๋ฐฐ์ด์ ๋ํด ํ์ตํ๊ธฐ (0) | 2024.06.19 |
C์ธ์ด ์ฌ๊ท์ ์๊ณ ๋ฆฌ์ฆ : ํ๋ ธ์ด ํ ๋ฌธ์ (0) | 2024.06.19 |