일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
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 |
Tags
- 도커
- Houdini
- C# delegate
- Data Structure
- 포인터
- c#
- 유니티
- C++
- git
- dart 언어
- Python
- jupyter
- HTML
- github
- 깃
- c# winform
- docker
- 다트 언어
- Unity
- c# 윈폼
- 구조체
- Algorithm
- c언어
- Flutter
- vim
- jupyter lab
- c# 추상 클래스
- gitlab
- C언어 포인터
- 플러터
Archives
- Today
- Total
nomad-programmer
[Programming/C] 여러 가지 포인터의 비교 본문
포인터의 선언과 그 포인터의 의미
단순한 포인터
선언 | 타입 | 의미 |
int* np; | 1차원 포인터 | int형의 주소를 저장 |
int** npp; | 2차원 포인터 | int형의 2차원 주소를 저장 |
단순한 배열
선언 | 타입 | 의미 |
int arr[3]; | 1차원 배열 | int형 값들을 저장 |
int arr[2][3]; | 2차원 배열 | int형 값들을 저장 |
배열과 포인터
선언 | 타입 | 의미 |
int* arr[3]; | 1차원 포인터 배열 | int형 주소값 3개를 저장 |
int (*arr)[3]; | 2차원 배열 포인터 | 포인터 연산시, int형 3개를 건너뛰는 2차원 배열 포인터이며 2차원 배열의 주소를 저장 |
int (*arr)[2][3]; | 3차원 배열 포인터 | 포인터 연산시, int형 2x3개를 건너뛰는 3차원 배열 포인터이며 3차원 배열의 주소를 저장 |
int (*arr[2])[3]; | 2차원 배열 포인터의 배열 | 포인터 연산시, int형 2개를 건너뛰는 2차원 배열 포인터 3개를 가지는 포인터 배열 |
int* (*arr)[3]; | 2차원 배열 포인터 | 포인터 연산시, int형 포인터 3개를 건너뛰는 2차원 배열 포인터. int형 주서를 저장하는 2차원 배열의 주소를 저장 |
함수와 포인터
선언 | 타입 | 의미 |
int* func(void); | 함수 원형 | int형 주소를 반환하고 매개변수가 없는 함수 원형 선언 |
int (*func)(void); | 함수 포인터 | int형을 반환하고 매개변수가 없는 함수들의 주소를 저장 |
int (*func[2])(void); | 함수 포인터 배열 | int형을 반환하고 매개변수가 없는 함수들의 주소를 저장하는 포인터 배열 |
다음은 선언한 변수들의 메모리와 간단한 예제들이다.
int* np; (1차원 포인터)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int n = 10;
int* np;
np = &n;
printf("%d %d\n", n, *np);
return 0;
}
/* 결과
10 10
*/
int** npp; (2차원 포인터)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int n = 10;
int* np = &n;
int** npp;
npp = &np;
printf("%d %d\n", n, **npp);
return 0;
}
/* 결과
10 10
*/
int arr[3]; (1차원 배열)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr[3] = {1, 2, 3};
printf("%d %d %d\n", arr[0], arr[1], arr[2]);
return 0;
}
/* 결과
1 2 3
*/
int arr[2][3]; (2차원 배열)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr[2][3] = {{1, 2, 3}, {100, 200, 300}};
printf("%d %d %d %d %d %d\n",
arr[0][0], arr[0][1], arr[0][2],
arr[1][0], arr[1][1], arr[1][2]);
return 0;
}
/* 결과
1 2 3 100 200 300
*/
int* arr[3]; (int형 주소를 저장하는 배열)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int n1 = 10;
int n2 = 20;
int n3 = 30;
int* arr[3] = {&n1, &n2, &n3};
printf("%d %d %d\n", n1, n2, n3);
printf("%d %d %d\n", *arr[0], *arr[1], *arr[2]);
return 0;
}
/* 결과
10 20 30
10 20 30
*/
int (*arr)[3]; (2차원 배열의 주소를 저장하는 포인터 변수)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr2[2][3] = {{10, 20, 30}, {100, 200, 300}};
int (*arr)[3];
arr = arr2;
printf("%d %d %d %d %d %d\n",
arr[0][0], arr[0][1], arr[0][2],
arr[1][0], arr[1][1], arr[1][2]);
return 0;
}
/* 결과
10 20 30 100 200 300
*/
int (*arr)[2][3]; (3차원 배열의 주소를 저장하는 포인터 변수)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr3[2][2][3] = {
{
{1, 2, 3},
{4, 5, 6}
},
{
{7, 8, 9},
{10, 11, 12}
}
};
int (*arr)[2][3];
arr = arr3;
printf("%d %d %d\n", arr[0][0][0], arr[0][0][1], arr[0][0][2]);
printf("%d %d %d\n", arr[0][1][0], arr[0][1][1], arr[0][1][2]);
printf("%d %d %d\n", arr[1][0][0], arr[1][0][1], arr[1][0][2]);
printf("%d %d %d\n", arr[1][1][0], arr[1][1][1], arr[1][1][2]);
return 0;
}
/* 결과
1 2 3
4 5 6
7 8 9
10 11 12
*/
arr은 3차원 배열의 주소를 저장하기 위한 포인터 변수로 행과 열의 개수가 [2][3]인 int형 3차원 배열의 시작 주소를 저장한다.
int (*arr[2])[3]; (2차원 배열의 주소를 저장하는 배열)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int iarr1[2][3] = {{1, 2, 3}, {4, 5, 6}};
int iarr2[3][3] = {{7, 8, 9}, {10, 11, 12}, {13, 14, 15}};
int (*arr[2])[3];
arr[0] = iarr1;
arr[1] = iarr2;
printf("%d %d %d\n", arr[0][0][0], arr[0][0][1], arr[0][0][2]);
printf("%d %d %d\n", arr[0][1][0], arr[0][1][1], arr[0][1][2]);
puts("=============================");
printf("%d %d %d\n", arr[1][0][0], arr[1][0][1], arr[1][0][2]);
printf("%d %d %d\n", arr[1][1][0], arr[1][1][1], arr[1][1][2]);
printf("%d %d %d\n", arr[1][2][0], arr[1][2][1], arr[1][2][2]);
return 0;
}
/* 결과
1 2 3
4 5 6
=============================
7 8 9
10 11 12
13 14 15
*/
int (*arr[2])[3]은 포인터 배열이다. 배열 요소 (arr[0], arr[1])는 열의 개수가 [3]인 int형 2차원 배열의 시작 주소 등을 저장한다.
int* (*arr)[3]; (int* 형 2차원 배열의 주소를 저장하는 포인터 변수)
#include <stdio.h>
int main(int argc, const char * argv[]) {
int n1 = 10, n2 = 20, n3 = 30, n4 = 40, n5 = 50, n6 = 60, n7 = 70, n8 = 80, n9 = 90;
int* iarr1[2][3] = {{&n1, &n2, &n3}, {&n4, &n5, &n6}};
int* iarr2[3][3] = {{&n1, &n2, &n3}, {&n4, &n5, &n6}, {&n7, &n8, &n9}};
int* (*arr)[3];
arr = iarr1;
for(int i=0; i<2; i++){
for(int j=0; j<3; j++){
printf("%d ", *arr[i][j]);
}
puts("");
}
puts("");
arr = iarr2;
for(int i=0; i<3; i++){
for(int j=0; j<3; j++){
printf("%d ", *arr[i][j]);
}
puts("");
}
return 0;
}
/* 결과
10 20 30
40 50 60
10 20 30
40 50 60
70 80 90
*/
arr은 포인터 변수로, iarr1과 iarr2와 같은 주소를 저장한다.
int* func(void); (함수의 원형)
#include <stdio.h>
static int n = 20;
int* func();
int main(int argc, const char * argv[]) {
int *np;
np = func();
printf("%d %d\n", n, *np);
return 0;
}
int* func(){
return &n;
}
/* 결과
20 20
*/
int (*func)(void) (함수 포인터)
#include <stdio.h>
int func1(){
puts("func1");
return 1;
}
int func2(){
puts("func2");
return 2;
}
int main(int argc, const char * argv[]) {
int (*func)();
func = func1;
printf("%d\n", func());
func = func2;
printf("%d\n", func());
return 0;
}
/* 결과
func1
1
func2
2
*/
int (*func[2])(void) (함수 포인터 배열)
#include <stdio.h>
int func1(){
puts("func1");
return 1;
}
int func2(){
puts("func2");
return 2;
}
int main(int argc, const char * argv[]) {
int (*func[2])();
func[0] = func1;
printf("%d\n", func[0]());
func[1] = func2;
printf("%d\n", func[1]());
return 0;
}
/* 결과
func1
1
func2
2
*/
int (*func[2])() 는 함수의 주소 2개를 저장할 수 있는 함수 포인터 배열이다. 각 배열의 요소(func[0], func[1])는 함수의 주소를 저장한다.
'Programming > C' 카테고리의 다른 글
[Programming/C] XOR(^)를 이용한 데이터 교환 (0) | 2021.01.20 |
---|---|
[Programming/C] printf() 함수와 비슷한 가변인자 함수 만들기 (0) | 2021.01.17 |
[Programming/C] 구조체의 크기를 예측하지 말라 (0) | 2021.01.16 |
[Programming/C] 문자 코드 (0) | 2021.01.15 |
[Programming/C] 배열 요소 접근 (0) | 2020.06.22 |
Comments