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/

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 ); printf ( "Analyzing string '%s'\n", test2 ); fflush( stdout ); analyze_string( test2 ); printf ( "Analyzing string '%s'\n", test3 ); fflush( stdout ); analyze_string( test3 ); 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 c1 = 97; // character 'a' 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 c1 = 97; // character 'a' 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 c1 = 32; // character space 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 c1 = 32; // character space 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 ) = %f\n", 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 ) = %f\n", x, y ); y = log10( x ); printf( "log10( %.2f ) = %f\n", 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 %.1f\n", 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 %f\n", answer ); else printf( "The square root of %.2f is %.2f\n", 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 %f\n", y ); y = floor( -2.8 ); printf( "The floor of -2.8 is %f\n", y ); y = ceil( 2.8 ); printf( "The ceil of 2.8 is %f\n", y ); y = ceil( -2.8 ); printf( "The ceil of -2.8 is %f\n", 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.1f\n", 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 = %d\n", 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 %.f\n", 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 %f\n", 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 ) = %f\n", x, y ); y = cos( x ); printf( "cos( %f ) = %f\n", x, y ); y = tan( x ); printf( "tan( %f ) = %f\n",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 ) = %f\n", x, y ); y = acos( x ); printf( "acos( %f ) = %f\n", x, y ); y = atan( x ); printf( "atan( %f ) = %f\n",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 ) = %f\n", 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 ) = %f\n",x, y ); y = cosh( x ); printf( "cosh( %f ) = %f\n",x, y ); y = tanh( x ); printf( "tanh( %f ) = %f\n", 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 = %s\n", s ); printf( "Character = %c\n", c );



printf( "Integer: = %d\n", i ); printf( "Real: = %f\n", 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 = %c\n", 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: %s\n", 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( "%s\n", 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( "%s\n", 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 opened\n" ); else printf( "The file 'vncoding.c' was opened\n" );



// Open for write if( (stream2 = fopen( "log.txt", "w+" )) == NULL ) printf( "The file 'log.txt' was not opened\n" ); else printf( "The file 'log.txt' was opened\n" ); 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 opened\n" ); else



{ fprintf( fp, "%s\n%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, "%s\n%ld %f %c", s, &l, &f, &c); // Output data read: printf("\nn_byte = %d\n",n_byte); printf( "%s\n", s ); printf( "%ld\n", l ); printf( "%f\n", f ); printf( "%c\n", 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 forum_name[] = "vncoding.net"; char s[80]; char c; char *p; int n_byte; // Print line to file 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); 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 forum_name[] = "vncoding.net"; char s[80]; if((fp = fopen("D:\\data.txt","w+")) == NULL) printf("\nError in opening file"); else { fputs(forum_name, fp); fseek(fp, 0L, SEEK_SET); 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) printf("\nError in openning file"); 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) printf("\nError in openning file"); 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 forum_name[] = "vncoding.net"; char s[80]; int res; if((fp = fopen("D:\\data.txt","w+")) == NULL) printf("\nError in opening file"); else { fputs(forum_name, fp);



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 forum_name[] = "vncoding.net"; char s[80]; int res; if((fp = fopen("D:\\data.txt","w+")) == NULL) printf("\nError in opening file"); else { fputs(forum_name, fp); 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 %ld\n", 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\" ) = %d\n", str, value ); // Another example of the atoi function. str = "31412764"; value = atoi( str ); printf( "Function: atoi( \"%s\" ) = %d\n", str, value ); // Another example of the atoi function // with an overflow condition occuring. str = "3336402735171707160320"; value = atoi( str ); printf( "Function: atoi( \"%s\" ) = %d\n", str, value ); 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\" ) = %e\n", str, value ); // Another example of the atof function // using the 'd' exponential formatting keyword. str = "3.1412764583d210"; value = atof( str ); printf( "Function: atof( \"%s\" ) = %e\n", str, value ); // An example of the atof function // using the 'e' exponential formatting keyword. str = " -2309.12E-15"; value = atof( str ); printf( "Function: atof( \"%s\" ) = %e\n", str, value ); 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 = %s\n", string ); printf(" strtod = %f\n", x ); printf(" Stopped scan at: %s\n\n", 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 ) { char *string, *stopstring; long l; int base; string = "-10110134This 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 ); 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 ) { char *string, *stopstring; unsigned long ul; int base; string = "10110134932"; printf( "string = %s\n", string ); 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: %s\n", 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 available\n" ); else { printf( "Memory space allocated for path name\n" ); free( string ); printf( "Memory freed\n" ); } 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 integers\n" ); else printf( "Can't allocate memory\n" ); 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 = %s\n", 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); printf("\ns = %s", s); strncpy(s + 3, "bb", 1); printf("\ns = %s", s); strncpy(s, "ZZ", 3); printf("\ns = %s", s); 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"); printf("\ns = %s", s); strcat(s, " DD EE"); printf("\ns = %s", s); 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 "); printf("\ns = %s", s); strncat(s, "DD EE ", 1); printf("\ns = %s", s); strncat(s, "D EE ", 9); //count > length of string "D EE" printf("\ns = %s", s); 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.

- 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 = 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 long\n", 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 pigs\n"; char *result = NULL; // Return pointer to first digit in "string". printf( "1: %s\n", string ); result = strpbrk( string, "0123456789" ); printf( "2: %s\n", result++ ); result = strpbrk( result, "0123456789" ); printf( "3: %s\n", result++ ); result = strpbrk( result, "0123456789" ); printf( "4: %s\n", 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 %s\n", string ); printf( " %s\n %s\n\n", fmt1, fmt2 ); pdest = strstr( string, str ); result = (int)(pdest - string + 1); if ( pdest != NULL ) printf( "%s found at position %d\n", str, result ); else printf( "%s not found\n", 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. - Hàm trả về NULL nếu không tìm thấy. - 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[] = " ,\t\n"; char *token; printf( "Tokens:\n" ); token = strtok(s, sep); while( token != NULL ) { // While there are tokens in "string" printf( "%s\n", 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: %s\n", str1 ); memcpy( str1 + 2, str1, 4 ); printf( "New string: %s\n", str1 ); strcpy_s( str1, sizeof(str1), "aabbcc" ); // reset string printf( "The string: %s\n", str1 ); memmove(str1 + 2, str1, 4 ); printf( "New string: %s\n", 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: %s\n", buffer ); memset( buffer, '*', 4 ); printf( "After: %s\n", 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 ); printf("Current local time and date: %s", asctime(info)); 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 ); printf("Current local time and date: %s", asctime(info)); // 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

Education