다유데브

0. 개요

다유데브 — Thu, 8 Dec 2022 08:36:20 +0900

리눅스 c-언어 초급과정에서는 c언어 구조, 간단한 문법, 컴파일방법에 대해서 알아봤습니다.

제가 처음에 말씀드렸듯이 예제 프로그램을 직접 입력하고 컴파일을 하셨다면 지금쯤 vim에 좀 익숙해지고

c언어에 대해서도 익숙해 졌으리라 생각됩니다.

예제프로그램은 반드시 vim으로 직접 입력해 보고 gcc로 컴파일을 해보고 실행해보고 궁금한게 있으면 예제 프로그램을 수정해서 실행해 보면서 익히셔야 합니다.

이방법이 c언어(다른언어도 마찬가지)를 익히는데 가장 좋은 방법입니다.

심화과정에서는 증권사 투자정보 시스템 기능하는 프로젝트를 목표로 강의를 진행하려고 합니다.

기초인 초급과정에서 다루지 않았던 여러가지를 예제를 통해서 설명드리려고 합니다.

최종 목표에 필요한 모듈개념, 라이브러리 만들기, makefile, cmake 등 과 같은 개발시 유용한 툴에 대해서 진행하도록 하겠씁니다.

아마도 초급 보다는 좀더 깊은 강의가 될텐데 잘 따라 오시기 바랍니다.

될수 있으면 소스를 자세히 설명드리도록 하겠습니다.

19. #include,#define,#ifdef ..

다유데브 — Wed, 23 Nov 2022 11:17:10 +0900

1) 목표

개발시 자주 사용되는 전처리기 이해하기

2) 설명

전처리기는 gcc 컴파일 하기전에 이루어지는 작업입니다.
전처리기는 #include, #define, #ifdef, #undef, 등 여러가지 형태가 있습니다.
이전 강의에서 배운 #pragma도 전처리기의 한 형태입니다.
여기서는 자주 사용되는 #include, #define, #ifdef 문에 대해서 알아봅니다.

// 사용자가 작성한 헤더파일을 포함시킬 수 있습니다.
#include "my_header.h"

// 매크로를 정의할 수 있습니다.
#define	MAX_ARRAY	100

// 매크로를 조건연산자로도 정의할 수 있습니다.
// a,b중 작은값을 구하는 매크로입니다.
#define MIN_LEN(a,b) (((a)<(b))?(a):(b))

// 매크로를 함수로도 정의할 수 있습니다.
#define ADD_PRINT(a,b) \
{ \
	printf("%d + %d = %d\n", (a), (b), (a) + (b)); \
}

// #define으로 정의된것을 제거할 수 있습니다.
#undef ADD_PRINT

// #define를 조건문으로 분기가 가능합니다.
#ifndef MY_HEADER
#include "my_header.h"
#define	MY_HEADER
...
#endif

3-1) #include문 예제 프로그램

▶ 구조체 예제 프로그램 struct8.c에서 구조체 정의를 stock.h 헤더파일로 분리해 봅니다.

▶ vi stock.h

#pragma pack(1)

// 값만을 가지는 struct
typedef struct {
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
} PRICE_ST;

// 주식 현재가 struct 의 새로운 타입을 정의
// struct의 멤버로 struct를 가질수 있습니다.
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    PRICE_ST price;
    double qty;             // 거래량
} CURRENT_PRICE_ST;

▶ vi struct9.c

#include <stdio.h>
// 구조체가 정의된 stock.h 헤더파일을 포함시킵니다.
#include "stock.h"

// call-by-value로 구조체 사용하기
void print_value(CURRENT_PRICE_ST valuePrice) {
    printf("--- print_value ---\n");
    printf("주식코드:[%s]\n", valuePrice.code);
    printf("주식명  :[%s]\n", valuePrice.name);
    printf("현재가  :[%d]\n", valuePrice.price.currentPrice);
    printf("시가    :[%d]\n", valuePrice.price.startPrice);
    printf("고가    :[%d]\n", valuePrice.price.highPrice);
    printf("저가    :[%d]\n", valuePrice.price.lowPrice);
    printf("거래량  :[%.0f]\n", valuePrice.qty);
}

// call-by-reference로 구조체 사용하기
void print_reference(CURRENT_PRICE_ST *ptrPrice) {
    printf("--- print_reference ---\n");
    printf("주식코드:[%s]\n", ptrPrice->code);
    printf("주식명  :[%s]\n", ptrPrice->name);
    printf("현재가  :[%d]\n", ptrPrice->price.currentPrice);
    printf("시가    :[%d]\n", ptrPrice->price.startPrice);
    printf("고가    :[%d]\n", ptrPrice->price.highPrice);
    printf("저가    :[%d]\n", ptrPrice->price.lowPrice);
    printf("거래량  :[%.0f]\n", ptrPrice->qty);
}

void main() {
    // struct _tagCurrentPrice의 선언
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", {61000, 60500, 62000, 60300}, 1234500.0};
    // 포인터 변수
    CURRENT_PRICE_ST *ptrPrice_st = &currentPrice_st;

    // call-by-value 값 출력
    print_value(currentPrice_st);

    // call-by-reference 값 출력
    print_reference(ptrPrice_st);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✹✭ ᐅ gcc -o struct9 struct9.c
~/c-lecture (master ✘)✹✭ ᐅ ./struct9
--- print_value ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
--- print_reference ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✹✭ ᐅ

▶ 분석

이전 구조체 강의 예제 struct8 과 동일하게 출력됩니다.
앞으로 배우시게 되겠지만 하나의 실행파일은 여러개의 c프로그램으로 만들어 질 수 있습니다.
여러개의 c프로그램에서 이런 구조체 정의가 필요하면 c프로그램안에 똑같은 구조체 정의를 넣어야 합니다.
이렇게 여러곳에서 필요한 내용을 헤더파일로 따로 만들어서 필요한곳에 #include문으로 정의해 주시면 간단히 사용 가능합니다.
#include <stdio.h> 와 다르게 #include "stock.h"로 코딩되어 있습니다.
이처럼 c언어에서 제공하는 헤더파일은 <> 로 사용되고, 여러분들이 작성한 헤더파일은 ""로 사용합니다.
그러니 여러분들이 만든 헤더파일을 포함할때는 #include "header.h" 로 작성하시기 바랍니다.

3-2) #define문 예제 프로그램

▶ vi def.c

#include <stdio.h>

// 값을 재정의할 수 있습니다.
#define MAX_ARRAY   100

#define STOCK_NAME  "주식명"

// 매크로를 조건연산자로도 정의할 수 있습니다.
// a,b중 작은값을 구하는 매크로입니다.
#define MIN_LEN(a,b) (((a)<(b))?(a):(b))

// 매크로를 함수로도 정의할 수 있습니다.
#define ADD_PRINT(a,b) \
{ \
    printf("%d + %d = %d\n", (a), (b), (a) + (b)); \
}

void main() {
    char my_array[MAX_ARRAY];
    int min_len;

    printf("MAX_ARRAY = [%d] : my_array 크기 = [%ld]\n", MAX_ARRAY, sizeof(my_array));

    printf("STOCK_NAME = [%s]\n", STOCK_NAME);

    // 작은값을 구하는 매크로
    min_len = MIN_LEN(10, 5);
    printf("MIN_LEN = [%d]\n", min_len);
    
    // 출력매크로
    ADD_PRINT(3, 5);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✹✭ ᐅ gcc -o def def.c
~/c-lecture (master ✘)✹✭ ᐅ ./def
MAX_ARRAY = [100] : my_array 크기 = [100]
STOCK_NAME = [주식명]
MIN_LEN = [5]
3 + 5 = 8
~/c-lecture (master ✘)✹✭ ᐅ

▶ 분석

#define 으로 값을 재정의 해서 사용합니다. 의미가 있는 숫자,문자열을 의미있는 이름으로 재정의해서 사용합니다.
숫자 100를 MAX_ARRAY로 정의, "주식명"을 STOCK_NAME으로 정의해서 프로그램안에서는 MAX_ARRAY를 사용하면 100으로 치환되고, STOCK_NAME을 사용하면 "주식명"으로 치환됩니다.
매크로를 정의해서 사용합니다. 두개의 변수중 작은값을 구하고자 할때 if문을 사욯할수도 있고, 조건연산자를 사용할수도 있고 이렇게 매크로를 사용해서 사용할 수 도 있습니다.
min_len = MIN_LEN(10, 5); 숫자 10, 5 중 작은값을 리턴해 줍니다.
MIN_LEN은 (10 < 5 ? 10 : 5)로 정의됩니다. 그래서 10은 5보다 작지 않기 때문에 거짓(false)인 5가 리턴됩니다.
매크로는 좀 더 길게 정의 될수 있습니다.

...
// 매크로를 함수로도 정의할 수 있습니다.
#define ADD_PRINT(a,b) \
{ \
    printf("%d + %d = %d\n", (a), (b), (a) + (b)); \
}

#define문은 한 줄로 정의가 됩니다. 그런데 코딩을 하다 보면 한줄이 길어 지는 경우도 있습니다. 이런경우
c언어에서는 줄의 마지막에 \ (역슬래쉬) 를 넣고 다음줄에 계속해서 작성해도 한줄로 인식을 합니다.
즉, 위의 문장은

// 매크로를 함수로도 정의할 수 있습니다.
#define ADD_PRINT(a,b) { printf("%d + %d = %d\n", (a), (b), (a) + (b)); }

이렇게 정의될 수 있습니다. 그런데 이렇게 한줄로 코딩을 하다보면 읽기가 어려운 경우가 있습니다.
그래서 \ (역슬래쉬)로 분리해서 읽기 편안하게 작성하는 경우가 있습니다.
ADD_PRINT(3, 5)로 불려지면 정의된 printf문이 실행됩니다.

#undef 문은 거의 사용하는 경우가 없습니다. 기능은 #define으로 정의된걸 제거합니다.

...
    // 출력매크로
    ADD_PRINT(3, 5);
#undef ADD_PRINT
    // 출력매크로
    ADD_PRINT(3, 5);

#undef ADD_PRINT 문 다음에 ADD_PRINT(3, 5);를 다시 호출하면 컴파일시 오류가 발생합니다.
ADD_PRINT가 정의가 안되어 있어서 발생합니다.

3-3) #ifdef문 예제 프로그램

