[ 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 .