📌C 문법 정리

문자열 저장/출력 처리

#include <stdio.h>
 
int main() {
    char binary_data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0xFF, 0xFF}; 
    printf("%.*s\n", binary_data); 
    return 0;
}
 
// 출력: Hello

여기서 %s가 일반적으로 문자열 출력을 위한 거라고 하는데, 주의해야 될것이
\0문자열 즉, 바이너리 값으로 0이 존재할 경우 해당 부분 까지만 출력이 된다.

다른 언어들에서처럼 디버깅 목적으로 printf를 사용하려고 할 때 문제는 바이너리 데이터를 문자열로 출력하려고 시도할 경우, \0(0x00)값을 마주한다면 문자열이 끝났다고 판단하여 멈춰버린다.

만일 \0을 포함하여 모든것을 출력하길 원한다면 fwrite 를 사용하자

#include <stdio.h>
 
int main() {
    char binary_data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0xFF, 0xFF}; 
    fwrite(binary_data, 1, sizeof(binary_data), stdout); 
    return 0;
}
 
// 출력: Hello??

당연하지만 실제 C언어에서 문자열을 다룰경우 \0값은 취급하지 않는다.
참고로 문자열 선언 시 아래 처럼 선언한 경우 맨 뒤에 \0을 자동 삽입해주는데

char str[] = "Hello, World!";

아래처럼 선언한 경우에는 삽입되지 않으므로 수동으로 \0을 삽입해야 한다.
안 그러면 실행 시 올바른 문자열 범위를 파악하지 못해 이상한 값이 저장된다.

char str[] = {'H', 'e', 'l', 'l', 'o'}; // 수동으로 널 종료

스택(Stack) 변수, 힙(Heap) 변수

Stack

메모리에 Stack 영역에 저장되는 변수
실제 물리적 램과 가장 가깝기 때문에 가장 빠른 속도를 지님
함수 호출 시 자동으로 할당되고, 해제됨

스택영역은 컴파일 타임에서 할당될 메모리에 총량이 계산된다.

실제 메모리에서 CPU와 가깝게 작동하기 위해서 만들어진 부분이라 용량이 좀 작음

char buff[500];
int a;
# 이거 말고도 일반적인 short. char형 들도 다 Stack 영역

• 지역에 선언된 경우 주소를 리턴 할 경우 함수가 종료되면 할당을 해제 하기 때문에 오류가 난다
• 위에 예시처럼 배열에도 똑같이 적용되므로 혹여나 배열도 포인터 처럼 쓰면 되
  라는 인식으로 함수 반환을 배열로 주면 안된다.
• 즉 C언어에서는 지역변수 배열 반환이 안된다.
• 배열에 경우 따로 Heap변수로 wapping 해야되고(문자열에 경우 strcpy())
  일반 변수는 최대한 값으로 반환하도록 해야 한다
  (아니면 위에처럼 memcpy() 등으로 Heap변수로 wapping이 필요)

배열에 동적할당에 대해

원래 배열에 수를 선언할떄는 무조건 적으로 상수 이거나, 숫자로만 가능했다.
하지만 C11 표준에서 배열 수 선언시 변수가 사용 가능 하도록 패치됬다.

// 숫자 배열
int arr[100];
// 변수를 사용한 동적 배열
int arr2[argc];

근데 문제는 MSVC가 이걸 아직까지도 지원 안한다.
GCC/LLVM 사용 시에는 가능하지만
만약 윈도우 개발을 위해 MSVC를 사용해야되면 이건 무조건 알아둬야 한다.

스택변수에 Undefined Behavior

위에서 스택 변수는 아래와 같이 함수에 리턴값을 해당 변수에 주소값으로 주면 안된다고 했는데

재밌는 점이 아래처럼 따로 포인터 변수 선언 후 해당 포인터로 값을 전달하면 전달이 된다.

Test* stack(){
    Test test;
    Test *res = &test;
    return res;
}
 
void main() { 
    Test *test = stack();
}

이것은 Undefined Behavior(정의되지 않은 동작) 이다

