11. 포인터

💡 endian := byte order 면접 때 자주 물어봄
     (MSB쪽) 0x12345678 (LSB)
      little endian in x86 → 78 56 34 12

      big endian in M68K → 12 34 56 78

      통신에서는 문제가 될 수 있어 TCP/IP에서는 바꿈

 

&a : a 변수의 주소 So, &변수

int* pointer; 포인터변수 선언
   //포인터는 첫 주소만 읽으므로 얼마나 읽어올지 타입 적어줘야 함

*pointer : (간접 참조 연산자) 포인터에 해당하는 값
              So, *주소

 

✅ 메모리 단위 : byte
       주소 하나 : 1byte = 8bit → 00 ~ 최대 FF = 1111 1111
       32bit cpu의 최대 메모리 용량 4GB → 32bit 주소 : 0xFFFF FFFF
       4bit = 1 nibble

 

#include <stdio.h>

int main(void)
{
	int a; // 윈도우 OS가 주소(포인터값)을 할당해줌
	int* pointer;
	int b;
	int* pointer_b;

	a = 0x12345678;
	pointer = &a;
	b = 3;
	pointer_b = &b;

	//d는 10진수로. x로 하면 그대로 나옴
	printf("%d, %p, %d, %p\\n", a, &a, *pointer, pointer);
	// 305419896, 0000007C165AF7A4, 305419896, 0000007C165AF7A4
	printf("%d, %p, %d, %p", b, &b, *pointer_b, pointer_b);
	// 3, 0000007C165AF7E4, 3, 0000007C165AF7E4

printf("포인터 변수의 크기: %zd 바이트\\n", sizeof(pointer));
	// 8바이트 ;64비트 주소체계

	return 0;
}

• 포인터 쓰면 메모리(복사) 덜 씀 ← 시작 주소만 쓰니까
• 메모리 할당은 OS가 → 실행마다 바뀜

💡 PC에서 pointer = 100; 포인터에 직접 할당하면 원랜 OS가 해야 하는 일이므로 에러 남.

     //빌드는 되지만, 사용하면 에러(엑세스 거부)

     반면, 아두이노 같은 임베디드는 본인이 건드려야 해서 오히려 사용

 

포인터 변수 초기화 = NULL

#include <stdio.h>
//void면 변수 부를 때마다 변수 타입 바꿀 수 있음

int main(void)
{
	int i = 3000;
	int* p = NULL; //아무것도 안 가르킴. 0의미

	p = &i;

	printf("i = %d\\n", i); //3000
	printf("&i = %p\\n\\n", &i); //000000EED0F0F944

	printf("p = %p\\n", p); //000000EED0F0F944
	printf("p = %d\\n", *p); //3000

	return 0;
}

 

포인터 이용해서 원래 값 바꾸기

#include <stdio.h>

int main(void)
{
	int i = 10;
	int* p;

	p = &i;
	printf("i = %d\\n", i);

	*p = 20; //포인터 p에 해당하는 값i에 20대입
	printf("i = %d\\n", i);

	return 0;
}

• 초기화 안 된 포인터를 사용하면 안 됨.int *p; *p = 100; 하면 안 됨. int x; *p = &x; 필요
• i.e. 어떤 값의 주소인지 말 안 하고
• 포인터 타입, 변수 타입 일치해야 함
• byte access가 다름

 

포인터와 배열

배열은 & 표시 안 해도 됨

주소	a	a+1	a+2	a+3	int니까 4byte씩 증가
“	&a[0]	&a[1]	&a[2]	&a[3]
변수이름	a[0]	a[1]	a[2]	a[3]
변수값	10	20	30	40
“	*a	*(a+1)	*(a+2)	*(a+3)	a는 주소니까 4byte씩 증가

포인터 형변환

#include <stdio.h>

int main(void)
{
	int data = 0x0A0B0C0D;
	char* pc;
	int* bb;

	pc = (char *)&data; //값 하나 가져오고 1byte씩 이동
	bb = (int*)&data; //4개 가져오고 4byte씩 이동 

	for (int i = 0; i < 4; i++) {
		printf("*(pc + %d) = %X\\n", i, *(pc + i));
	}
	for (int i = 0; i < 4; i++) {
		printf("*(bb + %d) = %X\\n", i, *(bb + i));
	}
	return 0;
}

함수 호출 시 인수 전달방법

1. 값에 의한 호출 call by value

• 함수로 복사본이 전달
• 기본적인 방법
• 계산이나 동작을 위해 값만 필요할 경우

   2. 참조에 의한 호출 call by reference

• 함수로 원본이 전달
• C에선 포인터 이용하여 흉내 낼 수 o
• 메모리가 효율적임
• func(int *px, *py){} 형태
• 함수 외부에서 선언된 변수의 값을 변경할 때

// 참조에 의한 호출
#include <stdio.h>

void sum(int x, int y, int* value)
{
	*value = x + y;
} // 반환 없이 결과 사용 가능, return을 써서 하나가 아닌 여러 결과 가능

int main(void)
{
	int a, b, value;

	a = 10;
	b = 20;
	value = 0;

	sum(a, b, &value); // a,b는 변할 필요 없으니 그대로
	// value는 영향을 받아야 하니 주소를 줘서 값 바꾸고 주소 가져오기
	printf("%d + %d = %d\\n", a, b, value);

	return 0;
}

scanf() 함수 : 사용자에게 주소받아서 변수에 값 저장

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main(void)
{
	int i;
	printf("정수를 입력하시오: "); //창에 출력
	scanf("%d", &i); //창에 입력
	printf("%d", i); //창에 출력
	return 0;
}

//예제
#include <stdio.h>

