λ³μμ λ©λͺ¨λ¦¬
- λ³μλ λ©λͺ¨λ¦¬μ μ μ₯λλ€
- λ©λͺ¨λ¦¬λ λ°μ΄νΈ λ¨μλ‘ μ‘μΈμ€ λλ€
- λ³μμ ν¬κΈ°μ λ°λΌμ μ°¨μ§νλ λ©λͺ¨λ¦¬ 곡κ°μ΄ λ¬λΌμ§λ€ 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 |