이것이 작동하는 이유는 2가지 인데

먼저 첫번째로 포인터 변수는 스택, 힙 영역 모두에서 존재할 수 있다.
즉 Test *res는 스택영역/힙 영역과 상관없이 어디서든 쓸 수 있다
포인터 변수는 스택영역에 할당 해제 하고는 상관이 없는것이다.

포인터 변수 없이 &test 로 바로 주소를 반환 해버리면 Segmentation Fault 애러가 난다.
근데 포인터로 값을 mapping 해서 전달하면 포인터 변수 자체는 할당해지 되지않고 정상 적으로 반환되기에 애러가 안나는 것이다

두번째는 프로그램 동작이 크게 복잡하지 않는 경우 함수가 반환되어 할당 해제 되어도
다른 스택 영역에서 해당 영역을 덮어쓰지 않았다면
정상적으로 값을 불러올 수 있다는 것이다.

즉 정상적인 상황은 아니고 이런 코드로 인해 추후 문제가 생길 수 있다.

Heap

메모리에 Heap 영역에 저장되는 변수
Stack영역 보다는 상대적으로 느리게 작동
프로그래머가 직접 메모리를 할당하고, 해제 해야 함

사실상 일반적으로 램이 사용하는 영역을 가르킴

힙 할당은 런타임에서 동적으로 할당이 됨, 그래서 메모리 동적할당 이라고도 함

오해하면 안되는게 구조체 등에서 초기화를 할 시 해당 구조체의 필요한 크기만큼 공간을 할당하겠다는 거라서 예를들어 이것을 동적리스트처럼 사용한다거나 하는것은 안됨

• Heap 변수만 할당 뒤 free()로 해제 해야 함

char *buff = (char *)malloc(500);

구조체의 경우

구조체를 malloc 으로 초기화 한 경우 메모리에 구조체 변수가 선언된 순서대로 저장된다.
이게 굉장히 중요한게 malloc으로 초기화된 구조체 내부 변수값의 주소값을 알고 있다면, 해당변수를 구조체 포인터로 변환하여, 구조체 내부 모든 프로퍼티에 접근이 가능하다.

이때 malloc() 으로 초기화된 구조체 내부 프로퍼티는 이상한 값을 가진다.
만약 0으로 초기화가 필요한 경우 memset을 쓰도록 하자

typedef struct {
	int test1; // 이때 구조체 포인가 가르키는 주소는 해당 변수임
	char test2[100];
} Client;
 
 
// obj 변수는 해당 malloc 으로 초기화 한 구조채 의 `test1` 변수의 주소값임
ClientList *test = (ClientList*) obj;
 
// 모든 프로퍼티를 0(NULL) 로 초기화
memset(test, 0, sizeof(test));
 
//이제 이렇게 참조 가능
test->test2

메모리 할당 헤제 시 유의사항

• 구조체 내부 프로퍼티의 주소값으로 free 하는 경우

  typedef struct struct_t {
      int a;
      char b;
  } struct_t;

  struct_t의 b 변수의 주소값을 알고있는 경우 free(b) 를 호출한다면?
  결론은 구조체 전체 영역이 메모리에서 할당 해제

  free()는 해당 주소에 메모리 범위를 전체 탐삭하고 삭제하기 때문

  각각을 따로 관리하고 싶다면 char *b 로 선언하여 b 변수를 따로 malloc 으로 초기화 해야함

• free된 변수 그 자체는 NULL로 만들면 안된다.

  int *a = (int*)malloc(sizeof(int) * 10);
  free(a);
  a = NULL;

  이렇게 하면 안되는 이유는 할당 해제 이후에는 다른 메모리 영역이
  해당 포인터 주소값을 쓸 수 가 있다.

  이게 뭘 의미 하냐면 멀티쓰레딩 환경에서는 free 된 이후 다른 쓰레드에서 malloc 으로 할당 받는 상황이 발생 할 수 있다. 그럼 저 free 된 영역을 할당 받을 수 도 있다는 것이다.

  그래서 해당 포인터를 NULL로 바꾼다면 다른 쓰레드가 할당중인 malloc() 영역을 침범 할 가능성이 생긴다.

  그리고 에초에 저런식으로 NULL로 바꾸는게 의미가 없는 게 지역 변수 *a 에 대해 NULL로 값을 바꾸는 거라 범위밖에 값을 바꾸지 못한다.