int main(void)
{
	int a[] = { 10, 20, 30, 40, 50 };
	printf("a = %u\\n", a);
	printf("a + 1 = %u\\n", a + 1);
	printf("*a= %d\\n", *a);
	printf("*(a+1) = 5%d\\n", *(a + 1));

	return 0;
}

//포인터를 배열처럼 사용
#include <stdio.h>

int main(void)
{
	int a[] = { 10, 20, 30, 40, 50 };
	int* p;

	p = a;
	printf("a[0]=%d a[1]=%d a[2]=%d \\n", a[0], a[1], a[2]);
	printf("p[0]=%d p[1]=%d p[2]=%d \\n\\n", p[0], p[1], p[2]);

	p[0] = 60;
	p[1] = 70;
	p[2] = 80;

	printf("a[0]=%d a[1]=%d a[2]=%d \\n", a[0], a[1], a[2]);
	printf("p[0]=%d p[1]=%d p[2]=%d \\n", p[0], p[1], p[2]);
	
	return 0;
}

// 포인터와 함수의 관계
#include <stdio.h>

void sub(int b[], int n); //참조 호출, 값 호출

int main(void)
{
	int a[3] = { 1,2,3 };

	printf("%d %d %d\\n", a[0], a[1], a[2]);
	sub(a, 3);
	printf("%d %d %d\\n", a[0], a[1], a[2]);

	return 0;
}

void sub(int b[], int n)
{
	b[0] = 4;
	b[1] = 5;
	b[2] = 6;
}

/*
#include <stdio.h>
#define SIZE 5

void print_image(int image[SIZE][SIZE])
{
	for (int r = 0; r < SIZE; r++) {
		for (int c = 0; c < SIZE; c++) {
			printf("%03d ", image[r][c]);
		}
		printf("\\n");
	}
	printf("\\n");
}

void brighten_image(int image[SIZE][SIZE])
{
	int* p = &image[0][0];
	for (int r = 0; r < SIZE; r++) {
		for (int c = 0; c < SIZE; c++) {
			//image[r][c] += 10; //인덱스 표기법
			*p += 10;
			p++;
		}
	}
}

int main(void)
{
	int image[SIZE][SIZE] = {
		{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;
}
*/

포인터 사용의 장점

• 연결 리스트, 이진 트리 등 향상된 자료 구조o
• 참조에 의한 호출 포인터를 매개변수로, 함수 외부변수 값 변경o
• 동적 메모리 할당 동적 메모리( in 11장) int *b, *c; b = malloc(40); 40바이트 할당 // 동적 메모리 할당을 위해 나눠둠 for (int i = 0; i < 10; i++) { *(b+i) = i;} free(b); b가 사라짐 //메모리 해제

c = malloc(40);

free(c);

 💡 스택은 정적할당 → 지역변수, 함수변수 등 저장
     힙은 동적할당 관리 영역 → ex_ malloc, calloc, realloc
      free() 안 하면 누수. 계속 남아서 에러

 

포인터와 레지스터

어셈블리어 mov r0, #20, ; //20에 r0를 저장

컴파일 cond 0 0 1 opcode S Rn Rd rot_imm imm8

• 32비트 Cpu가 가지는 주소의 범위도 32비트로 구성
  👌 GPIO : 입출력제어핀
       UART : 시리얼 통신하는 하드웨어 장치 → 비트 단위 데이터 전송,수신

          → 명령어, 어드레스, 어드레싱도 보통 32bit
              0x00000000 ~ 0xFFFFFFFF (총 4GB)
              위 범위에서 RAM, ROM과 같은 메모리와 GPIO, UART 같은 장치 제어 위해 레지스터의 주소들이 포함됨

• Memory MAP : 32비트 CPU의 메모리, 레지스터 주소값 보여주는 지도
  → GPIO, UART, usb, 타이머 … 등 제어?

포인터로 메모리와 레지스터 건드리기

• RAM 주소 0x00000000 0x12345678라는 4byte를 쓰고 싶음
  ((unsigned int) 0x100000000) = 0x12345678; //4byte니까 int
• 어떤 주소에 특정한 사이즈만큼 값을 쓰고 싶음
  *(( 사이즈에 해당하는 변수형 *) 주소) = 값;

10개의 모든 레지스터 모아서 한 번에 관리하면 더 편리

So, 실제 코드에선 “구조체” 사용

#define PERIPH_BASE           0x40000000UL
#define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000UL)
#define GPIOA_BASE            (AHB1PERIPH_BASE + 0x0000UL)
#define GPIOA               ((GPIO_TypeDef *) GPIOA_BASE) // 결국 0x40020000

GPIOA -> ODR = 0xFF;

typedef struct
{
__IO uint32_t MODER;    /*!< GPIO port mode register,               Address offset: 0x00      */
__IO uint32_t OTYPER;   /*!< GPIO port output type register,        Address offset: 0x04      */
__IO uint32_t OSPEEDR;  /*!< GPIO port output speed register,       Address offset: 0x08      */
__IO uint32_t PUPDR;    /*!< GPIO port pull-up/pull-down register,  Address offset: 0x0C      */
__IO uint32_t IDR;      /*!< GPIO port input data register,         Address offset: 0x10      */
__IO uint32_t ODR;      /*!< GPIO port output data register,        Address offset: 0x14      */
__IO uint32_t BSRR;     /*!< GPIO port bit set/reset register,      Address offset: 0x18      */
__IO uint32_t LCKR;     /*!< GPIO port configuration lock register, Address offset: 0x1C      */
__IO uint32_t AFR[2];   /*!< GPIO alternate function registers,     Address offset: 0x20-0x24 */
} GPIO_TypeDef;

void HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init);

HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 

👌 __IO : volatile unit32 : unsigned int 32비트