Sổ tay thư viện hàm ngôn ngữ C

Thư viện hàm ngôn ngữ lập trình C
http://vncoding.net/ Page 1
Title: Thư viện hàm ngôn ngữ lập trình C
Author: Vu Hong Viet
Date: 09/11/2014
<Tài liệu tham khảo từ diễn đàn: http://vncoding.net/thu-vien-ham-ngon-ngu-c/)

<assert.h>
void assert( int expression);
Parameters:
expression: biểu thức đầu vào (có thể là con trỏ)
Remark:
Hàm assert( ) được sử dụng để đánh giá biểu thức và phát hiện lỗi logic trong khâu
coding bằng cách đánh giá biểu thức đầu vào.
- Nếu biểu thức đầu vào có giá trị là false (0), hàm assert( ) sẽ in ra thông báo lỗi,
sau đó gọi hàm abort( ) để kết thúc chương trình
- Nếu biểu thức đầu vào có giá trị là true (1), hàm assert() sẽ không làm gì
(chương trình vẫn thực hiện như bình thường)
- Định dạng của thông báo lỗi phụ thuộc ứng dụng gọi hàm assert( ).
 Nếu là Console application thì thông báo lỗi sẽ được hiển thị lên màn hình
console như khi chúng ta sử dụng lệnh printf( ).
(Để xem thêm các bài tập C console application, bạn hãy truy cập link sau:
http://vncoding.net/bai-tap-lap-trinh-cc/ gồm hơn 1000 bài tập lập trình C
hữu ích cho bạn ôn luyện).
 Nếu là ứng dụng Win32 (ứng dụng có giao diện window), thì hàm assert( ) sẽ
gọi hàm MessageBox( ) hiển thị 1 cửa sổ message box với button “OK”. Nếu
bạn click vào button “OK”, ứng dụng Win32 của bạn sẽ kết thúc ngay lập tức.
(Để xem them các bài tập lập trình Win32, bạn hãy truy cập link sau:
http://vncoding.net/lap-trinh-win32-api/ , hy vọng sẽ giúp ích nhiều cho
các bạn).
Ví dụ: Trong đoạn code dưới đây, hàm analyze_string( ) gọi hàm assert( ) để kiểm
tra các điều kiện của string đầu vào ( con trỏ NULL, string là rỗng, chiều dài string
phải lớn hơn 2). Nếu 1 trong các điều kiện này trả về false, thì message lỗi tương
ứng sẽ được chỉ ra.

#include <stdio.h>
#include <conio.h>
#include <assert.h>
#include <string.h>
void analyze_string( char *string ); // Prototype
int main( void )
{
char test1[] = "abc", *test2 = NULL, test3[] = "";
printf ( "Analyzing string '%s'n", test1 );
fflush( stdout );
analyze_string( test1 );
fflush( stdout );
fflush( stdout );
getch();
}
// Tests a string to see if it is NULL,
// empty, or longer than 0 characters.
void analyze_string( char * string )
{
assert( string != NULL ); // Cannot be NULL
assert( *string != '0' ); // Cannot be empty
assert( strlen( string ) > 2 ); // Length must exceed 2
}
Kết quả:
Analyzing string 'abc'
Analyzing string '(null)'
Analyzing string ''

<ctype.h>
int isalnum(int c);
Parameter:
c : tham số đầu vào kiểu int
Remark:
Hàm isalnum( ) kiểm tra tham số c. Nếu c là kiểu alphanumberic ( nằm trong dải A
– Z, a – z, 0 – 9), hàm isalnum( ) giá trị khác 0. Còn c không thuộc các dải trên thì
hàm sẽ trả về giá trị 0.
Ví dụ:kiểm tra số nguyên c1 và c2 có phải là alphanumberic không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 45, c2 = 97;
if(isalnum(c1))
printf("nc1 is alphanumberic");
else
printf("nc1 is NOT alphanumberic");
if(isalnum(c2))
printf("nc2 is alphanumberic");
else
printf("nc2 is NOT alphanumberic");
getch();
}
Kết quả:
c1 is NOT alphanumberic
c2 is alphanumberic

int isalpha(int c);
Parameter:
Remark:
Hàm isalpha( ) sẽ kiểm tra tham số c. Nếu c là chữ cái (nằm trong dải A – Z, a – z),
thì hàm sẽ trả về giá trị khác 0. Còn nếu c là không phải là chữ cái, hàm sẽ trả về giá
trị 0.
Ví dụ: kiểm tra c1 = 48 (số 0 trong bảng mã ASCII), c2 = 97 (kí tự ‘a’).
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 48; // digit 0
int c2 = 97; // character 'a'
if(isalpha(c1))
printf("nc1 is alphabet");
else
printf("nc1 is NOT alphabet");
if(isalpha(c2))
printf("nc2 is alphabet");
else
printf("nc2 is NOT alphabet");
getch();
}
Kết quả:
c1 is NOT alphabet
c2 is alphabet

int iscntrl(int c);
Parameter:
Remark:
Hàm iscntrl( ) kiểm tra tham số c. Nếu c là kí tự điều khiển (nằm từ 0x00 – 0x1F,
0x7F), hàm sẽ trả về giá trị khác 0. Và nếu c không phải là kí tự điều khiển, hàm sẽ
trả về giá trị 0.
Ví dụ: kiểm tra c1 = 10 và c2 = 19 có phải là kí tự điều khiển không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 10, c2 = 19;
if(iscntrl(c1))
printf("nc1 is control character");
else
printf("nc1 is NOT control character");
if(iscntrl(c2))
printf("nc2 is control character");
else
printf("nc2 is NOT control character");
getch();
}
Kết quả:
c1 is control character
c2 is control character

int isdigit(int c);
Parameter:
Remark:
Hàm isdigit( ) kiểm tra tham số c. Nếu c là số thập phân(0 – 9), hàm sẽ trả về giá trị
khác 0. Và nếu c không phải là số thập phân, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 50 và c2 = 54 có phải là số thập phân không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 50, c2 = 54;
if(isdigit(c1))
printf("nc1 is decimal digit");
else
printf("nc1 is NOT decimal digit");
if(isdigit(c2))
printf("nc2 is decimal digit");
else
printf("nc2 is NOT decimal digit");
getch();
}
Kết quả:
c1 is decimal digit
c2 is decimal digit

int isgraph(int c);
Parameter:
Remark:
Hàm isgraph( ) kiểm tra tham số c. Nếu c là kí tự có thể in được(từ 0x21 – 0x7E),
hàm sẽ trả về giá trị khác 0. Và nếu c không phải là kí tự in được, hàm sẽ trả về giá
trị 0.
Ví dụ: kiểm tra c1 = 40 (kí tự @) và c2 = 7 (tiếng chuông) có phải là kí tự in được
không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 40; // character '@'
int c2 = 7; // bell sound
if(isgraph(c1))
printf("nc1 is printable character");
else
printf("nc1 is NOT printable character");
if(isgraph(c2))
printf("nc2 is printable character");
else
printf("nc2 is NOT printable character");
getch();
}
Kết quả:
c1 is printable character
c2 is NOT printable character

int islower(int c);
Parameter:
Remark:
Hàm islower( ) kiểm tra tham số c. Nếu c là kí tự in thường(a – z), hàm sẽ trả về giá
trị khác 0. Và nếu c không phải là kí tự in thường, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 97 và c2 = 65 có phải là kí tự in thường không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c2 = 65; // character 'A'
if(islower(c1))
printf("nc1 is lowercase character");
else
printf("nc1 is NOT lowercase character");
if(islower(c2))
printf("nc2 is lowercase character");
else
printf("nc2 is NOT lowercase character");
getch();
}
Kết quả:
c1 is lowercase character
c2 is NOT lowercase character

int isupper(int c);
Parameter:
Remark:
Hàm isupper( ) kiểm tra tham số c. Nếu c là kí tự in hoa(A – Z), hàm sẽ trả về giá trị
khác 0. Và nếu c không phải là kí tự in hoa, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 97 và c2 = 65 có phải là kí tự in hoa không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c2 = 65; // character 'A'
if(isupper(c1))
printf("nc1 is uppercase character");
else
printf("nc1 is NOT uppercase character");
if(isupper(c2))
printf("nc2 is uppercase character");
else
printf("nc2 is NOT uppercase character");
getch();
}
Kết quả:
c1 is NOT uppercase character
c2 is uppercase character

int isprint(int c);
Parameter:
Remark:
Hàm isprint( ) kiểm tra tham số c. Nếu c là kí tự in được (từ 0x20 – 0x7E), hàm sẽ
trả về giá trị khác 0. Và nếu c không phải là kí tự in được, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 32 và c2 = 69 có phải là kí tự in được không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 32; // character space
int c2 = 69; // character 'E'
if(isprint(c1))
printf("nc1 is printing character");
else
printf("nc1 is NOT printing character");
if(isprint(c2))
printf("nc2 is printing character");
else
printf("nc2 is NOT printing character");
getch();
}
Kết quả:
c1 is printing character
c2 is printing character

int ispunct(int c);
Parameter:
Remark:
Hàm ispunct( ) kiểm tra tham số c. Nếu c là kí tự in được (từ 0x20 – 0x7E, ngoại trừ
kí tự space, chữ cái và chữ số), hàm sẽ trả về giá trị khác 0. Và nếu c không phải là
kí tự in được, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 32 và c2 = 69 có phải là kí tự punctuation không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c2 = 69; // character 'E'
if(ispunct(c1))
printf("nc1 is punctuation character");
else
printf("nc1 is NOT punctuation character");
if(ispunct(c2))
printf("nc2 is punctuation character");
else
printf("nc2 is NOT punctuation character");
getch();
}
Kết quả:
c1 is NOT punctuation character
c2 is NOT punctuation character