• 구조체 내부 변수에 NULL 적용은 가능하다.

  typedef struct {
      char *str;
      int index;  
  } Obj;
   
  Obj *a = (Obj*)malloc(sizeof(Obj));
  a->str = (char*)malloc(sizeof(char) * 100);
  free(a->str);
  a->str = NULL;

  구조체 내부변수를 힙영역으로 초기화 한 경우에는 NULL 주소로 바꾸는게 가능하다.

  해당 주소를 NULL로 바꾸더라도 어차피 메인 구조체 자체가 주소값을 가지므로 free 되었다 한들 해당 영역에 할당이 이루어 질 수 없기 때문이다.

  또한 구조체의 주소값 참조를 통해 NULL로 바꾸게 되면 범위 밖에서도 적용 가능하다.

기타영역 (포인터 변수)

char *buff 이런식으로 선언된 포인터 변수는 스택/힙/데이터 영역 상관없이 어디서든 쓸 수 있다.

그래서 위에 스택변수에 Undefined Behavior 항목에서 설명했듯이 스택 변수를 포인터 변수로 한번 mapping 해서 반환하면 정상적으로 반환되는것 처럼 보일 수 있는것이다. ㄴ

비트 단위 값 판결

판별하고 싶은 비트를 1로 두고 나머지는 0으로 두는 비트 마스크 생성해서 & 연산

int main(int argc, char const *argv[]) {
    char a = 12;
    char b = 0b0000100;
 
    printf("%d\n", a & b);
	// 0, 1로 출력 되게 하고싶으면 비트쉬프트 사용 
	printf("%d\n", (a & b) >> 2);
    return 0;
}

가변 인자

#include <stdarg.h>
 
void varargs(int count, ...) {
    va_list arg;
    // 가변인자 사용
    va_start(arg, count);
    for (int i = 0; i < count; i++) {
	    // va_arg에 2번째 인자는 가변인자로 받을 변수 타입에 따라 변경
        printf("%s\n", va_arg(arg, char *));
    }
 
	// 가변인자 종료
    va_end(arg);
}
 
void main() {
	//2 라는 숫자는 뒤에 가변인자 개수를 뜻함
    varargs(2, "언젠가", "그가 너를");
}

가변인자는 ... 으로 선언하고 va_list 라는걸 통해서 처리하면 되는데

int count이게 왜 필요하냐 C언어에서는 가변 인자 개수를 자동으로 파악할 수 없다.
그니까 사용자가 직접 가변인자 개수를 기입해서 처리 해야한다.

가변 인자를 처리는 va_start-va_end 블록 내부에 처리 해야한다
va_start() 를 통해서 사용선언을 하고
다 썼으면 (모든 가변인자를 다 불러왔다면) va_end()로 종료해야한다.

작동 방식이 va_start를 호출하면 자동으로 가변인자 중 첫번째 가변 인자에 주소를 가르키도록 셋팅 되고 va_arg을 통해 char * 만큼 씩 포인터를 이동하여 다음 인자를 불러오도록 하고있다.
다 사용하면 va_end를 호출하여 포인터에 위치를 리셋시키게 된다.

여기서 알 수 있는 사실이 한번에 va_start-va_end 블록에서 똑같은 가변 인자를 여러번 불러 올 수 없다는 것이며, 그렇게 하고 싶을때는 다른 va_start-va_end 블록을 만들어서 해야한다는 것이다.

서식문자 처리하는 법

위 단순히 인자를 전달하는 것 외에 C언어에 가변인자는 printf 등에서 사용하는 서식문자에 처리를할 수 있다.

