[ C 언어 스터디 ]
자료출처 : 핵심 길잡이 C 프로그래밍언어
도서출판 : 성안당
12 라이브러리 함수
C 언어에서 라이브러리 함수( library function )는 종류가 매우 다양하며 , 이들 중의
일부는 매크로( macro )로 정의되어 있다. 라이브러리 함수들은 이미 컴파일되어 있어
링트( link )할 때 사용자 프로그램에 결합된다. 그러나 C 라이브러리 함수들은 시스템
에 따라 약간의 차이가 있을 수 있다. 이들 중 시스템에 포함되어 있는 함수들은 표준
라이브러리 함수( standard library function )라 한다. 이 장에서는 표준 라이브러리 함
수들 중에서 문자열 처리 함수와 수학 함수 , 메모리 관리 함수 , 날짜 및 시간 관련 함
수 , 데이터 변환 함수 등에 관하여 다룬다.
★ 문자열 처리 함수 ★
문자열 처리 함수들은 문자열의 길이 계산, 문자열의 복사, 문자열의 결합 등과 같은
기능들을 수행한다. 일반적으로 문자열 입출력 함수들은 헤더 파일 < stdio.h >에 선언되
어 있는 반면에, 문자열 처리 함수들은 < string.h >라는 헤더 파일에 선언되어 있다.
[ 표 12-1 ]은 문자열 처리 함수들과 그 기능을 나타낸 것이다.
[ 표 12-1 ] 문자열 처리 함수
함 수 |
기 능 |
strlen( str ) |
문자열 str의 길이를 계산한다. |
strcpy( str1 , str2 ) |
문자열 str2를 문자열 str1에 복사한다. |
strncpy( str1 , str2 , n ) |
문자열 str2의 첫 번째 문자부터 n 개의 문자를 문자열 str1에 복사한다. |
strcat( str1 , str2 ) |
문자열 str2를 문자열 str1에 연결한다. |
strncat( str1 , str2 , n ) |
문자열 str2의 첫 번째 문자부터 n 개의 문자를 문자열 str1에 연결한다. |
strcmp( str1 , str2 ) |
문자열 str1과 str2를 비교한다. |
strncmp( str1 , str2 , n ) |
문자열 str2의 첫 번째 문자부터 n 개의 문자를 문자열 str1과 비교한다. |
strchr( str , c ) |
문자열 str에서 c 에 해당하는 문자가 처음 나오는 위치를 찾는다. |
strrchr( str , c ) |
문자열 str에서 c 에 해당하는 문자가 마지막으로 나오는 위치를 찾는다. |
strrev( str ) |
문자열 str을 거꾸로 뒤집는다. |
strset ( str , c ) |
문자열 str의 각 문자를 c 에 해당하는 문자로 변경한다. |
strupr( str ) |
문자열 str의 소문자를 대문자로 변경한다. |
strlwr( str ) |
문자열 str의 대문자를 소문자로 변경한다. |
strstr( str , strCharSet ) |
문자열 str에서 strCharSet 문자열의 시작 위치를 찾는다. |
strtok( strToken , strDelimit ) |
문자열 strToken에서 다음 토큰을 찾는다. |
< strlen ( ) >
strlen ( ) 함수는 문자열의 길이를 함수의 값으로 돌려 준다. 이때 문자열의 마지막에
있는 null 문자 '\0'는 문자열의 길이에 포함되지 않는다. 그 형식은 다음과 같다.
형 식 |
int strlen( char *str ) ;
|
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < string.h >
void main ( void )
{
char *msg = " C programming language " ;
printf ( " %s 의 길이 = %d \n " , msg , strlen( msg ) ) ;
}
▶ 실행 결과
C programming language의 길이 = 22
|
< strcpy ( ) , strncpy ( ) >
strcpy ( ) 함수는 문자열을 복사하는 함수이다. 그 형식은 다음과 같다.
형 식 |
char *strcpy( char *str1 , char *str2 ) ;
|
strcpy ( ) 함수는 문자열 포인터 변수 str2가 가리키는 기억 장소에 있는 문자열을 한
문자씩 읽어 들여 문자열 포인터 변수 str1이 가리키는 기억 장소에 복사한다. 이 함수
는 반환 값으로 str1을 돌려 준다. 이때 str1이 가리키는 문자열의 길이가 str2가 가리
키는 문자열의 길이보다 크거나 같아야 한다. 그렇지 않으면 인접한 기억 장소의 내용
이 손실될 수 있으므로 주의하여야 한다.
형 식 |
char *strncpy ( char *str1 , char *str2 , int n ) ;
|
strncpy ( ) 함수는 str2가 가리키는 곳에 있는 문자열을 처음부터 n 개의 문자만을 추
출하여 str1이 가리키는 기억 장소에 복사한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < string.h >
void main ( void )
{
char *msg = " Hello World " ;
char str1[ 50 ] , str2[ 50 ] ;
strcpy( str1 , msg ) ;
strcpy( str2 , msg ) ;
strncpy( str2 , "abcde" , 5 ) ;
printf ( " msg = %s \n " , msg ) ;
printf ( " str1 = %s \n " , str1 ) ;
printf ( " str2 = %s \n " , str2 ) ;
}
▶ 실행 결과
msg = Hello World |
str1 = Hello World |
str2 = abcde World |
|
< strcat ( ) , strncat ( ) >
strcat ( ) 함수는 두 개의 문자열을 하나의 문자열로 연결하는 기능을 수행한다. 그
형식은 다음과 같다.
형 식 |
char *strcat( char *str1 , char *str2 ) ; |
strcat ( ) 함수는 포인터 변수 str1이 가리키는 문자열의 끝에 포인터 변수 str2가 가
리키는 문자열을 연결시켜 str1이 가리키는 기억 장소에 기억시킨다. 그러므로 연결된
문자열의 포인터는 str1과 같고 , 문자열의 길이만 str2가 가리키는 문자열의 길이만큼
추가되었다고 볼 수 있다 . 그러므로 str1이 가리키는 기억 장소는 두 문자열을 연결할
수 있을 만큼 충분하게 미리 확보해 놓아야 한다.
형 식 |
char *strncat( char *str1 , char *str2 , int n ) ;
|
strncat ( ) 함수는 str1이 가리키는 문자열의 끝에 str2가 가리키는 문자열의 처음부
터 n 개의 문자를 추출하여 연결시킨다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
void main ( void )
{
char str1[ 80 ] ;
char str2[ 80 ] = " This is the initial string ! " ;
char suffix[ ] = " extra text to add to the string... " ;
strcpy( str1 , " Hello " ) ;
strcat( str1 , " world " ) ;
printf ( " str1 = %s \n " , str1 ) ;
printf ( " Before : %s \n " ,str2 ) ;
strncat ( str2 , suffix , 19 ) ;
printf ( " After : %s \n " , str2 ) ;
}
▶ 실행 결과
str1 = Hello world
Before : This is the initial string !
After :
This is the initial string ! extra text to add
|
< strcmp ( ) , strncmp ( ) >
strcmp ( ) 함수의 형식은 다음과 같다.
형 식 |
int strcmp( char *str1 , char *str2 ) ;
|
strcmp ( ) 함수는 포인터 변수 str1과 str2가 가리키는 문자열들을 왼쪽부터 차례대
로 한 문자씩 비교해 가면서 서도 다른 것이 발견될 때까지 또는 어느 한쪽의 문자열
이 끝날 때까지 비교를 계속한다. 두 문자열이 같으면 0 , 그렇지 않으면 서로 다른 것
으로 판별된 문자들간의 차이를 함수의 리턴 값으로 돌려 준다.
형 식 |
int strncmp( char *str1 , char *str2 , int n ) ;
|
strncmp ( ) 함수는 포인터 변수 str1과 str2가 가리키는 문자열들을 처음부터 n 개의
문자까지만 비교한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < string.h >
void main ( void )
{
printf ( " %d \n " , strcmp( " character " , " character " ) ) ;
printf ( " %d \n " , strcmp( " char " , " character " ) ) ;
printf ( " %d \n " , strcmp( " figure " , " cat " ) ) ;
}
▶ 실행 결과 Turbo C ver 4.5
0
-97
3
▶ 실행 결과 Visual Studio 6.0
0
-1
1
|
strcmp( " character " , " character " )는 두 문자열이 같으므로 결과값이 0( zero )이다.
strcmp( " char " , " character " )는 첫 번째 문자열의 끝인 '\0'과 두 번째 문자열의 5번째
문자인 'a'까지만 비교된다. 따라서 함수의 값으로
'\0'의 ASCII 값 - 'a'의 ASCII 값 = 0 -97 = -97
을 반환한다. 또한 strcmp( " figure " , " cat " )는 두 문자열 " figure "와 " cat "를 첫 번째
문자만을 비교하고 더 이상은 비교하지 않는다. 함수의 값으로
'f' 의 ASCII 값 - 'c' 의 ASCII 값 = 102 -99 = 3
을 반환한다.
< strchr ( ) , strrchr ( ) >
strchr ( ) 와 strrchr ( ) 함수는 문자열에서 특정한 문자를 찾는 함수이다 . 그 형식은
다음과 같다.
형 식 |
char *strchr( char *str , int c ) ;
char *strrchr( char *str , int c ) ; |
strchr ( ) 함수는 정수 c에 해당하는 문자 ( ASCII 문자 )가 문자열 str에서 처음 나
오는 위치를 찾는다. 이때 c 는 정수형 변수여야 한다. 프로그램 상에서 문자를 입력
하면 해당하는 아스키 코드 값으로 비교가 이루어진다.
strrchr ( ) 함수는 정수 c 에 해당하는 문자 ( ASCII 문자 )가 문자열 str에서 마지막으
로 나오는 위치를 찾는다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
int ch = 's' ;
char string[ ] = " A dram of discretion is worth a pound of wisdom " ;
// 문자열의 위치를 나타내기 위해 사용
char fmt1[ ] = " |
1 |
2 |
3 |
4 |
5 " ; |
|
char fmt2[ ] = "12345678901234567890123456789012345678901234567890" ; |
void main ( void )
{
char *pdest ;
int result ;
printf ( " 검색 대상 문자열 \n " ) ;
printf ( " \t %s \n \t %s \n " , fmt1 , fmt2 ) ;
printf ( " \t %s \n\n " , string ) ;
printf ( " 검색할 문자 : \t %c \n\n " , ch ) ;
/* 전방향 검색 */
pdest = strchr( string , ch ) ;
result = pdest - string + 1 ;
if ( pdest != NULL )
{
printf ( " 결과 : \t first \' %c \' found at position %d \n\n " , ch , result ) ;
printf ( " strchr( string ,
\' %c \' ) ==> %s \n\n\n " , ch , pdest ) ;
}
else
printf ( " 결과 : \t %c not found \n " ) ;
/* 후방향 검색 */
pdest = strrchr( string , ch ) ;
result = pdest -string + 1 ;
if ( pdest != NULL )
{
printf ( " 결과 : \t last \' %c \' found at position %d \n\n " , ch , result ) ;
printf ( " strchr( string ,
\' %c \' ) ==> %s \n\n\n " , ch , pdest ) ;
}
else
printf ( " 결과 : \t %c not found \n " ) ;
}
▶ 실행 결과
검색 대상 문자열
|
1 |
2 |
3 |
4 |
5 |
|
12345678901234567890123456789012345678901234567890 |
A dram of discretion is worth a pound of wisdom |
검색할 문자 : s |
결과 : first 's' found at position 13 |
strchr< string , 's' > ==> scretion is worth a pound of wisdom |
결과 : last 's' found at position 44 |
strchr< string , 's' > ==> sdom |
Press any key to continue_ |
|
< strrev ( ) >
strrev ( ) 함수는 문자열을 거꾸로 출력해 주는 함수이며 , 그 형식은 다음과 같다.
형 식 |
char *strrev( char *str ) ;
|
문자열 포인터 변수 str이 가리키는 문자열을 거꾸로 기억시켜 반환해 주는 함수이다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
void main ( void )
{
char string[ 100 ] ;
printf ( " Input String : " ) ;
gets( string ) ;
printf ( " Reverse string : %s \n " , strrev( string ) ) ;
}
▶ 실행 결과
Input String : Korea
reverse string : aerok
Press any key to continue
|
< strset ( ) >
strset ( ) 함수는 문자열을 특정한 문자로 변경하고자 할 때 사용한다. 그 형식은 다
음과 같다.
형 식 |
char *strset( char *str , int c ) ;
|
문자열 포인터 변수 str이 가리키는 문자열의 각 문자를 정수형 변수 c 에 해당하는
문자로 모두 변경시킨다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
void main ( void )
{
char string[ ] = " Fill the string with something " ;
printf ( " Before : %s \n " , string ) ;
strset( string , ' * ' ) ;
printf ( " After : %s \n " , string ) ;
}
▶ 실행 결과
Before : Fill the string with something
After : *********************************
|
< strupr ( ) , strlwr ( ) >
strupr ( ) 과 strlwr ( ) 함수는 문자열의 대 소문자를 변경하는 데 사용한다. 그 형식
은 다음과 같다.
형 식 |
char *strupr( char *str ) ;
char *strlwr( char *str ) ;
|
strupr ( ) 함수는 문자열 포인터 변수 str이 가리키는 문자열에 소문자가 들어 있으면
해당 소문자를 모두 대문자로 변경시켜 준다 strlwr ( ) 함수는 str이 가리키는 문자열
의 대문자를 모두 소문자로 변경시켜 준다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
void main ( void )
{
char string[ 100 ] = " The String to End All Strings ! " ;
printf ( " 대상문자열 : %s \n " , string ) ;
printf ( " 소 문 자 : %s \n " , strlwr ( string ) ) ;
printf ( " 대 문 자 : %s \n " , strupr ( string ) ) ;
}
▶ 실행 결과
대상문자열 : The String to End All Strings !
소 문 자 : the string to end all strings !
대 문 자 : THE STRING TO END ALL STRINGS !
|
< strstr ( ) >
strstr ( ) 함수는 부분 문자열을 찾는다 그 형식은 다음과 같다.
형 식 |
char *strstr( char *str , char *strCharSet ) ; |
문자열 포인터 변수 str이 가리키는 문자열에서 문자집합 strCharSet이 처음 시작하
는 위치를 반환해 주는 함수이다 따라서 결과는 strCharSet 문자열이 시작되는 위치
에서 마지막 문자까지의 문자열을 가리키는 포인터를 반환 받게 된다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
char str[ ] = " small " ;
char string[ ] = " A large fire often comes from a small spark " ; |
char fmt1[ ] = " |
1 |
2 |
3 |
4 |
5 " ; |
char fmt2[ ] = " 12345678901234567890123456789012345678901234567890 " ; |
void main ( void )
{
char *pdest ;
int result ;
printf ( " 검색 대상문자열 : \n " ) ;
printf ( " \t %s \n\t %s \n " , fmt1 , fmt2 ) ;
printf ( " \t %s \n " , string ) ;
pdest = strstr( string , str ) ;
result = pdest -string + 1 ;
printf ( " \n\n 실행결과 : \n\n\t 검색문자열 : %s \n\n " , str ) ;
if( pdest != NULL )
{
printf ( " \t \' %s\' found at position %d \n\n " , str , result ) ;
printf ( " \t strstr( string ,
\' %s\' )의 결과 : %s \n " , str , pdest ) ;
}
else
printf ( " \' %s\' not found \n " , str ) ;
}
▶ 실행 결과
검색 대상문자열 :
|
1 |
2 |
3 |
4 |
5 |
12345678901234567890123456789012345678901234567890 |
A large fire often comes from a small spark |
실행결과 :
검색문자열 : small
' small ' found at position 33
strstr<string , ' small ' >의 결과 : small spark
|
< strtok ( ) >
strtok ( ) 함수는 문자열에서 토큰을 추출할 때 사용한다. 그 형식은 다음과 같다.
형 식 |
char *strtok( char *str , char *strDelimit ) ; |
여기서 str은 대상 문자열을 가리키는 포인터 변수이고 , strDelimit는 토큰을 구분해
주는 문자들의 집합을 나타낸다. 이때 각 토큰의 구분은 구분 문자들 중 어느 하나만
만족해도 토큰을 구분해 준다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < string.h >
# include < stdio.h >
char string[ ] = " A large \t fire ,, often comes \n from a small spark " ;
// 대상 문자열
char seps[ ] = " , \t\n " ; // 토큰 구분자
char *token ; // 토큰
void main ( void )
{
printf ( " 대상 문자열 : \n \t A large \\t fire ,, often comes \\n from a samll spark " ) ;
printf ( "\n\n 추출된 토큰들 : \n " ) ;
// 첫번째 토큰 얻기
token = strtok( string , seps ) ;
while( token != NULL )
{
// 토큰 출력
printf ( " %s \n " , token ) ;
// 다음 토큰 얻기
token = strtok ( NULL , seps ) ;
}
}
▶ 실행 결과
대상 문자열:
A large \t fire ,, often comes \n from a samll spark
추출된 토큰들 :
A
large
fire
often
comes
from
a
small
spark
|
★ 데이터 변환 및 랜덤 ( random ) 함수 ★
이 절에서는 숫자들로만 이루어진 문자열을 연산이 가능한 수치로 변환하는 함수 ,
수치형 데이터를 문자열로 변환하는 함수 , 0 과 1 사이의 임의의 수를 추출해 주는 함
수들에 대해서 살펴본다 . C 언어의 표준 라이브러리는 이러한 문자열 변환 함수와 랜
덤 함수들을 제공한다. 이 함수들은 일반적으로 < stdlib.h >라는 헤더 파일에 정의되어
있다.
[ 표 12-2 ]와 [ 표 12-3 ]은 stdlib.h에 정의되어 있는 데이터 변환 함수와 랜덤 함수를
나타낸 것이다.
[ 표 12-2 ] 데이터 변환 함수
함 수
|
기 능 |
atoi ( )
|
문자열을 int형 정수로 변환한다. |
atol ( )
|
문자열을 long형 정수로 변환한다. |
atof ( )
|
문자열을 float형 부동 소수점수로 변환한다. |
itoa ( )
|
int형 정수를 문자열로 변환한다. |
ltoa ( )
|
long형 정수를 문자열로 변환한다. |
ecvt ( )
|
double형 실수를 지정된 길이의 문자열로 변환한다. |
strtol ( )
|
문자열을 long형 정수로 변환한다. |
strtoul ( )
|
문자열을 unsigned long형 정수로 변환한다. |
strtod ( )
|
문자열을 double형 실수로 변환한다. |
ultoa ( )
|
unsigned long형 정수를 문자열로 변환한다. |
toascii ( )
|
문자를 ASCII 코드로 변환한다. |
tolower ( )
|
소문자로 변환한다. |
toupper ( )
|
대문자로 변환한다. |
[ 표 12-3 ] 랜덤 함수
함 수 |
기 능 |
srand ( )
|
난수생성기 ( pseudo-random-number generator )를 초기화한다. |
rand ( )
|
0과 RAND _ MAX 사이의 임의의 난수를 발생시킨다.
여기서 , RAND _ MAX는 시스템의 최대 정수값이다. |
< atoi ( ) , atol ( ) , atof ( ) >
이 함수들의 형식은 다음과 같다.
형 식 |
int atoi ( char *str ) ;
long atol ( char *str ) ;
double atof ( char *str ) ; |
atoi ( ) 함수는 포인터 변수 str이 가리키는 곳에 기억되어 있는 수치 형태의 문자열
을 int 형으로 변환한 후 , 그 값을 함수의 결과 값으로 돌려준다. atoi ( ) 함수는 숫자 앞
에 있는 공백들은 무시하며 , 숫자 앞의 부호는 인식한다. 그리고 문자열 내에서 처음으
로 정수로 변환하는 데 합당하지 않은 문자가 나오기 전까지만 변환한다.
atol ( ) 함수는 포인터 변수 str이 가리키는 곳에 기억되어 있는 수치 형태의 문자열
을 long 형으로 변환한 후 , 그 값을 함수의 결과 값으로 돌려준다.
atof ( ) 함수는 포인터 변수 str이 가리키는 곳에 기억되어 있는 부동 소수점수 형태
의 문자열을 double 형으로 변환한 후 , 그 값을 함수의 결과 값으로 돌려준다. atoi ( ) 함
수와 마찬가지로 숫자 앞에 있는 공백들은 무시하며 , 숫자 앞의 부호는 인식한다. 그리
고 문자열 중에서 부동 소수점수로 변환하는 데 합당하지 않은 문자가 나오기 전까지
만 변환한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < stdlib.h >
void main ( void )
{
char *str1 = " 560 " ;
char *str2 ; long l ;
char *str3 = " -3.14195 " ;
int result ;
result = atoi ( str1 ) ;
printf ( " result = %d \n " , result ) ;
str2 = " 37054 dollars " ;
l = atol ( str2 ) ;
printf ( " ASCII string : %s ===> long : %ld \n " , str2 , l ) ;
printf ( " %f \n " , atof ( str3 ) ) ;
}
▶ 실행 결과
result = 560
ASCII string : 37054 dollars ===> long : 37054
-3.141950
|
< itoa ( ) ltoa ( ) , ultoa ( ) >
itoa ( )는 int 형 정수를 문자열로 변환한다 ( integer to ASCII ) , ltoa ( )는 long형 정수
를 문자열로 변환 ( long to ASCII )한다. ultoa ( )는 unsigned long형 정수를 문자열로
변환한다. 이들 함수의 일반 형식은 다음과 같다.
형 식 |
char * itoa ( int value , char *str , int radix ) ;
char * ltoa ( long value , char *str , int radix ) ;
char * ultoa ( unsigned long value , char *str , int radix ) ; |
여기서 value는 변환할 값을 기억하고 있는 변수를 의미하고 , str은 결과를 저장할
문자열 포인터 변수를 의미한다. radix는 2 ~ 36 사이에 있는 value의 밑수 ( base ) 를 나
타낸다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdlib.h >
# include < stdio.h >
void main ( void )
{
char buffer[ 20 ] ;
int i = 1032 ;
long l = -259115L ;
unsigned long ul = 1234567890UL ;
itoa ( i , buffer , 10 ) ;
printf ( " String of integer %d ( radix = 10 ) : %s \n " , i , buffer ) ;
itoa ( i , buffer , 16 ) ;
printf ( " String of integer %d ( radix = 16 ) : 0x%s \n " , i , buffer ) ;
itoa ( i , buffer , 2 ) ;
printf ( " String of integer %d ( radix = 2 ) : %s \n " , i , buffer ) ;
ltoa ( l , buffer , 16 ) ;
printf ( " String of long int %ld ( radix = 16 ) : 0x%s \n " , l , buffer ) ;
ultoa ( ul , buffer , 16 ) ;
printf ( " String of unsigned long %lu ( radix = 16 ) : 0x%s \n " , ul , buffer ) ;
}
▶ 실행 결과
String of integer 1032 ( radix = 10 ) : 1032
String of integer 1032 ( radix = 16 ) : 0x408
String of integer 1032 ( radix = 2 ) : 10000001000
String of long int -259115 ( radix = 16 ) : 0xfffc0bd5
String of unsigned long 1234567890 ( radix = 16 ) : 0x499602d2
|
< ecvt ( ) >
ecvt 함수의 일반 형식은 다음과 같다.
형 식 |
char *ecvt ( double value , int count , int *dec , int *sign ) ; |
ecvt ( ) 함수는 double형 변수 value에 저장되어 있는 값을 자리수 count만큼의 길
이에 해당하는 문자열로 변환한다. dec는 10진 정수 부분의 자리수를 나타내고 , sign은
부호를 나타낸다. sign의 값이 0 이면 양수를 의미하고 , 그렇지 않으면 음수를 의미한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdlib.h >
# include < stdio.h >
void main ( void )
{
int decimal , sign ;
char *buffer ;
int precision = 10 ;
double source = 314.15926535 ;
buffer = ecvt ( source , precision , $decimal , &sign ) ;
printf ( " source : %2.10f buffer : ' %s ' decimal : %d sign : %d \n " , source , buffer , decimal , sign ) ;
}
▶ 실행 결과
source : 314.15926535 buffer : ' 31415926584 ' decimal : 3 sign : 0
|
< strtol ( ) , strtoul ( ) , strtod ( ) >
이 함수들의 일반 형식은 다음과 같다.
형 식 |
long strtol ( char *nptr , char **endptr , int base ) ;
unsigned long strtoul ( char *nptr , char **endptr , int base ) ;
double strtod ( char *nptr , char **endptr ) ;
|
*nptr은 변환할 문자열을 가리키는 포인터 변수이고 , **endptr은 변환을 종료할 문
자의 포인터다. base는 사용하고자 하는 수의 밑수( base )를 나타낸다.
strtol ( ) 함수는 *nptr이 가리키는 문자열을 long형 정수로 변환한다. strtoul ( ) 함수
는 *nptr이 가리키는 문자열을 unsigned long형 정수로 변환한다. strtol ( ) 함수와
strtoul ( ) 함수는 숫자로 인식되지 않는 첫 번째 문자를 만나면 숫자 부분까지만 읽어
들이고 종료된다. 또한 null 문자로 끝나거나 밑수( base )보다 크거나 같은 숫자형 문자
가 나오면 종료된다.
strtod ( ) 함수는 *nptr이 가리키는 문자열을 double형 실수 값으로 변환한다.
strtod ( ) 함수는 숫자로 인식되지 않는 첫 번째 문자를 만나면 숫자 부분까지만 읽어들
이고 종료된다 . 또한 null 문자로 끝나면 종료된다 .
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdlib.h >
# include < stdio.h >
void main ( void )
{
char *string , *stopstring ;
double x ;
long l ;
int base ;
unsigned long ul ;
string = " 3.1415926 This stopped it " ;
// 문자열을 double형 실수로 변환
x = strtod ( string , &stopstring ) ;
printf ( " string = %s \n " , string ) ;
printf ( " strtod = %f \n " , x ) ;
printf ( " Stopped scan at : %s \n\n " , stopstring ) ;
// 문자열을 long형 정수로 변환
string = " -314592625 This stopped it " ;
l = strtol ( string , &stopstring , 10 ) ;
printf ( " string = %s \n " , string ) ;
printf ( " strtol = %ld \n " , l ) ;
printf ( " Stopped scan at : %s \n\n " , stopstring ) ;
string = " 10110134932 " ;
printf ( " string = %s \n " , string ) ;
// 문자열을 밑수 2 , 4 , 8인 unsigned long형 정수로 변환
for ( base = 2 ; base <= 8 ; base *= 2 )
{
// 문자열 변환
ul = strtoul ( string , &stopstring , base ) ;
printf ( " strtol = %ld ( base %d ) \n " , ul , base ) ;
printf ( " Stopped scan at : %s \n\n " , stopstring ) ;
}
}
▶ 실행 결과
string = 3.1415926 This stopped it
strtod = 3.141593
Stopped scan at : This stopped it
string = -314592625 This stopped it
strtol = -314592625
Stopped scan at : This stopped it
string = 10110134932
strtol = 45 ( base 2 )
Stopped scan at : 34932
strtol = 4423 ( base 4 )
Stopped scan at : 4932
strtol = 2134108 ( base 8 )
Stopped scan at : 932
|
< toascii ( ) , tolower ( ) , toupper ( ) >
toascii ( ) , tolower ( ) , toupper ( ) 함수는 문자 변환 함수이다. 이들 함수는 < ctype.h >
라는 헤더 파일에 선언되어 있다 일반 형식은 다음과 같다.
형 식 |
int toascii ( int c ) ;
int tolower ( int c ) ;
int toupper ( int c ) ; |
여기서 c 는 변환할 문자나 숫자를 의미한다. toascii ( ) 함수는 주어진 문자를 ASCII
코드 문자로 변환한다. tolower ( ) 함수는 문자 c 가 대문자이면 소문자로 변환한다.
toupper ( ) 함수는 문자 c 가 소문자이면 대문자로 변환한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < ctype.h >
void main ( void )
{
int i ;
printf ( " i toascii ( i ) \t tolower ( i ) \n " ) ;
for ( i = 'A' ; i <= 'Z' ; i++ )
printf ( " %c \t %d \t\t %c \n " , i , toascii ( i ) ,
tolower ( i ) ) ;
printf ( " \n " ) ;
}
▶ 실행 결과
i
|
toascii ( i )
|
tolower ( i )
|
A
|
65
|
a
|
B
|
66
|
b
|
C
|
67
|
c
|
D
|
68
|
d
|
E
|
69
|
e
|
F
|
70
|
f
|
G
|
71
|
g
|
H
|
72
|
h
|
......
|
|
|
X
|
88
|
x
|
Y
|
89
|
y
|
Z
|
90
|
z
|
|
< srand ( ) , rand ( ) >
srand ( ) 와 rand ( ) 함수의 일반 형식은 다음과 같다.
형 식 |
void srand ( unsigned int seed ) ;
int rand ( void ) ;
|
srand ( ) 함수는 임의의 정수를 생성하기 위해 seed 값을 설정해 주는 함수이다. 난
수 생성기를 다시 초기화하려면 seed 값으로 1을 사용한다. srand ( ) 함수가 호출되기
전에 rand ( ) 함수를 호출하면 1에서 seed까지 같은 순서의 값이 생성된다. 따라서 매
번 rand ( ) 함수가 호출될 때마다 새로운 값이 생성되도록 하기 위해서는 srand ( ) 함수
를 rand ( ) 함수가 호출되기 이전에 미리 호출되어야 한다.
rand ( ) 함수는 0 과 RAND _ MAX 사이에 있는 임의의 정수를 반환한다.
0 과 10 사이의 임의의 난수를 5개 출력하는 프로그램을 작성하시오
▶ 프로그램
# include < stdio.h >
# include < stdlib.h >
# include < time.h >
void main ( void )
{
int i ;
// 매시간 값이 다른 임의의 수를 생성하기 위해 현재 시간을 seed 값으로 설정
srand ( ( unsigned ) time ( NULL ) ) ;
// 임의의 난수 5개 생성
for ( i=1 ; i <=5 ; i++ )
printf ( " %d \n " , rand ( ) % 10 ) ;
}
▶ 실행 결과
9
3
6
4
1
|
앞의 결과는 컴퓨터에 따라 다르게 나타날 수 있다 . 위의 프로그램을 다시 한 번
더 실행하여 보자 그러면 매번 실행할 때마다 임의의 다른 수들이 생성됨을 확인할
수 있다.
★ 메모리 할당 함수 ★
프로그램에서 사용할 데이터를 기억하기 위하여 변수나 배열 등을 선언하면 컴파일
러는 선언된 크기만큼의 고정된 메모리 영역을 할당해 준다. 이 영역은 프로그램의 실
행 도중에 늘리거나 줄일 수 없다. 이와 같은 방식의 메모리 할당을 정적 할당 ( static
allocation )이라 한다 .
정적 할당은 메모리를 효율적으로 관리할 수가 없다. 예를 들어 배열을 선언해 놓고
실제 프로그램이 실행될 때 선언된 배열만큼 다 사용하지 않거나 , 필요한 크기보다 배
열을 적게 선언하여 프로그램을 실행하지 못하는 경우가 발생할 수 있다. 이렇게 되면
메모리의 낭비를 초래하거나 필요한 만큼의 메모리 영역을 확보하기 위하여 새로 배열
을 선언하고 다시 컴파일해야 한다. 그러나 필요할 때마다 필요한 만큼 메모리 영역을
확보할 수 있다면 메모리 영역을 매우 효율적으로 이용할 수 있을 것이다. 이와 같이
프로그램의 실행 도중에 필요한 만큼의 메모리 영역을 할당하여 주는 방식을 동적 할
당 ( dynamic allocation )이라 한다.
C 라이브러리는 메모리를 동적으로 할당하거나 해제하는 함수들을 제공한다. 이 함수
들은 일반적으로 < malloc.h > 또는 < stdlib.h >라는 헤더 파일에 선언되어 있다.
[ 표 12-4 ] 메모리 할당 함수
함 수 |
기 능 |
void *calloc ( size_t num , size_t size ) ; |
배열 형식으로 메모리를 할당한다. |
void *malloc ( size_t size ) ; |
히프 ( heap ) 형식으로 메모리를 할당한다. |
void *realloc ( void *memblock , size_t size ) ; |
새로운 크기로 메모리를 재할당한다. |
void free ( void *memblock ) ; |
메모리 블록을 해제한다. |
< malloc ( ) >
malloc ( ) 함수는 메모리를 동적으로 할당해 준다 . 그 형식은 다음과 같다.
형 식 |
void *malloc ( unsigned size ) ; |
malloc ( ) 함수는 size 바이트만큼의 메모리 블록을 동적으로 할당하고 , 블록의 포인
터를 함수의 결과값으로 반환한다. 메모리 할당이 불가능하면 null 값을 반환한다. 함수
값이 void 형의 포인터이므로 할당된 블록에 다른 형의 데이터를 기억시키려면 cast 연
산자를 사용하여 형 변환을 하면 된다.
다름 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < stdlib.h >
void main ( void )
{
int i ;
char *str[ 3 ] ;
for ( i=0 ; i<3 ; i++ )
{
// 15Byte 단위의 블록을 각각 확보한다.
if ( ( str [ i ] = ( char * )malloc( 15 ) ) == NULL )
exit ( 1 ) ;
gets ( str [ i ] ) ;
}
for ( i=0 ; i<3 ; i++ )
{
printf ( " %s \n " , str[ i ] ) ;
free ( str [ i ] ) ;
}
}
▶ 실행 결과
kim huk su
park pang yun
hong gil dong |
입력 데이터 |
kim huk su
park pang yun
hong gil dong |
출력 데이터 |
|
< calloc ( ) >
calloc ( ) 함수는 메모리를 동적으로 할당해 준다 . 그 형식은 다음과 같다.
형 식 |
void *calloc ( unsigned n , unsigned size ) ; |
calloc ( ) 함수는 size 바이트 크기의 요소 n 개를 동적으로 할당하고 , 그 시작 포인터
를 함수의 결과값으로 반환한다. 그리고 확보된 모든 영역을 0( zero )로 초기화한다. 이
함수는 배열을 할당하는 데 주로 사용되며 , size는 sizeof 연산자를 이용하여 지정한다.
메모리 할당이 불가능하면 null 값을 함수의 결과값으로 반환한다.
예를 들어 , int 형 데이터 3개를 동적으로 할당하고 0로 초기화하려면 ,
int *ptr ;
ptr = ( int * ) calloc ( 3 , sizeof ( int ) ) ;
와 같이 선언하면 된다 .
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < string.h >
# include < stdlib.h >
void main ( void )
{
char *ch ;
// 1Byte 단위 크기로 25개의 기억 장소를 확보한다.
ch=( char * )calloc( 25 , sizeof ( char ) ) ;
if ( ch )
{
strcpy ( ch , " 2006 World Cup Fighting " ) ;
printf ( " %s \n " , ch ) ;
free ( ch ) ;
}
else
exit ( 1 ) ;
}
▶ 실행 결과
2006 World Cup Fighting
|
< realloc ( ) >
realloc ( ) 함수의 일반 형식은 다음과 같다.
형 식 |
void *realloc ( void *memblock , unsigned size ) ; |
realloc ( ) 함수는 이미 할당된 메모리 블록의 크기를 변경한다. 인수 memblock은 이
전에 calloc ( ) , malloc ( ) , realloc ( )에 의해 할당된 메모리 블록의 시작 위치를 의미한
다. memblock이 NULL이면 realloc ( ) 함수는 malloc ( ) 함수와 같은 방법으로 새로운
블록 크기의 바이트를 할당한다.
인수 size는 블록의 새로운 크기이다. 이때 새로운 블록의 크기가 기존의 블록 크기
보다 크면 새로운 블록은 새로운 메모리 영역에 할당된다. 따라서 realloc ( )에 의해 반
환되는 포인터는 memblock 인수로 전달되는 포인터와 다를 수 있다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < malloc.h >
# include < stdlib.h >
void main ( void )
{
long *buffer ;
unsigned size ;
if ( ( buffer = ( long * )malloc( 1000 * sizeof ( long ) ) ) == NULL )
exit ( 1 ) ;
size = _msize( buffer ) ;
printf ( " Size of block after malloc of 1000 longs : %u \n " , size ) ;
// 새로운 크기로 재할당한다.
if ( ( buffer = realloc ( buffer , size + ( 1000 * sizeof ( long ) ) ) ) == NULL )
exit ( 1 ) ;
size = _msize ( buffer ) ;
printf ( " Size of block after realloc of 1000 more longs : %u \n " , size ) ;
free ( buffer ) ;
exit ( 0 ) ;
}
▶ 실행 결과
Size of block after malloc of 1000 longs : 4000
Size of block after realloc of 1000 more longs : 8000
|
위 프로그램에서 _msize ( ) 함수는 히트 ( heap )에 할당된 메모리 블록의 크기를 반
환하는 함수이다. 그 형식은 다음과 같다 .
형 식 |
unsigned_msize ( void *memblock ) ; |
이 함수는 헤더 파일 < malloc.h >에 정의되어 있다.
< free ( ) >
free ( ) 함수는 malloc ( ) 함수나 calloc ( ) 함수 등에 의하여 이미 할당된 메모리 블록
을 해제한다. 그 형식은 다음과 같다.
형 식 |
void free ( char *block ) ;
|
여기서 , block은 이미 할당된 메모리 블록을 가리키는 포인터이다.
★ 수학 함수 ★
C 언어의 표준 라이브러리는 로그값 , 제곱근 , 삼각함수 등과 같은 연산을 수행하는
함수들도 제공한다. 이들은 < math.h >라는 헤더 파일에 선언되어 있다. 다음 [ 표 12-5 ]
는 일반적인 수학 함수를 나타낸 것이다.
[ 표 12-5 ] 수학 함수
함 수 |
기 능 |
인수의 형 |
함수의 반환값 형 |
exp ( x )
log ( x )
log10 ( x )
sqrt ( x )
pow ( x , y ) |
지수계산
자연로그 logex
사용로그 log10x
제곱근 계산 |
double
double
double
double
double |
double
double
double
double
double |
sin ( x )
cos ( x )
tan ( x )
asin ( x )
acos ( x )
atan ( x ) |
sin값 x는 radian 값
cosine값 , x는 radian 값
tangent값 , x는 radian 값
arcsine 값
arccosine 값
arctangent 값 |
double
double
double
double
double
double |
double
double
double
double
double
double |
abs ( i )
fabs ( x ) |
정수 i 의 절대값
실수 x 의 절대값 |
int
double |
int
double |
ceil ( x )
floor ( x ) |
실수 x 보다 큰 최소의 정수
실수 x 보다 작은 최대의 정수 |
double
double |
double
double |
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < math.h >
void main ( void )
{
double x , y ;
printf ( " x
sin ( x ) cos ( x ) tan ( x ) \n " ) ;
for ( x=0.0 ; x<=90.0 ; x=x+15.0 )
{
r = x * 3.14159 / 180.0 ;
printf ( " %6.2f
%12.5f %12.5f %12.5f \n " , sin ( r ) , cos ( r ) , tan ( r ) ) ;
}
}
▶ 실행 결과
x
|
sin ( x )
|
cos ( x )
|
tan ( x )
|
0.00
|
0.00000
|
1.00000
|
0.00000
|
15.00
|
0.25882
|
0.96593
|
0.26795
|
30.00
|
0.50000
|
0.86603
|
0.57735
|
45.00
|
0.70711
|
0.70711
|
1.00000
|
60.00
|
0.86602
|
0.50000
|
1.73205
|
75.00
|
0.96593
|
0.25882
|
3.73203
|
90.00
|
1.00000
|
0.00000
|
753695.99514
|
|
1에서 10까지 1씩 증가시키면서 log ( x ) , log10 ( x ) , sqrt ( x )의 값을 구하는 프로그램을 실행 하여 보자
▶ 프로그램
# include < stdio.h >
# include < math.h >
void main ( void )
{
double x ;
printf ( " \t x
log ( x ) log10 ( x ) sqrt ( x ) \n " ) ;
printf ( " ----------------------------------------------------- \n " ) ;
for ( x=1 ; x <=10 ; x++ )
printf ( " %10.5f
%10.5f %10.5f %10.5f \n " , x , log ( x ) , log10 ( x ) , sqrt ( x ) ) ;
printf ( " ----------------------------------------------------- \n " ) ;
}
▶ 실행 결과
x
|
log ( x )
|
log10 ( x )
|
sqrt ( x )
|
--------------------------------------------------------------------------------
|
1.00000
|
0.00000
|
0.00000
|
1.00000
|
2.00000
|
0.69315
|
0.30103
|
1.41421
|
3.00000
|
1.09861
|
0.47712
|
1.73205
|
4.00000
|
1.38629
|
0.60206
|
2.00000
|
5.00000
|
1.60944
|
0.69897
|
2.23607
|
6.00000
|
1.79176
|
0.77815
|
2.44949
|
7.00000
|
1.94591
|
0.84510
|
2.64575
|
8.00000
|
2.07944
|
0.90309
|
2.82843
|
9.00000
|
2.19722
|
0.95424
|
3.00000
|
10.00000
|
2.30259
|
1.00000
|
3.16228
|
-------------------------------------------------------------------------------
|
|
1에서 10까지 1씩 증가시키면서 exp ( x ) , pow ( 10.0 , x )의 값을 구하는 프로그램을 실행해 보자
# include < stdio.h >
# include < math.h >
void main ( void )
{
double x ;
printf ( " \t x \t exp ( x ) \t\t pow ( 10.0 , x ) \n " ) ;
printf ( " -------------------------------------------------------------- \n " ) ;
for ( x=1 ; x<=10 ; x++ )
printf ( " %10.5f %15.5f %20.5f \n " , x , exp ( x ) , pow ( 10.0 , x ) ) ;
printf ( " -------------------------------------------------------------- \n " ) ;
}
▶ 실행 결과
x
|
exp ( x )
|
pow ( 10.0 , x )
|
----------------------------------------------------------------------------
|
1.00000
|
2.71828
|
10.00000
|
2.00000
|
7.38906
|
100.00000
|
3.00000
|
20.08554
|
1000.00000
|
4.00000
|
54.59815
|
10000.00000
|
5.00000
|
148.41316
|
100000.00000
|
6.00000
|
403.42879
|
1000000.00000
|
7.00000
|
1096.63316
|
10000000.00000
|
8.00000
|
2980.95799
|
100000000.00000
|
9.00000
|
8103.08393
|
1000000000.00000
|
10.00000
|
22026.46579
|
10000000000.00000
|
-----------------------------------------------------------------------------
|
|
abs ( -237 ) , fabs ( -182 . 123 )의 값을 구하는 프로그램을 실행해 보자
▶ 프로그램
# include < stdio.h >
# include < math.h >
void main ( void )
{
int a = -237 ;
double b = -182 . 123 ;
printf ( " abs ( %d ) = %d \n " , a , abs ( a ) ) ;
printf ( " fabs ( %f ) = %f \n " , b , fabs ( b ) ) ;
}
▶ 실행 결과
abs ( -237 ) = 237
fabs ( -182 . 123000 ) = 182 . 123000
|
x를 -1.5에서 1.5까지 0.875 간격으로 증가시키면서 ceil ( ) 과 floor ( ) 함수를 구하는 프로
그램을 실행해 보자
▶ 프로그램
# include < stdio.h >
# include < math.h >
void main ( void )
{
double x ;
printf ( " \t x \t ceil ( x ) \t floor ( x ) \n " ) ;
printf ( " --------------------------------------------------- \n " ) ;
for ( x=-1.5 ; x<=1.5 ; x=x+0.875 )
printf ( " %12.5f %12.5f %12.5f \n " , x , ceil ( x ) ,floor ( x ) ) ;
printf ( " --------------------------------------------------- \n " ) ;
}
▶ 실행 결과
x
|
ceil ( x )
|
floor ( x )
|
-------------------------------------------------------------
|
-1.50000
|
-1.00000
|
-2.00000
|
-0.62500
|
0.00000
|
-1.00000
|
0.25000
|
1.00000
|
0.00000
|
1.12500
|
2.00000
|
1.00000
|
-------------------------------------------------------------
|
|
★ 문자 분류 함수 ★
문자가 어떤 종류에 속하는가를 평가하는 여러 가지 매크로 함수가 < ctype.h >라는
헤더 파일에 정의되어 있다. 그 중에서 문자 분류 함수는 [ 표 12-7 ]과 같다.
[ 표 12-7 ] 문자 분류 함수
매크로 |
기 능 |
int isalpha ( int c ) ; |
영문자 ( alphabet )이면 참 ( true ) |
int isalnum ( int c ) ; |
영숫자 ( alphanumeric )이면 참 ( true ) |
int isascii ( int c ) ; |
ASCII 코드 ( 0 ~ 127 )이면 참 ( true ) |
int isdigit ( int c ) ; |
숫자 ( digit )이면 참 ( true ) |
int islower ( int c ) ; |
소문자 ( lowercase )이면 참 ( true ) |
int isupper ( int c ) ; |
대문자 ( uppercase )이면 참 ( true ) |
int isspace ( int c ) ; |
공백 ( space ) , 탭 ( Tab ) , 개행문자 ( \n )이면 참 ( true ) |
int isprint ( int c ) ; |
인쇄가능문자 ( 0x20 ~ 0x7e )이면 참 ( true ) |
int iscntrl ( int c ) ; |
제어문자 ( 0x00 ~ 0x1F or 0x7F )이면 참 ( true ) |
int isxdigit ( int c ) ; |
16진수 ( A ~ F , a ~ f , or 0 ~ 9 )이면 참 ( true ) |
문자 분류 매크로는 결과가 참이면 0( zero )이 아닌 정수 값을 , 거짓이면 0( zero )를 결과
값으로 반환한다.
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < ctype.h >
void main ( void )
{
int ch ;
for ( ch=65 ; ch<=91 ; ch++ )
if ( isuppper ( ch ) )
putchar ( ch ) ;
putchar ( '\n' ) ;
}
▶ 실행 결과
ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < ctype.h >
void main ( void )
{
int c ;
printf ( " Input data : " ) ;
c=getchar ( ) ;
if ( isalnum ( c ) != 0 )
printf ( " \n %c = alphanumeric \n " , c ) ;
else
printf ( " \n %c = Not alphanumeric \n " , c ) ;
}
▶ 실행 결과
Input data : c
c = alphanumeric
|
★ 날짜와 시간 관련 함수 ★
날짜와 시간 관련 함수는 시스템의 현재 시간 몇 날짜에 관한 정보를 얻거나 형식을
변환하거나 , 저장하는 데 사용되는 함수이다 . [ 표 12-8 ]은 이러한 함수들의 종류를 나
타낸 것이다.
[ 표 12-8 ] 날짜 및 시간 관련 함수
함 수 |
기 능 |
asctime ( ) |
날짜와 시간을 ASCII로 변환한다. |
ctime ( ) |
날짜와 시간을 문자열로 변환한다. |
difftime ( t1 , t2 ) |
시간 t2와 시간 t1의 차이를 초 단위로 계산한다. |
_strdate ( ) |
현재 시스템의 날짜를 문자열로 반환한다. |
_strtime ( ) |
현재 시스템의 시간을 문자열로 반환한다. |
time ( ) |
현재 시스템의 시간을 long형으로 반환한다. |
localtime ( ) |
long형으로 저장된 시간을 struct tm형으로 변환한다. |
clock ( ) |
프로세스를 호출하는 데 이용된 프로세스 시간을 계산한다. |
utime ( ) |
파일의 변경 시간을 설정한다. |
형 식 |
long time ( long *timer ) ;
struct tm *localtime ( const long *timer ) ;
char *asctime ( const struct tm *timeptr ) ;
char *ctime ( const long *timer ) ;
long clock ( void ) ;
double difftime ( long timer 1 , long timer 2 ) ;
char *_strdate ( char *datestr ) ;
char *_strtime ( char *timestr ) ;
int utime ( unsigned char *filename , struct _utimbuf *times ) ;
|
구조체 struct tm은 시간 정보를 저장하고 검색하기 위해 asctime ( ) , gmtime ( ) ,
localtime ( ) , mktime ( ) , strftime ( )에 사용되며 , 헤더 파일 < time.h >에 정의되어 있다.
struct tm은 다음과 같이 정의되어 있다.
struct tm
{
int tm_sec ; // 초 [ 0 , 59 ]
int tm_min ; // 분 [ 0 , 59 ]
int tm_hour ; // 시 [ 0 , 23 ]
int tm_mday ; // 일 [ 1 , 31 ]
int tm_mon ; // 월 ( 0 - 11 ; january = 0 )
int tm_year ; // 년 ( 1900 ~ )
int tm_wday ; // 요일 ( 0 - 6 , Sunday = 0 )
int tm_yday ; // Day of year ( 0 - 365 , January 1 = 0 )
int tm_isdst ;
// 시간을 저장하기 위한 간격
} ;
|
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < time.h >
# include < stdio.h >
struct tm *newtime ;
long aclock ;
void main ( void )
{
time ( &aclock ) ;
newtime = localtime ( &aclock ) ;
// 현재 시스템 시간을 struct tm 형태로 변경
// 현재 시스템 시간을 문자열로 출력
printf ( " The current date and time are : %s " , asctime
( newtime ) ) ;
}
▶ 실행 결과
The current date and time are : Wed Jan 08 10 : 37 : 18 2003
|
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < stdlib.h >
# include < sys\types.h >
# include < sys \ utime.h >
void main ( void )
{
system ( " dir Ex 12-27.c " ) ;
if ( utime ( " Ex 12-27.c " , NULL ) == -1 )
perror ( " utime failed \n " ) ;
else
printf ( " File time modified \n " ) ;
system ( " dir Ex 12-27.c " ) ;
}
▶ 실행 결과
Volume in drive C is PROGRAM
Volume Serial Number is E02C - 9FE2 |
|
Directory of C : \ code |
|
2003-01-08 10 : 41p 451 Ex 12-27.c |
1 File ( s ) 451 bytes
|
83,320,832 bytes free
|
Volume in drive C is PROGRAM
Volume Serial Number is E02C - 9FE2
|
|
Directory of C : \ dolphin \ crt \ code |
|
2003-01-08 10 : 43p 451 Ex 12-27.c |
1 File ( s ) 451 bytes
|
83,320,832 bytes free
|
File time modified |
|
위의 결과는 컴퓨터에 따라 다르게 나타날 수 있다 . utime ( ) 함수는 헤더 파일
< sys \ utime.h >에 정의되어 있다.
다음 프로그램의 실해 결과를 나타내시오
▶ 프로그램
# include < time.h >
# include < stdio.h >
# include < sys \ types.h >
# include < sys \ timeb.h >
# include < string.h >
void main ( void )
{
char tmpbuf[ 128 ] , ampm[ ] = " AM " ;
long ltime ;
struct tm *today , *gmt , xmas = { 0 , 0 , 12 , 25 , 11 , 93 } ;
// 현재 시스템 시간 출력
_strtime ( tmpbuf ) ;
printf ( " OS time : \t\t\t\t %s \n " , tmpbuf ) ;
// 현재 시스템 날짜 출력
_strdate ( tmpbuf ) ;
printf ( " OS date : \t\t\t\t %s \n " , tmpbuf ) ;
// UNIX - style의 시간과 날짜 출력
time ( & ltime ) ;
printf ( " Time in seconds since UTC 1/1/70 : \t %ld \n " , ltime ) ;
printf ( " UNIX time and date : \t\t\t %s , ctime ( & ltime ) ) ;
/* UTC 표시 */
gmt = gmtime ( & ltime ) ;
printf ( " Coordinated universal time : \t\t %s " , asctime ( gmt ) ) ;
// 시간 구조체로 변경
today = localtime ( & ltime ) ;
if ( today -> tm_hour > 12 )
{
strcpy ( ampm , " PM " ) ;
today -> tm_hour -= 12 ;
}
if ( today -> tm_hour == 0 )
today -> tm_hour = 12 ;
printf ( " 12 - hour time : \t\t\t\t % .8s %s \n " , asctime ( today ) + 11 , ampm ) ;
}
▶ 실행 결과
OS time : |
10 : 56 : 50 |
OS date : |
01 / 08 / 03 |
Time in seconds since UTC 1/1/70 : |
1041991010 |
UNIX time and date : |
Wed Jan 08 10 : 56 : 50 2003 |
Coordinated universal time : |
Wed Jan 08 01 : 56 : 50 2003 |
12 - hour time : |
10 : 56 : 50 AM |
|
다음 프로그램의 실행 결과를 나타내시오
▶ 프로그램
# include < stdio.h >
# include < stdlib.h >
# include < time.h >
void main ( void )
{
long start , finish ; // 테스트 시작 시간 , 종료 시간
long loop ;
// 반복 횟수
double result , elapsed_time ;
time ( &start ) ;
printf ( " Start time : %s " , asctime ( localtime ( & start ) ) ) ;
printf ( " 수초간 걸릴 수 있습니다 ! .......... \n " ) ;
for ( loop = 0 ; loop < 1000000000 ; loop++ )
result = 3.63 * 5.27 ;
time ( & finish ) ;
printf ( " Finish time : %s " , asctime ( localtime ( &finish ) ) ) ;
elapsed_time = difftime ( finish , start ) ;
printf (" \n Program takes %6.0f seconds \n " ,elapsed_time ) ;
}
▶ 실행 결과
Start time : Wed Jan 08 11 : 10 : 02 2003
수초간 걸릴 수 있습니다 ! .........
Finish time : Wed Jan 08 11 : 10 : 09 2003
Program takes
7 seconds .
|