int isspace(int c);
Parameter:
Remark:
Hàm isspace ( ) kiểm tra tham số c. Nếu c là kí tự trắng (từ 0x09 – 0x0D, 0x20 là
các kí tự: space, formfeed, newline, carriage return, tab, vertical tab), hàm sẽ trả về
giá trị khác 0. Và nếu c không phải là kí tự in được, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 32 và c2 = 9 có phải là kí tự trắng không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c2 = 9; // horizontal tab
if(isspace(c1))
printf("nc1 is space character");
else
printf("nc1 is NOT space character");
if(isspace(c2))
printf("nc2 is space character");
else
printf("nc2 is NOT space character");
getch();
}
Kết quả:
c1 is space character
c2 is space character

int isxdigit(int c);
Parameter:
Remark:
Hàm isxdigit ( ) kiểm tra tham số c. Nếu c là chữ số hexa(A – F, a – f, 0 - 9), hàm sẽ
trả về giá trị khác 0. Và nếu c không phải là chữ số hexa, hàm sẽ trả về giá trị 0.
Ví dụ: kiểm tra c1 = 68 và c2 = 71 có phải là chữ số hexa không?
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c1 = 68; // character 'D'
int c2 = 71; // character 'G'
if(isxdigit(c1))
printf("nc1 is hexadecimal digit ");
else
printf("nc1 is NOT hexadecimal digit");
if(isxdigit(c2))
printf("nc2 is hexadecimal digit ");
else
printf("nc2 is NOT hexadecimal digit ");
getch();
}
Kết quả:
c1 is hexadecimal digit
c2 is NOT hexadecimal digit

int tolower(int c);
Parameter:
c : kí tự đầu vào để convert thành kí tự in thường
Remark:
Hàm tolower ( ) kiểm tra tham số c và convert kí tự c thành kí tự in thường. Nếu c là
kí tự in hoa, hàm sẽ trả về kí tự in thường. Để đảm bảo hàm tolower( ) trả về kết quả
mong muốn, chúng ta cần dùng hàm isupper( ) để kiểm tra kí tự cần convert là kí tự
in hoa.
Ví dụ:
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c = 68; // character 'D'
if(isupper(c))
{
printf("n%c is uppercase character", c);
printf("n%c is converted into lowercase: %c",c,
tolower(c));
}
else
{
printf("n%c is not uppercase character", c);
}
getch();
}
Kết quả:
D is uppercase character
D is converted into lowercase: d

int toupper( int c );
Parameter:
c : kí tự đầu vào để convert thành kí tự in hoa
Remark:
Hàm toupper ( ) kiểm tra tham số c và convert kí tự c thành kí tự in hoa. Nếu c là kí
tự in thường, hàm sẽ trả về kí tự in hoa. Để đảm bảo hàm toupper( ) trả về kết quả
mong muốn, chúng ta cần dùng hàm islower( ) để kiểm tra kí tự cần convert là kí tự
in thường.
Ví dụ:
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
void main()
{
int c = 97; // character 'a'
if(islower(c))
{
printf("n%c is lowercase character", c);
printf("n%c is converted into uppercase: %c",c,
toupper(c));
}
else
{
printf("n%c is not lowercase character", c);
}
getch();
}
Kết quả:
a is lowercase character
a is converted into uppercase: A

<math.h>
double exp(double x);
Parameter:
x: giá trị double
Remark:
Hàm exp( ) sẽ trả về giá trị e mũ x, nếu thành công.
- Nếu tràn trên (overflow), hàm sẽ trả về INF.
- Nếu tràn dưới (underflow), hàm sẽ trả về 0
Ví dụ:
#include <math.h>
#include <stdio.h>
#include <conio.h>
void main( void )
{
double x = 2.302585093, y;
y = exp( x );
printf( "exp( %f ) = %fn", x, y );
getch();
}
Kết quả:
exp( 2.302585 ) = 10.000000

double log(double x);
double log10(double x);
Parameter:
x: giá trị double
Remark:
Hàm log( ) tính logarit giá trị x.
- Hàm log( ) sẽ trả về giá trị logarit cơ số e (ln(x)) của x, nếu thành công
- Hàm log10( ) sẽ trả về logarit cơ số 10 của x, nếu thành công.
- Hàm log( ), log10() sẽ trả về giá trị không xác định, nếu x < 0.
- Hàm log( ), log10() sẽ trả về giá trị INF, nếu x = 0.
Ví dụ:
#include <math.h>
#include <stdio.h>
#include <conio.h>
void main( void )
{
double x = 9.0;
double y;
y = log( x );
printf( "log( %.2f ) = %fn", x, y );
y = log10( x );
printf( "log10( %.2f ) = %fn", x, y );
getch();
}
Kết quả:
log( 9.00 ) = 2.197225
log10( 9.00 ) = 0.954243

double pow(double x, double y);
Parameter:
x: cơ số
y: số mũ
Remark:
Hàm sẽ trả về giá trị x^y. Nếu có tràn trên hoặc tràn dưới, hàm sẽ không thông báo
message lỗi.
- x > 0 hoặc x < 0 và y = 0, Hàm trả về giá trị 1
- x = 0 và y = 0, hàm trả về giá trị 1
- x = 0 và y < 0, hàm trả về INF
Ví dụ:
#include <math.h>
#include <stdio.h>
#include <conio.h>
void main( void )
{
double x = 2.0, y = 3.0, z;
z = pow( x, y );
printf( "%.1f to the power of %.1f is %.1fn", x, y, z );
getch();
}
Kết quả:
2.0 to the power of 3.0 is 8.0

double sqrt(double x);
Parameter:
x: giá trị không âm
Remark:
Hàm sqrt( ) sẽ trả về căn bậc 2 của x. Nếu x < 0, hàm sẽ trả về giá trị không xác định
NaN.
Ví dụ:
#include <math.h>
#include <stdio.h>
#include <conio.h>
int main( void )
{
double question = 45.35, answer;
answer = sqrt( question );
if( question < 0 )
printf( "Error: sqrt returns %fn", answer );
else
printf( "The square root of %.2f is %.2fn",
question, answer );
getch();
}
Kết quả:
The square root of 45.35 is 6.73

double ceil(double x);
Parameter:
X: giá trị double
Remark:
Hàm ceil( ) trả về giá trị nguyên nhỏ nhất, lớn hơn hoặc bằng x
Ví dụ:
#include <math.h>
#include <stdio.h>
#include <conio.h>
int main( void )
{
double question = 45.35, answer;
answer = ceil( question );
printf("nceil(%.3f) = %.2f", question, answer);
getch();
}
Kết quả:
ceil(45.350) = 46.00

double floor(double x);
Parameter:
X: tham số đầu vào double
Remark:
Hàm floor( ) trả về giá trị lớn nhất và nhỏ hơn hoặc bằng x.
Ví dụ:
#include <math.h>
#include <conio.h>
#include <stdio.h>
void main( void )
{
double y;
y = floor( 2.8 );
printf( "The floor of 2.8 is %fn", y );
y = floor( -2.8 );
printf( "The floor of -2.8 is %fn", y );
y = ceil( 2.8 );
printf( "The ceil of 2.8 is %fn", y );
y = ceil( -2.8 );
printf( "The ceil of -2.8 is %fn", y );
getch();
}
Kết quả:
The floor of 2.8 is 2.000000
The floor of -2.8 is -3.000000
The ceil of 2.8 is 3.000000
The ceil of -2.8 is -2.000000

double fabs(double x);
Paramter:
x: tham số đầu vào double
Remark:
Hàm fabs( ) trả về giá trị tuyệt đối của x.
Ví dụ:
#include <math.h>
#include <conio.h>
#include <stdio.h>
void main( void )
{
double y;
y = fabs(-9.5);
printf("nAbsolute value of -9.5 is: %.2f", y);
getch();
}
Kết quả:
Absolute value of -9.5 is: 9.50

double ldexp(double x, int exp);
Parameter:
x: cơ số
exp: số mũ
Remark:
Hàm ldexp( ) trả về tích x nhân với 2^exp.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
int main( void )
{
double x = 4.0, y;
int p = 3;
y = ldexp( x, p );
printf( "%2.1f times two to the power of %d is %2.1fn",
x, p, y );
getch();
}
Kết quả:
4.0 times two to the power of 3 is 32.0

double frexp(double x,int *expptr);
Parameter:
expptr: Con trỏ trỏ tới vùng nhớ lưu giá trị mũ ( exponent)
Remark:
- Hàm frexp( ) chia nhỏ số dấu phẩy động x thành mantissa (m) và exponent( n).
Trong đó, giá trị tuyệt đối của m ( 0.5 <= m < 1.0) và x = m*2^n. Số mũ n
exponent được lưu tại vùng nhớ được trỏ tới bởi con trỏ expptr
- Hàm frexp( ) trả về phần mantissa. Nếu x = 0, mantissa và exponent đều bằng 0.
Nếu expptr = NULL, thì đầu vào không hợp lệ.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
int main( void )
{
double x, y;
int n;
x = 16.4;
y = frexp( x, &n );
printf( "frexp( %f, &n ) = %f, n = %dn", x, y, n );
getch();
}
Kết quả:
frexp( 16.400000, &n ) = 0.512500, n = 5