void varargs(char *format, ...) {
    va_list arg;           // 가변인자 리스트를 가리키는 포인터
    va_start(arg, format);  // 가변인자 리스트 포인터를 첫 주소로 초기화
 
	// 서식 문자로 출룍하기
    vprintf(format, arg);
 
    va_end(arg);
}
 
void main() {
    varargs("그냥 값: %d\n", 10);
}
// 출력: 그냥 값: 10

일반 가변인자 처리하는 것과 동일하게 va_start-va_end 블록 내부에서 처리해야 하며,
가변인자를 식별할 고정인자를 char *선언 하게 되고 해당 인자 부분에 서식 문자열을 지정하고, 나머지 인자는 변수로 채우게 된다.

아래 처럼 사용 할 경우 len변수는 서식 문자를 통해 만들어지는 문자열에 길이를 나타낸다
그럼 그 변수로 가변 배열을 만들어서 해당 배열에 완성된 문자열을 저장하는 용도로 쓸 수 있다.

va_start(args, _Format);
int len = vsnprintf(NULL, 0, _Format, args);
va_end(args);
 
char buf[len + 1];
 
va_start(args, _Format);
vsnprintf(buf, len + 1, _Format, args);
va_end(args);

vprintf, vsnprintf 기존 입출력 함수와, 파일 함수에 서식 문자 래핑 함수가 여럿 존재 하는데
아래 함수 정리 파트에서 정리해 두었다

void 포인터

C언어에 void 포인터는 보통 callback 구현이나 기타 클로져 기능 같은 역할을 수행한다.
여기서 알 수 있는 사실은 함수를 ()로 호출하지 않으면 void * 자료형으로 간주된다.

// `test_cb`는 타입 이름
// `int num`은 callback 함수에 구현될 인자
typedef void (*test_cb)(int num);
 
void test(test_cb cb) {
    cb(10);
}
 
void my_cb(int num) {
    printf("test_cb: %d\n", num);
}
 
void main() {
    test(my_cb);
}

함수나, 기타 타입이 명확하지 않는 자료형을 뭉뚱그려서 void *로 지정한 다음 사용자가 직접 형 변환 해서 쓰도록 하는 경우도 있다.

typedef void (*test_cb)(void *data);
 
void test(void *data, test_cb cb) { 
    cb(data);
}
 
void my_cb(void *data) {
    // 원하는 자료형으로 형변환
    char *str = (char *)data;
    printf("%s\n", str);
}
 
void main() {
    char *str = "Hello World!";
    test(str, my_cb);
}

실행 인자 처리법

참고자료

• Linux C getopt함수

실행 인자 처리는 getopt_long 함수로 처리 할 수 있다.
위 참고자료에는 getopt로 처리하는데 그러면 긴 인자를 처리할 수 없기에 getopt_long으로 한다.

• 옵션 목록 만들기

  struct option run_args[] = {{"port", required_argument, 0, 'p'},
                              {"dns", required_argument, 0, 0},
                              {"timeout", no_argument, 0, 't'},
                              {"help", no_argument, 0, 'h'},
                              {"nolog", no_argument, 0, 0},
                              {"logfile", required_argument, 0, 'l'},
                              {0, 0, 0, 0}};

  • 0: 긴 인자,
  • 1: required_argument: 실행인자에 값이 들어감
  • 2: 그냥 0 고정
  • 3: 축약 인자, 없으면 0으로

• 옵션 인자 파싱

          while ((opt = getopt_long(argc, argv, "p:ht:l:", run_args, &option_index)) != -1) {
              switch (opt) {
  	            // 축약인자가 없는경우
                  case 0:
                      if (strcmp(run_args[option_index].name, "nolog") == 0) {
                          SERVER_CONFIG.noLog = 1;
                      }
                      break;
                  case 'p':
                      if (atoi(optarg) < 1 || atoi(optarg) > 65535) {
                          put_log(LOG_ERROR, "잘못된 포트번호");
                          return 1;
                      }
                      SERVER_CONFIG.port = atoi(optarg);
                      break;
                  // 잘못 입력
                  default:
                      put_log(LOG_INFO, "'%s --help' 로 설명을 확인해 보세요.", argv[0]);
                      return 0;
              }
          }