▶ vi def2.c

#include <stdio.h>

#define APPLE   "apple"
#define ORANGE  "orange"

void main() {

#ifdef APPLE
    printf("APPLE 정의 : [%s]\n", APPLE);
#endif

#ifndef ORANGE
    printf("ORANGE 정의되어 있지 않음\n");
#else
    printf("ORANGE 정의 : [%s]\n", ORANGE);
#endif

#ifdef GRAPE
    printf("GRAPE 정의 : [%s]\n", GRAPE);
#elif MANGO
    printf("MANGO 정의 : [%s]\n", MANGO);
#else
    printf("정의되어 있지 않음\n");
#endif

}

▶ 컴파일/실행

~/c-lecture (master ✘)✹✭ ᐅ gcc -o def2 def2.c
~/c-lecture (master ✘)✹✭ ᐅ ./def2
APPLE 정의 : [apple]
ORANGE 정의 : [orange]
정의되어 있지 않음
~/c-lecture (master ✘)✹✭ ᐅ

▶ 분석

#ifdef문은 #define으로 정의가 되어 있으면 참(true)이고 정의가 안되어 있으면 거짓(false)입니다.
if문과 동일하게 동작합니다.
#ifdef APPLE ==> APPLE이 #define으로 정의가 되어 있어서 참입니다.
#ifndef문은 #ifdef문과 반대로 정의가 안되어 있으면 참이고 정의되어 있으면 거짓입니다.
#ifndef ORANGE ==> ORANGE가 정의 되어 있어서 거짓입니다. 그래서 #else 문의 printf()문이 실행됩니다.
if문과 마찬가지로 #ifdef ~ #elif ~ #elif ~ #else문으로 사용됩니다.
#ifdef GRAPE 문은 거짓이므로 다음문 #elif MANGO를 체크합니다. 그런데 MANGO도 정의가 안되어 있어서 거짓이므로 #else문이 실행됩니다.

※ #ifdef, #ifndef 문은 끝에 반드시 #endif문으로 끝이 납니다.

3-4) #ifndef - #include문 예제 프로그램

※ 사용자 헤더파일과 자주 사용되는 패턴을 알아보겠습니다.
위에서 작성한 stock.h를 수정합니다.

▶ vi stock.h

#ifndef STOCK_HEADER
#define STOCK_HEADER

#pragma pack(1)

// 값만을 가지는 struct
typedef struct {
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
} PRICE_ST;

// 주식 현재가 struct 의 새로운 타입을 정의
// struct의 멤버로 struct를 가질수 있습니다.
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    PRICE_ST price;
    double qty;             // 거래량
} CURRENT_PRICE_ST;

#endif

▶ 분석

작성한 헤더파일을 포함시켜서 사용하는데 프로그램이 복잡해지고 여러 헤더파일을 사용하다 보면 1번이상 포함시키는 경우도 발생할 수 있습니다. 그러면 컴파일시 중복 오류가 발생합니다. 그래서 1번만 포함시키려고 #ifndef문을 사용합니다.
헤더파일 처음에 #ifndef STOCK_HEADER 로 체크를 합니다. 처음에는 당연 STOCK_HEADER가 정의가 안되어 있어서 참이므로 아래문장이 실행됩니다.
#define STOCK_HEADER 정의가 안되어 있어서 정의를 합니다. 그리고 구조체 정의문이 나오고 마지막에 #endif문으로 끝이 납니다. 그럼 또 다시 stock.h가 포함이 되면 #ifndef STOCK_HEADER문에서 STOCK_HEADER문이 정의가 되어있으니 #endif문으로 바로 끝이 납니다. 이렇게 헤더파일 중복 포함을 배제합니다.
강의가 진행되면서 헤더파일을 만드는일이 있으면 이런방식으로 작성하게 됩니다.

18. 구조체 중첩

다유데브 — Mon, 21 Nov 2022 16:24:10 +0900

1) 목표

구조체안의 구조체 이해하기

2) 설명

// 값만을 가지는 struct
typedef struct {
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
} PRICE_ST;

// 주식 현재가 struct 의 새로운 타입을 정의
// struct의 멤버로 struct를 가질수 있습니다.
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    PRICE_ST price;
    double qty;             // 거래량
} CURRENT_PRICE_ST;

구조체의 멤버로 다른 구조체가 될 수 있습니다.
CURRENT_PRICE_ST안에 다른 구조체 PRICE_ST 가 멤버가 될 수 있습니다.

3) 예제 프로그램

▶ vi struct8.c

#include <stdio.h>

#pragma pack(1)

// 값만을 가지는 struct
typedef struct {
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
} PRICE_ST;

// 주식 현재가 struct 의 새로운 타입을 정의
// struct의 멤버로 struct를 가질수 있습니다.
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    PRICE_ST price;
    double qty;             // 거래량
} CURRENT_PRICE_ST;

// call-by-value로 구조체 사용하기
void print_value(CURRENT_PRICE_ST valuePrice) {
    printf("--- print_value ---\n");
    printf("주식코드:[%s]\n", valuePrice.code);
    printf("주식명  :[%s]\n", valuePrice.name);
    printf("현재가  :[%d]\n", valuePrice.price.currentPrice);
    printf("시가    :[%d]\n", valuePrice.price.startPrice);
    printf("고가    :[%d]\n", valuePrice.price.highPrice);
    printf("저가    :[%d]\n", valuePrice.price.lowPrice);
    printf("거래량  :[%.0f]\n", valuePrice.qty);
}

// call-by-reference로 구조체 사용하기
void print_reference(CURRENT_PRICE_ST *ptrPrice) {
    printf("--- print_reference ---\n");
    printf("주식코드:[%s]\n", ptrPrice->code);
    printf("주식명  :[%s]\n", ptrPrice->name);
    printf("현재가  :[%d]\n", ptrPrice->price.currentPrice);
    printf("시가    :[%d]\n", ptrPrice->price.startPrice);
    printf("고가    :[%d]\n", ptrPrice->price.highPrice);
    printf("저가    :[%d]\n", ptrPrice->price.lowPrice);
    printf("거래량  :[%.0f]\n", ptrPrice->qty);
}

void main() {
    // struct _tagCurrentPrice의 선언
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", {61000, 60500, 62000, 60300}, 1234500.0};
    // 포인터 변수
    CURRENT_PRICE_ST *ptrPrice_st = &currentPrice_st;

    // call-by-value 값 출력
    print_value(currentPrice_st);

    // call-by-reference 값 출력
    print_reference(ptrPrice_st);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct8 struct8.c
~/c-lecture (master ✘)✭ ᐅ ./struct8
--- print_value ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
--- print_reference ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

CURRENT_PRICE_ST 안에 PRICE_ST 를 멤버로 사용할 수 있습니다.
선언과 동시에 값을 할당할때 구조체는 {} 로 초기화하는데 구조체안의 구조체는 { {} }로 초기화합니다.
call-by-value에서 PRICE_ST 멤버의 접근은 구조체 멤버의 접근과 같습니다.

...
CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", {61000, 60500, 62000, 60300}, 1234500.0};

currentPrice_st의 멤버 price는 구조체이므로 다시 {}를 사용해서 {61000, 60500, 62000, 60300}로 초기화합니다.

...
    printf("현재가  :[%d]\n", valuePrice.price.currentPrice);
    printf("시가    :[%d]\n", valuePrice.price.startPrice);
    printf("고가    :[%d]\n", valuePrice.price.highPrice);
    printf("저가    :[%d]\n", valuePrice.price.lowPrice);

call-by-reference의 포인터로써의 접근은 ptrPrice포인터 변수의 -> price의 멤버는 . 로 접근가능합니다.

...
    printf("현재가  :[%d]\n", ptrPrice->price.currentPrice);
    printf("시가    :[%d]\n", ptrPrice->price.startPrice);
    printf("고가    :[%d]\n", ptrPrice->price.highPrice);
    printf("저가    :[%d]\n", ptrPrice->price.lowPrice);

다른 멤버처럼 PRICE_ST의 price는 -> 로 접근가능합니다.
ptrPrice->price 여기에 price는 구조체이므로 구조체의 멤버로 접근하는 . 멤버명을 사용합니다.
ptrPrice->price.currentPrice

17. 구조체와 포인터

다유데브 — Mon, 21 Nov 2022 15:19:15 +0900

1) 목표

구조체의 크기 알아보기
#pragma pack 에 대해서 이해하기
구조체를 함수 파라메타로 사용하기
구조체 포인터인 경우 멤버접근 방법 알아보기

2) 설명

// 구조체의 크기
sizeof(CURRENT_PRICE_ST);

// call-by-value로 구조체 사용하기
void print_value(CURRENT_PRICE_ST valuePrice) {
    printf("주식코드:[%s]\n", valuePrice.code);
    ...
}

// call-by-reference로 구조체 사용하기
void print_reference(CURRENT_PRICE_ST *ptrPrice) {
    printf("주식코드:[%s]\n", ptrPrice->code);
    ...
}

구조체의 크기도 sizeof 연산자로 구할수 있습니다.
정의된 구조체의 크기
sizeof(CURRENT_PRICE_ST);
선언된 구조체의 크기
sizeof(currentPrice_st);
call-by-value는 구조체를 그대로 받아서 같은 방식으로 사용합니다.
구조체 변수명에 . 멤버명으로 사용합니다.
call-by-reference는 구조체에 대한 포인터로 받아서 사용합니다.
이때 구조체 멤버는 구조체 포인터명에 ->멤버명으로 사용하면 됩니다.
code멤버에 대한 접근은 ptrPrice->code로 사용합니다.
또한 호출하는곳에서는 변수의 포인터처럼 & 를 붙여서 호출하면 포인터를 넘겨줍니다.
print_reference(&currentPrice_st);

3-1) 크기 예제 프로그램

▶ vi struct4.c

#include <stdio.h>

// 주식 현재가 struct 의 새로운 타입을 정의
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
} CURRENT_PRICE_ST;