double modf( double x, double *intptr);
Parameter:
intptr: con trỏ trỏ tới vùng nhớ lưu giá trị phân nguyên
Remark:
Hàm modf( ) chia số x thành 2 phần: phần nguyên và phần thập phân. Hàm trả về
giá trị phần thập phân, phần nguyên được trỏ bởi intptr.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
int main( void )
{
double x, y, n;
x = -14.87654321; /* Divide x into its fractional */
y = modf( x, &n ); /* and integer parts */
printf( "For %f, the fraction is %f and the integer
is %.fn",
x, y, n );
getch();
}
Kết quả:
For -14.876543, the fraction is -0.876543 and the integer is -14

double fmod(double x, double y);
Parameter:
x, y: tham số đầu vào double
Remark:
- Hàm fmod( ) trả về phần dư của phép chia x/y. Nếu y = 0, hàm sẽ trả về NaN.
- Hàm fmod( ) tính phần dư f của phép chia x/y. x = i*y + f (trong đó: i là số
nguyên)
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
int main( void )
{
double w = -10.0, x = 2.6, z;
z = fmod( w, x );
printf( "The remainder of %.2f / %.2f is %fn", w, x,
z );
getch();
}
Kết quả:
The remainder of -10.00 / 2.60 is -2.200000

double sin( double x );
double cos( double x );
double tan( double x);
Parameter:
x: góc (radian)
Remark:
Hàm trả về sin(x), cos(x), tan(x).
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
void main( void )
{
double pi = 3.1415926535;
double x, y;
x = pi / 2;
y = sin( x );
printf( "sin( %f ) = %fn", x, y );
y = cos( x );
printf( "cos( %f ) = %fn", x, y );
y = tan( x );
printf( "tan( %f ) = %fn",x, y );
getch();
}
Kết quả:
sin( 1.570796 ) = 1.000000
cos( 1.570796 ) = 0.000000
tan( 1.570796 ) = 22273405433.954350

double asin( double x );
double acos( double x );
double atan( double x );
Parameter:
x: giá trị cần tính acsin, accos, actan.
Remark:
Giá trị đầu vào x ( -1 <= x <= 1). Nếu x > 1 hoặc x < -1, hàm asin( ) và acos( ) trả
về giá trị INVALID.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
void main( void )
{
double x = -1.0, y;
y = asin( x );
printf( "asin( %f ) = %fn", x, y );
y = acos( x );
printf( "acos( %f ) = %fn", x, y );
y = atan( x );
printf( "atan( %f ) = %fn",x, y );
getch();
}
Kết quả:
asin( -1.000000 ) = -1.570796
acos( -1.000000 ) = 3.141593
atan( -1.000000 ) = -0.785398

double atan2(double y, double x);
Parameter:
x, y: góc (radian)
Remark:
Hàm atan2( ) tính arctan của x/y.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
void main( void )
{
double x = 1.0, y = 4.5;
printf( "atan2( %.2f, %.2f ) = %fn", x, y, atan2(x, y));
getch();
}
Kết quả:
atan2( 1.00, 4.50 ) = 0.218669

double sinh(double x);
double cosh(double x);
double tanh(double x);
Parameter:
x: góc (radian)
Remark:
Các hàm trên trả về hypebol sin, cos, tan của x.
Ví dụ:
#include <math.h>
#include "conio.h"
#include <stdio.h>
void main( void )
{
double pi = 3.1415926535;
double x, y;
x = pi / 2;
y = sinh( x );
printf( "sinh( %f ) = %fn",x, y );
y = cosh( x );
printf( "cosh( %f ) = %fn",x, y );
y = tanh( x );
printf( "tanh( %f ) = %fn", x, y );
getch();
}
Kết quả:
sinh( 1.570796 ) = 2.301299
cosh( 1.570796 ) = 2.509178
tanh( 1.570796 ) = 0.917152

<stdio.h>
Hàm nhập xuất dữ liệu từ bàn phím
int printf( const char *format [, argument]... );
Parameter:
format: string cần in ra
argument: biến tùy chọn
%d hoặc %i : in ra số nguyên
%u : in ra số nguyên không dấu
%o : in ra số hệ 8 (octal)
%x hoặc %X : in ra số hê 16 (hexa)
%f : in ra số dấu phẩy động
%c : in ra kí tự
%s : in ra string
%e hoặc %E: in dạng M*e^x
Một số kí tự đặc biệt:
‘/n’ : kí tự xuống dòng
‘/t’ : kí tự cách ra 1 tab (4 space)
‘/r’ : kí tự trở về đầu dòng in
‘/b’: kí tự lùi con trỏ màn hình về sau 1 kí tự
Remark:
- Hàm printf( ) in các kí tự và giá trị ra đầu ra chuẩn ( màn hình console).
- Hàm printf( ) trả về số lượng kí tự in ra màn hình thành công

Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
int x = 14;
char s[] = "vncoding.net";
char name[] = "VuHongViet";
int age = 25;
printf("nHello Everybody");
printf("nx = %d", x);
printf("nx = %x", x);
printf("nx = %o", x);
printf("nx = %e", x);
printf("nMy forum is: %s", s);
printf("nMy name's: %s. I'm %d age", name, age);
getch();
}
Kết quả:
Hello Everybody
x = 14
x = e
x = 16
x = 3.436183e-305
My forum is: vncoding.net
My name's: VuHongViet. I'm 25 age

int putchar(int c);
Paramter:
c : mã ASCII của kí tự muốn ghi ra màn hình
Remark:
Hàm trả về kí tự được ghi thành công. Nếu gặp lỗi hàm sẽ trả về mã EOF
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
putchar(65);
putchar('a');
getch();
}
Kết quả:
Aa

int puts(const char *str);
Parameter:
str: string muốn ghi ra
Remark:
Hàm puts( ) ghi ra màn hình string.
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
puts("vncoding forum");
getch();
}
Kết quả:
vncoding forum

Hàm nhập dữ liệu
int scanf(const char *format [,argument]...);
Parameter:
format: định dạng nhập dữ liệu
argument: biến tùy chọn (giống như hàm printf( ))
Remark:
- Hàm scanf( ) đọc dữ liệu từ đầu vào và lưu giá trị này vào các biến.
- Hàm scanf( ) trả về số lượng trường dữ liệu được đọc vào thành công.
Ví dụ: Khai báo biến nguyên n, nhập giá trị cho biến n từ bàn phím.
#include "conio.h"
#include <stdio.h>
void main( void )
{
int n;
scanf("%d", &n); // 4
printf("n = %d", n);
getch();
}
Kết quả:
4
n = 4

int sscanf(const char *buffer, const char
*format[,argument ] ...);
Parameter:
buffer: lưu dữ liệu đầu vào
format: string định dạng dữ liệu
argument: biến tùy chọn (giống như hàm printf( ))
Remark:
- Hàm sscanf( ) đọc đữ liệu theo định dạng từ string đầu vào và lưu vào các biến.
- Hàm trả về số trường dữ liệu được đọc thành công
- Hàm trả về EOF nếu xảy ra lỗi hoặc kết thúc buffer đầu vào
- Hàm trả về -1 nếu buffer đầu vào NULL
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
char tokenstring[] = "15 12 14...";
char s[81];
char c;
int i;
float fp;
// Input various data from tokenstring:
// max 80 character string:
sscanf( tokenstring, "%80s", s ); // C4996
sscanf( tokenstring, "%c", &c ); // C4996
sscanf( tokenstring, "%d", &i ); // C4996
sscanf( tokenstring, "%f", &fp ); // C4996
// Note: sscanf is deprecated; consider using sscanf_s
instead
// Output the data read
printf( "String = %sn", s );
printf( "Character = %cn", c );

printf( "Integer: = %dn", i );
printf( "Real: = %fn", fp );
getch();
}
Kết quả:
String = 15
Character = 1
Integer: = 15
Real: = 15.000000

int getchar();
Parameter:
void
Remark:
- Hàm getchar( ) đọc 1 kí tự đầu vào ( bàn phím).
- Hàm trả về kí tự đọc được, nếu đọc thành công
- Hàm trả về EOF nếu xảy ra lỗi
Ví dụ: đọc kí tự từ bàn phím đến khi nhập vào kí tự ‘q’ thì kết thúc.
#include "conio.h"
#include <stdio.h>
void main( void )
{
char c;
// read character until input is 'q'
while((c = getchar()) != 'q')
{
fflush(stdin);
printf("nc = %cn", c);
}
getch();
}
Kết quả:
1
c = 1
a
c = a
p
c = p
q

char *gets(char *buffer);
Parameter:
buffer: con trỏ kiểu char lưu string đầu vào
Remark:
Hàm gets( ) đọc string từ đầu vào stdin (bàn phím) và lưu nó trong buffer.
- Hàm gets( ) trả về con trỏ trỏ tới vùng nhớ lưu string, nếu đọc thành công
- Hàm gets() trả về NULL, nếu đọc không thành công
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
char line[21]; // room for 20 chars + '0'
gets( line ); // C4996
// Danger: No way to limit input to 20 chars.
// Consider using gets_s instead.
printf( "The line entered was: %sn", line );
getch();
}
Kết quả:
vu hong viet
The line entered was: vu hong viet

int fflush( FILE *stream );
Parameter:
stream: con trỏ file
Remark:
- Hàm fflush( ) “làm sạch” stream( stdin: đầu vào, stdout: đầu vào).
- Hàm fflush( ) trả về 0, nếu stream được “làm sạch” thành công. Và trả về EOF
nếu lỗi xuất hiện.
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
int integer;
char string[81];
// Read each word as a string.
printf( "Enter a sentence of four words with scanf: " );
for( integer = 0; integer < 4; integer++ )
{
scanf( "%s", string, sizeof(string) );
printf( "%sn", string );
}
// You must flush the input buffer before using gets.
// fflush on input stream is an extension to the C
standard
fflush( stdin );
printf( "Enter the same sentence with gets: " );
gets(string);
printf( "%sn", string );
getch();
}
Kết quả:

Enter a sentence of four words with scanf: this is a test
this
is
a
test
Enter the same sentence with gets: this is a test
this is a test

Hàm thao tác file
FILE *fopen( const char *filename,const char *mode);
Parameter:
filename: tên file (bao gồm cả đường dẫn tới file)
mode: các chế độ open khác nhau
“r” : mở để đọc. Nếu file không tồn tại hoặc không tìm thấy file, hàm fopen() trả về
NULL.
“w” : mở để ghi. Nếu file đã tồn tại thì nội dung trong file sẽ bị xóa.
“a” : mở để ghi tiếp vào cuối file. Nếu file không tồn tại, file sẽ được tạo mới
“r+”: mở để đọc và ghi. Điều kiện: file phải tồn tại
“w+” : mở file trống để đọc và ghi. Nếu file đã tồn tại, nội dung sẽ bị xóa.
“a+” : mở để đọc và ghi tiếp vào cuối file. Sẽ tạo file mới nếu file không tồn tại
Remark:
- Hàm fopen( ) dùng để mở file để đọc/ghi/
- Hàm fopen( ) sẽ trả về con trỏ FILE nếu mở thành công, và trả về NULL nếu xảy
ra lỗi (không tìm thấy file, file không tồn tại,..)
Ví dụ:
#include "conio.h"
#include <stdio.h>
void main( void )
{
FILE *stream, *stream2;
//Open for reading
if( (stream = fopen( "vncoding.c", "r" )) == NULL )
printf( "The file 'vncoding.c' was not openedn" );
else
printf( "The file 'vncoding.c' was openedn" );

// Open for write
if( (stream2 = fopen( "log.txt", "w+" )) == NULL )
printf( "The file 'log.txt' was not openedn" );
else
printf( "The file 'log.txt' was openedn" );
getch();
}
Kết quả:
The file 'vncoding.c' was not opened
The file 'log.txt' was opened

int fclose(FILE *stream);
Parameter:
stream: con trỏ FILE
Remark:
- Hàm fclose( ) dùng để đóng file sau khi hoàn thành các thao tác đọc/ghi.
- Hàm fclose( ) trả về 0 nếu đóng file thành công. Và trả về EOF nếu đóng file xảy
ra lỗi.

int fprintf(FILE *stream, const char *format [,argument ]...)
Parameter:
stream: con trỏ FILE
format: tương tự như hàm printf( ).
Remark:
Hàm fprintf() dùng để ghi dữ liệu ra file (dạng text)
- Hàm fprintf() trả về số byte được ghi ra file
- Hàm trả về giá trị âm, nếu đầu ra xuất hiện lỗi.
Ví dụ: Ghi ra file nội dung sau: “This is forum for all developers”.
#include "stdio.h"
#include "conio.h"
void main()
{
char str[] = "This is forum for all developers";
FILE *fp = NULL;
fp = fopen("D:data.txt","w");
if(fp == NULL)
{
printf("nError in openning file");
}
else
{
fprintf(fp,"%s", str);
fclose(fp);
}
}
Kết quả:
data.txt
This is forum for all developers

int fscanf(FILE *stream,const char *format [, argument ]...);
Paramter:
format: giống hàm printf( ) và scanf( ).
Remark:
Hàm fscanf( ) đọc dữ liệu có định dạng từ file.
- Hàm fscanf( ) trả về số lượng trường dữ liệu đọc thành công
- Hàm trả về 0 nếu đọc không thành công.
- Format của hàm fscanf( ) phải giống của đầu vào hàm fprintf( ).
Chú ý:
- Hàm fscanf( ) đọc dữ liệu xong, con trỏ file sẽ bị dịch chuyển đi.
- Nếu hàm fprintf( ) ghi xuống file nhiều dữ liệu khác nhau (int, float, char*,..) thì
định dạng ghi xuống nên phân tách giữa các dữ liệu này (có thể bằng dấu cách
hoặc tab ‘t’ hoặc dấu xuông dòng ‘n’) , thì hàm fscanf( ) mới có thể đọc được
Ví dụ: Ghi và đọc file bằng hàm fprintf( ) và fscanf( ).
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
long l;
float f;
char s[81];
char c;
int n_byte;
if( (fp = fopen("D:data.bar", "w+" )) == NULL)
printf( "The file data.bar was not openedn" );
else

{
fprintf( fp, "%sn%ld %f %c", "vncoding.net", 2013,
3.14159, 'x' );
// Set pointer to beginning of file:
fseek( fp, 0L, SEEK_SET );
// Read data back from file:
n_byte = fscanf(fp, "%sn%ld %f %c", s, &l, &f, &c);
// Output data read:
printf("nn_byte = %dn",n_byte);
printf( "%sn", s );
printf( "%ldn", l );
printf( "%fn", f );
printf( "%cn", c );
fclose( fp );
}
getch();
}
Kết quả:
n_byte = 4
vncoding.net
2013
3.141590
x

int fputc(int c, FILE *stream);
Parameter:
C: mã ASCII của kí tự muốn ghi xuống file
Remark:
- Hàm fputc( ) ghi 1 kí tự xuống file.
- Hàm trả về mã ASCII của kí tự được ghi xuống file thành công
- Hàm trả về mã EOF nếu lỗi xảy ra.
Ví dụ:
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
char forum_name[] = "vncoding.net";
char s[80];
char *p;
int n_byte;
// Print line to stream using fputc.
p = forum_name;
if((fp = fopen("D:data.txt","w+")) == NULL)
printf("nError in opening file");
else
{
while( (*p != '0') && fputc( *(p++), fp ) != EOF );
fseek(fp, 0L, SEEK_SET);
n_byte = fscanf(fp,"%s", s);
printf("nn_byte = %d", n_byte);
printf("n%s", s);

fclose( fp );
}
getch();
}
Kết quả:
n_byte = 1
vncoding.net

int fgetc(FILE *stream);
Parameter:
Remark:
Hàm fgetc( ) đọc 1 kí tự từ file.
- Hàm fgetc( ) trả về mã ASCII của kí tự đọc được
- Hàm trả về EOF nếu gặp lỗi hoặc cuối file.
Ví dụ:
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
char s[80];
char c;
char *p;
int n_byte;
// Print line to file using fputc.
p = forum_name;
else
{
while( (*p != '0') && fputc( *(p++), fp ) != EOF );
p = s;
while((c = fgetc(fp)) != EOF)
{
*(p++) = c;
}

*p = '0'; // NULL at the end of string
printf("n%s", s);
fclose( fp );
}
getch();
}
Kết quả:
vncoding.net

int fputs(const char *str, FILE *stream);
Parameter:
str: con trỏ tới string
Remark:
Hàm fputs( ) ghi string (kiểu char*) xuống file.
- Hàm fputs( ) trả về giá trị không âm nếu ghi thành công
- Hàm trả về EOF nếu lỗi xảy ra.
Ví dụ: xem ví dụ ở hàm fgets( ).

char *fgets(char *str, int n, FILE *stream);
Parameter:
str: con trỏ trỏ tới string (đã được khởi tạo hoặc cấp phát bộ nhớ để lưu string đọc từ
file)
n: số lượng kí tự tối đa để đọc
Remark:
Hàm fgets( ) đọc string từ file.
- Hàm fgets( ) trả về con trỏ tới string đọc được nếu thành công
- Hàm trả về NULL nếu xảy ra lỗi hoặc gặp cuối file.
Ví dụ:
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
char s[80];
else
{
fputs(forum_name, fp);
if(fgets(s, 12, fp) != NULL)
printf("n%s", s);
fclose( fp );
}
getch();

}
Kết quả:
vncoding.ne

size_t fwrite( const void *buffer, size_t size, size_t count,
FILE *stream );
Parameter:
buffer: con trỏ trỏ tới data cần ghi xuống file.
size: kích thước data cần ghi xuống file (tính theo byte)
count: số lượng data được ghi xuống file.
Remark:
Hàm fwrite() ghi data xuống file. Hàm fwrite( ) khác với hàm fprintf( ) ở chỗ: hàm
fwrite( ) có thể ghi cả struct, object,.. xuống file theo kiểu binary. Còn hàm fprintf( )
chỉ có thể ghi data có định dạng xuống file (dạng text)
- Hàm fwrite( ) trả về số lượng data được ghi xuống, nếu ghi thành công.
- Nếu xảy ra lỗi, hàm sẽ trả về số nguyên nhỏ hơn số lượng data được ghi.

size_t fread( void *buffer, size_t size, size_t count, FILE
*stream);
Parameter:
buffer: con trỏ trỏ tới data cần ghi xuống file.
size: kích thước data ghi xuống file (tính theo byte)
count: số lượng data được ghi xuống file.
Remark:
Hàm fread( ) đọc dữ liệu từ file. Hàm fread( ) khác với hàm fscanf( ) ở chỗ có thể
đọc cả struct, object,…(đọc cả khối dữ liệu chỉ cần biết kích thước và cấu trúc).
- Hàm fread( ) trả về số lượng data được đọc (không phải là số byte) nếu thành
công.
- Nếu xảy ra lỗi hoặc gặp cuối file, hàm fread( ) sẽ trả về số nguyên nhỏ hơn số
lượng data được ghi.
Chú ý: Khi ghi xuống file bằng hàm fwrite( ) thì khi đọc, chúng ta sử dụng hàm
fread( ).
Ví dụ: Ghi xuống file struct dd/mm/yyyy bằng hàm fwrite( ). Sau đó dùng hàm
fread( ) để đọc dữ liệu từ file và hiển thị lên màn hình console
#include "stdio.h"
#include "conio.h"
struct Date
{
int d;
int m;
int y;
};
Date m_date = {16, 9, 1989};