함수 정리

문자열 함수

• char * strdup(const char *_String): 문자열을 힙 영역으로 복사

  • 특정 문자열을 함수 외부에도 써야되서 힙 영역으로 복사 해야 될때
    malloc + memcpy 조합 대신 쓰는 방법

    <주의할점>
    문자열에 대한 복사는 \0 즉 바이너리로 0x00을 만나는 지점까지만 복사가 됨
    그래서 내가 복사 하려는 데이터가 진짜 문자열인지, 아니면 바이너리를 포함한 형테의 문자열인지 를잘 알아야 함

    char str[] = "안녕하세요";
    char *p = strdup(str);

• char * strncpy(char *_Destination, const char *_Source, size_t _Count): 문자열 복사

  • _Source 문자열을 _Destination 으로 복사
    위 strdup 마냥 메모리 영역이 달라지진 않고 그냥 단순 영역 복사

    _Count: 복사할 길이

    반환: _Destination 주소값 (무시 해도 될듯)

    <주의할점>
    문자열에 대한 복사는 \0 즉 바이너리로 0x00을 만나는 지점까지만 복사가 됨
    그래서 내가 복사 하려는 데이터가 진짜 문자열인지, 아니면 바이너리를 포함한 형테의 문자열인지 를잘 알아야 함

    만약 바이너리 라면 memmove()를 쓰도록 하자.

    char str[] = "안녕하세요";
    char *p = malloc(100 * sizeof(char));
    strcpy(p, str);

• char * strchr(const char *_Str, int _Val): 문자 존재여부 & 구분자

  • _Str 문자열에 _Val 문자가 등장하는 위치에 주소값을 반환

    만약 _Val 문자열이 존재하지 않으면 NULL을 반환

    이런 성질을 사용해서 문자 존재 여부 뿐 아니라 구분자로 사용해 문자를 나누는 역할도
    가능

    문자열 존재 여부나 문자열로 구분자를 하고싶다면 strtok함수를 쓰도록 하자

    만약 _Val 문자가 여려 개 존재하더라도 가장 첫번째 등장한 문자 주소를 반환

    char str[] = "안녕:하세요";
    strchr(str, ':');
    char* token = strchr(str, ':');
    // : 문자를 NULL로 바꿔서 문자열을 나누는 방법
    *token = '\0';
    printf("%s\n", str); // 안녕
    printf("%s\n", token + 1); //하세요

• int strcmp(const char *_Str1, const char *_Str2): 문자열 동일 비교

  • 반환값: 0이면 동일한거 1이면 다른거

    char str[] = "안녕하세요";
    int res = strcmp(str, "안녕하세요");
    printf("res: %d\n", res);

• int atoi(const char *_String): 문자열 → 숫자

버퍼 할당 함수 & 서식 문자 사용함수

참고로 %d, %s 같이 prtinf 함수같은데서 사용하는 특수 기호를 서식문자라 함

• int snprintf(char *const _Buffer, const size_t _BufferCount, const char *const _Format, ...): 문자열에 변수 포함

  • printf 마냥 서식문자 써서 _Buffer에 저장

    즉 문자열 _Buffer에 변수를 포함하여 저장

    _BufferCount: 문자열에 최종 크기 지정

    참고로 sprintf가 해당 함수 원형인데 안전하지 않아서 이걸로 필기함

    char buf[500];
    int i = 10;
    sprintf(buf, 500, "Hello: %s", i);

• int sscanf(const char *const _Buffer, const char *const _Format, ...): 문자열 타입 분리

  • _Buffer에 이있는 문자열을 형식 지정자에 맞는 타입으로 변환 해서 각각에 인자에 전달해줌

    즉 위 sprintf는 형식문자→버퍼 인데 sscanf는 버퍼→ 형식 문자임

    그래서 타입 변환 할 때 쓰기 좋음

    char origin[] = "안녕친구들 1";
     
    char buf[500];
    int i = 10;
     
    sscanf(origin, "%s %d", buf, &i);
    printf("%s %d\n", buf, i);

