표준 라이브러리 정리 <cstdlib> (stdlib.h) - C++ (C)
▶ C++ C 표준 라이브러리 정리글 입니다.
{[ 포함된 함수목록 (계산관련) ]}
[1] div_t div (int, int) => 나누기 함수
[2] ldiv_t ldiv (long int, long int) => 나누기 함수
[3] lldiv_t lldiv (long long int, long long int) => 나누기 함수
[4] long int labs (long int) => 절댓값 반환함수
[5] long long int llabs (long long int) => 절댓값 반환함수
[6] int abs(int) => 절댓값을 반환하는 함수
[7] void* bsearch(const void*, const void*, size_t, size_t, int (*)(const void*,const void*)) => 바이너리탐색 함수
[8] void qsort (void*, size_t, size_t, int (*)(const void*,const void*)) => 배열정렬 함수
[9] int rand (void) => 난수값을 생성하는 함수
[10] void srand (unsigned int) => 난수발생을 초기화하는 함수
{[ 포함된 함수목록 (메모리및 프로세스관련) ]}
[1] void* malloc (size_t) => 메모리블럭 할당함수
[2] void* calloc (size_t, size_t) => 메모리블럭 할당함수
[3] void* realloc (void*, size_t) => 메모리블럭 재할당함수
[4] void free (void*) => 메모리블럭 할당해제 함수
[5] void exit (int) => 프로세스 종료함수
[6] void _Exit (int) => 프로세스 종료함수
[7] void abort (void) => 프로세스 종료함수
[8] char* getenv (const char*) => 환경변수 설정값 불러오기 함수
[9] int system (const char*) => 시스템 명령어 실행함수
{[ 포함된 함수목록 (문자열관련) ]}
[1] int atoi(const *char) => char*자료형값을 int형값으로 바꾸는 함수
[2] long atol(const *char) => char*자료형값을 long형값으로 바꾸는 함수
[3] double atof(const *char) => char*자료형값을 double형값으로 바꾸는 함수
[4] long long atoll(const *char) => char*자료형값을 long long형값으로 바꾸는 함수
[5] char* itoa(int, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
[6] char* ltoa(long, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
[7] char* ultoa(unsigned long, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
[8] double strtod (const char*, char**) => char**자료형값을 double형값으로 바꾸는 함수
[9] float strtof (const char*, char**) => char**자료형값을 float형값으로 바꾸는 함수
[10] long int strtol (const char*, char**, int) => char**자료형값을 long int형값으로 바꾸는 함수
[11] long double strtold (const char*, char**) => char**자료형값을 long double형값으로 바꾸는 함수
[12] long long int strtoll (const char*, char**, int) => char**자료형값을 long long int형값으로 바꾸는 함수
[13] unsigned long int strtoul (const char*, char**, int) => char**자료형값을 unsigned long int형값으로 바꾸는 함수
[14] unsigned long long int strtoull (const char*, char**, int) => char**자료형값을 unsigned long long int형값으로 바꾸는 함수
[15] int mblen (const char*, size_t) => 멀티바이트문자열 문자단위 반환 함수
[16] size_t mbstowcs (wchar_t*, const char*, size_t) => 멀티바이트문자열을 와이트문자열로 전환하는 함수
[17] int mbtowc (wchar_t*, const char*, size_t) => 멀티바이트시퀀스를 와이트문자열로 전환하는 함수
[18] size_t wcstombs (char*, const wchar_t*, size_t) => 와이드문자열을 멀티바이트문자열로 전환하는 함수
[19] int wctomb (char*, wchar_t) => 와이드문자열을 멀티바이트시퀀스로 전환하는 함수
● 나누기함수
● div_t div (int, int)
● ldiv_t ldiv (long int, long int)
● lldiv_t lldiv (long long int, long long int)
우선 나누기 함수는 반환값이 div_t인 구조체를 알아야합니다
먼저 이 구조체내에는 몫과 나머지값이 들어있는데요!
몫은 quot이고, 나머지는 rem입니다!
typedef struct _div_t
{
int quot;
int rem;
} div_t;quot이 몫부분이구요 rem이 나머지 부분입니다!
그러면 사용법을 알려드리겠습니다!
● 사용방법
#include <stdio.h> //printf()
#include <stdlib.h> //div_t
int main ()
{
div_t ret1; //나누기함수의 결과값을 받을 구조체 int
ret1 = div(50,9);
printf("몫: %d\n나머지: %d\n\n", ret1.quot, ret1.rem);
ldiv_t ret2; //나누기함수의 결과값을 받을 구조체 long int
ret2 = ldiv(34,2);
printf("몫: %d\n나머지: %d\n\n", ret2.quot, ret2.rem);
lldiv_t ret3; //나누기함수의 결과값을 받을 구조체 long long int
ret3 = lldiv(77,7);
printf("몫: %d\n나머지: %d\n\n", ret3.quot, ret3.rem);
}
결과값은 다음과 같습니다.
● 절댓값 반환함수
● long int labs (long int)
● long long int llabs (long long int)
● int abs (int)
다음은 절댓값 반환함수입니다.
이것도 마찬가지로 반환타입이 다를뿐이지 하는 역할은 동일합니다.
그러면 사용법을 알려드리겠습니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //abs // labs // llabs
int main ()
{
printf("%d\n%d\n%d"
, abs(-123)
, labs(-14124)
, llabs(1312)
);
}
와우~ 다 정상적으로 절댓값이 나왔네요!
● 바이너리탐색 함수
● void* bsearch(const void*, const void*, size_t, size_t, int (*)(const void*,const void*))
bsearch함수는 바이너리탐색함수입니다.
특정 키값을 이용해서 배열내의 일치하는 값을 찾는 함수입니다.
● 사용방법
#include <stdio.h>
#include <stdlib.h>
#define SIZET 11
int compare(const void* a, const void* b){
return (*(int*)a > *(int*)b);
}
int main ()
{
int *ret;
int key = 129;
int array[SIZET] = {10, 51, 21, 5, 76, 129, 534, 1000, 20000, 121, 2};
ret = (int*)bsearch(&key, array, SIZET, sizeof(int), compare);
if(ret != NULL){
printf("Found : %d", *ret);
}
else printf("Not Found : %d", key);
}
우선 헷갈리시는분들을 위해서 설명해드리겠습니다.
첫번째인자는 키값입니다. 하지만 함수원형을 보면
const void*타입이기때문에 참조자를 추가해서 형을 맞추어 주어야합니다!
두번째인자는 배열입니다! 배열을 넣고
세번째인자는 배열의 크기
네번째인자는 배열원소 하나의 크기
마지막인자는 비교기준입니다
bsearch함수는 기본적으로 void*반환타입이기때문에 int*형으로 캐스팅을 해주었습니다!
● 배열정렬 함수
● void qsort (void*, size_t, size_t, int (*)(const void*,const void*))
특정 논리에 따라 배열이 정렬되는 함수입니다
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //qsort
#define SIZET 11 //배열의 크기
int great(const void* a, const void* b){ //오름차순
return (*(int*)a > *(int*)b);
}
int less(const void* a, const void* b){ //내림차순
return (*(int*)a < *(int*)b);
}
int main ()
{
int array[SIZET] = {10, 51, 21, 5, 76, 129, 534, 1000, 20000, 121, 2};
printf("오름차순: ");
qsort(array, SIZET, sizeof(int), great); //오름차순정렬
for(int i=0;i<SIZET;i++) printf("%d ", array[i]); //출력
printf("\n\n\n내름차순: ");
qsort(array, SIZET, sizeof(int), less); //내림차순정렬
for(int i=0;i<SIZET;i++) printf("%d ", array[i]); //출력
}
와우~~~~~
● 난수 이벤트함수
● int rand (void) => 난수값을 생성
● void srand (unsigned int) => 난수발생을 초기화
먼저 rand와 srand는 같이 사용하여 설명하겠습니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //rand //srand
#include <time.h> //time
int main ()
{
srand(time(NULL));
for(int i=0;i<10;i++) printf("%d ", rand() % 10 + 1);
}
해당 코드는 1부터 10까지의 값을 랜덤으로 10번 출력하는 함수입니다!
우선 srand함수는 랜덤시드의 값을 초기화해주는 역할을 합니다!
이 함수를 빼고사용한다면 계속 같은 값만 나올것입니다!
rand함수는 rand() % n + 1; 이런식으로 사용이 1~n까지의 랜덤한 값생성이 가능합니다!
● 메모리블럭 관리함수
● void* malloc (size_t) => 메모리블럭 할당
● void* calloc (size_t, size_t) => 메모리블럭 할당
● void* realloc (void*, size_t) => 메모리블럭 재할당
● void free (void*) => 메모리블럭 할당해제
먼저 malloc함수는 메모리블럭을 할당하는 함수입니다.
반대로 free함수는 할당된 메모리블럭을 해제하는 함수이기때문에
둘이 같이씁니다~!
어떻게 사용하는지 알아보겠습니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //malloc //free
#define MAXSIZE 100 // 할당할 배열의 크기
int main ()
{
char str[] = "Hello world Dp"; //문자열 복사원본
char *ptr; //할당할 문자배열
ptr = (char*)malloc(sizeof(char) * MAXSIZE); //메모리블럭 할당
for(int i=0;i<MAXSIZE;i++) ptr[i] = '\0'; //내용초기화
for(int i=0;i<sizeof(str);i++) ptr[i] = str[i]; //문자열 내용복사
printf("할당함! >> %s\n", ptr); //출력
free(ptr); //메모리블럭 할당해제
ptr = NULL; //포인터변수 초기화
printf("할당해제함! >> %s\n", ptr); //출력
}
우선 malloc함수의 첫번째인자는 크기입니다.
자료형마다 차지하는 바이트크기가 다르기때문에 sizeof()연산자와 설정해놓은 매크로를 곱하여 최종 크기로 메모리블럭에 공간을 할당하였습니다.
그후 free함수를 이용해서 할당된 메모리블럭 해제하였습니다!
calloc함수 또한 비슷하게 사용할 수있지만
calloc함수는 malloc함수와 다르게 메모리블럭을 할당한뒤 그공간을 초기화합니다.
어떻게 사용하는지 알려드리겠습니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //calloc //free
#define MAXSIZE 100
int main ()
{
char str[] = "Hello world Dp"; //문자열 원본
char *ptr; //포인터변수
ptr = (char*)calloc(MAXSIZE, sizeof(char)); //메모리블럭 할당
for(int i=0;i<sizeof(str);i++) ptr[i] = str[i]; //문자열복사
printf("할당함! >> %s\n", ptr); //출력
free(ptr); //메모리블럭 할당해제
ptr = NULL; //포인터 초기화
printf("할당해제함! >> %s\n", ptr); //출력
}
출력값은 같습니다!!
이번엔 realloc을 사용해보겠습니다!!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //calloc //realloc //free
#define MAXSIZE 100 //배열크기
int main ()
{
char str1[] = "Hello world Dp"; //문자열원본
char str2[] = "Hello world Dp Plus!!"; //크기가 커진 문자열 원본
char *ptr; //포인터
ptr = (char*)calloc(MAXSIZE, sizeof(char)); //메모리블럭 할당
for(int i=0;i<sizeof(str1);i++) ptr[i] = str1[i]; //문자열 원본복사
printf("할당함! >> %s\n", ptr); //출력
ptr = (char*)realloc(ptr, sizeof(char) * MAXSIZE + 200); //메모리블럭 재할당 크기+=200
for(int i=0;i<sizeof(str2);i++) ptr[i] = str2[i]; //크기가 커진 문자열 원본복사
printf("공간이 부족해서 더 할당함! >> %s\n", ptr); //출력
free(ptr); //메모리블럭 할당해제
ptr = NULL; //포인터 초기화
printf("할당해제함! >> %s %s\n", ptr); //출력
}
와우~!
● 프로세스 종료함수
● void exit (int)
● void _Exit (int)
● void abort(void)
위 함수들은 수행하는 역할이 비슷하기 때문에 같이 설명하겠습니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //exit //_Exit //_exit //abort
int main ()
{
int i = 7;
printf("메인함수 시작");
if( i == 7 ){
//exit(EXIT_SUCCESS);
//_Exit(EXIT_SUCCESS);
//_exit(EXIT_SUCCESS);
abort();
}
printf("메인함수 종료");
}
다음과같이 "메인함수 종료"라는 메세지는 나오지않고 바로 끝난것을 볼 수가있습니다!!
● 환경변수 설정값 불러오기 함수
● char* getenv (const char*)
먼저 getenv함수는 환경변수의 내용을 반환합니다!
● 사용방법
#include <stdio.h> //printf
#include <stdlib.h> //getenv
int main ()
{
char *str = getenv("PATH");
printf("%s", str);
}
환경변수의 자세한 결과값을 알고싶다면 직접 실행해보세요!!
● 시스템 명령어 실행함수
● int system (const char*)
system함수는 시스템 명령어를 사용할 수 있도록하는 함수입니다.
Windows의 경우 cmd를, Linux의 경우 Terminal의 시스템명령어를 실행합니다.
● 사용방법
#include <stdio.h>
#include <stdlib.h>
int main ()
{
char t[] = "dir";
int ret = system(t);
printf("%d", ret);
}
● char*타입변수의 자료형을 바꾸는 함수
● int atoi(const *char) => char*자료형값을 int형값으로 바꾸는 함수
● long atol(const *char) => char*자료형값을 long형값으로 바꾸는 함수
● double atof(const *char) => char*자료형값을 double형값으로 바꾸는 함수
● long long atoll(const *char) => char*자료형값을 long long형값으로 바꾸는 함수
● char* itoa(int, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
● char* ltoa(long, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
● char* ultoa(unsigned long, char*, int) => int자료형값을 char*형값으로 바꾸는 함수
이번에도 다 비슷한 역할을 수행하는 함수라서 한꺼번에 설명해드리겠습니다!
우선 1번째부터 4번째함수와 5번째부터 7번째함수는 서로 반대의 설질을 가지는데요
어떻게 쓰는지 알려드리겠습니다~!
● 사용방법
#include <stdio.h>
#include <stdlib.h>
#define SIZE 64 //크기
int main(){
char str[SIZE]="1234.56789"; //변수 선언
int Int; //변수 선언
long Long; //변수 선언
long long LongLong; //변수 선언
float Float; //변수 선언
Int = atoi(str); //형변환
Long = atol(str); //형변환
LongLong = atoll(str); //형변환
Float = atof(str); //형변환
printf("%s %d %ld %lld %f", str, Int, Long, LongLong, Float);
}
우선 첫번째 인자는 char*타입이구요!
반환타입은 각각 int과 long과 long long과 float입니다~
#include <stdio.h>
#include <stdlib.h>
#define SIZE 64
int main(){
char str[SIZE];
int Int = 13;
long Long = 124;
unsigned long UnsignedLong = 132423;
itoa(Int, str, 10); //형변환
printf("%s ", str);
ltoa(Long, str, 10); //형변환
printf("%s ", str);
_ultoa_s(UnsignedLong, str, SIZE, 10); //형변환
printf("%s ", str);
}
우선 첫번째 인자는 변환할 숫자!
두번째는 변환받을 공간!
세번째는 진수입니다 저는 10진수로 변환할거기때문에 10으로 적었습니다~
ultoa는 좀 특이한데 그냥은 안되더라구요 그래서
_ultoa_s(변환받을 ul타입, char*, char*의 크기, 진수);
이렇게 적어주시면 됩니다!
● char**타입변수의 자료형을 바꾸는 함수
● double strtod (const char*, char**) => char**자료형값을 double형값으로 바꾸는 함수
● float strtof (const char*, char**) => char**자료형값을 float형값으로 바꾸는 함수
● long int strtol (const char*, char**, int) => char**자료형값을 long int형값으로 바꾸는 함수
● long double strtold (const char*, char**) => char**자료형값을 long double형값으로 바꾸는 함수
● unsigned long int strtoul (const char*, char**, int) => char**자료형값을 unsigned long int형값으로 바꾸는 함수
● unsigned long long int strtoull (const char*, char**, int) => char**자료형값을 unsigned long long int형값으로 바꾸는 함수
이녀석들은 좀 특이한데요
첫번째인자로부터 받은 문자열에 소속된 여러개의 숫자들을 두번째인자로 받은 포인터를 이용해서
쪼개나가면서 하나씩 하나씩 변환해주며, 세번째인자는 그 숫자의 진수입니다!
● 사용방법
#include <stdio.h>
#include <stdlib.h>
#define SIZE 64
int main(){
char numbers[SIZE] = "123.456 1242.34 0.12";
char *key;
double Double;
Double = strtod(numbers, &key);
printf("%lf ", Double);
Double = strtod(key, &key);
printf("%lf ", Double);
Double = strtod(key, NULL);
printf("%lf ", Double);
}
따란~~~
첫번째인자는 문자열원본이구요!
두번째인자가 잘려진 문자열을 받을공간입니다!
따라서 " "를 기준으로 잘려나가면서 값이 key에 들어가게되며 잘려진숫자는 반환값으로 전달받게됩니다!!
마지막은 전달받을 객체가 더이상 없기때문에 NULL로 했습니다~!
#include <stdio.h>
#include <stdlib.h>
#define SIZE 64
int main(){
char numbers[SIZE] = "7233 0x14 0x00ff00";
char *key;
long Long;
Long = strtol(numbers, &key, 10); //형 변환
printf("%ld ", Long);
Long = strtol(key, &key, 16); //형 변환
printf("%ld ", Long);
Long = strtol(key, NULL, 0); //형 변환
printf("%ld ", Long);
}
짜란~~~~
값이 정상적으로 나왔으며,
위에 나와있는 다른 함수들도 이런식으로 사용이 가능합니다~!
● 와이드 문자열 관련 함수
● int mblen (const char*, size_t) => 멀티바이트문자열 문자단위 반환 함수
● size_t mbstowcs (wchar_t*, const char*, size_t) => 멀티바이트문자열을 와이트문자열로 전환하는 함수
● size_t mbstowcs (wchar_t*, const char*, size_t) => 멀티바이트시퀀스를 와이트문자열로 전환하는 함수
● size_t wcstombs (char*, const wchar_t*, size_t) => 와이드문자열을 멀티바이트문자열로 전환하는 함수
● int wctomb (char*, wchar_t) => 와이드문자열을 멀티바이트시퀀스로 전환하는 함수
이번에는 와이드문자열을 다루기위한 함수들입니다!
● 사용방법
//mblen 사용됨
//mbtowc 사용됨
#include <stdio.h>
#include <stdlib.h>
int strlen(const char* str){ //문자열길이 반환함수
int cnt = 0;
while(str[cnt] != '\0') cnt++;
return cnt;
}
int main(){
char multibyte_sequence;
char *multibyte_string = "multibyte";
int multibyte_length = strlen(multibyte_string); //문자열길이반환
wchar_t wide_sequence;
wchar_t *wide_string = L"wide"; //와이드문자열 옆에는 L을 적어줍니다~
int len, end = 0;
//len은 멀티바이트문자열의 길이단위 크기
//end는 현재 지나고있는 multibyte_length의 포인터위치의 길이
while(1){
len = mblen(multibyte_string, sizeof(multibyte_string));
mbtowc(&wide_sequence, multibyte_string, len);
printf("%lc ", wide_sequence);
multibyte_string += len; end += len;
if(end == multibyte_length) break;
}
}
//wctomb => wchar_t -> char*
//wctombs => wchar_t* -> char*
#include <stdio.h>
#include <stdlib.h>
int main(){
char multibyte_string[64] = {0};
wchar_t wide_sequence = L'W';
wchar_t wide_string[64] = L"wide";
wctomb(multibyte_string, wide_sequence);
printf("%s ", multibyte_string);
wcstombs(multibyte_string, wide_string, 64);
printf("%s ", multibyte_string);
}
//mbstowcs => char* -> wchar_t*
#include <stdio.h>
#include <stdlib.h>
int main(){
char multibyte_string[64] = "multibyte";
wchar_t wide_string[64] = {0};
mbstowcs(wide_string, multibyte_string, 64);
printf("%ls", wide_string);
}
따란~~~~
결과값처럼 잘 나오는것을 볼수가있습니다....!
그렇다면 다음에는 <cstdio> (stdio.h) 라이브러리함수에 대해서 정리해보겠습니다...!
안녕~!!
'🧼C, C++ > 기초및 입문' 카테고리의 다른 글
| 우주선 연산자 '<=>' 사용법 ( C++20 ) (1) | 2021.06.19 |
|---|---|
| 키로거 만들기 C++ (4) | 2021.01.29 |
| C언어 기초 #3 if문과 연산자 (0) | 2021.01.13 |
| C언어 기초 #2 배열과 함수 (0) | 2021.01.12 |
| C언어 기초 #1 자료형 (0) | 2021.01.12 |
댓글