void main()
{
FILE *fp = NULL;
int n_byte;
Date date;
//openning file to writting
fp = fopen("D:data.dat","w");
if(fp == NULL)
else
{
//ghi struct date xuong file data.dat
if(fwrite(&m_date, sizeof(Date), 1, fp) != 1)
printf("Error in writting");
fclose(fp);
}
//openning file to read
fp = fopen("D:data.dat","r");
if(fp == NULL)
else
{
if(fread(&date, sizeof(Date), 1, fp) != 1)
printf("nError in reading ");
else
{
printf("ndd/mm/yyyy = %.2d/%.2d/%.4d", date.d,
date.m, date.y);
}
fclose(fp);
}
getch();
}
Kết quả:
dd/mm/yyyy = 16/09/1989

int fseek(FILE *stream, long offset, int origin);
Parameter:
offset: Số byte sẽ di chuyển con trỏ file từ vị trí origin
origin: vị trí ban đầu của con trỏ file. Dưới đây là một số hằng số đã được định nghĩa
sắn trong thư viện stdio.h
SEEK_CUR: vị trí hiện tại của con trỏ file
SEEK_END: vị trí cuối file
SEEK_SET: vị trí đầu file
Remark:
Hàm fseek( ) dịch con trỏ file tới vị trí mong muốn.
- Hàm fseek( ) trả về 0 nếu dịch con trỏ file thành công
- Hàm trả về giá trị khác 0 nếu xảy ra lỗi.
Ví dụ:
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
char s[80];
int res;
else
{

res = fseek(fp, 2L, SEEK_SET);
if(res)
printf("nError in seek file pointer");
else
if(fgets(s, 12, fp) != NULL)
printf("n%s", s);
fclose( fp );
}
getch();
}
Kết quả:
coding.net

long ftell(FILE *stream);
Parameter:
Remark:
Hàm ftell( ) trả về vị trí của con trỏ file hiện tại.
Ví dụ:
#include "stdio.h"
#include "conio.h"
void main()
{
FILE *fp;
char s[80];
int res;
else
{
res = ftell(fp);
printf("n position of file pointer: %d", res);
fclose( fp );
}
getch();
}
Kết quả:
position of file pointer: 12

void rewind(FILE *stream);
Parameter:
Remark:
Hàm rewind( ) di chuyển con trỏ file về đầu file. Hàm rewind( ) tương đương với
hàm fseek( stream, 0L, SEEK_SET );

int fsetpos(FILE *stream, const fpos_t *pos);
Parameter:
pos: vị trí cần set cho con trỏ file
Remark:
Hàm fsetpos( ) set giá trị cho con trỏ file.
- Hàm trả về 0 nếu thành công
- Hàm trả về khác 0 nếu có lỗi xảy ra.

int fgetpos(FILE *stream, fpos_t *pos);
Parameter:
pos: con trỏ lưu vị trí con trỏ file
Remark:
Hàm fgetpos( ) lấy vị trí con trỏ file hiện tại và lưu vào biến pos.
- Hàm fgetpos( ) trả 0 nếu thành công
- Trả về khác 0 nếu lỗi xảy ra.

int feof(FILE *stream);
Parameter:
Remark:
Hàm feof( ) kiểm tra xem con trỏ file đang ở cuối file chưa?
- Nếu ở cuối file, hàm trả về giá trị khác 0.
- Nếu chưa gặp cuối file, hàm trả về giá trị 0

<stdlib.h>
int abs(int n);
long labs(long n);
Parameter:
n: đầu vào
Remark:
Hàm abs( ) (labs()) trả về trị tuyệt đối của n.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main()
{
int x = -123;
long y = -134L;
printf("abs(%d) = %d", x, abs(x));
printf("nlabs(%d) = %d", y, labs(y));
getch();
}
Kết quả:
abs(-123) = 123
labs(-134) = 134

div_t div(int numer, int denom);
ldiv_t ldiv(long numer, long denom);
Parameter:
numer: tử số
denom: mẫu số
Remark:
Hàm div( ) (ldiv( )) tính toán phép chia numer/denom. Hàm trả về struct div_t hoặc
ldiv_t. struct div_t (ldiv_t) gồm có 2 thành phần thương và số dư.
- Nếu denom = 0 thì chương trình sẽ kết thúc (exception) với message lỗi.
typedef struct _div_t {
int quot;
int rem;
} div_t;
typedef struct _ldiv_t {
long quot;
long rem;
} ldiv_t;
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
long x = 5149627, y = 234879;
ldiv_t div_result;
div_result = ldiv( x, y );
printf( "For %ld / %ld, the quotient is ", x, y );
printf( "%ld, and the remainder is %ldn",
div_result.quot, div_result.rem );
getch();
}

Kết quả:
For 5149627 / 234879, the quotient is 21, and the remainder is 217168

int atoi(const char *str);
long atol(const char *str);
Parameter:
str: chuỗi kí tự cần được convert
Remark:
Hàm atoi( ) (atol( ))convert string (kiểu char*) thành số nguyên int (long)
- Hàm sẽ trả về 0 nếu convert không thành công
- Nếu bị overflow, hàm sẽ trả về hằng số LONG_MIN hoặc LONG_MAX, errno
sẽ được set hằng số ERANGE.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
#include <errno.h>
void main( void )
{
char *str = NULL;
int value = 0;
// An example of the atoi function.
str = " -2309 ";
value = atoi( str );
printf( "Function: atoi( "%s" ) = %dn", str, value );
// Another example of the atoi function.
str = "31412764";
// Another example of the atoi function
// with an overflow condition occuring.
str = "3336402735171707160320";
if (errno == ERANGE)

{
printf("Overflow condition occurred.n");
}
getch();
}
Kết quả:
Function: atoi( " -2309 " ) = -2309
Function: atoi( "31412764" ) = 31412764
Function: atoi( "3336402735171707160320" ) = 2147483647
Overflow condition occurred.

double atof(const char *str);
Parameter:
str: chuỗi kí tự cần convert
Remark:
Hàm atof( ) convert chuỗi kí tự (kiểu char*) thành kiểu double.
- Hàm atof( ) trả về 0.0 nếu convert không thành công
- Trong trường hợp overflow, errno được set hằng số ERANGE
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
char *str = NULL;
double value = 0;
// An example of the atof function
// using leading and training spaces.
str = " 3336402735171707160320 ";
value = atof( str );
printf( "Function: atof( "%s" ) = %en", str, value );
// Another example of the atof function
// using the 'd' exponential formatting keyword.
str = "3.1412764583d210";
// An example of the atof function
// using the 'e' exponential formatting keyword.
str = " -2309.12E-15";
getch();

}
Kết quả:
Function: atof( " 3336402735171707160320 " ) = 3.336403e+021
Function: atof( "3.1412764583d210" ) = 3.141276e+210
Function: atof( " -2309.12E-15" ) = -2.309120e-012

double strtod(const char *nptr, char **endptr);
Parameter:
nptr: chuỗi kí tự (kiểu char*) cần convert
endptr: con trỏ trỏ tới kí tự không thể convert được.
Remark:
Hàm strtod( ) convert chuỗi kí tự đầu vào thành số double (long). Hàm strtod( ) sẽ
đọc và convert cho tới khi gặp kí tự không convert được thành số.
- Hàm trả về +/- HUGE_VAL khi overflow.
- Hàm trả về 0 nếu không thể convert string hoặc underflow.
- Trong cả 2 trường hợp overflow, underflow, errno được set ERANGE
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
char *string, *stopstring;
double x;
string = "3.1415926This stopped it";
x = strtod( string, &stopstring );
printf( "string = %sn", string );
printf(" strtod = %fn", x );
printf(" Stopped scan at: %snn", stopstring );
getch();
}
Kết quả:
string = 3.1415926This stopped it
strtod = 3.141593
Stopped scan at: This stopped it

long strtol(const char *nptr, char **endptr, int base);
Parameter:
nptr: chuỗi kí tự đầu vào cần convert
base: cơ số ( 2: binary, 8: octal, 10: decimal,…)
Remark:
Hàm strtol( ) convert chuỗi kí tự (kiểu char*) dựa vào cơ số và trả về số kiểu long.
- Hàm trả về 0 nếu nptr = NULL.
- Nếu overflow xảy ra, hàm trả về LONG_MAX và LONG_MIN
- Trong cả 2 trường hợp overflow, underflow, errno được set ERANGE
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
long l;
int base;
string = "-10110134This stopped it";
l = strtol( string, &stopstring, 10);
printf(" strtol = %ldn", l );
printf(" Stopped scan at: %snn", stopstring );
getch();
}
Kết quả:
string = -10110134This stopped it
strtol = -10110134
Stopped scan at: This stopped it

unsigned long strtoul( const char *nptr, char **endptr, int
base );
Parameter:
nptr: chuỗi kí tự đầu vào cần convert
base: cơ số ( 2: binary, 8: octal, 10: decimal)
Remark:
Hàm strtoul( ) trả về giá trị được convert từ string.
- Hàm trả về 0 nếu nptr = NULL
- Trong trường hợp overflow xảy ra, hàm strtoul( ) trả về ULONG_MAX và
errno được set bằng ERANGE.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
unsigned long ul;
int base;
string = "10110134932";
for( base = 2; base <= 8; base *= 2 )
{
/* Convert the string: */
ul = strtoul( string, &stopstring, base );
printf( " strtol = %ld (base %d)n", ul, base );
printf( " Stopped scan at: %sn", stopstring );
}
getch();
}

Kết quả:
string = 10110134932
strtol = 45 (base 2)
Stopped scan at: 34932