파일 함수 (바이너리 다루기)

참고로 표준, 입출력도 사실 파일이다. 그래서 File *file에 각각 stdout, stdin, stderr 상수로 설정하면 표준 입출력 처리도 가능하다.

대부분에 함수가 서식 문자 함수에서 상속되있는거라 f*로 시작하고 file 스트림을 다룬다는 차이 정도

fputs, fgets도 파일 함수긴 한데 텍스트 데이터만 취급 가능하고 파일 쪽 보다 표준입 출력에 유용하여 여기에 서술하진 않음

• FILE * fopen(const char *_FileName, const char *_Mode): 파일 열기

  • _Mode 같은 경우 알아서 찾아볼 것 (보통 다른언어랑 비슷함)
    만약 파일을 열 수 없는 경우 반환 값은 NULL

• int fflush(FILE *_Stream): 버퍼 비우기

  • fclose 호출하기전 반드시 호출하고 가자

• int fclose(FILE *_Stream): 스트림 닫기

  • 파일 작업 전체 다 끝나면 호출

• size_t fread(void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream): 파일 읽어서 버퍼에 저장

  • _Stream 파일에서 읽어 _Buffer에 저장

    _ElementSize: 파일을 읽는 기본 바이트 단위 인데, 뭔가 특수한 목적이 없지 않는 이상 1로 고정, 즉 1바이트 단위로 읽겠다는 거

    _ElementCount: 읽을 크기, 사실상 _Buffer에 크기와 동일하게 가져가야 함

    반환값: 정상이면 읽은 바이트 수, 오류이거나, 다 읽으면 0
    만약 텍스트를 다루는거라면 _Buffer[읽은 바이트 수+1]=\0을 추가하자.
    태생이 바이너리를 다루는거라 자동으로 텍스트 끝처리를 안해준다.

• size_t fwrite(const void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream): 버퍼로 파일 쓰기 & 바이너리 출력

  • _Buffer에있는 데이터를 _Stream파일에 쓰기

    _ElementSize파일에 쓰는 기본 바이트 단위 인데, 뭔가 특수한 목적이 없지 않는 이상 1로 고정, 즉 1바이트 단위로 쓰겠다는 거

    _ElementCount는 _Buffer에서 실제 쓰기 길이

    반환값: 정상이면 쓴 바이트 수, 오류면 0

    <참고>
    _Stream을 stdout으로 둔다면 printf에서는 무조건 문자열로 취급되어 \0 문자열을 취급하지 못하는데 fwrite는 바이너리를 다루는거라 전체 출력이 나옴

    그래서 바이너리 출력할 때 사용하기도 함

• int fprintf(FILE *const _Stream, const char *const _Format, ...): 서식 문자 사용해서 파일에 쓰기

  • _Stream 파일에 서식 문자를 사용해서 파일에 쓰기
    stdout, stderr로 설정 하면 표준 출력으로도 사용 가능

    fprintf(fp, "안녕 %d\n", num);

• int fscanf(FILE *const _Stream, const char *const _Format, ...): 파일을 읽어 각각 타입으로 분리

  • 기능은 sscanf 랑 똑같음

    const _Stream 파일을 읽어 문자열을 형식 지정자에 맞는 타입으로 변환 해서 각각에 인자에 전달해줌

    아래 예제로 설명하면 fp 에서 읽어서 buf, i 변수 각각 타입에 맞게 변환해서 전달

    char buf[500];
    int i = 10;
    sprintf(fp, "%s %d", buf,  i);

전체적인 파일 입출력 로직

FILE *fp = fopen("test.txt", "r");
if (fp == NULL) {
	printf("File not found\n");
	return 1;
}
 
char line[256] = {0};
int nread = 0;
while ((nread = fread(line, 1, 256, fp))) {
	line[nread+1] = '\0';
	printf("%s", line);
}
 
fflush(fp);
fclose(fp);