void main() {
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};

    // 정의된 CURRENT_PRICE_ST의 크기
    printf("CURRENT_PRICE 크기[%ld]\n", sizeof(CURRENT_PRICE_ST));

    // currentPrice_st 크기
    printf("currentPrice_st 크기[%ld]\n", sizeof(currentPrice_st));
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct4 struct4.c
~/c-lecture (master ✘)✭ ᐅ ./struct4
CURRENT_PRICE 크기[120]
currentPrice_st 크기[120]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

typedef로 정의된 CURRENT_PRICE_ST로 크기를 구하거나 선언된 currentPrice_st로 구해도 값은 동일합니다.
CURRENT_PRICE_ST의 멤버의 각각을 sizeof()로 구해보면
code[10]:10바이트
code[80]:80바이트
int : 4바이트 * 4개 (currentPrice, startPrice, highPrice, lowPrice) : 16바이트
double : 8바이트
모두 합해보면 114입니다. 그런데 sizeof()로 출력해 보면 120이 출력된걸 보실수 있습니다.
구조체를 선언할때 시스템에서는 구조체중 가장 크기가 큰 타입 (여기서는 double qty)의 배수로 메모리를 할당해 줍니다. 그래서 차이가 생깁니다.
이렇게 차이가 나면 개발시 구조체를 사용할때 문제가 발생합니다.
그럼 이런 차이를 없애는 방법은 어떻게 하면 될까요?

3-2) #pragma pack 예제 프로그램

▶ vi struct5.c

#include <stdio.h>

#pragma pack(1)

// 주식 현재가 struct 의 새로운 타입을 정의
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
} CURRENT_PRICE_ST;

void main() {
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};

    // 정의된 CURRENT_PRICE_ST의 크기
    printf("CURRENT_PRICE 크기[%ld]\n", sizeof(CURRENT_PRICE_ST));

    // currentPrice_st 크기
    printf("currentPrice_st 크기[%ld]\n", sizeof(currentPrice_st));
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct5 struct5.c
~/c-lecture (master ✘)✭ ᐅ ./struct5
CURRENT_PRICE 크기[114]
currentPrice_st 크기[114]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

실행을 보시면 114가 출력된걸 보실 수 있습니다.
#pragma pack(1)
struct문의 가장 큰 타입의 크기로 메모리가 할당되는것을 1바이트 단위로 할당하라는 명령어 입니다.
개발중에 struct를 정의를 정확한 크기를 사용하실 경우 #pragma pack(1) 를 넣고 작업하시기 바랍니다.

3-3) 함수 예제 프로그램

▶ vi struct6.c

#include <stdio.h>

#pragma pack(1)

// 주식 현재가 struct 의 새로운 타입을 정의
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
} CURRENT_PRICE_ST;

// call-by-value로 구조체 사용하기
void print_value(CURRENT_PRICE_ST valuePrice) {
    printf("--- print_value(%p) ---\n", &valuePrice);       // 메모리주소 출력
    printf("주식코드:[%s]\n", valuePrice.code);
    printf("주식명  :[%s]\n", valuePrice.name);
    printf("현재가  :[%d]\n", valuePrice.currentPrice);
    printf("시가    :[%d]\n", valuePrice.startPrice);
    printf("고가    :[%d]\n", valuePrice.highPrice);
    printf("저가    :[%d]\n", valuePrice.lowPrice);
    printf("거래량  :[%.0f]\n", valuePrice.qty);
}

// call-by-reference로 구조체 사용하기
void print_reference(CURRENT_PRICE_ST *ptrPrice) {
    printf("--- print_reference(%p) ---\n", ptrPrice);  // 메모리주소 출력
    printf("주식코드:[%s]\n", ptrPrice->code);
    printf("주식명  :[%s]\n", ptrPrice->name);
    printf("현재가  :[%d]\n", ptrPrice->currentPrice);
    printf("시가    :[%d]\n", ptrPrice->startPrice);
    printf("고가    :[%d]\n", ptrPrice->highPrice);
    printf("저가    :[%d]\n", ptrPrice->lowPrice);
    printf("거래량  :[%.0f]\n", ptrPrice->qty);
}

void main() {
    // struct _tagCurrentPrice의 선언
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};

    // currentPrice_st 크기와 메모리 주소 출력
    printf("currentPrice_st 주소[%p]\n", &currentPrice_st);

    // call-by-value 값 출력
    print_value(currentPrice_st);

    // call-by-reference 값 출력
    print_reference(&currentPrice_st);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct6 struct6.c
~/c-lecture (master ✘)✭ ᐅ ./struct6
currentPrice_st 주소[0x7fff83553cb0]
--- print_value(0x7fff83553c30) ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
--- print_reference(0x7fff83553cb0) ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

구조체의 내용을 출력하는 함수를 call-by-value, call-by-reference로 호출합니다.
call-by-value 방식
print_value(currentPrice_st);
출력된 내용을 보시면 이전 강의에서 설명드린대로 메모리 주소가 다릅니다.
currentPrice_st 주소와 print_value() 주소가 다른 이유는 call-by-value방식은 함수가 호출될때 파라메타로 받은 변수를 새롭게 메모리가 할당됩니다. 즉, currentPrice_st 의 크기 114바이트 만큼 메모리가 새롭게 할당됩니다.
개발을 하다 보면 수백,수천되는 구조체를 정의하고 사용하는 경우가 많습니다. 그럼 이렇게 call-by-value로 호출을 하면 함수가 호출될때 마다 구조체의 크기 만큼 메모리가 할당되어서 상당히 비효율적이 됩니다.
이런 이유도 포인터를 사용하는 이유중 하나입니다.
call-by-reference 방식
print_reference(&currentPrice_st);
변수에 대한 주소는 변수앞에 & 를 붙여서 만든다고 설명드렸지요. 그래서 여기서도 &currentPrice_st로 파라메타를 넘겨줍니다.
출력에서 알수 있듯이 currentPrice_st 주소와 print_reference() 주소가 같은걸 알수 있습니다.
call-by-value 방식과 다르게 call-by-reference에서는 구조체 크기 만큼 메모리 할당이 일어나지 않습니다.
currentPrice_st의 메모리를 포인터로 바로 사용하기 때문입니다.
이때 구조체 멤버를 접근할때는 -> 를 사용합니다.
구조체의 멤버 접근은 구조체 변수명 . 멤버명이고
구조체의 포인터 멤버 접근은 구조체 변수명->멤버명 입니다.

3-4) 함수 예제 프로그램2

▶ vi struct7.c

#include <stdio.h>

#pragma pack(1)

// 주식 현재가 struct 의 새로운 타입을 정의
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
} CURRENT_PRICE_ST;

// call-by-value로 구조체 사용하기
void print_value(CURRENT_PRICE_ST valuePrice) {
    printf("--- print_value(%p) ---\n", &valuePrice);       // 메모리주소 출력
    printf("주식코드:[%s]\n", valuePrice.code);
    printf("주식명  :[%s]\n", valuePrice.name);
    printf("현재가  :[%d]\n", valuePrice.currentPrice);
    printf("시가    :[%d]\n", valuePrice.startPrice);
    printf("고가    :[%d]\n", valuePrice.highPrice);
    printf("저가    :[%d]\n", valuePrice.lowPrice);
    printf("거래량  :[%.0f]\n", valuePrice.qty);
}

// call-by-reference로 구조체 사용하기
void print_reference(CURRENT_PRICE_ST *ptrPrice) {
    printf("--- print_reference(%p) ---\n", ptrPrice);  // 메모리주소 출력
    printf("주식코드:[%s]\n", ptrPrice->code);
    printf("주식명  :[%s]\n", ptrPrice->name);
    printf("현재가  :[%d]\n", ptrPrice->currentPrice);
    printf("시가    :[%d]\n", ptrPrice->startPrice);
    printf("고가    :[%d]\n", ptrPrice->highPrice);
    printf("저가    :[%d]\n", ptrPrice->lowPrice);
    printf("거래량  :[%.0f]\n", ptrPrice->qty);
}

void main() {
    // struct _tagCurrentPrice의 선언
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};
    // 포인터 변수
    CURRENT_PRICE_ST *ptrPrice_st = &currentPrice_st;

    // currentPrice_st 크기와 메모리 주소 출력
    printf("currentPrice_st 주소[%p]\n", &currentPrice_st);
    printf("    ptrPrice_st 주소[%p]\n", ptrPrice_st);

    // call-by-value 값 출력
    print_value(currentPrice_st);

    // call-by-reference 값 출력
    print_reference(ptrPrice_st);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct7 struct7.c
~/c-lecture (master ✘)✭ ᐅ ./struct7
currentPrice_st 주소[0x7ffe4f50e980]
    ptrPrice_st 주소[0x7ffe4f50e980]
--- print_value(0x7ffe4f50e8f0) ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
--- print_reference(0x7ffe4f50e980) ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

구조체의 포인터 변수를 선언과 동시에 버퍼 주소를 할당합니다.

...
    // 포인터 변수
    CURRENT_PRICE_ST *ptrPrice_st = &currentPrice_st;

이전 강의에서 설명드렸는데 포인터 변수는 단독(버퍼없이)으로는 사용할 수 없다고 말씀드렸습니다.
ptrPrice_st = &currentPrice_st; 로 currentPrice_st의 주소를 ptrPrice_st에 할당합니다.
그래서 여기서는 currentPrice_st가 포인터변수의 버퍼입니다. 114바이트 크기의 버퍼.
출력을 보시면 ptrPrice_st값이 같은걸 알 수 있습니다.
포인터의 중요한 개념이므로 다시 한번 강조해서 설명드립니다.
포인터 변수는 항상 버퍼의 주소를 할당 받아서 사용합니다. 단독으로는 사용하실 수 없습니다.

16. 구조체(struct)

다유데브 — Mon, 21 Nov 2022 13:26:33 +0900

1) 목표

구조체(struct) 이해하기
구조체 사용법 이해하기

2) 설명

구조체는 여러 타입을 묶어서 사용하는 자료구조형입니다.

// struct 정의
struct tag {
    char member1;
    int member2;
    double member3;
};

// struct 선언
struct tag myTag;

