24/05/2018, 20:09

Các dạng nhập-xuất không định dạng

Nhập/xuất không định dạng được thực hiện với các hàm thành viên istream::read() và ostream::write() . Hàm istream::read() : istream& read(unsigned char* puch , int nCount ...

Nhập/xuất không định dạng được thực hiện với các hàm thành viên istream::read() và ostream::write().

Hàm istream::read():

istream& read(unsigned char* puch , int nCount );

istream& read(signed char* psch , int nCount );

Trích các byte từ dòng cho đến khi giới hạn nCount đạt đến hoặc cho đến khi end- of-file đạt đến. Hàm này có ích cho dòng nhập nhị phân.

Hàm ostream::write():

ostream& write(const unsigned char * puch , int nCount );

ostream& write(const signed char * psch , int nCount );

Chèn nCount byte vào từ vùng đệm (được trỏ bởi puch và psch) vào dòng. Nếu file được mở ở chế độ text, các ký tự CR có thể được chèn vào. Hàm này có ích cho dòng xuất nhị phân. Chẳng hạn:

char Buff[]="HAPPY BIRTHDAY";

cout.write(Buff,10);

Hàm istream::gcount():

int gcount();

Hàm trả về số ký tự đã trích bởi hàm nhập không định dạng cuối cùng.

Ví dụ 8.12: Sử dụng hàm getline()


CT8_12.CPP1: //Chương trình 8.122: #include <iostream.h>3:4: const int SIZE = 80;5:6: int main()7: {8: char Buffer[SIZE];9: cout << "Enter a sentence:" << endl;10: cin.read(Buffer, 20);11: cout << endl << "The sentence entered was:" << endl;12: cout.write(Buffer, cin.gcount());13: cout << endl;14: return 0;15: }

Chúng ta chạy ví dụ 8.12, kết quả ở hình 8.14

Hình 8.14: Kết quả của ví dụ 8.12

C++ cung cấp các bộ xử lý dòng khác nhau mà thực hiện các công việc định dạng. Các bộ xử lý dòng cung cấp các khả năng như ấn định các chiều rộng trường, ấn định độ chính xác, ấn định và không ấn định các cờ định dạng, ấn định lấp đầy (fill) ký tự trong các trường, flush dòng, chèn một ký tự newline vào dòng xuất và flush dòng, chèn một ký tự null vào dòng xuất và nhảy khoảng trắng trong dòng nhập.

Các bộ xử lý dec, oct, hex và setbase():

Các số nguyên bình thường được thể hiện các giá trị thập phân (cơ số 10). Để thay đổi mà các số nguyên được thể hiện trên dòng, chèn bộ xử lý ios::hex để ấn định cơ số 16 hoặc chèn bộ xử lý ios::oct để ấn định cơ số 8. Chèn bộ xử lý dòng ios::dec để xác lặp lại cơ số dòng thập phân.

Cơ số của dòng cũng có thể thay đổi bởi bộ xử lý dòng setbase() có một tham số là số nguyên với các giá trị:

0:Dùng cơ sơ mặc định (cơ số 10). Trong trường hợp này muốn nhập số ở dạng bát phân, chúng ta phải ghi chữ số 0 phía trước số đó.

8: Dùng cơ số 8.

10: Dùng cơ số 10.

16: Dùng cơ số 16.

Vì hàm setbase() có một tham số nên nó được gọi là một bộ xử lý dòng có tham số. Sử dụng hoặc bất kỳ bộ xử lý dòng có tham số nào phải include tập tin <iomanip.h>. Trong file này có ba lớp làm mẫu OMANIP, IMANIP, và SMANIP lần lượt cần cho việc định nghĩa bộ xử lý có tham số trên dòng xuất, dòng nhập và trên dòng nhập/xuất.

Lớp mẫu (class template) còn gọi là lớp chung chung (generic class). Gọi như vậy là vì lớp được định nghĩa với nhiều yếu tố được bỏ ngỏ. Chẳng hạn, lớp OMANIP(class Type) có dùng một kiểu dữ liệu chung chung gọi là Type. Khi Type thay bằng kiểu cụ thể, chẳng hạn OMANIP(int), chúng ta có một lớp cụ thể tương ứng.

Ví dụ 8.13:


CT8_13.CPP1: //Chương trình 8.132: #include <iostream.h>3: #include <iomanip.h>4:5: int main()6: {7: int n;8: cout << "Enter a decimal number: ";9: cin >> n;10: cout << n << " in hexadecimal is: "11: << hex << n << endl12: << dec << n << " in octal is: "13: << oct << n << endl14: << setbase(10) << n << " in decimal is: "15: << n << endl;16: return 0;17: }

Chúng ta chạy ví dụ 8.13, kết quả ở hình 8.15

Hình 8.15: Kết quả của ví dụ 8.13

Độ chính xác dấu chấm động (ios::precision(), setprecision()):

Chúng ta có thể điều khiển độ chính xác của các số chấm động, nghĩa là số các chữ số bên phải dấu chấm thập phân, bằng cách sử dụng các hàm ios::precision() và setprecision().

Hàm ios::precision():

(1) int precision(int np);

(2) int precision();

Dạng (2) trả về giá tri chính xác hiện giờ. Dạng (1) ấn định độ chính xác và trả về độ chính xác giá trị chính xác trước đó. Nếu np bằng 0 thì khôi phục độ chính xác mặc định (là 6).

Hàm setprecision():

SMANIP(int) setprecision(int np );

np cho biết độ chính xác của số chấm động.

Ví dụ 8.14:


CT8_14.CPP1: //Chương trình 8.142: #include <iostream.h>3: #include <iomanip.h>4: #include <math.h>5:6: int main()7: {8: double Root2 = sqrt(2.0);9: cout << "Square root of 2 with precisions 0-9." << endl10: << "Precision set by the "11: << "precision member function:" << endl;12: for (int Places = 0; Places <= 9; Places++)13: {14: cout.precision(Places);15: cout << Root2 << endl;16: }17: cout << endl << "Precision set by the "18: << "setprecision manipulator:" << endl;19: for (Places = 0; Places <= 9; Places++)20: cout << setprecision(Places) << Root2 << endl;21: return 0;22: }

Chúng ta chạy ví dụ 8.14, kết quả ở hình 8.16

Hình 8.16: Kết quả của ví dụ 8.14

Độ rộng trường (setw(), ios::awidth()):

Hàm ios::awidth():

(1) int awidth(int nw);

(2) int awidth();

Dạng (1) sẽ ấn định độ rộng trường nội tại của dòng với tham số nw. Khi độ rộng là 0 (mặc định). Việc chèn chỉ chèn số các ký tự cần thiết để biểu diễn giá trị đã chèn. Khi độ rộng khác 0, việc chèn độn vào trường với ký tự lấp đầy của dòng, lên tới nw. Giá trị độ rộng nội tại xác lặp lại 0 sau mỗi lần trích hoặc chèn. Dạng (2) trả về giá trị hiện tại của biến độ rộng của dòng.

Hàm setw():

SMANIP(int) setw(int nw );

nw là số nguyên cho biết độ rộng của trường.

Ví dụ 8.15:


CT8_15.CPP1: //Chương trình 8.152: #include <iostream.h>3:4: int main()5: {6: int W = 4;7: char St[10];8: cout << "Enter a sentence:" << endl;9: cin.awidth(5);10: while (cin >> St)11: {12: cout.awidth(W++);13: cout << St << endl;14: cin.awidth(5);15: }16: return 0;17: }

Chúng ta chạy ví dụ 8.15, kết quả ở hình 8.17

Hình 8.17: Kết quả của ví dụ 8.15

Các bộ xử lý người dùng định nghĩa:

Người dùng có thể tạo các bộ xử lý dòng cho riêng mình. Định nghĩa bộ xử lý không tham số:

istream & function_name (istream & in )

{

………….

return in;

}

ostream & function_name (ostream & out )

{

………….

return out;

}

Ví dụ 8.16: Bộ xử lý không tham số.


CT8_16.CPP1: //Chương trình 8.162: #include <iostream.h>3:4: //Bộ xử lý bell (sử dụng chuỗi thoát a)5: ostream& bell(ostream& output)6: {7: return output << 'a';8: }9:10: //Bộ xử lý ret (sử dụng chuỗi thoát )11: ostream& ret(ostream& output)12: {13: return output << ' ';14: }15:16: //Bộ xử lý tab (su dung chuoi thoat )17: ostream& tab(ostream& output)18: {19: return output << ' ';20: }21:22: //Bộ xử lý endline (sử dụng chuỗi thoát và hàm flush())23: ostream& endline(ostream& output)24: {25: return output << ' ' << flush;26: }27:28: int main()29: {30: cout << "Testing the tab manipulator:" << endline31: << 'a' << tab << 'b' << tab << 'c' << endline32: << "Testing the ret and bell manipulators:"33: << endline << "..........";34: for (int I = 1; I <= 100; I++)35: cout << bell;36: cout << ret << "-----" << endline;37: return 0;38: }

Chúng ta chạy ví dụ 8.16, kết quả ở hình 8.18

Hình 8.18: Kết quả của ví dụ 8.16

Muốn định nghĩa bộ xử lý có tham số, chúng ta phải include tập tin <iomanip.h>. Bộ xử lý có tham số trên dòng xuất có dạng:

ostream & function_name(ostream & out, parameter_type parameter)

{

………….

return out;

}

OMANIP(type) function_name(parameter_type parameter)

{

return OMANIP( type ) ( function_name , parameter );

}

Tương tự dạng định nghĩa bộ xử lý trên dòng nhập và trên dòng nhập/xuất.

Ví dụ 8.17: Bộ xử lý có tham số.


CT8_17.CPP1: //Chương trình 8.172: #include <iostream.h>3: #include <iomanip.h>4:5: ostream & indent(ostream & Stream,int Len)6: {7: for(int I=0;I<Len;++I)8: cout<<" ";9: return Stream;10: }11:12: OMANIP (int) indent(int Len)13: {14: return OMANIP(int)(indent,Len);15: }16:17: int main()18: {19: cout<<indent(10)<<"Hello"<<endl;20: cout<<indent(20)<<"Peter"<<endl;21: cout<<indent(5)<<"John"<<endl;22: return 0;23: }