만약 하나의 특정 파일을 여러번 읽기/쓰기를 하려고 한다면
fopen() 으로 얻은 파일 포인터를 재사용 하자.

파일 입출력이 필요 할때 마다 fopen-fclose를 호출하면 미친듯한 오버헤드가 발생한다.
그러니 완벽히 쓸일이 없을때만 fclose를 호출하고 그러지 않으면 이미 fopen된 파일 포인터를 재사용 하는것이 좋다.

fflush 함수는 이런식으로 fopen 파일에 여러번 쓰기 작업을 할때 유용한데, 가끔 버퍼를 전부 쓰지를 못하고 남아있는 경우가 있는데 이때 fflush를 호출해서 남은 바이트를 소모하도록 한다.

표준 입출력 함수 추가

참고로 gets, puts 함수는 버퍼 오버플로우 취약성 때문에 C 표준에서 제외됬다 카더라
fgets, fputs는 파일 함수 이지만 표준 입출력에 더 유용하여 여기다 서술한다.

• char * fgets(char *_Buffer, int _MaxCount, FILE *_Stream): \n을 허용하는 입력 & 텍스트 파일 읽기

  • _Stream을 stdin으로 설정하면 _Buffer는 입력에 사용된 결과를 저장할 용도로 사용된다

    scanf랑 차이는 바로 \n을 하나의 입력으로 처리할 수 있다. 사용자가 enter키를 입력 했는지, 그리고 아무런 값을 입력하지 않고 넘어갔는지 등을 처리할 수 있게 된다.

    이때 문자열 끝은 \n을 포함하니 끝을 \0으로 바꾸는 처리를 해야한다.

    문자열로 밖에 반환이 안되서 만약 형 변환이 필요하면 추가적으로 fscanf나 이런걸로 바꾸면 된다.

    _MaxCount는 최대 길이

    반환값: 문자열 끝 (\n)의 주소값, 오류라면 null

    만약 파일로 다루게 된다면 문자열을 읽을때 \n을 기준으로 읽기 때문에 개행이 있다면 첫줄만 읽게 된다. 이때는 해당 반환값을 사용해서 반환값+1 부터 다시 읽게 하여 모든 줄을 끝까지 읽을 수 있게 할 수도 있다,

    char str[100];
    fgets(str, sizeof(str), stdin);
    printf("%s", str);

• int fputs(const char *_Buffer, FILE *_Stream): 문자열을 \n 단위로 출력 & 텍스트 파일 쓰기

  • _Stream을 stdout으로 설정하면 _Buffer를 출력할 버퍼로 사용된다.

    \n이 문자열에 끝이므로 개행이 없는 버퍼를 출력할 때 용인하긴 한데 잘 쓸일은 없고 사실 puts는 파일 쓰기 할때 좀더 좋은 편이긴 하다.

    반환값: _Stream에 쓴 바이트 수, 오류라면 0

메모리 할당 & 조작 함수

• void * malloc(size_t _Size): 힙 영역으로 메모리 할당

  • 참고로 malloc 은 실패 할 수 있다. (물리 메모리 공간이 부족하든지 하면)
    이때 반환값으로 NULL을 보내니 참고하자

• void * realloc(void *_Block, size_t _Size): 힙 영영 메모리 확장

  • 이미 malloc 으로 할당된 힙 영역에 크기를 확장한다
    _Block은 힙에 할당된 포인터이고 그걸 _Size 만큼 확장

    기존에 있던 데이터는 그대로 보존되고 새로운 크기가 할당된다.
    그래서 가변길이 리스트 만들거나 할때 많이 사용된다.

    realloc 은 기존에 메모리 주소를 따라가지 않는다.
    그래서 새로 할당된 주소는 반환값으로 알 수 있게 된다.
    다만 기존에 있던 메모리 공간을 free 시킬 필요는 없다.
    즉 realloc에 반환값으로 나온 주소값으로만 free 시키면 된다.

    하지만 만약 realloc이 실패한 경우 NULL을 반환하는데 이때는 기존에 메모리 공간을 free 해야 된다.
    즉 malloc 으로 할당한 기존 포인터 값을 알고 있어야 한다는 소리