void *malloc(size_t size);
Parameter:
size: số byte cần cấp phát
Remark:
Hàm malloc( ) cấp phát vùng nhớ (các byte liên tiếp).
- Hàm trả về con trỏ tới vùng nhớ nếu thành công
- Hàm trả về NULL nếu không đủ vùng nhớ
Chú ý:
- Hàm malloc( ) có thể dùng để cấp phát vùng nhớ cho kiểu dữ liệu: mảng kí tự
(char*), int*, struct,…
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
char *string;
// Allocate space for a path name
string = (char*)malloc( _MAX_PATH );
if( string == NULL )
printf( "Insufficient memory availablen" );
else
{
printf( "Memory space allocated for path namen" );
free( string );
printf( "Memory freedn" );
}
getch();
}
Kết quả:
Memory space allocated for path name
Memory freed

void *realloc(void *memblock, size_t size);
Parameter:
memblock: con trỏ trỏ tới vùng nhớ đã được cấp phát trước đó
size: số byte giành cho vùng nhớ mới
Remark:
Hàm realloc( ) thay đổi kích thước của vùng nhớ đã được cấp phát. memblock trỏ
tới vùng nhớ đã được cấp phát trước đó.
- Nếu không đủ vùng nhớ để cấp phát mới, vùng nhớ cũ không thay đổi. Hàm trả
về NULL
- Nếu memblock là NULL, hàm realloc( ) tương tự như hàm malloc( ), sẽ cấp phát
1 vùng nhớ mới và trả về con trỏ tới vùng nhớ mới.
- size: đưa ra kích thước mới cho vùng nhớ. Nếu kích thước nhỏ hơn kích thước
vùng nhớ trước đó, dữ liệu trong vùng nhớ đó có thể bị thay đổi.
- Nếu size = 0, vùng nhớ memblock được giải phóng, giá trị trả về là NULL
- Vùng nhớ mới được cấp phát có thể ở địa chỉ khác với vùng nhớ đã được cấp
phát. Do vậy, con trỏ trả về của hàm có thể không phải là con trỏ truyền vào
memblock.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
#include <malloc.h>
void main( void )
{
char* buff, *old_buff;
int size;
if((buff = (char*)malloc(100*sizeof(char))) == NULL)
{
printf("nInsufficient memory for malloc()");
return;
}
size = _msize( buff );
printf("nSize of original memory: %d", size);

old_buff = buff;
if((buff = (char*)realloc(buff, 50 + 100*sizeof(char)))
== NULL)
{
free(old_buff);
printf("nInsufficient memory for realloc()");
}
size = _msize( buff );
printf("nSize of newly reallocated memory: %d", size);
getch();
}
Kết quả:
Size of original memory: 100
Size of newly reallocated memory: 150

void *calloc(size_t num, size_t size);
Parameter:
num: số phần tử
size: kích thước (byte) của mỗi phần tử
Remark:
Hàm calloc( ) cấp phát bộ nhớ cho mảng với các phần tử của mảng được khởi tạo
bằng 0.
- Hàm trả về con trỏ trỏ tới vùng nhớ được cấp phát.
- Hàm trả về NULL nếu lỗi xảy ra.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
long *buffer;
buffer = (long *)calloc( 40, sizeof( long ) );
if( buffer != NULL )
printf( "Allocated 40 long integersn" );
else
printf( "Can't allocate memoryn" );
free( buffer );
getch();
}
Kết quả:
Allocated 40 long integers

void free( void *memblock );
Parameter:
memblock: con trỏ trỏ tới vùng nhớ đã cấp phát
Remark:
Hàm free( ) giải phóng vùng nhớ đã cấp phát. Giúp cho chương trình tránh khỏi leak
memory.

void abort( void );
Parameter:
void
Remark:
Hàm abort( ) kết thúc chương trình đang chạy. Dialog lỗi sẽ xuất hiện trên màn hình
console.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
int a = 9, b = 0;
if(b == 0)
abort();
else
printf("na/b = %d/%d = %f", a, b, (float)a/b);
getch();
}
Kết quả:Dialog thông báo lỗi trên màn hình.

void exit(int status);
Parameter:
status: mã exit
Remark:
Hàm exit( ) kết thúc chương trình đang chạy.
- status là 0 để chỉ hàm kết thúc bình thường
- status khác 0 để chỉ hàm kết thúc bất thường.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
int a = 9, b = 0;
if(b == 0)
exit(1);
else
printf("na/b = %d/%d = %f", a, b, (float)a/b);
getch();
}

int rand( void );
Parameter:
void
Remark:
Hàm rand( ) trả về số nguyên ngẫu nhiên từ 0 đến RAND_MAX
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
void main( void )
{
int n = 5;
int i;
for(i = 0; i < n; i++)
{
printf("n%d",rand());
}
getch();
}
Kết quả:
41
18467
6334
26500
19169

<string.h>
char *strcpy(char *strDestination, const char *strSource);
Parameter:
strDestination: chuỗi kí tự đích
strSource: chuỗi kí tự nguồn
Remark:
Hàm strcpy( ) copy nội dung của strSource( gồm cả kí tự NULL ở cuối) sang
strDestination.
- Hàm strcpy( ) trả về con trỏ char* trỏ tới chuỗi kí tự đích
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char string[50];
strcpy( string, "This is vncoding forum" );
printf( "String = %sn", string );
getch();
}
Kết quả:
String = This is vncoding forum

char *strncpy(char *strDest, const char *strSource, size_t
count);
Parameter:
strDest: chuỗi kí tự đích
count: số kí tự cần coppy
Remark:
Hàm strncpy( ) copy một số byte từ strSource sang strDest và trả về strDest.
- Nếu count nhỏ hơn số lượng byte của strSource, thì kí tự NULL sẽ không được
chèn tự động vào cuối string được copy.
- Nếu count lớn hơn số lượng byte của strSource, thì string đích sẽ được chèn các
kí tự NULL đến số kí tự bằng count.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s[20];
strcpy(s, "AA BB CC");
printf("ns = %s", s);
strncpy(s, "aa", 2);
strncpy(s + 3, "bb", 1);
strncpy(s, "ZZ", 3);
getch();
}
Kết quả:

s = AA BB CC
s = aa BB CC
s = aa bB CC
s = ZZ

char *strcat(char *strDestination, const char *strSource);
Parameter:
strDestination: chuỗi kí tự đích
Remark:
Hàm strcat( ) nối chuỗi strSource vào cuối chuỗi strDestination.
- Hàm trả về chuỗi strDestination.
Chú ý:
Độ dài của chuỗi kí tự đích phải đủ chứa cả chuỗi kí tự nguồn.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s[20];
strcpy(s, "AA BB CC");
strcat(s, " DD EE");
getch();
}
Kết quả:
s = AA BB CC
s = AA BB CC DD EE

char *strncat(char *strDest, const char *strSource, size_t
count);
Parameter:
count: số byte cần nối
Remark:
Hàm strncat( ) nối count byte của chuỗi kí tự nguồn tới chuỗi kí tự đích.
- Hàm trả về con trỏ trỏ tới chuỗi kí tự đích.
- Nếu count lớn hơn độ dài của chuỗi kí tự nguồn, thì hàm strncat( ) sẽ copy toàn
bộ chuỗi kí tự nguồn.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s[20];
strcpy(s, "AA BB CC ");
strncat(s, "DD EE ", 1);
strncat(s, "D EE ", 9); //count > length of string "D EE"
getch();
}
Kết quả:
s = AA BB CC
s = AA BB CC D
s = AA BB CC DD EE

int strcmp(const char *string1, const char *string2);
Parameter:
string1, string2: 2 chuỗi đầu vào để so sánh.
Remark:
Hàm strcmp( ) so sánh nội dung 2 chuỗi. Giá trị trả về của hàm strcmp( ) phụ thuộc
vào nội dung của 2 chuỗi.
- Giá trị trả về > 0: chuỗi 1 “lớn hơn” chuỗi 2
- Giá trị trả về = 0: 2 chuỗi có nội dung giống nhau
- Giá trị trả về < 0: chuỗi 1 “nhỏ hơn” chuỗi 2
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s1[] = "vncoding.net";
char s2[] = "coding.net";
int res;
res = strcmp(s1, s2);
if(res < 0)
printf("n'%s' < '%s'", s1, s2);
else if(res == 0)
printf("n'%s' == '%s'", s1, s2);
else
printf("n'%s' > '%s'", s1, s2);
res = strcmp(s1+2, s2);
if(res < 0)
printf("n'%s' < '%s'", s1+2, s2);
else if(res == 0)
printf("n'%s' == '%s'", s1+2, s2);
else
printf("n'%s' > '%s'", s1+2, s2);

getch();
}
Kết quả:
'vncoding.net' > 'coding.net'
'coding.net' == 'coding.net'

int strncmp(const char *string1, const char *string2, size_t
count);
Parameter:
String1, string2: 2 chuỗi đầu vào để so sánh.
count: số byte cần so sánh.
Remark:
Hàm strncmp( ) so sánh 2 chuỗi con của 2 chuỗi string1 và string2. Giá trị trả về của
hàm phụ thuộc vào các kí tự cần so sánh
- Giá trị trả về > 0: chuỗi con 1 “lớn hơn” chuỗi con 2
- Giá trị trả về = 0: 2 chuỗi con có nội dung giống nhau
- Giá trị trả về < 0: chuỗi con 1 “nhỏ hơn” chuỗi con 2
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s1[] = "vncoding.net";
char s2[] = "vncoding";
int res;
res = strncmp(s1, s2, 8);
if(res < 0)
printf("n'%.8s' < '%.8s'", s1, s2);
else if(res == 0)
printf("n'%.8s' == '%.8s'", s1, s2);
else
printf("n'%.8s' > '%.8s'", s1, s2);
getch();
}
Kết quả:
'vncoding' == 'vncoding'