// typedef를 사용한 struct 정의
// MY_TAG를 새로운 타입으로 생성
typedef struct {
    char member1;
    int member2;
    double member3;
} MY_TAG;

// struct 선언
MY_TAG myTag;

구조체의 정의는
struct (키워드) tag(태그명) { 사용하고자 하는 타입들 };
태그명은 여러분들이 알맞은 이름을 사용하시면 됩니다.
주식의 현재를 예를 들면 주식의 코드, 주식명, 현재가, 시가, 고가, 저가, 거래량 으로 정의 될수 있습니다.

// 주식의 현재가
struct _tagCurrentPrice {
    char code[10];     // 주식코드
    char name[80];     // 주식명
    int currentPrice;  // 현재가
    int startPrice;    // 시가
    int highPrice;     // 고가
    int lowPrice;      // 저가
    double qty;        // 거래량
};

태그명은 _tagCurrentPrice로 지정했고, 현재가라는 구조체가 관리(처리)하는 데이타는 code, name, currentPrice, startPrice, highPrice, lowPrice, qty 라는 멤버로 정의 합니다.
현재가 구조체를 사용하고자 하면

struct _tagCurrentPrice CurrentPrice_st;

이렇게 선언을 해서 사용합니다. c언어에서 제공하는 타입을 선언할때 타입 변수명; 으로 선언을 했듯이 구조체도 struct _tagCurrentPrice 타입으로 CurrentPrice_st라는 변수명으로 선언을 합니다.
※ 선언을 할때만 메모리에 할당이 됩니다. 위에서 현재가 구조체를 정의할때는 메모리에 할당되지 않습니다.
현재가 구조체의 멤버 (code, name, currentPrice, startPrice, highPrice, lowPrice, qty)에 접근할때는
CurrentPrice_st.code, CurrentPrice_st.name, CurrentPrice_st.currentPrice, CurrentPrice_st.startPrice, CurrentPrice_st.highPrice, CurrentPrice_st.lowPrice, CurrentPrice_st.qty 로
구조체 변수명에 . 를 붙이고 멤버명을 써 주시면 해당하는 멤버에 접근 할 수 있습니다.

3-1) 예제 프로그램

▶ vi struct.c

#include <stdio.h>
#include <string.h>

// 주식 현재가 struct 정의
struct _tagCurrentPrice {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
};

void main() {
    // struct _tagCurrentPrice의 선언
    struct _tagCurrentPrice currentPrice_st;

    // 멤버 주식코드 값을 설정
    memset(currentPrice_st.code, 0x00, sizeof(currentPrice_st.code));
    strcpy(currentPrice_st.code, "A005930");

    // 멤버 주식명 값을 설정
    memset(currentPrice_st.name, 0x00, sizeof(currentPrice_st.name));
    strcpy(currentPrice_st.name, "삼성전자");

    // 멤버 현재가 값을 설정
    currentPrice_st.currentPrice = 61000;

    // 멤버 시가 값을 설정
    currentPrice_st.startPrice = 60500;

    // 멤버 고가 값을 설정
    currentPrice_st.highPrice = 62000;

    // 멤버 저가 값을 설정
    currentPrice_st.lowPrice = 60300;

    // 멤버 거래량 값을 설정
    currentPrice_st.qty = 1234500.0;

    // 값 출력
    printf("주식코드:[%s]\n", currentPrice_st.code);
    printf("주식명  :[%s]\n", currentPrice_st.name);
    printf("현재가  :[%d]\n", currentPrice_st.currentPrice);
    printf("시가    :[%d]\n", currentPrice_st.startPrice);
    printf("고가    :[%d]\n", currentPrice_st.highPrice);
    printf("저가    :[%d]\n", currentPrice_st.lowPrice);
    printf("거래량  :[%.0f]\n", currentPrice_st.qty);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct struct.c
~/c-lecture (master ✘)✭ ᐅ ./struct
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

구조체를 struct _tagCurrentPrice 로 정의를 했고, struct _tagCurrentPrice currentPrice_st 로 선언을 했습니다.
구조체의 멤버에 값을 할당합니다.
char code[10], char name[80] 은 문자열로 값을 할당하는데 memset()로 초기화를 하고 strcpy()를 사용을 해서 값을 설정합니다.
strcpy(currentPrice_st.code, "A005930");
strcpy(currentPrice_st.name, "삼성전자");
struct 변수 . 멤버이름으로 접근합니다.
struct도 선언과 동시에 초기값을 설정할 수 있습니다.
struct _tagCurrentPrice currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};
printf()함수로 멤버를 출력합니다.

3-2) 값대입 예제 프로그램

▶ vi struct2.c

#include <stdio.h>
#include <string.h>

// 주식 현재가 struct 정의
struct _tagCurrentPrice {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
};

void main() {
    // struct _tagCurrentPrice의 선언
    struct _tagCurrentPrice currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};
    struct _tagCurrentPrice tmpPrice_st;

    // 값 출력
    printf("--- currentPrice_st 출력 ---\n");
    printf("주식코드:[%s]\n", currentPrice_st.code);
    printf("주식명  :[%s]\n", currentPrice_st.name);
    printf("현재가  :[%d]\n", currentPrice_st.currentPrice);
    printf("시가    :[%d]\n", currentPrice_st.startPrice);
    printf("고가    :[%d]\n", currentPrice_st.highPrice);
    printf("저가    :[%d]\n", currentPrice_st.lowPrice);
    printf("거래량  :[%.0f]\n", currentPrice_st.qty);

    // struct 값 대입
    tmpPrice_st = currentPrice_st;

    printf("--- tmpPrice_st 출력 ---\n");
    printf("주식코드:[%s]\n", tmpPrice_st.code);
    printf("주식명  :[%s]\n", tmpPrice_st.name);
    printf("현재가  :[%d]\n", tmpPrice_st.currentPrice);
    printf("시가    :[%d]\n", tmpPrice_st.startPrice);
    printf("고가    :[%d]\n", tmpPrice_st.highPrice);
    printf("저가    :[%d]\n", tmpPrice_st.lowPrice);
    printf("거래량  :[%.0f]\n", tmpPrice_st.qty);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct2 struct2.c
~/c-lecture (master ✘)✭ ᐅ ./struct2
--- currentPrice_st 출력 ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
--- tmpPrice_st 출력 ---
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

currentPrice_st 선언과 동시에 값을 할당합니다.
struct _tagCurrentPrice currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};
struct _tagCurrentPrice 의 다른 변수 tmpPrice_st를 선언합니다.
같은 struct인 경우 = 대입 연산자로 값을 할당할 수 있습니다.
tmpPrice_st = currentPrice_st;
출력을 보면 값이 같은걸 확인하실 수 있습니다.

3-3) typedef문 예제 프로그램

▶ vi struct3.c

#include <stdio.h>
#include <string.h>

// 주식 현재가 struct 의 새로운 타입을 정의
typedef struct {
    char code[10];          // 주식코드
    char name[80];          // 주식명
    int currentPrice;       // 현재가
    int startPrice;         // 시가
    int highPrice;          // 고가
    int lowPrice;           // 저가
    double qty;             // 거래량
} CURRENT_PRICE_ST;

void main() {
    // struct _tagCurrentPrice의 선언
    CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};

    // 값 출력
    printf("주식코드:[%s]\n", currentPrice_st.code);
    printf("주식명  :[%s]\n", currentPrice_st.name);
    printf("현재가  :[%d]\n", currentPrice_st.currentPrice);
    printf("시가    :[%d]\n", currentPrice_st.startPrice);
    printf("고가    :[%d]\n", currentPrice_st.highPrice);
    printf("저가    :[%d]\n", currentPrice_st.lowPrice);
    printf("거래량  :[%.0f]\n", currentPrice_st.qty);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o struct2 struct2.c
~/c-lecture (master ✘)✭ ᐅ ./struct2
주식코드:[A005930]
주식명  :[삼성전자]
현재가  :[61000]
시가    :[60500]
고가    :[62000]
저가    :[60300]
거래량  :[1234500]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

typedef 문을 사용해서 struct 태그명을 사용하기 쉬운 별칭으로 정의할 수 있습니다.
struct _tagCurrentPrice 를 typedef struct ~~ CURRENT_PRICE_ST 로 별칭을 새롭게 정의하였습니다.
구조체를 선언할때 이 별칭으로 사용됩니다.
CURRENT_PRICE_ST currentPrice_st;
struct _tagCurrentPrice로 사용할때 보다 간결하게 사용가능합니다.
보통 개발할때 구조체는 typedef로 별칭을 새롭게 정의해서 사용합니다.
선언과 동시에 초기값을 설정해 보았습니다.
CURRENT_PRICE_ST currentPrice_st = {"A005930", "삼성전자", 61000, 60500, 62000, 60300, 1234500.0};

15. 문자열(배열) 다루기

다유데브 — Thu, 17 Nov 2022 11:06:14 +0900

1) 목표

문자열(배열)을 다루는 함수 알아보기
문자열(배열) 함수 사용해 보기

2) 설명

제목처럼 문자열(배열) 다루는 것은 사실 메모리를 다루는 기술입니다.
변수를 선언하면 메모리가 할당이 되고 변수에 값을 넣고 참조할 수 있는것이 메모리를 다루는것 입니다.
여기서는 c언어에서 제공하는 문자열 관련 함수, 메모리 관련 함수를 다루고자 합니다.

3-1) 메모리 관련 함수 예제 프로그램

▶ vi mem.c

#include <stdio.h>
#include <string.h>