• void * memset(void *_Dst, int _Val, size_t _Size): 메모리를 특정 값으로 초기화

  • _Dst 메모리 영영역을 _Val 값으로 _Size 만큼 초기화

    _Size값은 보통 구조체 크기가 온다

    스택 영역에 경우 Data a = {0} 등으로 0 초기화가 가능하지만, 힙으로 초기화 한 경우에는 초기값 할당이 불가 하니 memset을 활용하는 경우가 많다.

• void * memmove(void *_Dst, const void *_Src, size_t _Size): 메모리 이동

  • _Src 메모리 영역에 _Size 만큼을 _Dst 주소로 옮김

    문자열을 포함한 모든 데이터를 다른 메모리 주소로 옮긴다.
    스택, 힙 영역 구분 없이 옮길 수 있지만, 힙 영역은 옮기기 이전 주소를 free 시켜야한다.

• void * memcpy(void *_Dst, const void *_Src, size_t _Size)

  • _Src 메모리 영역에 _Size 만큼을 _Dst 주소로 복사

    문자열을 포함한 모든 데이터를 다른 메모리 주소에 복사한다.
    스택, 힙 영역 구분 없이 옮길 수 있지만, 힙 영역은 복사하기 이전 주소를 free 시켜야한다.

가변 인자 서식 문자 처리 함수

va_start-va_end 블록 내부에 서식 문자 처리용 함수

• int vprintf(const char *const _Format, va_list _ArgList): 서식 문자열 출력

  • printf에 가변인자 래핑함수

• int vfprintf(FILE *const _Stream, const char *const _Format, va_list _ArgList): 서식 문자열을 파일 스트림으로 저장

  • fprintf에 가변인자 래핑함수

• int vsnprintf(char *const _Buffer, const size_t _BufferCount, const char *const _Format, va_list _ArgList): 가변인자 버퍼 저장 함수

  • snprintf에 가변인자 래핑함수
    반환값: 서식 문자를 통해 만들어지는 문자열에 길이

기타 함수

• sizeof(Any): 자료형 크기를 반환

  • 주의: 초기화된 메모리 크기를 반환하는게 아님!!!

    예를 들어, malloc 으로 100 크기에 힙공간을 하고 해당 포인터에 sizeof 결과 값을 확인 해보면 100을 반환하는게 아니라 포인터 크기인 8(x32는 4)을 반환한다.

서식문자 종류

https://programfrall.tistory.com/91

기타 사항

• 0이 아닌 모든 수는 참이다

  int main(int argc, char const *argv[]) {
  	int a = 1;
  	int b = -1;
  	int c = 0;
  	if (a) {
  		printf("a는 참");
  	}
  	if (b) {
  		printf("b는 참");
  	}
  	if (c) {
  		printf("c는 거짓");
  	}
  }

  js나, python과같이 0이 아닌 모든 수는 조건식에 참을 만족한다.
  이러한 식은 포인터(주소) 와, 숫자형 만 비교가 된다.

• 0 == NULL
  컴파일러 마다 정의가 쬐끔 다른데 MSVC에 경우 진짜로 NULL 이 0으로
  define 되어있는데, gcc에 경우 ((void*)0) 으로 선언 되어
  0의 주소를 가르키는 포인터로 되어있다.

  그래서 GCC 같은 경우 포인터가 아닌 변수들을 NULL로 초기화 하려면 (int) NULL
  이런식으로 형 변환 해야 한다.

• 외부 변수 참조

  extern int tt;

  다른 소스파일에 변수를 사용하고 싶을 때

• 리눅스는 _s 함수(safe 함수)를 쓸 수 없다
  MSVC에서는 _s 함수를 강요했는데, 시실 이거 비표준 이더라
  C99에서 표준으로 지정 되었지만 여전히 리눅스에서는 지원안하더라
  물론 라이브러리를 설치하면 되지만 기본 지원은 안되는거니 참고하자