char *strchr(const char *str,int c);
Parameter:
str: chuỗi kí tự đầu vào
c: kí tự cần tìm
Remark:
Hàm strchr( ) tìm kiếm kí tự c trong chuỗi str.
- Hàm strchr( ) trả về con trỏ trỏ tới vị trí xuất hiện đầu tiên kí tự c trong chuỗi str.
- Hàm trả về NULL nếu không tìm thấy.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s1[] = "name = vuhongviet";
char *s;
s = strchr(s1, 'v');
if(s == NULL)
printf("nDo not find 'v' in %s", s1);
else
printf("%s", s);
getch();
}
Kết quả:
vuhongviet

char *strrchr(const char *str, int c);
Parameter:
str: chuỗi đầu vào
c: kí tự cần tìm
Remark:
Hàm strrchr( ) tìm kiếm kí tự c trong chuỗi str.
- Hàm sẽ trả về con trỏ trỏ tới vị trí xuất hiện cuối cùng kí tự c trong chuỗi str.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s1[] = "name = vuhongviet";
char *s;
s = strrchr(s1, 'v');
if(s == NULL)
printf("nDo not find 'v' in %s", s1);
else
printf("%s", s);
getch();
}
Kết quả:
viet

size_t strspn(const char *str, const char *strCharSet);
Parameter:
strCharSet: bộ kí tự cần tìm
Remark:
Hàm strspn( ) tìm kiếm bộ kí tự strCharSet trong chuỗi str.
- Hàm trả về độ dài chuỗi con (trong chuỗi str) bao gồm bộ kí tự strCharSet. Hay
nói cách khác là: hàm trả về vị trí đầu tiên trong chuỗi str mà không xuất hiện kí
tự (trong bộ kí tự strCharSet)
- Nếu kí tự đầu tiên trong chuỗi str không xuất hiện trong bộ kí tự strCharSet, thì
hàm sẽ trả về 0.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char string[] = "cabbage";
int result;
result = strspn( string, "abc" );
printf( "The portion of '%s' containing only a, b, or c "
"is %d bytes longn", string, result );
getch();
}
Kết quả:
The portion of 'cabbage' containing only a, b, or c is 5 bytes long

char *strpbrk(const char *str, const char *strCharSet);
Parameter:
strCharSet: bộ kí tự cần tìm
Remark:
- Hàm strpbrk( ) trả về con trỏ tới vị trí xuất hiện đầu tiên của 1 trong các kí tự
(trong bộ kí tự strCharSet).
- Hàm trả về NULL, nếu không tìm thấy hoặc str, strCharSet = NULL.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char string[100] = "The 3 men and 2 boys ate 5 pigsn";
char *result = NULL;
// Return pointer to first digit in "string".
printf( "1: %sn", string );
result = strpbrk( string, "0123456789" );
printf( "2: %sn", result++ );
result = strpbrk( result, "0123456789" );
printf( "3: %sn", result++ );
result = strpbrk( result, "0123456789" );
printf( "4: %sn", result );
getch();
}
Kết quả:
1: The 3 men and 2 boys ate 5 pigs
2: 3 men and 2 boys ate 5 pigs
3: 2 boys ate 5 pigs
4: 5 pigs

char *strstr(const char *str, const char *strSearch);
Parameter:
strSearch: chuỗi con cần tìm
Remark:
Hàm strstr( ) tìm kiếm chuỗi con strSearch trong chuỗi str.
- Hàm trả về con trỏ trỏ tới vị trí đầu tiên xuất hiện strSearch trong chuỗi str.
- Hàm trả về NULL, nếu không tìm thấy.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char str[] = "lazy";
char string[] = "The quick brown dog jumps over the lazy
fox";
char fmt1[] = " 1 2 3 4
5";
char fmt2[] =
"12345678901234567890123456789012345678901234567890";
char *pdest;
int result;
printf( "String to be searched:n %sn", string );
printf( " %sn %snn", fmt1, fmt2 );
pdest = strstr( string, str );
result = (int)(pdest - string + 1);
if ( pdest != NULL )
printf( "%s found at position %dn", str, result );
else
printf( "%s not foundn", str );
getch();
}

Kết quả:
String to be searched:
The quick brown dog jumps over the lazy fox
1 2 3 4 5
12345678901234567890123456789012345678901234567890
lazy found at position 36

size_t strlen(const char *str);
Parameter:
Remark:
Hàm strlen( ) tính độ dài chuỗi kí tự.
- Hàm trả về độ dài chuỗi kí tự (không tính kí tự NULL)
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char str[] = "high school";
printf("nLength of '%s' is: %d", str, strlen(str));
getch();
}
Kết quả:
Length of 'high school' is: 11

char *strtok(char *strToken, const char *strDelimit);
Parameter:
strToken: chuỗi đầu vào
strDelimit: bộ kí tự cần tìm kiếm
Remark:
Hàm strtok( ) sẽ tìm chuỗi con trong chuỗi strToken dựa vào bộ kí tự strDelimit.
Dựa vào bộ kí tự strDelimit, chuỗi strToken sẽ được tách thành những chuỗi con.
- Hàm sẽ trả về con trỏ tới chuỗi con được tìm thấy trong strToken.
- Khi phát hiện thấy kí tự (nằm trong bộ kí tự strDelimit) trong strToken, kí tự này
sẽ được thay thế bởi kí tự NULL. Kết quả chuỗi strToken bị thay đổi
Trong lần gọi hàm strtok( ) đầu tiên, hàm sẽ trả về chuỗi con đầu tiên nếu gặp kí tự
trong bộ kí tự strDelimit. Muốn lấy các chuỗi con còn lại của strToken, ta gọi hàm
strtok( ) với tham số strToken = NULL.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s[] = "My name is,, nVuHongViet";
char sep[] = " ,tn";
char *token;
printf( "Tokens:n" );
token = strtok(s, sep);
while( token != NULL )
{
// While there are tokens in "string"
printf( "%sn", token );
// Get next token:
token = strtok( NULL, sep);
}
getch();

}
Kết quả:
Tokens:
My
name
is
VuHongViet

size_t strxfrm(char *strDest, const char *strSource, size_t
count);
Parameter:
count: số kí tự tối đa đặt trong strDest.
Remark:
Hàm strxfrm( ) copy count kí tự từ strSource vào strDest. Hàm sẽ trả về số kí tự
copy được từ strSource. Nếu xảy ra lỗi, hàm sẽ set giá trị errno và trả về INT_MAX.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char s[] = "ABCDEFGHIKLM";
char d[30];
memset(d, NULL, 30);
int res;
res = strxfrm(d, s, 3);
printf("n%s", d);
getch();
}
Kết quả:
ABC

void *memcpy(void *dest, const void *src, size_t count);
Parameter:
dest: vùng nhớ mới chứa số byte copy từ src (kiểu int, long, char,…)
src: vùng nhớ chứa dữ liệu cần copy
count: số byte cần copy
Remark:
Hàm memcpy( ) sẽ copy count byte từ src vào vùng nhớ mới dest. Nếu vùng nhớ
của dest và src bị chồng lên nhau (overlap) thì hàm sẽ không xử lí được hoặc xử lí
không đúng.
Chú ý: kích thước vùng nhớ phải lớn hơn hoặc bằng kích thước của src.
Ví dụ: xem hàm memmove( )

void *memmove(void *dest, const void *src, size_t count);
Parameter:
dest: vùng nhớ mới chứa số byte copy từ src (kiểu int, long, char,…)
drc: vùng nhớ chứa dữ liệu cần copy
count: số byte cần copy
Remark:
Hàm memmove( ) copy count byte từ src vào vùng nhớ mới dest. Nếu vùng nhớ dest
và src bị chồng lên nhau (overlap) thì hàm memmove( ) sẽ đảm bảo các byte trong
vùng chồng lấn sẽ được copy trước khi ghi đè xuống. Nói một cách đơn giản tức là
hàm memove( ) sẽ đảm bảo việc xử lí là chính xác không như hàm memcpy( ).
Chú ý: kích thước vùng nhớ phải lớn hơn hoặc bằng kích thước của src.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
char str1[] = "aabbcc";
void main( void )
{
printf( "The string: %sn", str1 );
memcpy( str1 + 2, str1, 4 );
printf( "New string: %sn", str1 );
strcpy_s( str1, sizeof(str1), "aabbcc" ); // reset
string
printf( "The string: %sn", str1 );
memmove(str1 + 2, str1, 4 );
printf( "New string: %sn", str1 );
getch();
}

Kết quả:
The string: aabbcc
New string: aaaabb
The string: aabbcc
New string: aaaabb

int memcmp(const void *buf1, const void *buf2, size_t count);
Parameter:
buf1: vùng nhớ cần so sánh
buf2: vùng nhớ cần so sánh
count: số byte cần so sánh
Remark:
Hàm memcpy( ) so sánh count byte của buf1 và buf2. Hàm trả về:
>0 : nếu buf1 “nhỏ hơn” buf2
<0 : nếu buf1 “lớn hơn” buf2
=0 : nếu buf1 “ bằng” buf2
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
int int_arr1[] = {1,2,3,4};
int int_arr2[] = {1,2,3,5};
int res;
res = memcmp(int_arr1, int_arr2, 1*sizeof(int));
if(res == 0)
printf("narr1 is equal to arr2");
else if(res > 0)
printf("narr1 is greater than arr2");
else
printf("narr1 is less than arr2");
res = memcmp(int_arr1, int_arr2, 4*sizeof(int));
if(res == 0)
printf("narr1 is equal to arr2");
else if(res > 0)