void main() {
    char str[] = "Hello, World";
    char buf[12];

    // str의 내용을 buf로 복사함
    memcpy(buf, str, 12);               // Hello, World (12자)

    printf("buf:[%12.12s]\n", buf);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o mem mem.c
~/c-lecture (master ✘)✭ ᐅ ./mem
buf:[Hello, World]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

처음 살펴볼 함수는 상당히 많이 쓰이는 memcpy()함수 입니다.
이 함수를 사용하기 위해서 #include <string.h> 문이 추가됩니다.
man memcpy 로 확인해 보시면 아래와 같습니다.

함수의 프로토타입도 자세히 나와 있습니다.
void *memcpy(void *dest, const void *src, size_t n);
간략하게 설명을 드리면 두번째 인자 src에서 첫번째 인자 dest로 세번째 인자 크기 n 만큼 복사하는 함수 입니다.
※ void * 가 나오는데 void 포인터형입니다. 이 void 포인터형은 어떠한 타입으로도 될 수 있다는 의미입니다.
예제 mem.c에서는 char 타입을 넘겨주는데 memcpy 함수가 void 타입으로 받아서 가능합니다.
※ size_t 은 정수형으로 크기를 나타내고 있다는 정도로만 알아두세요.
※ 두번째 인자를 보시면 앞에 const가 붙은걸 알수 있습니다. const 의미는 상수의 의미가 있습니다.
변수와 다르게 상수는 값을 변경할 수 없습니다.
그래서 memcpy()함수내에서 src의 내용은 변경할 수 없다는걸 정의하고 있습니다.
memcpy()함수를 사용하면 for문으로 반복처리를 할 필요가 없습니다.
'Hello, World'의 문자수는 12자 즉, 12바이트를 차지합니다. 그래서 복사할 대상를 char buf[12];로 선언을 하고
memcpy(buf, str, 12); 변수 str의 값을 buf로 12바이트 복사하는 것입니다.
buf를 출력할때 printf의 서식 %12.12s 를 사용했는데요. 이 서식은 %s 문자열 출력 서식과 유사합니다.
소수점(.)를 기준으로 앞의 12는 전체자리수 뒤의 12는 출력할 변수(buf)의 자리수를 의미합니다.
즉, buf[12] 12바이트를 출력하고자 %12.12s 의 서식을 사용했습니다.
printf()함수의 서식은 상당히 많이 있습니다. 필자도 전부 외우지 못합니다. 여러분도 이런 서식이 있구나. 라고 인지만 하시고 나중에 필요할때 man 3 printf 라던가 구글에서 검색해서 사용하시면 됩니다.
문자열에서 설명드렸는데요. 예제의 char buf[12]; 은 문자열(string)이 아닙니다.
문자열은 마지막에 null(0x00) 문자가 있어야 문자열이 된다고 말씀을 드렸죠.
문자열이 아니기 때문에 printf()에서도 %s가 아닌 %12.12s로 출력한 것입니다.
(%s 서식은 출력할 변수에서 null문자까지 출력합니다.)
그럼 buf를 문자열로 바꿀려면 어떻게 하면 되나요? 그렇죠 마지막에 null(0x00)를 추가하면 되겠죠.
그런데 memcpy()함수를 사용하는데 마지막에 null(0x00)를 추가하는게 쉽지가 않습니다.
buf의 마지막 위치를 알아야 하지요. 이때 이런 문제를 해결할수 있는 함수가 존재합니다.

3-2) 메모리 관련 함수 예제 프로그램 2

▶ vi mem2.c

#include <stdio.h>
#include <string.h>

void main() {
    char str[] = "Hello, World";
    char buf[32];                       // 버퍼 크기를 12 -> 32로 넉넉히 잡습니다.

    // buf를 null 문자로 초기화 합니다.
    memset(buf, 0x00, sizeof(buf));

    // str의 내용을 buf로 복사함
    memcpy(buf, str, 12);               // Hello, World (12자)

    printf("buf:[%s]\n", buf);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o mem2 mem2.c
~/c-lecture (master ✘)✭ ᐅ ./mem2
buf:[Hello, World]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

buf를 문자열(string)로 만드는게 목표입니다.
여기서 memset() 함수가 새로게 등장합니다. 이함수도 memcpy와 같이 상당히 많이 쓰입니다.
memcpy()함수를 사용할때 한짝으로 memset()가 자주 사용됩니다.
memset도 자세히 알고 싶으시면 man memset 으로 보시면 됩니다.

memset함수의 프로토타입을 보면
void *memset(void *s, int c, size_t n);
첫번째 인자 s를 두번째 인자 c로 세번째 인자 n만큼 채우라는 의미 입니다.
memset(buf, 'A', 10); 의 의미는 buf값을 'A'로 10개 채우라는 의미입니다.

...
    // buf를 null 문자로 초기화 합니다.
    memset(buf, 0x00, sizeof(buf));

변수 buf의 값을 null(0x00)으로 채우라는 의미입니다. 여기서 sizeof(buf) 가 나오는데요
4.변수 강의에서 설명드렸는데요. sizeof()는 변수타입뿐 아니라 이렇게 배열의 크기를 구하는데도 사용됩니다.
sizeof() 는 상당히 많이 사용됩니다. 이렇게 사용되는것도 알아두세요.
그래서 sizeof(buf) == 32입니다. char buf[32]; 로 선언되었기 때문에 32입니다.
buf 배열은 크기가 32바이트이고 그값은 전부 null로 되어있게 됩니다.
여기에 memcpy()문으로 str값 12바이트를 복사하게 되면
buf의 처음 12바이트는 'Hello World'가 되고 나머지는 null(0x00)로 그대로 있습니다.
그러면 buf는 문자열인가요? 맞습니다 원하는 데이타 마지막에 null(0x00)문자가 있기 때문에 문자열입니다.
buf 문자열을 출력하기 위해서 printf()의 서식을 %s 만을 사용해서 출력합니다.

3-3) 문자열 관련 함수 예제 프로그램

▶ vi str.c

#include <stdio.h>
#include <string.h>

void main() {
    char str[] = "Hello, World";
    char buf[32];

    // str의 내용을 buf로 복사함
    strcpy(buf, str);

    printf("buf:[%s]\n", buf);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o str str.c
~/c-lecture (master ✘)✭ ᐅ ./str
buf:[Hello, World]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

이번 예제는 문자열을 다룹니다.
char str[] = "Hello World"; 이전 강의에서 설명드렸는데
배열을 선언과 동시에 문자열로 초기화 가능합니다. str은 문자열입니다.
이번 예제에서는 strcpy()함수가 나옵니다. memcpy()함수와 마찬가지로 많이 쓰이는 함수입니다.
man strcpy 로 보시면 프로토타입등 상세한 설명을 보실 수 있습니다.

프로토타입을 보면
char *strcpy(char *dest, const char *src);
두번째 인자 src를 첫번째 인자 dest로 복사하는 함수입니다. 주의할점은 src는 문자열이어야 합니다.
src의 값에서 null(0x00)일때 까지 dest로 복사합니다. 만약 src가 문자열이 아닌 경우 문제가 발생할 수 있습니다.
그러니 문자열의 개념은 반드시 알아두셔야 합니다. 반드시 null(0x00)값을 끝나야 합니다.
첫번째 인자 dest의 크기는 src보다 반드시 크거나 같아야 합니다.
strcpy()함수를 사용하면 복사된 변수도 문자열이 됩니다.
printf()함수에서 %s 서식으로 출력 가능합니다.

3-4) 문자열 관련 함수 예제 프로그램

▶ vi str2.c

#include <stdio.h>
#include <string.h>

void main() {
    char str[] = "Hello, World";
    char buf[32];
    int len;

    // str의 내용을 buf로 복사함
    strcpy(buf, str);

    // 문자열의 크기를 구하는 함수
    len = strlen(buf);

    printf("buf:[%s] 길이:[%d]\n", buf, len);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o str2 str2.c
~/c-lecture (master ✘)✭ ᐅ ./str2
buf:[Hello, World] 길이:[12]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

문자열 함수중 많이 사용하는 strlen()함수를 알아보겠습니다.
함수 이름에서 알수 있듯이 문자열의 길이(크기)를 구하는 함수입니다.
문자열의 길이는 null문자가 제외된 길이입니다.
man strlen 으로 보시면 좀 더 상세히 보실 수 있습니다.
strcpy()와 같이 strlen()함수도 알아 두세요.

※ 개발을 하다 보면 memcpy(), strcpy() 등 관련된 함수가 상당히 많이 사용됩니다.
강의를 진행하면서 언제 어떻게 사용되는 자세히 알아 보도록 하겠습니다.
※ 이번 강의에서는 memcpy(), strcpy()함수 함께 문자열을 개념을 다시 한번 잘 이해하시기 바랍니다.
상당히 중요한 개념입니다.

14. 함수 파라메타 유형

다유데브 — Thu, 17 Nov 2022 08:17:14 +0900

1) 목표

▶함수 파라메타 유형에 대해서 알아보기

call-by-value 이해하기.
call-by-reference 이해하기.

2) 설명

함수에 넘겨주는 파라메타(인자값)의 유형은
값을 넘겨 주는 방식(call-by-value),
주소(포인터)를 넘겨 주는 방식(call-by-reference)이 있습니다.
call-by-value 방식은 함수를 부르는쪽이나 함수나 서로 영향을 주기 않습니다.
14.함수에서 살펴본 sum(int a, int b) 함수가 call-by-value의 전형적인 함수입니다.
call-by-reference 방식은 주소를 넘겨 주고, 넘겨 받아서 처리하기에 값에 영향을 줍니다.

3-1) call-by-value 방식 예제 프로그램

▶ vi func3.c

#include <stdio.h>

// val1값과 val2값을 바꾸는 swap함수

// call-by-value 방식
void swap_value(int val1, int val2) {
    int tmp;

    printf("swap_value: swap전 val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);

    // tmp를 이용한 val1 <-> val2
    tmp = val1;
    val1 = val2;
    val2 = tmp;

    printf("swap_value: swap후 val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);
}

// swap함수
void main() {
    int val1, val2;

    val1 = 100;
    val2 = 200;

    printf("main: swap_value() 호출전 : val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);

    // call-by-value 방식
    swap_value(val1, val2);

    printf("main: swap_value() 호출후 : val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func3 func3.c
~/c-lecture (master ✘)✭ ᐅ ./func3
main: swap_value() 호출전 : val1[100][0x7ffc1fbbb670] val2[200][0x7ffc1fbbb674]
swap_value: swap전 val1[100][0x7ffc1fbbb64c] val2[200][0x7ffc1fbbb648]
swap_value: swap후 val1[200][0x7ffc1fbbb64c] val2[100][0x7ffc1fbbb648]
main: swap_value() 호출후 : val1[100][0x7ffc1fbbb670] val2[200][0x7ffc1fbbb674]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

swap함수내에서는 swap전, swap후의 값을 보면 val1값과 val2값이 바뀌어 있는걸 보실 수 있습니다.
그런데 main()내에서는 swap() 호출전이나 호출후의 값을 보면 그대로 인걸 알수 있습니다.
이렇듯 call-by-value방식은 호출하는쪽의 변수값을 바꾸질 못합니다.
이유는 main()함수내에서 int val1, val2; 선언시 메모리가 할당이 되고 swap_value()함수를 호출을 하면
swap_value()함수에서 파라메타에 대해서 새로운 메모리가 할당이 됩니다.
그래서 swap_value()함수내에서 작업하는 곳은 새롭게 할당된 메모리가 되어서 main()함수에서 할당받은
메모리에 여향을 주지 못합니다.

printf("main: swap_value() 호출전 : val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);

선언한 변수에 대해서 메모리 주소를 알아 보기 위해서 이전 강의에서 배운 %p를 사용했습니다.
또한 %p 에 대한 값으로는 변수에 대한 주소를 사용하기 위해서 변수앞에 & 를 붙여서 사용합니다.
위의 결과를 보시면 main()함수에서 val1주소, val2주소가 swap_value()함수에서는 전혀 다른 주소가 출력된걸 확인하실 수 있습니다.
main()에서 선언한 val1, val2값을 바꾸기 위해서는 어떻게 해야할까요?
해답은 이전 강의에서 배운 포인터가 사용됩니다. 알아볼까요?

3-2) call-by-reference 방식 예제 프로그램

▶ vi func4.c

#include <stdio.h>

// val1값과 val2값을 바꾸는 swap함수

// call-by-reference 방식
void swap_reference(int *pVal1, int *pVal2) {
    int tmp;

    printf("swap_reference: swap전 val1[%d][%p] val2[%d][%p]\n", *pVal1, pVal1, *pVal2, pVal2);

    // tmp를 이용한 val1 <-> val2
    tmp = *pVal1;
    *pVal1 = *pVal2;
    *pVal2 = tmp;

    printf("swap_reference: swap후 val1[%d][%p] val2[%d][%p]\n", *pVal1, pVal1, *pVal2, pVal2);
}

// swap함수
void main() {
    int val1, val2;

    val1 = 100;
    val2 = 200;

    printf("main: swap_reference() 호출전 : val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);

    // call-by-reference 방식
    swap_reference(&val1, &val2);

    printf("main: swap_reference() 호출후 : val1[%d][%p] val2[%d][%p]\n", val1, &val1, val2, &val2);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func4 func4.c
~/c-lecture (master ✘)✭ ᐅ ./func4
main: swap_reference() 호출전 : val1[100][0x7ffced6b8ae0] val2[200][0x7ffced6b8ae4]
swap_reference: swap전 val1[100][0x7ffced6b8ae0] val2[200][0x7ffced6b8ae4]
swap_reference: swap후 val1[200][0x7ffced6b8ae0] val2[100][0x7ffced6b8ae4]
main: swap_reference() 호출후 : val1[200][0x7ffced6b8ae0] val2[100][0x7ffced6b8ae4]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

실행한 결과를 보시면 main() 내 val1, val2값이 swap_reference() 호출후에 바뀌어 있는걸 확인하실 수 있습니다.
또한 main()함수내 val1, val2주소가 swap_reference()함수내에서도 같은걸 보실 수 있습니다.
이렇듯 같은 메모리 주소를 사용하므로 변수에 영향을 줄 수 있습니다.

...
    // call-by-reference 방식
    swap_reference(&val1, &val2);

함수를 호출할때 변수에 대한 주소를 넘겨주기 위해서 변수명 앞에 & 를 붙여서 넘겨 주고 있습니다.

...
// call-by-reference 방식
void swap_reference(int *pVal1, int *pVal2) {

호출된 함수에서도 파라메타가 주소, 즉 포인터이므로 포인터 형으로 정의가 되어 있습니다.

3-2) call-by-reference 배열 예제 프로그램

▶ vi func5.c

#include <stdio.h>

// 배열값 hello를 world로 바꾸는 함수

// call-by-reference 방식
void array_reference(char *pStr) {
    char new_str[] = "world";
    int i;

    printf("array_reference: swap전 [%s][%p]\n", pStr, pStr);

    for (i = 0; i < 6; i++) {
        // new_str:world로 대체
        *(pStr + i) = new_str[i];
    }

    printf("array_reference: swap후 [%s][%p]\n", pStr, pStr);
}

// swap함수
void main() {
    char str[] = "hello";

    printf("main: array_reference() 호출전 : str[%s][%p]\n", str, str);

    // call-by-reference 방식
    array_reference(str);

    printf("main: array_reference() 호출후 : str[%s][%p]\n", str, str);
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func5 func5.c
~/c-lecture (master ✘)✭ ᐅ ./func5
main: array_reference() 호출전 : str[hello][0x7fff674cba82]
array_reference: swap전 [hello][0x7fff674cba82]
array_reference: swap후 [world][0x7fff674cba82]
main: array_reference() 호출후 : str[world][0x7fff674cba82]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

main()함수의 str='hello'를 array_reference()에서 'world'로 바꾸는 프로그램입니다.
결과를 보시면 main() 에서 호출전은 'hello', 호출후에는 'world'로 바뀌어 있는걸 확인 하실 수 있습니다.
물론 str의 주소와 array_reference()내에서의 주소도 동일합니다.

...
    // call-by-reference 방식
    array_reference(str);

이전 강의에서도 설명한대로 배열은 배열 이름 자체가 주소가 됩니다. 그래서 array_reference 호출시 배열변수명 str이 그대로 사용되었습니다.

...
// call-by-reference 방식
void array_reference(char *pStr) {

함수 파라메타에서도 포인터형으로 정의되어 있습니다.
call-by-reference 방식은 c프로그램에서 상당히 많이 사용하는 방식입니다.
함수호출 방식과 호출된 함수의 파라메타 정의에 대해서 이해하시기 바랍니다.

14. 함수

다유데브 — Wed, 16 Nov 2022 16:58:42 +0900

1) 목표

함수 이해하기
함수 리턴값 이해하기
함수 파라메타 이해하기

2) 설명

// 함수형식
int func(int arg1) {
	return 0;
}

// 리턴값이 있는 함수
int func() {
	return 0;
}

// 리턴값이 없는 함수
void func() {
}

// 파라메타가 있는 함수
int func(int arg1) {
	return 0;
}

// 파라메타가 여러개 있는 함수
int func(int arg1, int arg2, char arg3) {
	return 0;
}

▶ 함수구성은
리턴값타입 함수명(파라메타) { 함수 내용 }
int func(int argc); 리턴타입은 int 함수명은 func 파라메타는 int argc 1개로 정의된 함수입니다.
int func(); 리턴타입은 int 함수명은 func 파라메타는 없는 함수입니다.
void func(); 리턴값이 없고 (void) 함수명은 func 파라메타는 없는 함수입니다.

리턴값이 없는 경우는 void 로 표기합니다. 참조하세요.

▶ 함수의 끝은 return 문을 만나면 끝이나고, 만약 return문이 없다면 함수의 끝을 나타내는 } 를 만나면 끝이 납니다.

▶ 이제는 이런 함수형식으로 내가 원하는 기능을 하는 함수를 만들어서 사용하시면 됩니다.

3-1) 예제프로그램

▶ vi func.c

#include <stdio.h>

// 리턴값이 없는 함수
void func1() {
    printf("func1()...\n");
}

// 리턴값이 있는 함수
int func2() {
    return 1;
}

// 더하기 함수
int sum(int a, int b) {
    int sum;
    sum = a + b;

    return sum;
}

int main() {
    int ret;

    // 리턴타입이 없는 함수 호출
    func1();

    // 리턴값이 있는 함수 호출
    ret = func2();
    printf("func2() return value:[%d]\n", ret);

    // 더하기 함수
    ret = sum(1, 3);
    printf("sum() return value:[%d]\n", ret);

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func func.c
~/c-lecture (master ✘)✭ ᐅ ./func
func1()...
func2() return value:[1]
sum() return value:[4]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

함수를 사용할때는 함수의 타입/파라메타 갯수-형식등을 보고 타입을 맞쳐서 사용하시면 됩니다.
리턴값이 없는 함수 void func1() 를 사용할때는 func1(); 이렇게 불러서 사용하시면 됩니다.
void func1() 에는 return문이 없습니다. 리턴값타입이 void라서 없습니다. 그런데 함수내에서
return; 문을 추가 할수도 있습니다. 보통은 return 값; 이런 형식으로 사용하는데 void형의 리턴은 값이 없기 때문에 그냥 return; 문으로 사용할 수 있습니다.

...
void func1() {
	printf("func1()...\n");
	return;
}

리턴값이 있는 함수 int func2() 를 사용할때는 리턴값을 받아서 사용할 수 있으므로
ret = func2(); 이렇게 사용하고 func2()함수에서 리턴해주는 값을 ret를 조회해서 확인합니다.
리턴값이 있고 파라메타도 int 형으로 2개가 있는 함수 int sum(int a, int b)를 사용할때는
ret = sum(1, 3); 이렇게 사용하고 sum()함수에서 리턴해주는 값은 ret를 조회해서 확인합니다.
※ c에서는 사용할 함수가 소스 위에 있어야 합니다. 즉, main()함수에서 func1(), func2()를 호출 하는데는 main()함수 보다 먼저 func1(), func2() 함수가 있는걸 보실수 있습니다. 이렇게 사용할 함수가 먼저 나와야 합니다. 아니면 컴파일시 오류가 발생합니다.

3-2) 함수정의 예제프로그램

▶ vi func2.c

#include <stdio.h>

int main() {
    int ret;

    // 리턴타입이 없는 함수 호출
    func1();

    // 리턴값이 있는 함수 호출
    ret = func2();
    printf("func2() return value:[%d]\n", ret);

    // 더하기 함수
    ret = sum(1, 3);
    printf("sum() return value:[%d]\n", ret);

    return 0;
}

// 리턴값이 없는 함수
void func1() {
    printf("func1()...\n");
}

// 리턴값이 있는 함수
int func2() {
    return 1;
}

// 더하기 함수
int sum(int a, int b) {
    int sum;
    sum = a + b;

    return sum;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func2 func2.c
func2.c: In function ‘main’:
func2.c:7:2: warning: implicit declaration of function ‘func1’ [-Wimplicit-function-declaration]
    7 |  func1();
      |  ^~~~~
func2.c:10:8: warning: implicit declaration of function ‘func2’ [-Wimplicit-function-declaration]
   10 |  ret = func2();
      |        ^~~~~
func2.c:14:8: warning: implicit declaration of function ‘sum’ [-Wimplicit-function-declaration]
   14 |  ret = sum(1, 3);
      |        ^~~
func2.c: At top level:
func2.c:21:6: warning: conflicting types for ‘func1’
   21 | void func1() {
      |      ^~~~~
func2.c:7:2: note: previous implicit declaration of ‘func1’ was here
    7 |  func1();
      |  ^~~~~
~/c-lecture (master ✘)✭ ᐅ

이렇게 사용할 함수의 형식(프로토타입)이 사용하는 위치 보다 선행되어 있어야 합니다.
지금까지 예제에서 #include <stdio.h> 를 사용하였는데 바로 stdio.h 파일에는 제공하는 함수의 형식(프로토타입)이 정의 되어 있습니다.
그럼 오류를 바로 잡아 보겠습니다.

#include <stdio.h>

// 리턴값이 없는 함수
void func1();
// 리턴값이 있는 함수
int func2();
// 더하기 함수
int sum(int a, int b);

int main() {
    int ret;

    // 리턴타입이 없는 함수 호출
    func1();

    // 리턴값이 있는 함수 호출
    ret = func2();
    printf("func2() return value:[%d]\n", ret);

    // 더하기 함수
    ret = sum(1, 3);
    printf("sum() return value:[%d]\n", ret);

    return 0;
}

// 리턴값이 없는 함수
void func1() {
    printf("func1()...\n");
}

// 리턴값이 있는 함수
int func2() {
    return 1;
}

// 더하기 함수
int sum(int a, int b) {
    int sum;
    sum = a + b;

    return sum;
}

함수를 사용하는 main()함수 위에 사용할 함수의 형식을 정의합니다.
void func1();
int func2();
int sum(int a, int b);

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o func2 func2.c
~/c-lecture (master ✘)✭ ᐅ ./func2
func1()...
func2() return value:[1]
sum() return value:[4]
~/c-lecture (master ✘)✭ ᐅ

정상적으로 컴파일이 되고 실행됩니다.
c언어에서는 사용할 함수가 먼저 정의되어 있어야 한다. 라고 이해하시면 됩니다.
좀 더 큰 프로그램을 개발할때는 이런 함수의 형식을 모아서 하나의 include파일로 만들어서 사용합니다.

13. 포인터

다유데브 — Wed, 16 Nov 2022 14:07:33 +0900

1) 목표

포인터 개념 이해하기
이번 강의에서는 포인터의 기본 개념을 배우고 계속되는 강의에서 자세히 다루겠습니다.

2) 설명

▶ 포인터는 c언어에서 제공하는 타입중 하나입니다.
다른 타입과 다르게 포인터 변수는 그값을 주소(어드레스)를 가진다는점이 다릅니다.

// 포인터 변수 선언
char *ptr;

// 포인터 변수에 값을 할당
char sbuf[6];
char *ptr;
ptr = sbuf;

int nVal;
int *nPtr;
nPtr = &nVal;

▶ 포인터 변수는 변수명 앞에 * 를 붙여서 선언합니다.
포인터 타입은 앞에서 살펴본 타입으로 선언 가능합니다.

char *ptr, int *ptr, long *ptr, double *ptr ...
포인터 변수의 타입은 대상이 되는 변수의 타입과 일치해야겠지요.
char에 대한 포인터는 char *, int는 int * ...

▶ 변수가 선언이 되면 메모리가 할당된다고 말씀을 드렸는데 이렇게 메모리가 할당이 되면 메모리의 주소를 갖게 됩니다. 바로 이런 주소를 다루는 변수가 포인터입니다.

▶ char sbuf[6]; 이렇게 선언이 되면 메모리에 6바이트(char가 1바이트, 배열크기가 6)가 할당됩니다.
char *ptr; 포인터 변수가 선언되면 이 변수도 메모리에 8바이트(포인터크기)가 할당됩니다.
sbuf가 메모리에 할당된 주소를 포인터 변수에 대입해서 사용합니다.
ptr = sbuf; sbuf에 할당된 메모리 주소를 ptr변수에 대입합니다.

※ 포인터 변수는 단독(버퍼 없이)으로 사용할 수 없습니다.
포인터 변수는 반드시 어떤 메모리의 주소를 할당(값)해서 사용됩니다. (ptr = sbuf 처럼)

이처럼 어떤 메모리(sbuf[6])가 바로 버퍼라는 용어로 사용됩니다.
즉, 포인터 변수는 버퍼와 같이 사용됩니다.

3-1) 변수와 포인터 예제 프로그램

▶ vi pointer.c

#include <stdio.h>

int main() {
    int nval = 10;
    int *nptr;

    // 단일 변수에 대한 포인터
    printf("대입전 메모리주소:[%p][%p]\n", &nval, nptr);
    nptr = &nval;
    printf("대입후 메모리주소:[%p][%p]\n", &nval, nptr);
    printf("값: nval=[%d] nptr=[%d]\n", nval, *nptr);

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o pointer pointer.c
~/c-lecture (master ✘)✭ ᐅ
~/c-lecture (master ✘)✭ ᐅ ./pointer
대입전 메모리주소:[0x7ffeb6cc6b3c][0x7ffeb6cc6c40]
대입후 메모리주소:[0x7ffeb6cc6b3c][0x7ffeb6cc6b3c]
값: nval=[10] nptr=[10]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

배열이 아닌 변수가 선언될때 크기 만큼 메모리가 할당되는데 이 메모리를 참조할때는
변수앞에 & 를 붙입니다. 변수앞에 &를 붙이면 이 의미는 변수의 메모리 주소라는 의미입니다.
c언어의 문법입니다. 변수앞에 &를 붙이면 메모리주소다 라고 외워주세요!!
포인터는 주소값을 갖는 변수라고 말씀드렸는데요. 이렇게 변수의 주소를 포인터에 할당할 수 있습니다.
nptr = &nval; --> nval 변수의 주소를 포인터 nptr에 대입
포인터는 주소값을 갖는 변수지요. 그럼 그 주소에 들어있는 값을 참조할때는 포인터 변수명 앞에
* 를 붙입니다.
nval 의 값은 10입니다. *nptr의 값도 10이 됩니다.
&nval의 주소는 nptr과 같습니다.

변수	주소(어드레스)	값
nval	&nval	10
*nptr	nptr	*nptr

예제 실행에서 nptr = &nval; 문 전 printf문입니다.
printf()에서 %p 서식은 주소를 출력하는 서식입니다. 포인터 공부 하실때 사용하시면 유용합니다.
대입전 메모리주소:[0x7ffeb6cc6b3c][0x7ffeb6cc6c40]
2개의 주소가 다르다는걸 아실수 있습니다. nptr값은 선언되면서 무작위의 값이 할당됩니다.(가비지)
nptr = &nval; 할당후 출력되는걸 보시면
대입후 메모리주소:[0x7ffeb6cc6b3c][0x7ffeb6cc6b3c]
같아진걸 보실수 있습니다.
값을 출력하는 printf문을 보시면
printf("값: nval=[%d] nptr=[%d]\n", nval, *nptr);
nval은 변수 자체이지만 포인터 변수 nptr의 값을 출력할때는 *nptr로 사용됩니다.

3-2) char 배열과 포인터 예제 프로그램

▶ vi pointer2.c

#include <stdio.h>

int main() {
    char sbuf[5] = {'h', 'e', 'l', 'l', 'o'};
    char *sptr;
    int i;

    // 배열 변수에 대한 포인터
    printf("대입전 메모리주소:[%p][%p]\n", sbuf, sptr);
    sptr = sbuf;
    printf("대입후 메모리주소:[%p][%p]\n", sbuf, sptr);

    // 포인터를 사용해서 sbuf값을 출력
    for (i = 0; i < 5; i++) {
        printf("sbuf[%d]:주소-[%p][%p] 값-[%c][%c]\n", i, &sbuf[i], sptr+i, sbuf[i], *(sptr+i));
    }

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o pointer2 pointer2.c
~/c-lecture (master ✘)✭ ᐅ ./pointer2
대입전 메모리주소:[0x7ffda177f183][0x562caed4d080]
대입후 메모리주소:[0x7ffda177f183][0x7ffda177f183]
sbuf[0]:주소-[0x7ffda177f183][0x7ffda177f183] 값-[h][h]
sbuf[1]:주소-[0x7ffda177f184][0x7ffda177f184] 값-[e][e]
sbuf[2]:주소-[0x7ffda177f185][0x7ffda177f185] 값-[l][l]
sbuf[3]:주소-[0x7ffda177f186][0x7ffda177f186] 값-[l][l]
sbuf[4]:주소-[0x7ffda177f187][0x7ffda177f187] 값-[o][o]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

char sbuf[5]; 배열로 선언하면 5바이트 크기의 메모리가 할당됩니다.
일반 변수에서 할당된 메모리를 참조할때는 & 를 붙여서 참조를 했는데
배열에서는 배열 이름 자체가 메모리의 주소가 됩니다. 이부분도 외워주세요!
char sbuf[5]에 할당된 메모리 주소의 시작은 sbuf입니다.
그런데 배열에서 3번째 주소를 알고 싶은 경우는 일반 변수처럼 & 를 붙여줍니다.
sbuf[2] 의 주소는 &sbuf[2] 입니다.
sptr = sbuf; 포인터 변수 대입전에는 2개의 주소가 서로 다릅니다.
여기서 배열에서는 변수명이 메모리 주소가 되어서 sbuf 를 그대로 포인터 변수에 대입합니다.
sbuf는 배열의 시작 주소라 말씀을 드렸는데요. 그래서 대입문은
sptr = &sbuf[0]; 으로도 가능합니다. 즉, sbuf = &sbuf[0] 입니다.
포인트 변수 대입전

포인트 변수 대입

printf("sbuf[%d]:주소-[%p][%p] 값-[%c][%c]\n", i, &sbuf[i], sptr+i, sbuf[i], *(sptr+i)); 출력문에서
배열 각각의 주소를 출력합니다. &sbuf[i] 로 출력합니다. 또한 포인터 변수로도 출력하는데
그 문법은 sptr+i로 하고 있습니다. 즉, &sbuf[i] == sptr + i 와 같습니다.
값을 출력할때 배열은 sbuf[i] 으로 배열의 값을 출력하고, 포인터로 값을 출력할때는
*(sptr+i) 로 출력합니다. sptr+i 가 각 배열의 주소를 뜻하고 포인터 값에 접근할 경우는 * 를 붙인다고 말씀을 드렸지요. 그래서 *(sptr+i) 주소앞에 * 를 붙인겁니다. 연산자 우선순위가 * 가 + 보다 앞서서 ()로 감싸줍니다.
주소 출력 부분에서 눈여겨 보실게 있는데요.
sbuf[0]:주소-[0x7ffda177f183]
sbuf[1]:주소-[0x7ffda177f184]
sbuf[2]:주소-[0x7ffda177f185]
sbuf[3]:주소-[0x7ffda177f186]
sbuf[4]:주소-[0x7ffda177f187]
주소를 보시면 +1씩 증가한것을 보실수 있습니다. 이것은 char 타입이 1바이트라서 배열의 다음 주소가 1씩 증가합니다. 이렇게 메모리 주소를 다루는 변수가 포인터입니다.

3-3) int 배열과 포인터 예제 프로그램

▶ vi pointer3.c

#include <stdio.h>

int main() {
    int nbuf[5] = {1, 2, 3, 4, 5};
    int *nptr;
    int i;

    // 배열 변수에 대한 포인터
    printf("대입전 메모리주소:[%p][%p]\n", nbuf, nptr);
    nptr = nbuf;
    printf("대입후 메모리주소:[%p][%p]\n", nbuf, nptr);

    // 포인터를 사용해서 sbuf값을 출력
    for (i = 0; i < 5; i++) {
        printf("nbuf[%d]:주소-[%p][%p] 값-[%d][%d]\n", i, &nbuf[i], nptr+i, nbuf[i], *(nptr+i));
    }

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o pointer3 pointer3.c
~/c-lecture (master ✘)✭ ᐅ ./pointer3
대입전 메모리주소:[0x7fffeafb5cb0][0x55e4fac89280]
대입후 메모리주소:[0x7fffeafb5cb0][0x7fffeafb5cb0]
nbuf[0]:주소-[0x7fffeafb5cb0][0x7fffeafb5cb0] 값-[1][1]
nbuf[1]:주소-[0x7fffeafb5cb4][0x7fffeafb5cb4] 값-[2][2]
nbuf[2]:주소-[0x7fffeafb5cb8][0x7fffeafb5cb8] 값-[3][3]
nbuf[3]:주소-[0x7fffeafb5cbc][0x7fffeafb5cbc] 값-[4][4]
nbuf[4]:주소-[0x7fffeafb5cc0][0x7fffeafb5cc0] 값-[5][5]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

char 배열을 int 배열로 바꿘본 예제입니다.
실행한 주소를 보시면 char 는 주소가 1씩 증가를 했는데 int 배열은 4씩 증가한 걸 보실수 있습니다.
int 타입의 크기가 4바이트입니다. 이렇게 타입에 따라서 메모리가 할당된 모습을 확인하실 수 있습니다.

printf("nbuf[%d]:주소-[%p][%p] 값-[%d][%d]\n", i, &nbuf[i], nptr+i, nbuf[i], *(nptr+i));

이문장을

printf("nbuf[%d]:주소-[%p][%p] 값-[%d][%d]\n", i, &nbuf[i], nptr, nbuf[i], *nptr);
nptr++;

이렇게 변경 가능합니다.
nptr주소로 *nptr은 주소에 대한 값으로 사용합니다.
nptr++; ++연산자로 포인터를 다음 데이타로 이동시킵니다.

nptr = &nbuf[0]; -> 1번째 배열 주소
nptr++; --> 2번째 배열 주소

nptr++; --> 3번째 배열 주소

...

포인터의 ++, -- 연산자는 struct 문법에서 다시 자세히 다루겠습니다.

12. 문자열(string)

다유데브 — Wed, 16 Nov 2022 11:07:12 +0900

1) 목표

문자열 이해하기
문자열 활용하기

2) 설명

▶ c언어에서 문자열이라는 것은 char, int와 같이 타입이 존재하는건 아닙니다.
문자열(string)은 null(널)로 끝나는 문자의 집합입니다.

// 문자 타입의 배열
char cbuf[5] = {'h', 'e', 'l', 'l', 'o'};

// 문자 타입의 배열 이면서 마지막값이 null이므로 문자열이 됩니다.
// null 표현 : '\0', 0x00, 0
char sbuf[6] = {'h', 'e', 'l', 'l', 'o', '\0'};

▶ 차이점을 아시겠습니까?
cbuf[5] 배열은 마지막 문자가 null이 아니므로 문자열이 아닙니다.
sbuf[6] 배열은 마지막 문자가 null이므로 문자열입니다.

※ 마지막 null문자도 1바이트를 차지합니다.
그래서 문자열로 만드실 경우 문자수 + 1로 배열/메모리를 확보하셔야 합니다.

3-1) 예제프로그램

▶ vi string.c

#include <stdio.h>

int main() {
    char sbuf[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
    int i;

    // 배열의 값을 출력해 봅니다.
    printf("----- sbuf 출력 -----\n");
    for (i = 0; i < 6; i++) {
        printf("sbuf[%d]=%c\n", i, sbuf[i]);
    }

    // 문자열을 출력합니다.
    printf("----- 문자열 출력 -----\n");
    printf("sbuf[%s]\n", sbuf);

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o string string.c
~/c-lecture (master ✘)✭ ᐅ ./string
----- sbuf 출력 -----
sbuf[0]=h
sbuf[1]=e
sbuf[2]=l
sbuf[3]=l
sbuf[4]=o
sbuf[5]=
----- 문자열 출력 -----
sbuf[hello]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

char sbuf[6] = {'h', 'e', 'l', 'l', 'o', '\0'};

char타입 배열을 선언과 동시에 값을 할당하는데 마지막에 null문자('\0')를 넣어서 문자열로 만듭니다.
for 문으로 배열의 값을 출력합니다.

printf("sbuf[%s]\n", sbuf);

printf문의 서식 %s 로 문자열을 출력합니다.
%s 서식을 사용하실때 해당하는 값은 변수명만을 사용했습니다.
(포인터에서 자세히 다루도록 하겠습니다.)

3-2) 아스키코드값 출력하기

▶ vi string2.c

#include <stdio.h>

int main() {
    char sbuf[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
    int i;

    // 배열의 값을 출력해 봅니다.
    printf("----- sbuf 아스키코드 출력 -----\n");
    for (i = 0; i < 6; i++) {
        printf("sbuf[%d]=%c:[%d]:[%x]\n", i, sbuf[i], sbuf[i], sbuf[i]);
    }

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o string2 string2.c
~/c-lecture (master ✘)✭ ᐅ ./string2
----- sbuf 아스키코드 출력 -----
sbuf[0]=h:[104]:[68]
sbuf[1]=e:[101]:[65]
sbuf[2]=l:[108]:[6c]
sbuf[3]=l:[108]:[6c]
sbuf[4]=o:[111]:[6f]
sbuf[5]=:[0]:[0]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

printf("sbuf[%d]=%c:[%d]:[%x]\n", i, sbuf[i], sbuf[i], sbuf[i]);

%c다음의 [%d]:[%x]가 있습니다.
printf문 서식에서 %d는 알고 계신데로 정수형이고 %x는 16진수로 표현하는 서식입니다.
같은값 sbuf[i] 를 %c, %d, %x로 출력할 수 있습니다.
출력중 알파벳 h 값은 아스키코드값은 104이고 16진수로는 0x68인 것을 나타냅니다.
(c언어에서 16진수를 표시할때 0x를 붙입니다.)
man ascii 로 매뉴얼을 보시면 더 자세히 알수 있습니다.

3-3) string 선언 예제 프로그램

▶ vi string3.c

#include <stdio.h>

int main() {
    // 문자열로 선언
    char sbuf[] = "hello";
    int i;

    // 배열의 값을 출력해 봅니다.
    printf("----- sbuf 아스키코드 출력 -----\n");
    for (i = 0; i < 6; i++) {
        printf("sbuf[%d]=%c:[%d]:[%x]\n", i, sbuf[i], sbuf[i], sbuf[i]);
    }

    return 0;
}

▶ 컴파일/실행

~/c-lecture (master ✘)✭ ᐅ gcc -o string3 string3.c
~/c-lecture (master ✘)✭ ᐅ ./string3
----- sbuf 아스키코드 출력 -----
sbuf[0]=h:[104]:[68]
sbuf[1]=e:[101]:[65]
sbuf[2]=l:[108]:[6c]
sbuf[3]=l:[108]:[6c]
sbuf[4]=o:[111]:[6f]
sbuf[5]=:[0]:[0]
~/c-lecture (master ✘)✭ ᐅ

▶ 분석

위의 예제와 동일한 결과를 나타냅니다.
배열에 문자열을 바로 할당하는 문법입니다.
char sbuf[] = "hello";
이 선언은 char sbuf[6] = {'h', 'e', 'l', 'l', 'o', '\0'}; 와 같은 효과를 냅니다.
문자열을 바로 선언해서 사용하고자 할 경우 편리합니다.
※ 문자열을 좀 더 자세히 다룰때 다른 형태를 살펴보겠습니다.
여기서는 문자열을 선언할떄 이런형태로 선언하는구나. 정도만 아셔도 됩니다.