printf("narr1 is greater than arr2");
else
printf("narr1 is less than arr2");
getch();
}
Kết quả:
arr1 is equal to arr2
arr1 is less than arr2

void *memchr(const void *buf, int c, size_t count);
Parameter:
buf: con trỏ tới vùng dữ liệu
c: kí tự cần tìm kiếm
count: số byte kí tự cần tìm kiếm.
Remark:
Hàm memchr( ) tìm kiếm kí tự c trong giới hạn count byte kí tự.
- Hàm sẽ trả về vị trí đầu tiên mà kí tự c xuất hiện.
- Nếu không tìm thấy, hàm sẽ trả về NULL
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char str[] = "vncoding forum";
int c = 'o';
char *des;
des = (char*)memchr(str, c, 3);
if(des == NULL)
printf("nNot found");
else
printf("n%c occur at %d", c, des - str + 1);
des = (char*)memchr(str, c, 10);
if(des == NULL)
printf("nNot found");
else
printf("n'%c' occurs at %d", c, des - str + 1);
getch();
}
Kết quả:

Not found
'o' occurs at 4

void *memset(void *dest, int c, size_t count);
Parameter:
dest: vùng nhớ cần gán giá trị
c: giá trị cần gán cho dest
count: cần gán c cho bao nhiêu byte của dest.
Remark:
Hàm memset( ) gán giá trị c cho count byte đầu của dest.
- Hàm trả về con trỏ tới dest.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "string.h"
void main( void )
{
char buffer[] = "This is a test of the memset function";
printf( "Before: %sn", buffer );
memset( buffer, '*', 4 );
printf( "After: %sn", buffer );
getch();
}
Kết quả:
Before: This is a test of the memset function
After: **** is a test of the memset function

<time.h>
struct tm
struct gồm các thành phần trên lịch hệ thống bao gồm:
tm_sec : giây (0 – 59)
tm_min : phút (0 – 59)
tm_hour : giờ (0 – 23)
tm_mday : ngày (1 – 31)
tm_mon : tháng (0 – 11), 0 : tháng 1
tm_year : năm hiện tại ( cộng thêm 1900)
tm_wday : ngày trong tuần (0 – 6), 0 : chủ nhật
tm_yday : ngày trong năm (0 – 365), 0 : ngày 1/1
tm_isdst : quy ước giờ mùa hè là quy ước tăng 1 khoảng thời gian (thường là 1 giờ)
so với giờ tiêu chuẩn. Tại một số địa phương của một số quốc gia, trong một giai
đoạn (thường là vào mùa hè) trong năm.
Quy ước này thường được thực hiện tại các nước ôn đới hay gần cực, nơi mà vào
mùa hè, ban ngày bắt đầu sớm hơn so với mùa đông vài tiếng đồng hồ. Nó có ý
nghĩa thực tiễn là giúp tiết kiệm năng lượng chiếu sáng và sưởi ấm, khi tận dụng ánh
sáng ban ngày của ngày làm việc từ sớm, giảm chiếu sáng ban đêm nhờ ngủ sớm.
Chính vì ý nghĩa này mà một số nước gọi quy ước này với cái tên "Giờ tiết kiệm
ánh sáng ngày" (daylight saving time trong tiếng anh).
- tm_isdst > 0: đang thực hiện quy ước này
- tm_isdst = 0 : không thực hiện quy ước này
- tm_isdst < 0 : không xác định được thông tin.

clock_t clock( void );
Parameter:
void
Remark:
Hàm clock( ) dùng để tính thời gian mà processor sử dụng để thực hiện một khối
lệnh trong chương trình.
- Hàm trả về xung clock đã trôi qua của processor. Để đổi ra giây, ta đem số xung
clock chia cho CLOCKS_PER_SEC (có giá trị 1000).
- Hàm trả về -1 nếu không xác định được số xung clock.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
clock_t start, finish;
double duration;
long i = 600000L;
start = clock();
while(i--);
finish = clock();
duration = (float)(finish - start)/CLOCKS_PER_SEC;
printf("nDuration is to perform while(i--) is: %f
seconds", duration);
getch();
}
Kết quả:
Duration is to perform while(i--) is: 0.003000 seconds

time_t time(time_t *timer);
Parameter:
time_t: con trỏ trỏ tới vùng nhớ lưu trữ thời gian.
Remark:
- Hàm time( ) trả về số giây từ thời điểm 1/1/1970 đến thời điểm gọi hàm time( ).
- Hàm trả về -1 nếu lỗi xuất hiện
Ví dụ: xem hàm asctime( ).

struct tm *localtime(const time_t *timer);
Parameter:
timer: con trỏ tới vùng nhớ lưu thời gian ( lấy từ hàm time( ))
Remark:
Hàm localtime( ) convert timer thành thời gian(giờ, phút, giây, ngày, tháng, năm,..)
lưu vào struct tm.
Ví dụ: xem hàm asctime( ).

char *asctime(const struct tm *timeptr);
Parameter:
timeptr: con trỏ tm tới vùng nhớ
Remark:
Hàm asctime( ) covert struct tm thành định dạng như sau:
Sun Feb 03 11:38:58 2002
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime;
struct tm *info;
time( &ltime );
info = localtime( &ltime );
printf("Current local time and date: %s", asctime(info));
getch();
}
Kết quả:
Current local time and date: Sat Nov 08 21:06:10 2014

char *ctime( const time_t *timer );
Parameter:
timer: con trỏ trỏ tới vùng lưu thời gian
Remark:
- Hàm convert timer thành thời gian định dạng như sau:
Sun Feb 03 11:38:58 2002
- Hàm ctime( ) tương đương với hàm asctime(localtime(timer)).
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime;
time( &ltime );
printf("Current local time and date: %s", ctime(&ltime));
getch();
}
Kết quả:

struct tm *gmtime(const time_t *timer);
Parameter:
timer: con trỏ trỏ tới vùng nhớ lưu trữ thời gian
Remark:
Hàm gmtime( ) convert timer thành thời gian UTC
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime;
struct tm *info;
time( &ltime );
info = gmtime( &ltime );
getch();
}
Kết quả:

time_t mktime(struct tm *timeptr);
Parameter:
timeptr: con trỏ trỏ tới vùng nhớ lưu thời gian
Remark:
Hàm mktime( ) convert thời gian định dạng tm (ngày, tháng, năm, giờ, phút,
giây,…) sang định dạng time_t.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime;
struct tm *info;
int day = 9;
time( &ltime );
info = localtime( &ltime );
// After 9 days, what date will be?
info->tm_mday += day;
ltime = mktime(info);
printf("nAfter 9 days, time will be: %s",
ctime(&ltime));
getch();
}
Kết quả:
After 9 days, time will be: Mon Nov 17 23:32:10 2014

double difftime(time_t timer1, time_t timer0);
Parameter:
time1: mốc thời gian thứ nhất
time2: mốc thời gian thứ hai
Remark:
Hàm difftime( ) sẽ trả về khoảng thời gian (tính bằng giây) giữa 2 mốc timer1 và
timer2.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime0, ltime1;
long i = 600000000L;
time(&ltime0);
while(i--);
time(&ltime1);
printf("nDuration between ltime0 and ltime1 is: %f
seconds", difftime(ltime1, ltime0));
getch();
}
Kết quả:
Duration between ltime0 and ltime1 is: 4.000000 seconds

size_t strftime(char *strDest, size_t maxsize, const char
*format, const struct tm *timeptr);
Parameter:
strDest: chuỗi kí tự đầu ra
maxsize: kích thước strDest (tính theo số kí tự)
format: định dạng của chuỗi kí tự
%a: Abbreviated weekday name
%A: Full weekday name
%b: Abbreviated month name
%B: Full month name
%c: Date and time representation appropriate for locale
%d: Day of month as decimal number (01 – 31)
%H: Hour in 24-hour format (00 – 23)
%I: Hour in 12-hour format (01 – 12)
%j: Day of year as decimal number (001 – 366)
%m: Month as decimal number (01 – 12)
%M: Minute as decimal number (00 – 59)
%p: Current locale's A.M./P.M. indicator for 12-hour clock
%S: Second as decimal number (00 – 59)
%U: Week of year as decimal number, with Sunday as first day of week (00 – 53)
%w: Weekday as decimal number (0 – 6; Sunday is 0)
%W: Week of year as decimal number, with Monday as first day of week (00 – 53)
%x: Date representation for current locale
%X: Time representation for current locale
%y: Year without century, as decimal number (00 – 99)
%Y: Year with century, as decimal number
%z, %Z: Either the time-zone name or time zone abbreviation, depending on
registry settings; no characters if time zone is unknown
%%: Percent sign
timeptr: thời gian lưu trong struct tm
Remark:
Hàm strftime( ) trả về số kí tự được đặt trong strDest

- Nếu tổng số ki tự + 1 kí tựu NULL mà lớn hơn maxsize, hàm trả về 0 và nội
dung của strDest không chính xác.
Ví dụ:
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main( void )
{
time_t ltime;
struct tm *info;
char str_time[120];
time(&ltime);
info = localtime(&ltime);
strftime(str_time, 120, "Today is %A, %d/%m/%Y.", info);
printf("n%s", str_time);
getch();
}
Kết quả:
Today is Sunday, 09/11/2014.

Sổ tay thư viện hàm ngôn ngữ C

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Sổ tay thư viện hàm ngôn ngữ C

Similar to Sổ tay thư viện hàm ngôn ngữ C (20)

Recently uploaded

Recently uploaded (19)

Sổ tay thư viện hàm ngôn ngữ C